chore: move wrapped signal impl to separate file

Varixo · Varixo · commit e0109596b5dc · 2025-04-08T22:26:44.000+02:00
diff --git a/packages/qwik/src/core/client/vnode-diff.ts b/packages/qwik/src/core/client/vnode-diff.ts
@@ -91,7 +91,7 @@ import {
 import { mapApp_findIndx } from './util-mapArray';
 import { mapArray_set } from './util-mapArray';
 import { getNewElementNamespaceData } from './vnode-namespace';
-import { WrappedSignal, isSignal } from '../signal/signal';
+import { isSignal } from '../signal/signal';
 import type { Signal } from '../signal/signal.public';
 import { executeComponent } from '../shared/component-execution';
 import { isSlotProp } from '../shared/utils/prop';
@@ -102,6 +102,7 @@ import { QError, qError } from '../shared/error/error';
 import { getFileLocationFromJsx } from '../shared/utils/jsx-filename';
 import { EffectProperty } from '../signal/types';
 import { SubscriptionData } from '../signal/subscription-data';
+import { WrappedSignalImpl } from '../signal/impl/wrapped-signal-impl';
 
 export const vnode_diff = (
   container: ClientContainer,
@@ -514,7 +515,7 @@ export const vnode_diff = (
     const constProps = jsxNode.constProps;
     if (constProps && typeof constProps == 'object' && 'name' in constProps) {
       const constValue = constProps.name;
-      if (vHost && constValue instanceof WrappedSignal) {
+      if (vHost && constValue instanceof WrappedSignalImpl) {
         return trackSignalAndAssignHost(constValue, vHost, EffectProperty.COMPONENT, container);
       }
     }
diff --git a/packages/qwik/src/core/debug.ts b/packages/qwik/src/core/debug.ts
@@ -2,10 +2,11 @@ import { isQrl } from '../server/prefetch-strategy';
 import { isJSXNode } from './shared/jsx/jsx-runtime';
 import { isTask } from './use/use-task';
 import { vnode_getProp, vnode_isVNode } from './client/vnode';
-import { WrappedSignal, isSignal } from './signal/signal';
+import { isSignal } from './signal/signal';
 import { isStore } from './signal/store';
 import { DEBUG_TYPE } from './shared/types';
 import { ComputedSignalImpl } from './signal/impl/computed-signal-impl';
+import { WrappedSignalImpl } from './signal/impl/wrapped-signal-impl';
 
 const stringifyPath: any[] = [];
 export function qwikDebugToString(value: any): any {
@@ -37,7 +38,7 @@ export function qwikDebugToString(value: any): any {
           return value.map(qwikDebugToString);
         }
       } else if (isSignal(value)) {
-        if (value instanceof WrappedSignal) {
+        if (value instanceof WrappedSignalImpl) {
           return 'WrappedSignal';
         } else if (value instanceof ComputedSignalImpl) {
           return 'ComputedSignal';
diff --git a/packages/qwik/src/core/shared/jsx/jsx-runtime.ts b/packages/qwik/src/core/shared/jsx/jsx-runtime.ts
@@ -8,7 +8,7 @@ import { logOnceWarn, logWarn } from '../utils/log';
 import { ELEMENT_ID, OnRenderProp, QScopedStyle, QSlot, QSlotS } from '../utils/markers';
 import { qDev, seal } from '../utils/qdev';
 import { isArray, isObject, isString } from '../utils/types';
-import { WrappedSignal } from '../../signal/signal';
+import { WrappedSignalImpl } from '../../signal/impl/wrapped-signal-impl';
 import { WrappedSignalFlags } from '../../signal/types';
 import type { DevJSX, FunctionComponent, JSXNode, JSXNodeInternal } from './types/jsx-node';
 import type { QwikJSX } from './types/jsx-qwik';
@@ -346,7 +346,7 @@ class PropsProxyHandler implements ProxyHandler<any> {
         ? this.$constProps$[prop as string]
         : this.$varProps$[prop as string];
     // a proxied value that the optimizer made
-    return value instanceof WrappedSignal && value.$flags$ & WrappedSignalFlags.UNWRAP
+    return value instanceof WrappedSignalImpl && value.$flags$ & WrappedSignalFlags.UNWRAP
       ? value.value
       : value;
   }
diff --git a/packages/qwik/src/core/shared/qrl/inlined-fn.ts b/packages/qwik/src/core/shared/qrl/inlined-fn.ts
@@ -1,10 +1,10 @@
-import { WrappedSignal } from '../../signal/signal';
+import { WrappedSignalImpl } from '../../signal/impl/wrapped-signal-impl';
 
 /** @internal */
 export const _fnSignal = <T extends (...args: any) => any>(
   fn: T,
   args: Parameters<T>,
   fnStr?: string
 ) => {
-  return new WrappedSignal(null, fn, args, fnStr || null);
+  return new WrappedSignalImpl(null, fn, args, fnStr || null);
 };
diff --git a/packages/qwik/src/core/shared/scheduler.ts b/packages/qwik/src/core/shared/scheduler.ts
@@ -91,7 +91,7 @@ import {
 } from '../client/types';
 import { VNodeJournalOpCode, vnode_isVNode, vnode_setAttr } from '../client/vnode';
 import { vnode_diff } from '../client/vnode-diff';
-import { triggerEffects, type WrappedSignal } from '../signal/signal';
+import { triggerEffects } from '../signal/signal';
 import { isSignal, type Signal } from '../signal/signal.public';
 import type { TargetType } from '../signal/store';
 import type { ISsrNode } from '../ssr/ssr-types';
@@ -121,6 +121,7 @@ import { serializeAttribute } from './utils/styles';
 import type { ValueOrPromise } from './utils/types';
 import type { NodePropPayload } from '../signal/subscription-data';
 import type { ComputedSignalImpl } from '../signal/impl/computed-signal-impl';
+import type { WrappedSignalImpl } from '../signal/impl/wrapped-signal-impl';
 
 // Turn this on to get debug output of what the scheduler is doing.
 const DEBUG: boolean = false;
@@ -462,7 +463,9 @@ export const createScheduler = (
         }
         case ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS: {
           {
-            const target = chore.$target$ as ComputedSignalImpl<unknown> | WrappedSignal<unknown>;
+            const target = chore.$target$ as
+              | ComputedSignalImpl<unknown>
+              | WrappedSignalImpl<unknown>;
             const forceRunEffects = target.$forceRunEffects$;
             target.$forceRunEffects$ = false;
             if (!target.$effects$?.size) {
diff --git a/packages/qwik/src/core/shared/shared-serialization.ts b/packages/qwik/src/core/shared/shared-serialization.ts
@@ -8,12 +8,7 @@ import { type DomContainer } from '../client/dom-container';
 import type { VNode } from '../client/types';
 import { vnode_getNode, vnode_isVNode, vnode_locate, vnode_toString } from '../client/vnode';
 import { _EFFECT_BACK_REF, NEEDS_COMPUTATION } from '../signal/flags';
-import {
-  SerializerSignalImpl,
-  WrappedSignal,
-  isSerializerObj,
-  type SerializerArg,
-} from '../signal/signal';
+import { SerializerSignalImpl, isSerializerObj, type SerializerArg } from '../signal/signal';
 import {
   getOrCreateStore,
   getStoreHandler,
@@ -59,6 +54,7 @@ import {
 import { SubscriptionData, type NodePropData } from '../signal/subscription-data';
 import { SignalImpl } from '../signal/impl/signal-impl';
 import { ComputedSignalImpl } from '../signal/impl/computed-signal-impl';
+import { WrappedSignalImpl } from '../signal/impl/wrapped-signal-impl';
 
 const deserializedProxyMap = new WeakMap<object, unknown[]>();
 
@@ -271,7 +267,7 @@ const inflate = (
       break;
     }
     case TypeIds.WrappedSignal: {
-      const signal = target as WrappedSignal<unknown>;
+      const signal = target as WrappedSignalImpl<unknown>;
       const d = data as [
         number,
         unknown[],
@@ -491,7 +487,7 @@ const allocate = (container: DeserializeContainer, typeId: number, value: unknow
     case TypeIds.Signal:
       return new SignalImpl(container as any, 0);
     case TypeIds.WrappedSignal:
-      return new WrappedSignal(container as any, null!, null!, null!);
+      return new WrappedSignalImpl(container as any, null!, null!, null!);
     case TypeIds.ComputedSignal:
       return new ComputedSignalImpl(container as any, null!);
     case TypeIds.SerializerSignal:
@@ -876,7 +872,7 @@ export const createSerializationContext = (
           discoveredValues.push(obj.$effects$);
         }
         // WrappedSignal uses syncQrl which has no captured refs
-        if (obj instanceof WrappedSignal) {
+        if (obj instanceof WrappedSignalImpl) {
           discoverEffectBackRefs(obj[_EFFECT_BACK_REF], discoveredValues);
           if (obj.$args$) {
             discoveredValues.push(...obj.$args$);
@@ -1235,7 +1231,7 @@ function serialize(serializationContext: SerializationContext): void {
           ? NEEDS_COMPUTATION
           : value.$untrackedValue$;
 
-      if (value instanceof WrappedSignal) {
+      if (value instanceof WrappedSignalImpl) {
         output(TypeIds.WrappedSignal, [
           ...serializeWrappingFn(serializationContext, value),
           filterEffectBackRefs(value[_EFFECT_BACK_REF]),
@@ -1380,7 +1376,7 @@ function filterEffectBackRefs(effectBackRef: Map<string, EffectSubscription> | n
 
 function serializeWrappingFn(
   serializationContext: SerializationContext,
-  value: WrappedSignal<any>
+  value: WrappedSignalImpl<any>
 ) {
   // if value is an object then we need to wrap this in ()
   if (value.$funcStr$ && value.$funcStr$[0] === '{') {
diff --git a/packages/qwik/src/core/signal/impl/wrapped-signal-impl.ts b/packages/qwik/src/core/signal/impl/wrapped-signal-impl.ts
@@ -0,0 +1,96 @@
+import { assertFalse } from '../../shared/error/assert';
+import { QError, qError } from '../../shared/error/error';
+import type { Container, HostElement } from '../../shared/types';
+import { ChoreType } from '../../shared/util-chore-type';
+import { trackSignal } from '../../use/use-core';
+import { _EFFECT_BACK_REF, NEEDS_COMPUTATION } from '../flags';
+import { triggerEffects } from '../signal';
+import type { BackRef } from '../signal-cleanup';
+import type { AllSignalFlags, EffectSubscription } from '../types';
+import { EffectProperty, SignalFlags, WrappedSignalFlags } from '../types';
+import { SignalImpl } from './signal-impl';
+
+export class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
+  $args$: any[];
+  $func$: (...args: any[]) => T;
+  $funcStr$: string | null;
+
+  $flags$: AllSignalFlags;
+  $hostElement$: HostElement | null = null;
+  $forceRunEffects$: boolean = false;
+  [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null = null;
+
+  constructor(
+    container: Container | null,
+    fn: (...args: any[]) => T,
+    args: any[],
+    fnStr: string | null,
+    // We need a separate flag to know when the computation needs running because
+    // we need the old value to know if effects need running after computation
+    flags: SignalFlags = SignalFlags.INVALID | WrappedSignalFlags.UNWRAP
+  ) {
+    super(container, NEEDS_COMPUTATION);
+    this.$args$ = args;
+    this.$func$ = fn;
+    this.$funcStr$ = fnStr;
+    this.$flags$ = flags;
+  }
+
+  $invalidate$() {
+    this.$flags$ |= SignalFlags.INVALID;
+    this.$forceRunEffects$ = false;
+    // We should only call subscribers if the calculation actually changed.
+    // Therefore, we need to calculate the value now.
+    this.$container$?.$scheduler$(
+      ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS,
+      this.$hostElement$,
+      this
+    );
+  }
+
+  /**
+   * Use this to force running subscribers, for example when the calculated value has mutated but
+   * remained the same object.
+   */
+  force() {
+    this.$flags$ |= SignalFlags.INVALID;
+    this.$forceRunEffects$ = false;
+    triggerEffects(this.$container$, this, this.$effects$);
+  }
+
+  get untrackedValue() {
+    const didChange = this.$computeIfNeeded$();
+    if (didChange) {
+      this.$forceRunEffects$ = didChange;
+    }
+    assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, 'Invalid state');
+    return this.$untrackedValue$;
+  }
+
+  $computeIfNeeded$() {
+    if (!(this.$flags$ & SignalFlags.INVALID)) {
+      return false;
+    }
+    const untrackedValue = trackSignal(
+      () => this.$func$(...this.$args$),
+      this,
+      EffectProperty.VNODE,
+      this.$container$!
+    );
+    // TODO: we should remove invalid flag here
+    // this.$flags$ &= ~SignalFlags.INVALID;
+    const didChange = untrackedValue !== this.$untrackedValue$;
+    if (didChange) {
+      this.$untrackedValue$ = untrackedValue;
+    }
+    return didChange;
+  }
+  // Make this signal read-only
+  set value(_: any) {
+    throw qError(QError.wrappedReadOnly);
+  }
+  // Getters don't get inherited when overriding a setter
+  get value() {
+    return super.value;
+  }
+}
diff --git a/packages/qwik/src/core/signal/signal-cleanup.ts b/packages/qwik/src/core/signal/signal-cleanup.ts
@@ -1,4 +1,3 @@
-import { WrappedSignal } from './signal';
 import { StoreHandler, getStoreHandler } from './store';
 import type { Container } from '../shared/types';
 import { ensureMaterialized, vnode_isElementVNode, vnode_isVNode } from '../client/vnode';
@@ -10,6 +9,7 @@ import {
   type EffectSubscription,
 } from './types';
 import { SignalImpl } from './impl/signal-impl';
+import { WrappedSignalImpl } from './impl/wrapped-signal-impl';
 
 /** Class for back reference to the EffectSubscription */
 export abstract class BackRef {
@@ -47,7 +47,7 @@ function clearSignal(container: Container, producer: SignalImpl, effect: EffectS
     effects.delete(effect);
   }
 
-  if (producer instanceof WrappedSignal) {
+  if (producer instanceof WrappedSignalImpl) {
     producer.$hostElement$ = null;
     clearAllEffects(container, producer);
   }
diff --git a/packages/qwik/src/core/signal/signal-utils.ts b/packages/qwik/src/core/signal/signal-utils.ts
@@ -1,18 +1,18 @@
 import { _CONST_PROPS, _IMMUTABLE } from '../shared/utils/constants';
 import { assertEqual } from '../shared/error/assert';
 import { isObject } from '../shared/utils/types';
-import { WrappedSignal } from './signal';
 import { isSignal, type Signal } from './signal.public';
 import { getStoreTarget } from './store';
 import { isPropsProxy } from '../shared/jsx/jsx-runtime';
 import { SignalFlags, WrappedSignalFlags } from './types';
+import { WrappedSignalImpl } from './impl/wrapped-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 getWrapped = (args: any[]) =>
-  new WrappedSignal(null, args.length === 1 ? getValueProp : getProp, args, null);
+  new WrappedSignalImpl(null, args.length === 1 ? getValueProp : getProp, args, null);
 
 /**
  * This wraps a property access of a possible Signal/Store into a WrappedSignal. The optimizer does
@@ -34,7 +34,7 @@ export const _wrapProp = <T extends Record<any, any>, P extends keyof T>(...args
   }
   if (isSignal(obj)) {
     assertEqual(prop, 'value', 'Left side is a signal, prop must be value');
-    if (obj instanceof WrappedSignal && obj.flags & WrappedSignalFlags.UNWRAP) {
+    if (obj instanceof WrappedSignalImpl && obj.flags & WrappedSignalFlags.UNWRAP) {
       return obj;
     }
     return getWrapped(args);
@@ -70,7 +70,7 @@ export const _wrapStore = <T extends Record<any, any>, P extends keyof T>(
   if (isSignal(value)) {
     return value;
   } else {
-    return new WrappedSignal(null, getProp, [obj, prop], null, SignalFlags.INVALID);
+    return new WrappedSignalImpl(null, getProp, [obj, prop], null, SignalFlags.INVALID);
   }
 };
 
diff --git a/packages/qwik/src/core/signal/signal.ts b/packages/qwik/src/core/signal/signal.ts
diff --git a/packages/qwik/src/core/ssr/ssr-render-jsx.ts b/packages/qwik/src/core/ssr/ssr-render-jsx.ts
diff --git a/packages/qwik/src/core/tests/use-task.spec.tsx b/packages/qwik/src/core/tests/use-task.spec.tsx
diff --git a/packages/qwik/src/core/use/use-core.ts b/packages/qwik/src/core/use/use-core.ts
