chore: move serializer signal impl to separate file

Varixo · Varixo · commit 4f5207bc1ff9 · 2025-04-08T22:27:09.000+02:00
diff --git a/packages/qwik/src/core/shared/shared-serialization.ts b/packages/qwik/src/core/shared/shared-serialization.ts
@@ -8,7 +8,8 @@ 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, isSerializerObj, type SerializerArg } from '../signal/signal';
+import { isSerializerObj } from '../signal/signal';
+import type { SerializerArg } from '../signal/types';
 import {
   getOrCreateStore,
   getStoreHandler,
@@ -55,6 +56,7 @@ 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';
+import { SerializerSignalImpl } from '../signal/impl/serializer-signal-impl';
 
 const deserializedProxyMap = new WeakMap<object, unknown[]>();
 
diff --git a/packages/qwik/src/core/signal/impl/README.md b/packages/qwik/src/core/signal/impl/README.md
@@ -0,0 +1,11 @@
+# Signals
+
+Signals come in two types:
+
+1. `Signal` - A storage of data
+2. `ComputedSignal` - A signal which is computed from other signals.
+
+## Why is `ComputedSignal` different?
+
+- It needs to store a function which needs to re-run.
+- It is `Readonly` because it is computed.
diff --git a/packages/qwik/src/core/signal/impl/computed-signal-impl.ts b/packages/qwik/src/core/signal/impl/computed-signal-impl.ts
@@ -1,18 +1,17 @@
-import type { ComputeQRL, EffectSubscription } from '../types';
-import { EffectProperty } from '../types';
-import type { BackRef } from '../signal-cleanup';
-import { SignalFlags } from '../types';
-import { SignalImpl } from './signal-impl';
-import { _EFFECT_BACK_REF, NEEDS_COMPUTATION } from '../flags';
+import { qwikDebugToString } from '../../debug';
+import { assertFalse } from '../../shared/error/assert';
+import { QError, qError } from '../../shared/error/error';
 import type { Container } from '../../shared/types';
 import { ChoreType } from '../../shared/util-chore-type';
-import { assertFalse } from '../../shared/error/assert';
-import { throwIfQRLNotResolved } from '../signal';
+import { isPromise } from '../../shared/utils/promises';
 import { tryGetInvokeContext } from '../../use/use-core';
+import { _EFFECT_BACK_REF, NEEDS_COMPUTATION } from '../flags';
+import { throwIfQRLNotResolved } from '../signal';
+import type { BackRef } from '../signal-cleanup';
 import { getSubscriber } from '../subscriber';
-import { isPromise } from '../../shared/utils/promises';
-import { QError, qError } from '../../shared/error/error';
-import { qwikDebugToString } from '../../debug';
+import type { ComputeQRL, EffectSubscription } from '../types';
+import { EffectProperty, SignalFlags } from '../types';
+import { SignalImpl } from './signal-impl';
 
 const DEBUG = false;
 // eslint-disable-next-line no-console
diff --git a/packages/qwik/src/core/signal/impl/serializer-signal-impl.ts b/packages/qwik/src/core/signal/impl/serializer-signal-impl.ts
@@ -0,0 +1,60 @@
+import { qwikDebugToString } from '../../debug';
+import type { QRLInternal } from '../../shared/qrl/qrl-class';
+import type { Container } from '../../shared/types';
+import { trackSignal } from '../../use/use-core';
+import { NEEDS_COMPUTATION } from '../flags';
+import { throwIfQRLNotResolved } from '../signal';
+import type { SerializerArg } from '../types';
+import { EffectProperty, SignalFlags, type ComputeQRL } from '../types';
+import { ComputedSignalImpl } from './computed-signal-impl';
+
+const DEBUG = false;
+// eslint-disable-next-line no-console
+const log = (...args: any[]) => console.log('SERIALIZER SIGNAL', ...args.map(qwikDebugToString));
+
+/**
+ * A signal which provides a non-serializable value. It works like a computed signal, but it is
+ * handled slightly differently during serdes.
+ *
+ * @public
+ */
+export class SerializerSignalImpl<T, S> extends ComputedSignalImpl<T> {
+  constructor(container: Container | null, argQrl: QRLInternal<SerializerArg<T, S>>) {
+    super(container, argQrl as unknown as ComputeQRL<T>);
+  }
+  $didInitialize$: boolean = false;
+
+  $computeIfNeeded$(): boolean {
+    if (!(this.$flags$ & SignalFlags.INVALID)) {
+      return false;
+    }
+    throwIfQRLNotResolved(this.$computeQrl$);
+    let arg = (this.$computeQrl$ as any as QRLInternal<SerializerArg<T, S>>).resolved!;
+    if (typeof arg === 'function') {
+      arg = arg();
+    }
+    const { deserialize, initial } = arg;
+    const update = (arg as any).update as ((current: T) => T) | undefined;
+    const currentValue =
+      this.$untrackedValue$ === NEEDS_COMPUTATION ? initial : this.$untrackedValue$;
+    const untrackedValue = trackSignal(
+      () =>
+        this.$didInitialize$
+          ? update?.(currentValue as T)
+          : deserialize(currentValue as Awaited<S>),
+      this,
+      EffectProperty.VNODE,
+      this.$container$!
+    );
+    DEBUG && log('SerializerSignal.$compute$', untrackedValue);
+    const didChange =
+      (this.$didInitialize$ && untrackedValue !== 'undefined') ||
+      untrackedValue !== this.$untrackedValue$;
+    this.$flags$ &= ~SignalFlags.INVALID;
+    this.$didInitialize$ = true;
+    if (didChange) {
+      this.$untrackedValue$ = untrackedValue as T;
+    }
+    return didChange;
+  }
+}
diff --git a/packages/qwik/src/core/signal/impl/signal-impl.ts b/packages/qwik/src/core/signal/impl/signal-impl.ts
@@ -1,15 +1,18 @@
-import { qError, QError } from '../../shared/error/error';
+import { isDev } from '@qwik.dev/core/build';
+import { pad, qwikDebugToString } from '../../debug';
 import { assertTrue } from '../../shared/error/assert';
+import { qError, QError } from '../../shared/error/error';
 import type { Container } from '../../shared/types';
-import { addQrlToSerializationCtx, triggerEffects } from '../signal';
-import { ensureContainsBackRef } from '../signal';
+import { qDev } from '../../shared/utils/qdev';
 import { tryGetInvokeContext } from '../../use/use-core';
-import { ensureContainsSubscription } from '../signal';
+import {
+  addQrlToSerializationCtx,
+  ensureContainsBackRef,
+  ensureContainsSubscription,
+  triggerEffects,
+} from '../signal';
 import type { Signal } from '../signal.public';
 import { SignalFlags, type EffectSubscription } from '../types';
-import { pad, qwikDebugToString } from '../../debug';
-import { qDev } from '../../shared/utils/qdev';
-import { isDev } from '@qwik.dev/core/build';
 
 const DEBUG = false;
 // eslint-disable-next-line no-console
diff --git a/packages/qwik/src/core/signal/signal-api.ts b/packages/qwik/src/core/signal/signal-api.ts
@@ -2,8 +2,10 @@ import type { QRLInternal } from '../shared/qrl/qrl-class';
 import type { QRL } from '../shared/qrl/qrl.public';
 import { SignalImpl } from './impl/signal-impl';
 import { ComputedSignalImpl } from './impl/computed-signal-impl';
-import { SerializerSignalImpl, throwIfQRLNotResolved, type SerializerArg } from './signal';
+import { throwIfQRLNotResolved } from './signal';
 import type { Signal } from './signal.public';
+import type { SerializerArg } from './types';
+import { SerializerSignalImpl } from './impl/serializer-signal-impl';
 
 /** @internal */
 export const createSignal = <T>(value?: T): Signal<T> => {
diff --git a/packages/qwik/src/core/signal/signal.public.ts b/packages/qwik/src/core/signal/signal.public.ts
@@ -1,5 +1,5 @@
 import { implicit$FirstArg } from '../shared/qrl/implicit_dollar';
-import type { SerializerArg } from './signal';
+import type { SerializerArg } from './types';
 import {
   createSignal as _createSignal,
   createComputedSignal as createComputedQrl,
diff --git a/packages/qwik/src/core/signal/signal.ts b/packages/qwik/src/core/signal/signal.ts
@@ -1,16 +1,3 @@
-/**
- * @file
- *
- *   Signals come in two types:
- *
- *   1. `Signal` - A storage of data
- *   2. `ComputedSignal` - A signal which is computed from other signals.
- *
- *   ## Why is `ComputedSignal` different?
- *
- *   - It needs to store a function which needs to re-run.
- *   - It is `Readonly` because it is computed.
- */
 import { isDomContainer } from '../client/dom-container';
 import { pad, qwikDebugToString } from '../debug';
 import type { OnRenderFn } from '../shared/component.public';
@@ -23,9 +10,8 @@ import { ChoreType } from '../shared/util-chore-type';
 import { ELEMENT_PROPS, OnRenderProp } from '../shared/utils/markers';
 import { SerializerSymbol } from '../shared/utils/serialize-utils';
 import type { ISsrNode, SSRContainer } from '../ssr/ssr-types';
-import { trackSignal } from '../use/use-core';
 import { TaskFlags, isTask } from '../use/use-task';
-import { NEEDS_COMPUTATION, _EFFECT_BACK_REF } from './flags';
+import { _EFFECT_BACK_REF } from './flags';
 import { ComputedSignalImpl } from './impl/computed-signal-impl';
 import { SignalImpl } from './impl/signal-impl';
 import type { WrappedSignalImpl } from './impl/wrapped-signal-impl';
@@ -35,8 +21,7 @@ import { SubscriptionData, type NodePropPayload } from './subscription-data';
 import {
   EffectProperty,
   EffectSubscriptionProp,
-  SignalFlags,
-  type ComputeQRL,
+  type CustomSerializable,
   type EffectSubscription,
 } from './types';
 
@@ -159,103 +144,6 @@ export const triggerEffects = (
   DEBUG && log('done scheduling');
 };
 
-/** @public */
-export type SerializerArgObject<T, S> = {
-  /**
-   * This will be called with initial or serialized data to reconstruct an object. If no
-   * `initialData` is provided, it will be called with `undefined`.
-   *
-   * This must not return a Promise.
-   */
-  deserialize: (data: Awaited<S>) => T;
-  /** The initial value to use when deserializing. */
-  initial?: S | undefined;
-  /**
-   * This will be called with the object to get the serialized data. You can return a Promise if you
-   * need to do async work.
-   *
-   * The result may be anything that Qwik can serialize.
-   *
-   * If you do not provide it, the object will be serialized as `undefined`. However, if the object
-   * has a `[SerializerSymbol]` property, that will be used as the serializer instead.
-   */
-  serialize?: (obj: T) => S;
-};
-
-/**
- * Serialize and deserialize custom objects.
- *
- * If you need to use scoped state, you can pass a function instead of an object. The function will
- * be called with the current value, and you can return a new value.
- *
- * @public
- */
-export type SerializerArg<T, S> =
-  | SerializerArgObject<T, S>
-  | (() => SerializerArgObject<T, S> & {
-      /**
-       * This gets called when reactive state used during `deserialize` changes. You may mutate the
-       * current object, or return a new object.
-       *
-       * If it returns a value, that will be used as the new value, and listeners will be triggered.
-       * If no change happened, don't return anything.
-       *
-       * If you mutate the current object, you must return it so that it will trigger listeners.
-       */
-      update?: (current: T) => T | void;
-    });
-
-/**
- * A signal which provides a non-serializable value. It works like a computed signal, but it is
- * handled slightly differently during serdes.
- *
- * @public
- */
-export class SerializerSignalImpl<T, S> extends ComputedSignalImpl<T> {
-  constructor(container: Container | null, argQrl: QRLInternal<SerializerArg<T, S>>) {
-    super(container, argQrl as unknown as ComputeQRL<T>);
-  }
-  $didInitialize$: boolean = false;
-
-  $computeIfNeeded$(): boolean {
-    if (!(this.$flags$ & SignalFlags.INVALID)) {
-      return false;
-    }
-    throwIfQRLNotResolved(this.$computeQrl$);
-    let arg = (this.$computeQrl$ as any as QRLInternal<SerializerArg<T, S>>).resolved!;
-    if (typeof arg === 'function') {
-      arg = arg();
-    }
-    const { deserialize, initial } = arg;
-    const update = (arg as any).update as ((current: T) => T) | undefined;
-    const currentValue =
-      this.$untrackedValue$ === NEEDS_COMPUTATION ? initial : this.$untrackedValue$;
-    const untrackedValue = trackSignal(
-      () =>
-        this.$didInitialize$
-          ? update?.(currentValue as T)
-          : deserialize(currentValue as Awaited<S>),
-      this,
-      EffectProperty.VNODE,
-      this.$container$!
-    );
-    DEBUG && log('SerializerSignal.$compute$', untrackedValue);
-    const didChange =
-      (this.$didInitialize$ && untrackedValue !== 'undefined') ||
-      untrackedValue !== this.$untrackedValue$;
-    this.$flags$ &= ~SignalFlags.INVALID;
-    this.$didInitialize$ = true;
-    if (didChange) {
-      this.$untrackedValue$ = untrackedValue as T;
-    }
-    return didChange;
-  }
-}
-
-// TODO move to serializer
-export type CustomSerializable<T extends { [SerializerSymbol]: (obj: any) => any }, S> = {
-  [SerializerSymbol]: (obj: T) => S;
-};
 /** @internal */
 export const isSerializerObj = <T extends { [SerializerSymbol]: (obj: any) => any }, S>(
   obj: unknown
diff --git a/packages/qwik/src/core/signal/types.ts b/packages/qwik/src/core/signal/types.ts
@@ -6,6 +6,7 @@ import type { ReadonlySignal } from './signal.public';
 import type { TargetType } from './store';
 import type { SignalImpl } from './impl/signal-impl';
 import type { QRLInternal } from '../shared/qrl/qrl-class';
+import type { SerializerSymbol } from '../shared/utils/serialize-utils';
 
 export interface InternalReadonlySignal<T = unknown> extends ReadonlySignal<T> {
   readonly untrackedValue: T;
@@ -94,3 +95,53 @@ export const enum EffectProperty {
   COMPONENT = ':',
   VNODE = '.',
 }
+
+/** @public */
+export type SerializerArgObject<T, S> = {
+  /**
+   * This will be called with initial or serialized data to reconstruct an object. If no
+   * `initialData` is provided, it will be called with `undefined`.
+   *
+   * This must not return a Promise.
+   */
+  deserialize: (data: Awaited<S>) => T;
+  /** The initial value to use when deserializing. */
+  initial?: S | undefined;
+  /**
+   * This will be called with the object to get the serialized data. You can return a Promise if you
+   * need to do async work.
+   *
+   * The result may be anything that Qwik can serialize.
+   *
+   * If you do not provide it, the object will be serialized as `undefined`. However, if the object
+   * has a `[SerializerSymbol]` property, that will be used as the serializer instead.
+   */
+  serialize?: (obj: T) => S;
+};
+
+/**
+ * Serialize and deserialize custom objects.
+ *
+ * If you need to use scoped state, you can pass a function instead of an object. The function will
+ * be called with the current value, and you can return a new value.
+ *
+ * @public
+ */
+export type SerializerArg<T, S> =
+  | SerializerArgObject<T, S>
+  | (() => SerializerArgObject<T, S> & {
+      /**
+       * This gets called when reactive state used during `deserialize` changes. You may mutate the
+       * current object, or return a new object.
+       *
+       * If it returns a value, that will be used as the new value, and listeners will be triggered.
+       * If no change happened, don't return anything.
+       *
+       * If you mutate the current object, you must return it so that it will trigger listeners.
+       */
+      update?: (current: T) => T | void;
+    });
+
+export type CustomSerializable<T extends { [SerializerSymbol]: (obj: any) => any }, S> = {
+  [SerializerSymbol]: (obj: T) => S;
+};
diff --git a/packages/qwik/src/core/use/use-serializer.ts b/packages/qwik/src/core/use/use-serializer.ts
@@ -1,7 +1,8 @@
 import { implicit$FirstArg } from '../shared/qrl/implicit_dollar';
 import type { QRL } from '../shared/qrl/qrl.public';
 import type { ComputedSignalImpl } from '../signal/impl/computed-signal-impl';
-import { SerializerSignalImpl, type SerializerArg } from '../signal/signal';
+import { SerializerSignalImpl } from '../signal/impl/serializer-signal-impl';
+import type { SerializerArg } from '../signal/types';
 import type { createSerializer$ } from '../signal/signal.public';
 import { useComputedCommon } from './use-computed';
 
