fix(wrapProp): correct flag read

Author: wmertens

packages/qwik/src/core/qwik.core.api.md

@@ -1946,11 +1946,13 @@ export function _walkJSX(ssr: SSRContainer, value: JSXOutput, options: {
 // @public
 export function withLocale<T>(locale: string, fn: () => T): T;
 
+// Warning: (ae-forgotten-export) The symbol "WrappedProp" needs to be exported by the entry point index.d.ts
+//
 // @internal
-export const _wrapProp: <T extends Record<any, any>, P extends keyof T>(...args: [T, P?]) => any;
+export const _wrapProp: <T extends object, P extends keyof T>(...args: [T, P?]) => WrappedProp<T, P>;
 
 // @internal @deprecated (undocumented)
-export const _wrapSignal: <T extends Record<any, any>, P extends keyof T>(obj: T, prop: P) => any;
+export const _wrapSignal: <T extends object, P extends keyof T>(obj: T, prop: P) => T[P] | WrappedProp<T, P>;
 
 // (No @packageDocumentation comment for this package)
 

packages/qwik/src/core/reactive-primitives/impl/signal.unit.tsx

@@ -1,4 +1,4 @@
-import { $, isBrowser } from '@qwik.dev/core';
+import { $, _wrapProp, isBrowser } from '@qwik.dev/core';
 import { createDocument, getTestPlatform } from '@qwik.dev/core/testing';
 import { afterEach, beforeEach, describe, expect, expectTypeOf, it } from 'vitest';
 import { getDomContainer } from '../../client/dom-container';
@@ -244,6 +244,16 @@ describe('signal', () => {
         expect(log).toEqual([1, 2]);
       });
     });
+    describe('wrapped', () => {
+      it('should not re-wrap wrapped signal', () => {
+        const signal = createSignal(1);
+        const wrapped = _wrapProp(signal);
+        expect(wrapped).toHaveProperty('value', 1);
+        expect(wrapped).not.toBe(signal);
+        const wrapped2 = _wrapProp(wrapped);
+        expect(wrapped2).toBe(wrapped);
+      });
+    });
   });
   ////////////////////////////////////////
 

packages/qwik/src/core/reactive-primitives/internal-api.ts

@@ -1,20 +1,29 @@
 import { _CONST_PROPS, _IMMUTABLE } from '../shared/utils/constants';
 import { assertEqual } from '../shared/error/assert';
 import { isObject } from '../shared/utils/types';
-import { isSignal } from './signal.public';
+import { isSignal, type Signal } from './signal.public';
 import { getStoreTarget } from './impl/store';
 import { isPropsProxy } from '../shared/jsx/jsx-runtime';
 import { WrappedSignalFlags } from './types';
 import { WrappedSignalImpl } from './impl/wrapped-signal-impl';
 import { AsyncComputedSignalImpl } from './impl/async-computed-signal-impl';
 
 // Keep these properties named like this so they're the same as from wrapSignal
-const getValueProp = (p0: any) => p0.value;
-const getProp = (p0: any, p1: string) => p0[p1];
+const getValueProp = <T>(p0: { value: T }) => p0.value;
+const getProp = <T extends object, P extends keyof T>(p0: T, p1: P) => p0[p1];
 
-const getWrapped = (args: any[]) =>
+const getWrapped = <T extends object>(args: [T, (keyof T | undefined)?]) =>
   new WrappedSignalImpl(null, args.length === 1 ? getValueProp : getProp, args, null);
 
+type PropType<T extends object, P extends keyof T> = P extends keyof T
+  ? T[P]
+  : 'value' extends keyof T
+    ? T['value']
+    : never;
+type WrappedProp<T extends object, P extends keyof T> = T extends Signal
+  ? WrappedSignalImpl<PropType<T, P>>
+  : PropType<T, P>;
+
 /**
  * This wraps a property access of a possible Signal/Store into a WrappedSignal. The optimizer does
  * this automatically when a prop is only used as a prop on JSX.
@@ -26,7 +35,9 @@ const getWrapped = (args: any[]) =>
  *
  * @internal
  */
-export const _wrapProp = <T extends Record<any, any>, P extends keyof T>(...args: [T, P?]): any => {
+export const _wrapProp = <T extends object, P extends keyof T>(
+  ...args: [T, P?]
+): WrappedProp<T, P> => {
   const obj = args[0];
   const prop = args.length < 2 ? 'value' : args[1]!;
 
@@ -37,37 +48,34 @@ export const _wrapProp = <T extends Record<any, any>, P extends keyof T>(...args
     if (!(obj instanceof AsyncComputedSignalImpl)) {
       assertEqual(prop, 'value', 'Left side is a signal, prop must be value');
     }
-    if (obj instanceof WrappedSignalImpl && obj.flags & WrappedSignalFlags.UNWRAP) {
-      return obj;
+    if (obj instanceof WrappedSignalImpl && obj.$flags$ & WrappedSignalFlags.UNWRAP) {
+      return obj as WrappedProp<T, P>;
     }
-    return getWrapped(args);
+    return getWrapped(args) as WrappedProp<T, P>;
   }
   if (isPropsProxy(obj)) {
-    const constProps = obj[_CONST_PROPS] as any;
+    const constProps = obj[_CONST_PROPS];
     if (constProps && prop in constProps) {
       // Const props don't need wrapping
-      return constProps[prop];
+      return constProps[prop as keyof typeof constProps] as WrappedProp<T, P>;
     }
   } else {
     const target = getStoreTarget(obj);
     if (target) {
-      const value = target[prop];
+      const value = target[prop as P];
       const wrappedValue = isSignal(value)
         ? // If the value is already a signal, we don't need to wrap it again
           value
         : getWrapped(args);
-      return wrappedValue;
+      return wrappedValue as WrappedProp<T, P>;
     }
   }
   // the object is not reactive, so we can just return the value
-  return obj[prop];
+  return obj[prop as P] as WrappedProp<T, P>;
 };
 
 /** @internal @deprecated v1 compat */
-export const _wrapSignal = <T extends Record<any, any>, P extends keyof T>(
-  obj: T,
-  prop: P
-): any => {
+export const _wrapSignal = <T extends object, P extends keyof T>(obj: T, prop: P) => {
   const r = _wrapProp(obj, prop);
   if (r === _IMMUTABLE) {
     return obj[prop];