@angular-architects/ngrx-toolkit 19.4.0 → 19.4.2

package/src/lib/devtools/with-devtools.ts

@@ -1,81 +0,0 @@
-import { inject, InjectionToken } from '@angular/core';
-import {
-  EmptyFeatureResult,
-  SignalStoreFeature,
-  signalStoreFeature,
-  withHooks,
-  withMethods,
-} from '@ngrx/signals';
-import { DefaultTracker } from './internal/default-tracker';
-import {
-  DevtoolsFeature,
-  DevtoolsInnerOptions,
-} from './internal/devtools-feature';
-import { DevtoolsSyncer } from './internal/devtools-syncer.service';
-import { ReduxDevtoolsExtension } from './internal/models';
-
-declare global {
-  interface Window {
-    __REDUX_DEVTOOLS_EXTENSION__: ReduxDevtoolsExtension | undefined;
-  }
-}
-
-export const renameDevtoolsMethodName = '___renameDevtoolsName';
-export const uniqueDevtoolsId = '___uniqueDevtoolsId';
-
-const EXISTING_NAMES = new InjectionToken(
-  'Array contain existing names for the signal stores',
-  { factory: () => [] as string[], providedIn: 'root' },
-);
-
-/**
- * Adds this store as a feature state to the Redux DevTools.
- *
- * By default, the action name is 'Store Update'. You can
- * change that via the {@link updateState} method, which has as second
- * parameter the action name.
- *
- * The standalone function {@link renameDevtoolsName} can rename
- * the store name.
- *
- * @param name name of the store as it should appear in the DevTools
- * @param features features to extend or modify the behavior of the Devtools
- */
-export function withDevtools(name: string, ...features: DevtoolsFeature[]) {
-  return signalStoreFeature(
-    withMethods(() => {
-      const syncer = inject(DevtoolsSyncer);
-
-      const id = syncer.getNextId();
-
-      // TODO: use withProps and symbols
-      return {
-        [renameDevtoolsMethodName]: (newName: string) => {
-          syncer.renameStore(name, newName);
-        },
-        [uniqueDevtoolsId]: () => id,
-      } as Record<string, (newName?: unknown) => unknown>;
-    }),
-    withHooks((store) => {
-      const syncer = inject(DevtoolsSyncer);
-      const id = String(store[uniqueDevtoolsId]());
-      return {
-        onInit() {
-          const id = String(store[uniqueDevtoolsId]());
-          const finalOptions: DevtoolsInnerOptions = {
-            indexNames: !features.some((f) => f.indexNames === false),
-            map: features.find((f) => f.map)?.map ?? ((state) => state),
-            tracker: inject(
-              features.find((f) => f.tracker)?.tracker || DefaultTracker,
-            ),
-          };
-
-          syncer.addStore(id, name, store, finalOptions);
-        },
-        onDestroy() {
-          syncer.removeStore(id);
-        },
-      };
-    }),
-  ) as SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult>;
-}

package/src/lib/flattening-operator.ts

@@ -1,42 +0,0 @@
-import {
-  concatMap,
-  exhaustMap,
-  mergeMap,
-  ObservableInput,
-  ObservedValueOf,
-  OperatorFunction,
-  switchMap,
-} from 'rxjs';
-
-export type RxJsFlatteningOperator = <T, O extends ObservableInput<unknown>>(
-  project: (value: T, index: number) => O,
-) => OperatorFunction<T, ObservedValueOf<O>>;
-
-/**
- * A wrapper for an RxJS flattening operator.
- * This wrapper informs about whether the operator has exhaust semantics or not.
- */
-export type FlatteningOperator = {
-  rxJsOperator: RxJsFlatteningOperator;
-  exhaustSemantics: boolean;
-};
-
-export const switchOp: FlatteningOperator = {
-  rxJsOperator: switchMap,
-  exhaustSemantics: false,
-};
-
-export const mergeOp: FlatteningOperator = {
-  rxJsOperator: mergeMap,
-  exhaustSemantics: false,
-};
-
-export const concatOp: FlatteningOperator = {
-  rxJsOperator: concatMap,
-  exhaustSemantics: false,
-};
-
-export const exhaustOp: FlatteningOperator = {
-  rxJsOperator: exhaustMap,
-  exhaustSemantics: true,
-};

package/src/lib/immutable-state/deep-freeze.ts

@@ -1,43 +0,0 @@
-/**
- * Deep freezes a state object along its properties with primitive values
- * on the first level.
- *
- * The reason for this is that the final state is a merge of all
- * root properties of all states, i.e. `withState`,....
- *
- * Since the root object will not be part of the state (shadow clone),
- * we are not freezing it.
- */
-
-export function deepFreeze<T extends Record<string | symbol, unknown>>(
-  target: T,
-  // if empty all properties will be frozen
-  propertyNamesToBeFrozen: (string | symbol)[],
-  // also means that we are on the first level
-  isRoot = true,
-): void {
-  const runPropertyNameCheck = propertyNamesToBeFrozen.length > 0;
-  for (const key of Reflect.ownKeys(target)) {
-    if (runPropertyNameCheck && !propertyNamesToBeFrozen.includes(key)) {
-      continue;
-    }
-
-    const propValue = target[key];
-    if (isRecordLike(propValue) && !Object.isFrozen(propValue)) {
-      Object.freeze(propValue);
-      deepFreeze(propValue, [], false);
-    } else if (isRoot) {
-      Object.defineProperty(target, key, {
-        value: propValue,
-        writable: false,
-        configurable: false,
-      });
-    }
-  }
-}
-
-function isRecordLike(
-  target: unknown,
-): target is Record<string | symbol, unknown> {
-  return typeof target === 'object' && target !== null;
-}

package/src/lib/immutable-state/is-dev-mode.ts

@@ -1,6 +0,0 @@
-import { isDevMode as ngIsInDevMode } from '@angular/core';
-
-// necessary wrapper function to test prod mode
-export function isDevMode() {
-  return ngIsInDevMode();
-}

package/src/lib/immutable-state/tests/with-immutable-state.spec.ts

@@ -1,260 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { getState, patchState, signalStore, withState } from '@ngrx/signals';
-import * as devMode from '../is-dev-mode';
-import { withImmutableState } from '../with-immutable-state';
-
-describe('withImmutableState', () => {
-  const SECRET = Symbol('secret');
-
-  const createInitialState = () => ({
-    user: {
-      firstName: 'John',
-      lastName: 'Smith',
-    },
-    foo: 'bar',
-    numbers: [1, 2, 3],
-    ngrx: 'signals',
-    nestedSymbol: {
-      [SECRET]: 'another secret',
-    },
-    [SECRET]: {
-      code: 'secret',
-      value: '123',
-    },
-  });
-
-  const createStore = (enableInProduction: boolean | undefined) => {
-    const initialState = createInitialState();
-    const Store = signalStore(
-      { protectedState: false },
-      enableInProduction === undefined
-        ? withImmutableState(initialState)
-        : withImmutableState(initialState, { enableInProduction }),
-    );
-    return TestBed.configureTestingModule({ providers: [Store] }).inject(Store);
-  };
-
-  for (const isDevMode of [true, false]) {
-    describe(isDevMode ? 'dev mode' : 'production mode', () => {
-      beforeEach(() => {
-        jest.spyOn(devMode, 'isDevMode').mockReturnValue(isDevMode);
-      });
-      for (const { stateFactory, enableInProduction, name, protectionOn } of [
-        {
-          name: 'dev-only protection',
-          stateFactory: () => createStore(false),
-          enableInProduction: false,
-          protectionOn: isDevMode,
-        },
-        {
-          name: 'production protection',
-          enableInProduction: true,
-          stateFactory: () => createStore(true),
-          protectionOn: true,
-        },
-        {
-          name: 'default settings',
-          enableInProduction: undefined,
-          stateFactory: () => createStore(undefined),
-          protectionOn: isDevMode,
-        },
-      ]) {
-        describe(name, () => {
-          it(`throws ${protectionOn ? '' : 'not '}on a mutable change`, () => {
-            const state = stateFactory();
-
-            const patch = () =>
-              patchState(state, (state) => {
-                state.ngrx = 'mutable change';
-                return state;
-              });
-
-            if (protectionOn) {
-              expect(patch).toThrowError(
-                "Cannot assign to read only property 'ngrx' of object",
-              );
-            } else {
-              expect(patch).not.toThrowError();
-            }
-          });
-
-          it(`throws ${
-            protectionOn ? '' : 'not '
-          }on a nested mutable change`, () => {
-            const state = stateFactory();
-
-            const patch = () =>
-              patchState(state, (state) => {
-                state.user.firstName = 'mutable change';
-                return state;
-              });
-
-            if (protectionOn) {
-              expect(patch).toThrowError(
-                "Cannot assign to read only property 'firstName' of object",
-              );
-            } else {
-              expect(patch).not.toThrowError();
-            }
-          });
-
-          describe('mutable changes outside of patchState', () => {
-            it(`throws${
-              protectionOn ? '' : ' not'
-            } on reassigned a property of the exposed state`, () => {
-              const state = stateFactory();
-              const patch = () => {
-                state.user().firstName = 'mutable change 1';
-              };
-              if (protectionOn) {
-                expect(patch).toThrowError(
-                  "Cannot assign to read only property 'firstName' of object",
-                );
-              } else {
-                expect(patch).not.toThrowError();
-              }
-            });
-
-            it(`throws ${
-              protectionOn ? '' : 'not '
-            }when exposed state via getState is mutated`, () => {
-              const state = stateFactory();
-              const s = getState(state);
-
-              const patch = () => (s.ngrx = 'mutable change 2');
-
-              if (protectionOn) {
-                expect(patch).toThrowError(
-                  "Cannot assign to read only property 'ngrx' of object",
-                );
-              } else {
-                expect(patch).not.toThrowError();
-              }
-            });
-
-            it(`throws ${
-              protectionOn ? '' : 'not '
-            }when mutable change happens`, () => {
-              const state = stateFactory();
-              const s = { user: { firstName: 'M', lastName: 'S' } };
-              patchState(state, s);
-              const patch = () => {
-                s.user.firstName = 'mutable change 3';
-              };
-              if (protectionOn) {
-                expect(patch).toThrowError(
-                  "Cannot assign to read only property 'firstName' of object",
-                );
-              } else {
-                expect(patch).not.toThrowError();
-              }
-            });
-
-            it(`throws ${
-              protectionOn ? '' : 'not '
-            }when mutable change of root symbol property happens`, () => {
-              const state = stateFactory();
-              const s = getState(state);
-
-              const patch = () => {
-                s[SECRET].code = 'mutable change';
-              };
-
-              if (protectionOn) {
-                expect(patch).toThrowError(
-                  "Cannot assign to read only property 'code' of object",
-                );
-              } else {
-                expect(patch).not.toThrowError();
-              }
-            });
-
-            it(`throws ${
-              protectionOn ? '' : 'not '
-            }when mutable change of nested symbol property happens`, () => {
-              const state = stateFactory();
-              const s = getState(state);
-
-              const patch = () => {
-                s.nestedSymbol[SECRET] = 'mutable change';
-              };
-
-              if (protectionOn) {
-                expect(patch).toThrowError(
-                  "Cannot assign to read only property 'Symbol(secret)' of object",
-                );
-              } else {
-                expect(patch).not.toThrowError();
-              }
-            });
-          });
-
-          describe('special tests', () => {
-            for (const { name, mutationFn } of [
-              {
-                name: 'location',
-                mutationFn: (state: { location: { city: string } }) =>
-                  (state.location.city = 'Paris'),
-              },
-              {
-                name: 'user',
-                mutationFn: (state: { user: { firstName: string } }) =>
-                  (state.user.firstName = 'Jane'),
-              },
-            ]) {
-              it(`throws ${
-                protectionOn ? '' : 'not '
-              }on concatenated state (${name})`, () => {
-                const UserStore = signalStore(
-                  { providedIn: 'root' },
-                  withImmutableState(createInitialState(), {
-                    enableInProduction,
-                  }),
-                  withImmutableState(
-                    { location: { city: 'London' } },
-                    { enableInProduction },
-                  ),
-                );
-                const store = TestBed.inject(UserStore);
-                const state = getState(store);
-
-                if (protectionOn) {
-                  expect(() => mutationFn(state)).toThrowError();
-                } else {
-                  expect(() => mutationFn(state)).not.toThrowError();
-                }
-              });
-            }
-          });
-
-          it('should be possible to mix both mutable and immutable state', () => {
-            const immutableState = {
-              id: 1,
-              name: 'John',
-            };
-
-            const mutableState = {
-              address: 'London',
-            };
-            const TestStore = signalStore(
-              { providedIn: 'root', protectedState: false },
-              withImmutableState(immutableState, { enableInProduction }),
-              withState(mutableState),
-            );
-
-            TestBed.inject(TestStore);
-
-            if (protectionOn) {
-              expect(() => (immutableState.name = 'Jane')).toThrow();
-            } else {
-              expect(() => (immutableState.name = 'Jane')).not.toThrow();
-            }
-            expect(
-              () => (mutableState.address = 'Glastonbury'),
-            ).not.toThrowError();
-          });
-        });
-      }
-    });
-  }
-});

package/src/lib/immutable-state/with-immutable-state.ts

@@ -1,115 +0,0 @@
-import {
-  EmptyFeatureResult,
-  signalStoreFeature,
-  SignalStoreFeature,
-  SignalStoreFeatureResult,
-  watchState,
-  withHooks,
-  withState,
-} from '@ngrx/signals';
-import { deepFreeze } from './deep-freeze';
-import { isDevMode } from './is-dev-mode';
-
-/**
- * The implementation of this feature is a little bit tricky.
- *
- * `signalStore` does a shallow clone in the initial phase, in order to
- * merge all different states together.
- *
- * Shallow cloning also happens in `patchState`.
- *
- * With shallow cloning, the root state object is replaced, which means,
- * the freezing only stays for its nested properties but not for
- * the primitive and immediate properties.
- *
- * For example:
- *
- * ```ts
- * const state = {
- *   id: 1,
- *   address: {
- *     street: 'Main St',
- *     city: 'Springfield',
- *   }
- * }
- * ```
- *
- * Running `Object.freeze` on `state` will freeze the `address` object, and
- * the `id`. But since `state` is shallow cloned, the "frozing" state of the
- * `id` is lost. `address`, being an object, is still frozen.
- *
- * To overcome that, we run `watchState` and run `deepFreeze`
- * on every change.
- */
-
-/**
- * Prevents mutation of the state.
- *
- * This is done by deeply applying `Object.freeze`. Any mutable change within
- * or outside the `SignalStore` will throw an error.
- *
- * @param state the state object
- * @param options enable protection in production (default: false)
- */
-export function withImmutableState<State extends object>(
-  state: State,
-  options?: { enableInProduction?: boolean },
-): SignalStoreFeature<
-  SignalStoreFeatureResult,
-  EmptyFeatureResult & { state: State }
->;
-/**
- * Prevents mutation of the state.
- *
- * This is done by deeply applying `Object.freeze`. Any mutable change within
- * or outside the `SignalStore` will throw an error.
- *
- * @param stateFactory a function returning the state object
- * @param options enable protection in production (default: false)
- */
-export function withImmutableState<State extends object>(
-  stateFactory: () => State,
-  options?: { enableInProduction?: boolean },
-): SignalStoreFeature<
-  SignalStoreFeatureResult,
-  EmptyFeatureResult & { state: State }
->;
-export function withImmutableState<State extends object>(
-  stateOrFactory: State | (() => State),
-  options?: { enableInProduction?: boolean },
-): SignalStoreFeature<
-  SignalStoreFeatureResult,
-  EmptyFeatureResult & { state: State }
-> {
-  const immutableState =
-    typeof stateOrFactory === 'function' ? stateOrFactory() : stateOrFactory;
-  const stateKeys = Reflect.ownKeys(immutableState);
-
-  const applyFreezing = isDevMode() || options?.enableInProduction === true;
-  return signalStoreFeature(
-    withState(immutableState),
-    withHooks((store) => ({
-      onInit() {
-        if (!applyFreezing) {
-          return;
-        }
-        /**
-         * `immutableState` will be initially frozen. That is because
-         * of potential mutations outside the SignalStore
-         *
-         * ```ts
-         * const initialState = {id: 1};
-         * signalStore(withImmutableState(initialState));
-         *
-         * initialState.id = 2; // must throw immutability
-         * ```
-         */
-
-        Object.freeze(immutableState);
-        watchState(store, (state) => {
-          deepFreeze(state, stateKeys);
-        });
-      },
-    })),
-  );
-}