chore(core): sync signal state with ngrx/signals

Author: nartc

libs/core/src/lib/utils/signal-state.ts

@@ -1,5 +1,6 @@
 /** ported from ngrx/signals */
-import { computed, isSignal, Signal as NgSignal, signal, untracked, WritableSignal } from '@angular/core';
+/** Last synced: 08/16/2025 */
+import { computed, isSignal, type Signal, signal, untracked, type WritableSignal } from '@angular/core';
 
 type NonRecord =
 	| Iterable<any>
@@ -20,50 +21,69 @@ type IsKnownRecord<T> = IsRecord<T> extends true ? (IsUnknownRecord<T> extends t
 
 const STATE_SOURCE = Symbol('STATE_SOURCE');
 
-type WritableStateSource<State extends object> = {
-	[STATE_SOURCE]: WritableSignal<State>;
+export type WritableStateSource<State extends object> = {
+	[STATE_SOURCE]: { [K in keyof State]: WritableSignal<State[K]> };
+};
+
+export type StateSource<State extends object> = {
+	[STATE_SOURCE]: { [K in keyof State]: Signal<State[K]> };
 };
 
 export type PartialStateUpdater<State extends object> = (state: State) => Partial<State>;
 
+function getState<State extends object>(stateSource: StateSource<State>): State {
+	const signals: Record<string | symbol, Signal<unknown>> = stateSource[STATE_SOURCE];
+	return Reflect.ownKeys(stateSource[STATE_SOURCE]).reduce((state, key) => {
+		const value = signals[key]();
+		return Object.assign(state, { [key]: value });
+	}, {} as State);
+}
+
 function patchState<State extends object>(
 	stateSource: WritableStateSource<State>,
-	...updaters: Array<Partial<Prettify<State>> | PartialStateUpdater<Prettify<State>>>
+	...updaters: Array<Partial<NoInfer<State>> | PartialStateUpdater<NoInfer<State>>>
 ): void {
-	stateSource[STATE_SOURCE].update((currentState) =>
-		updaters.reduce(
-			(nextState: State, updater) => ({
-				...nextState,
-				...(typeof updater === 'function' ? updater(nextState) : updater),
-			}),
-			currentState,
-		),
+	const currentState = untracked(() => getState(stateSource));
+	const newState = updaters.reduce(
+		(nextState: State, updater) => ({
+			...nextState,
+			...(typeof updater === 'function' ? updater(nextState) : updater),
+		}),
+		currentState,
 	);
-}
 
-// An extended Signal type that enables the correct typing
-// of nested signals with the `name` or `length` key.
-export interface Signal<T> extends NgSignal<T> {
-	name: unknown;
-	length: unknown;
+	const signals = stateSource[STATE_SOURCE];
+
+	for (const key of Reflect.ownKeys(newState)) {
+		const signalKey = key as keyof State;
+
+		if (currentState[signalKey] !== newState[signalKey]) {
+			signals[signalKey].set(newState[signalKey]);
+		}
+	}
 }
 
+const DEEP_SIGNAL = Symbol('DEEP_SIGNAL');
+
 export type DeepSignal<T> = Signal<T> &
 	(IsKnownRecord<T> extends true
 		? Readonly<{
 				[K in keyof T]: IsKnownRecord<T[K]> extends true ? DeepSignal<T[K]> : Signal<T[K]>;
 			}>
 		: unknown);
 
-function toDeepSignal<T>(signal: Signal<T>): DeepSignal<T> {
-	const value = untracked(() => signal());
-	if (!isRecord(value)) {
-		return signal as DeepSignal<T>;
-	}
-
+export function toDeepSignal<T>(signal: Signal<T>): DeepSignal<T> {
 	return new Proxy(signal, {
+		has(target: any, prop) {
+			return !!this.get!(target, prop, undefined);
+		},
 		get(target: any, prop) {
-			if (!(prop in value)) {
+			const value = untracked(target);
+			if (!isRecord(value) || !(prop in value)) {
+				if (isSignal(target[prop]) && (target[prop] as any)[DEEP_SIGNAL]) {
+					delete target[prop];
+				}
+
 				return target[prop];
 			}
 
@@ -72,6 +92,7 @@ function toDeepSignal<T>(signal: Signal<T>): DeepSignal<T> {
 					value: computed(() => target()[prop]),
 					configurable: true,
 				});
+				target[prop][DEEP_SIGNAL] = true;
 			}
 
 			return toDeepSignal(target[prop]);
@@ -112,14 +133,29 @@ export type SignalState<State extends object> = DeepSignal<State> &
 	};
 
 export function signalState<State extends object>(initialState: State): SignalState<State> {
-	const stateSource = signal(initialState as State);
-	const signalState = toDeepSignal(stateSource.asReadonly());
+	const stateKeys = Reflect.ownKeys(initialState);
+
+	const stateSource = stateKeys.reduce(
+		(signalsDict, key) =>
+			Object.assign(signalsDict, {
+				[key]: signal((initialState as Record<string | symbol, unknown>)[key]),
+			}),
+		{} as Record<string | symbol, any>,
+	);
+
+	const signalState = computed(() => stateKeys.reduce((state, key) => ({ ...state, [key]: stateSource[key]() }), {}));
 
 	Object.defineProperties(signalState, {
 		[STATE_SOURCE]: { value: stateSource },
 		update: { value: patchState.bind(null, signalState as SignalState<State>) },
-		snapshot: { get: () => untracked(stateSource) },
+		snapshot: { get: () => untracked(signalState) },
 	});
 
+	for (const key of stateKeys) {
+		Object.defineProperty(signalState, key, {
+			value: toDeepSignal(stateSource[key]),
+		});
+	}
+
 	return signalState as SignalState<State>;
 }