@angular-architects/ngrx-toolkit 19.4.0 → 19.4.2

package/src/lib/devtools/tests/naming.spec.ts

@@ -1,216 +0,0 @@
-import {
-  createEnvironmentInjector,
-  EnvironmentInjector,
-  inject,
-  runInInjectionContext,
-} from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { signalStore, withState } from '@ngrx/signals';
-import { withDisabledNameIndices } from '../features/with-disabled-name-indicies';
-import { renameDevtoolsName } from '../rename-devtools-name';
-import { withDevtools } from '../with-devtools';
-import { setupExtensions } from './helpers.spec';
-
-describe('withDevtools / renaming', () => {
-  it('should automatically index multiple instances', () => {
-    const { sendSpy } = setupExtensions();
-    const Store = signalStore(
-      { providedIn: 'root' },
-      withDevtools('flights'),
-      withState({ airline: 'Lufthansa' }),
-    );
-
-    const childContext = createEnvironmentInjector(
-      [Store],
-      TestBed.inject(EnvironmentInjector),
-    );
-
-    TestBed.inject(Store);
-    runInInjectionContext(childContext, () => inject(Store));
-
-    TestBed.flushEffects();
-
-    expect(sendSpy).lastCalledWith(
-      { type: 'Store Update' },
-      {
-        flights: { airline: 'Lufthansa' },
-        'flights-1': { airline: 'Lufthansa' },
-      },
-    );
-  });
-
-  it('not index, if multiple instances do not exist simultaneously', () => {
-    const { sendSpy } = setupExtensions();
-    const Store = signalStore(
-      withDevtools('flights'),
-      withState({ airline: 'Lufthansa' }),
-    );
-
-    const envInjector = TestBed.inject(EnvironmentInjector);
-    const childContext1 = createEnvironmentInjector([Store], envInjector);
-    const childContext2 = createEnvironmentInjector([Store], envInjector);
-
-    runInInjectionContext(childContext1, () => inject(Store));
-    TestBed.flushEffects();
-    childContext1.destroy();
-
-    expect(sendSpy.mock.calls).toEqual([
-      [
-        { type: 'Store Update' },
-        {
-          flights: { airline: 'Lufthansa' },
-        },
-      ],
-    ]);
-
-    runInInjectionContext(childContext2, () => inject(Store));
-    TestBed.flushEffects();
-    expect(sendSpy.mock.calls).toEqual([
-      [
-        { type: 'Store Update' },
-        {
-          flights: { airline: 'Lufthansa' },
-        },
-      ],
-      [
-        { type: 'Store Update' },
-        {
-          flights: { airline: 'Lufthansa' },
-        },
-      ],
-    ]);
-  });
-
-  it('should throw if automatic indexing is disabled', () => {
-    setupExtensions();
-    const Store = signalStore(
-      { providedIn: 'root' },
-      withDevtools('flights', withDisabledNameIndices()),
-      withState({ airline: 'Lufthansa' }),
-    );
-
-    const childContext = createEnvironmentInjector(
-      [Store],
-      TestBed.inject(EnvironmentInjector),
-    );
-
-    TestBed.inject(Store);
-    expect(() =>
-      runInInjectionContext(childContext, () => inject(Store)),
-    ).toThrow(
-      `An instance of the store flights already exists. \
-Enable automatic indexing via withDevTools('flights', { indexNames: true }), or rename it upon instantiation.`,
-    );
-  });
-
-  it('should index for two different stores with same devtools name', () => {
-    const { sendSpy } = setupExtensions();
-
-    TestBed.inject(
-      signalStore({ providedIn: 'root' }, withDevtools('flights')),
-    );
-    TestBed.inject(
-      signalStore({ providedIn: 'root' }, withDevtools('flights')),
-    );
-
-    TestBed.flushEffects();
-    expect(sendSpy.mock.calls).toEqual([
-      [
-        { type: 'Store Update' },
-        {
-          flights: {},
-          'flights-1': {},
-        },
-      ],
-    ]);
-  });
-
-  it('should throw for two different stores when indexing is disabled', () => {
-    setupExtensions();
-
-    TestBed.inject(
-      signalStore({ providedIn: 'root' }, withDevtools('flights')),
-    );
-    expect(() =>
-      TestBed.inject(
-        signalStore(
-          { providedIn: 'root' },
-          withDevtools('flights', withDisabledNameIndices()),
-        ),
-      ),
-    ).toThrow();
-  });
-
-  it('should not throw for two different stores if only the first one has indexing disabled', () => {
-    setupExtensions();
-
-    TestBed.inject(
-      signalStore(
-        { providedIn: 'root' },
-        withDevtools('flights', withDisabledNameIndices()),
-      ),
-    );
-    expect(() =>
-      TestBed.inject(
-        signalStore({ providedIn: 'root' }, withDevtools('flights')),
-      ),
-    ).not.toThrow();
-  });
-
-  describe('renaming', () => {
-    it('should allow to rename the store before first sync', () => {
-      const { sendSpy } = setupExtensions();
-
-      const Store = signalStore(
-        { providedIn: 'root' },
-        withState({ name: 'Product', price: 10.5 }),
-        withDevtools('flight'),
-      );
-
-      const store = TestBed.inject(Store);
-      renameDevtoolsName(store, 'flights');
-      TestBed.flushEffects();
-
-      expect(sendSpy).toHaveBeenCalledWith(
-        { type: 'Store Update' },
-        { flights: { name: 'Product', price: 10.5 } },
-      );
-    });
-
-    it('should throw on rename if name already exists', () => {
-      setupExtensions();
-      const Store1 = signalStore(
-        { providedIn: 'root' },
-        withState({ name: 'Product', price: 10.5 }),
-        withDevtools('shop'),
-      );
-
-      const Store2 = signalStore(
-        { providedIn: 'root' },
-        withState({ name: 'Product', price: 10.5 }),
-        withDevtools('mall'),
-      );
-      TestBed.inject(Store1);
-      const store = TestBed.inject(Store2);
-      TestBed.flushEffects();
-
-      expect(() => renameDevtoolsName(store, 'shop')).toThrow(
-        'NgRx Toolkit/DevTools: cannot rename from mall to shop. shop is already assigned to another SignalStore instance.',
-      );
-    });
-
-    it('should throw if applied to a SignalStore without DevTools', () => {
-      setupExtensions();
-      const Store = signalStore(
-        { providedIn: 'root' },
-        withState({ name: 'Product', price: 10.5 }),
-      );
-
-      const store = TestBed.inject(Store);
-
-      expect(() => renameDevtoolsName(store, 'shop')).toThrow(
-        "Devtools extensions haven't been added to this store.",
-      );
-    });
-  });
-});

package/src/lib/devtools/tests/provide-devtools-config.spec.ts

@@ -1,25 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { DevtoolsSyncer } from '../internal/devtools-syncer.service';
-import { provideDevtoolsConfig } from '../provide-devtools-config';
-import { setupExtensions } from './helpers.spec';
-
-describe('provideDevtoolsConfig', () => {
-  it('DevtoolsSyncer should use the default configuration if none is provided', () => {
-    const { connectSpy } = setupExtensions();
-    TestBed.inject(DevtoolsSyncer);
-    expect(connectSpy).toHaveBeenCalledWith({
-      name: 'NgRx SignalStore',
-    });
-  });
-
-  it('DevtoolsSyncer should use the configuration provided', () => {
-    const { connectSpy } = setupExtensions();
-    TestBed.configureTestingModule({
-      providers: [provideDevtoolsConfig({ name: 'test' })],
-    });
-    TestBed.inject(DevtoolsSyncer);
-    expect(connectSpy).toHaveBeenCalledWith({
-      name: 'test',
-    });
-  });
-});

package/src/lib/devtools/tests/types.spec.ts

@@ -1,19 +0,0 @@
-import { computed } from '@angular/core';
-import { patchState, signalStore, withState } from '@ngrx/signals';
-import { withDevtools } from '../with-devtools';
-
-it('should compile when signalStore is extended from', () => {
-  class CounterStore extends signalStore(
-    { protectedState: false },
-    withState({ count: 0 }),
-    withDevtools('counter-store'),
-  ) {
-    readonly myReadonlyProp = 42;
-
-    readonly doubleCount = computed(() => this.count() * 2);
-
-    increment(): void {
-      patchState(this, { count: this.count() + 1 });
-    }
-  }
-});

package/src/lib/devtools/tests/update-state.spec.ts

@@ -1,29 +0,0 @@
-import { signalStore, withMethods } from '@ngrx/signals';
-import { setAllEntities, withEntities } from '@ngrx/signals/entities';
-import { setLoaded, withCallState } from '../../with-call-state';
-import { updateState } from '../update-state';
-
-describe('updateState', () => {
-  it('should work with multiple updaters', () => {
-    interface Item {
-      id: string;
-      name: string;
-    }
-
-    signalStore(
-      withEntities<Item>(),
-      withCallState({ collection: 'items' }),
-      withMethods((store) => ({
-        loadItems() {
-          // This should not cause a type error
-          updateState(
-            store,
-            'Items loaded successfully',
-            setAllEntities([] as Item[]),
-            setLoaded('items'),
-          );
-        },
-      })),
-    );
-  });
-});

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

@@ -1,5 +0,0 @@
-describe('Devtools', () => {
-  it.todo('should group multiple patchStates (glitch-free) in one action');
-  it.todo('should allow time-travel (revert state via devtools');
-  it.todo('should clear actionNames automatically onDestroy');
-});

package/src/lib/devtools/tests/with-glitch-tracking.spec.ts

@@ -1,272 +0,0 @@
-import {
-  createEnvironmentInjector,
-  EnvironmentInjector,
-  inject,
-  runInInjectionContext,
-} from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { patchState, signalStore, withMethods, withState } from '@ngrx/signals';
-import { withGlitchTracking } from '../features/with-glitch-tracking';
-import { renameDevtoolsName } from '../rename-devtools-name';
-import { withDevtools } from '../with-devtools';
-import { setupExtensions } from './helpers.spec';
-
-describe('withGlitchTracking', () => {
-  it('should sync immediately upon instantiation', () => {
-    const { sendSpy } = setupExtensions();
-
-    const Store = signalStore(
-      { providedIn: 'root' },
-      withDevtools('counter', withGlitchTracking()),
-      withState({ count: 0 }),
-    );
-
-    expect(sendSpy).not.toHaveBeenCalled();
-    TestBed.inject(Store);
-
-    expect(sendSpy).toHaveBeenCalledWith(
-      { type: 'Store Update' },
-      { counter: { count: 0 } },
-    );
-  });
-
-  it('should sync synchronous state changes', () => {
-    const { sendSpy } = setupExtensions();
-
-    const Store = signalStore(
-      { providedIn: 'root' },
-      withState({ count: 0 }),
-      withDevtools('counter', withGlitchTracking()),
-      withMethods((store) => ({
-        increase: () =>
-          patchState(store, (value) => ({ count: value.count + 1 })),
-      })),
-    );
-
-    const store = TestBed.inject(Store);
-
-    store.increase();
-    store.increase();
-    store.increase();
-    TestBed.flushEffects();
-
-    expect(sendSpy.mock.calls).toEqual([
-      [{ type: 'Store Update' }, { counter: { count: 0 } }],
-      [{ type: 'Store Update' }, { counter: { count: 1 } }],
-      [{ type: 'Store Update' }, { counter: { count: 2 } }],
-      [{ type: 'Store Update' }, { counter: { count: 3 } }],
-    ]);
-  });
-
-  it('should support a mixed approach', () => {
-    const { sendSpy } = setupExtensions();
-
-    const GlitchFreeStore = signalStore(
-      { providedIn: 'root' },
-      withState({ count: 0 }),
-      withDevtools('glitch-free counter'),
-      withMethods((store) => ({
-        increase: () =>
-          patchState(store, (value) => ({ count: value.count + 1 })),
-      })),
-    );
-
-    const GlitchStore = signalStore(
-      { providedIn: 'root' },
-      withState({ count: 0 }),
-      withDevtools('glitch counter', withGlitchTracking()),
-      withMethods((store) => ({
-        increase: () =>
-          patchState(store, (value) => ({ count: value.count + 1 })),
-      })),
-    );
-
-    const glitchFreeStore = TestBed.inject(GlitchFreeStore);
-    const glitchStore = TestBed.inject(GlitchStore);
-
-    TestBed.flushEffects();
-    for (let i = 0; i < 2; i++) {
-      glitchFreeStore.increase();
-      glitchStore.increase();
-    }
-    TestBed.flushEffects();
-
-    expect(sendSpy.mock.calls).toEqual([
-      [{ type: 'Store Update' }, { 'glitch counter': { count: 0 } }],
-      [
-        { type: 'Store Update' },
-        { 'glitch-free counter': { count: 0 }, 'glitch counter': { count: 0 } },
-      ],
-      [
-        { type: 'Store Update' },
-        { 'glitch-free counter': { count: 0 }, 'glitch counter': { count: 1 } },
-      ],
-      [
-        { type: 'Store Update' },
-        { 'glitch-free counter': { count: 0 }, 'glitch counter': { count: 2 } },
-      ],
-      [
-        { type: 'Store Update' },
-        { 'glitch-free counter': { count: 2 }, 'glitch counter': { count: 2 } },
-      ],
-    ]);
-  });
-
-  it('two glitch stores should sync per change', () => {
-    const { sendSpy } = setupExtensions();
-
-    const GlitchStore1 = signalStore(
-      { providedIn: 'root' },
-      withState({ count: 0 }),
-      withDevtools('glitch counter 1', withGlitchTracking()),
-      withMethods((store) => ({
-        increase: () =>
-          patchState(store, (value) => ({ count: value.count + 1 })),
-      })),
-    );
-
-    const GlitchStore2 = signalStore(
-      { providedIn: 'root' },
-      withState({ count: 0 }),
-      withDevtools('glitch counter 2', withGlitchTracking()),
-      withMethods((store) => ({
-        increase: () =>
-          patchState(store, (value) => ({ count: value.count + 1 })),
-      })),
-    );
-
-    const glitchStore1 = TestBed.inject(GlitchStore1);
-    const glitchStore2 = TestBed.inject(GlitchStore2);
-
-    for (let i = 0; i < 2; i++) {
-      glitchStore1.increase();
-      glitchStore2.increase();
-    }
-    TestBed.flushEffects();
-
-    expect(sendSpy.mock.calls).toEqual([
-      [{ type: 'Store Update' }, { 'glitch counter 1': { count: 0 } }],
-      [
-        { type: 'Store Update' },
-        { 'glitch counter 1': { count: 0 }, 'glitch counter 2': { count: 0 } },
-      ],
-      [
-        { type: 'Store Update' },
-        { 'glitch counter 1': { count: 1 }, 'glitch counter 2': { count: 0 } },
-      ],
-      [
-        { type: 'Store Update' },
-        { 'glitch counter 1': { count: 1 }, 'glitch counter 2': { count: 1 } },
-      ],
-      [
-        { type: 'Store Update' },
-        { 'glitch counter 1': { count: 2 }, 'glitch counter 2': { count: 1 } },
-      ],
-      [
-        { type: 'Store Update' },
-        { 'glitch counter 1': { count: 2 }, 'glitch counter 2': { count: 2 } },
-      ],
-    ]);
-  });
-
-  it('should not sync glitch-free if glitched is renamed', () => {
-    const { sendSpy } = setupExtensions();
-
-    const GlitchFreeStore = signalStore(
-      { providedIn: 'root' },
-      withState({ name: 'Product', price: 10.5 }),
-      withDevtools('flight1'),
-    );
-
-    const GlitchStore = signalStore(
-      { providedIn: 'root' },
-      withState({ name: 'Product', price: 10.5 }),
-      withDevtools('flight2', withGlitchTracking()),
-    );
-
-    TestBed.inject(GlitchFreeStore);
-    const glitchStore = TestBed.inject(GlitchStore);
-
-    TestBed.flushEffects();
-
-    expect(sendSpy.mock.calls).toEqual([
-      [{ type: 'Store Update' }, { flight2: { name: 'Product', price: 10.5 } }],
-      [
-        { type: 'Store Update' },
-        {
-          flight1: { name: 'Product', price: 10.5 },
-          flight2: { name: 'Product', price: 10.5 },
-        },
-      ],
-    ]);
-    sendSpy.mockClear();
-
-    renameDevtoolsName(glitchStore, 'flights2');
-    TestBed.flushEffects();
-
-    expect(sendSpy.mock.calls).toEqual([
-      [
-        { type: 'Store Update' },
-        {
-          flight1: { name: 'Product', price: 10.5 },
-          flights2: { name: 'Product', price: 10.5 },
-        },
-      ],
-    ]);
-  });
-
-  it('should not sync glitch tracker if glitch-free store is renamed', () => {
-    const { sendSpy } = setupExtensions();
-
-    const GlitchFreeStore = signalStore(
-      { providedIn: 'root' },
-      withState({ name: 'Product', price: 10.5 }),
-      withDevtools('flight1'),
-    );
-
-    const GlitchStore = signalStore(
-      { providedIn: 'root' },
-      withState({ name: 'Product', price: 10.5 }),
-      withDevtools('glitched Flights', withGlitchTracking()),
-    );
-
-    const glitchFreeStore = TestBed.inject(GlitchFreeStore);
-    TestBed.inject(GlitchStore);
-    TestBed.flushEffects();
-
-    sendSpy.mockClear();
-    renameDevtoolsName(glitchFreeStore, 'glitch-free Flights');
-    expect(sendSpy).not.toHaveBeenCalled();
-    TestBed.flushEffects();
-
-    expect(sendSpy.mock.calls).toEqual([
-      [
-        { type: 'Store Update' },
-        {
-          'glitch-free Flights': { name: 'Product', price: 10.5 },
-          'glitched Flights': { name: 'Product', price: 10.5 },
-        },
-      ],
-    ]);
-  });
-
-  it('should destroy watcher if store is destroyed', () => {
-    const { sendSpy } = setupExtensions();
-
-    const GlitchStore = signalStore(
-      withState({ name: 'Product', price: 10.5 }),
-      withDevtools('Glitched Store', withGlitchTracking()),
-    );
-
-    const childContext = createEnvironmentInjector(
-      [GlitchStore],
-      TestBed.inject(EnvironmentInjector),
-    );
-    runInInjectionContext(childContext, () => inject(GlitchStore));
-
-    expect(sendSpy).toHaveBeenCalled();
-    sendSpy.mockClear();
-    childContext.destroy();
-    expect(sendSpy).toHaveBeenCalledWith({ type: 'Store Update' }, {});
-  });
-});

package/src/lib/devtools/tests/with-mapper.spec.ts

@@ -1,69 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { signalStore, withState } from '@ngrx/signals';
-import { withMapper } from '../features/with-mapper';
-import { withDevtools } from '../with-devtools';
-import { setupExtensions } from './helpers.spec';
-
-function domRemover(state: Record<string, unknown>) {
-  return Object.keys(state).reduce((acc, key) => {
-    const value = state[key];
-
-    if (value instanceof HTMLElement) {
-      return acc;
-    } else {
-      return { ...acc, [key]: value };
-    }
-  }, {});
-}
-
-describe('with-mapper', () => {
-  it('should remove DOM Nodes', () => {
-    const { sendSpy } = setupExtensions();
-
-    const Store = signalStore(
-      { providedIn: 'root' },
-      withState({
-        name: 'Car',
-        carElement: document.createElement('div'),
-      }),
-      withDevtools('shop', withMapper(domRemover)),
-    );
-
-    TestBed.inject(Store);
-    TestBed.flushEffects();
-    expect(sendSpy).toHaveBeenCalledWith(
-      { type: 'Store Update' },
-      { shop: { name: 'Car' } },
-    );
-  });
-
-  it('should every property ending with *Key', () => {
-    const { sendSpy } = setupExtensions();
-    const Store = signalStore(
-      { providedIn: 'root' },
-      withState({
-        name: 'Car',
-        unlockKey: '1234',
-      }),
-      withDevtools(
-        'shop',
-        withMapper((state: Record<string, unknown>) =>
-          Object.keys(state).reduce((acc, key) => {
-            if (key.endsWith('Key')) {
-              return acc;
-            } else {
-              return { ...acc, [key]: state[key] };
-            }
-          }, {}),
-        ),
-      ),
-    );
-
-    TestBed.inject(Store);
-    TestBed.flushEffects();
-    expect(sendSpy).toHaveBeenCalledWith(
-      { type: 'Store Update' },
-      { shop: { name: 'Car' } },
-    );
-  });
-});

package/src/lib/devtools/update-state.ts

@@ -1,38 +0,0 @@
-import {
-  patchState as originalPatchState,
-  PartialStateUpdater,
-  WritableStateSource,
-} from '@ngrx/signals';
-import { currentActionNames } from './internal/current-action-names';
-
-type PatchFn = typeof originalPatchState extends (
-  arg1: infer First,
-  ...args: infer Rest
-) => infer Returner
-  ? (state: First, action: string, ...rest: Rest) => Returner
-  : never;
-
-/**
- * @deprecated Has been renamed to `updateState`
- */
-export const patchState: PatchFn = (state, action, ...rest) => {
-  updateState(state, action, ...rest);
-};
-
-/**
- * Wrapper of `patchState` for DevTools integration. Next to updating the state,
- * it also sends the action to the DevTools.
- * @param stateSource state of Signal Store
- * @param action name of action how it will show in DevTools
- * @param updaters updater functions or objects
- */
-export function updateState<State extends object>(
-  stateSource: WritableStateSource<State>,
-  action: string,
-  ...updaters: Array<
-    Partial<NoInfer<State>> | PartialStateUpdater<NoInfer<State>>
-  >
-): void {
-  currentActionNames.add(action);
-  return originalPatchState(stateSource, ...updaters);
-}