@angular-architects/ngrx-toolkit 18.1.0 → 19.0.0

package/fesm2022/angular-architects-ngrx-toolkit.mjs

@@ -1,80 +1,428 @@
-import { patchState as patchState$1, signalStoreFeature, withState, withComputed, withMethods, withHooks, getState } from '@ngrx/signals';
-import { signal, effect, inject, PLATFORM_ID, computed, isSignal, untracked } from '@angular/core';
-import { isPlatformServer } from '@angular/common';
+import { getState, signalStoreFeature, withMethods, withHooks, watchState, patchState as patchState$1, withState, withComputed, withProps } from '@ngrx/signals';
+import * as i0 from '@angular/core';
+import { inject, PLATFORM_ID, Injectable, signal, effect, computed, isSignal, untracked } from '@angular/core';
+import { isPlatformBrowser, isPlatformServer } from '@angular/common';
 import { Subject } from 'rxjs';
 import { setAllEntities, addEntity, updateEntity, removeEntity } from '@ngrx/signals/entities';
 
-const storeRegistry = signal({});
-let currentActionNames = new Set();
-let synchronizationInitialized = false;
-function initSynchronization() {
-    effect(() => {
-        if (!connection) {
+/**
+ * Stub for DevTools integration. Can be used to disable DevTools in production.
+ */
+const withDevToolsStub = () => (store) => store;
+
+const currentActionNames = new Set();
+
+function throwIfNull(obj) {
+    if (obj === null || obj === undefined) {
+        throw new Error('');
+    }
+    return obj;
+}
+
+const dummyConnection = {
+    send: () => void true,
+};
+/**
+ * A service provided by the root injector is
+ * required because the synchronization runs
+ * globally.
+ *
+ * The SignalStore could be provided in a component.
+ * If the effect starts in the injection
+ * context of the SignalStore, the complete sync
+ * process would shut down once the component gets
+ * destroyed.
+ */
+class DevtoolsSyncer {
+    /**
+     * Stores all SignalStores that are connected to the
+     * DevTools along their options, names and id.
+     */
+    #stores = {};
+    #isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    #trackers = [];
+    /**
+     * Maintains the current states of all stores to avoid conflicts
+     * between glitch-free and glitched trackers when used simultaneously.
+     *
+     * The challenge lies in ensuring that glitched trackers do not
+     * interfere with the synchronization process of glitch-free trackers.
+     * Specifically, glitched trackers could cause the synchronization to
+     * read the current state of stores managed by glitch-free trackers.
+     *
+     * Therefore, the synchronization process doesn't read the state from
+     * each store, but relies on #currentState.
+     *
+     * Please note, that here the key is the name and not the id.
+     */
+    #currentState = {};
+    #currentId = 1;
+    #connection = this.#isBrowser
+        ? window.__REDUX_DEVTOOLS_EXTENSION__
+            ? window.__REDUX_DEVTOOLS_EXTENSION__.connect({
+                name: 'NgRx SignalStore',
+            })
+            : dummyConnection
+        : dummyConnection;
+    constructor() {
+        if (!this.#isBrowser) {
             return;
         }
-        const stores = storeRegistry();
-        const rootState = {};
-        for (const name in stores) {
-            const store = stores[name];
-            rootState[name] = store();
+        const isToolkitAvailable = Boolean(window.__REDUX_DEVTOOLS_EXTENSION__);
+        if (!isToolkitAvailable) {
+            throw new Error('NgRx Toolkit/DevTools: Redux DevTools Extension is not available.');
         }
+    }
+    ngOnDestroy() {
+        currentActionNames.clear();
+    }
+    syncToDevTools(changedStatePerId) {
+        const mappedChangedStatePerName = Object.entries(changedStatePerId).reduce((acc, [id, store]) => {
+            const { options, name } = this.#stores[id];
+            acc[name] = options.map(store);
+            return acc;
+        }, {});
+        this.#currentState = {
+            ...this.#currentState,
+            ...mappedChangedStatePerName,
+        };
         const names = Array.from(currentActionNames);
         const type = names.length ? names.join(', ') : 'Store Update';
-        currentActionNames = new Set();
-        connection.send({ type }, rootState);
-    });
+        currentActionNames.clear();
+        this.#connection.send({ type }, this.#currentState);
+    }
+    getNextId() {
+        return String(this.#currentId++);
+    }
+    /**
+     * Consumer provides the id. That is because we can only start
+     * tracking the store in the init hook.
+     * Unfortunately, methods for renaming having the final id
+     * need to be defined already before.
+     * That's why `withDevtools` requests first the id and
+     * then registers itself later.
+     */
+    addStore(id, name, store, options) {
+        let storeName = name;
+        const names = Object.values(this.#stores).map((store) => store.name);
+        if (names.includes(storeName)) {
+            const { options } = throwIfNull(Object.values(this.#stores).find((store) => store.name === storeName));
+            if (!options.indexNames) {
+                throw new Error(`An instance of the store ${storeName} already exists. \
+Enable automatic indexing via withDevTools('${storeName}', { indexNames: true }), or rename it upon instantiation.`);
+            }
+        }
+        for (let i = 1; names.includes(storeName); i++) {
+            storeName = `${name}-${i}`;
+        }
+        this.#stores[id] = { name: storeName, options };
+        const tracker = options.tracker;
+        if (!this.#trackers.includes(tracker)) {
+            this.#trackers.push(tracker);
+        }
+        tracker.onChange((changedState) => this.syncToDevTools(changedState));
+        tracker.track(id, store);
+    }
+    removeStore(id) {
+        const name = this.#stores[id].name;
+        this.#stores = Object.entries(this.#stores).reduce((newStore, [storeId, value]) => {
+            if (storeId !== id) {
+                newStore[storeId] = value;
+            }
+            return newStore;
+        }, {});
+        this.#currentState = Object.entries(this.#currentState).reduce((newState, [storeName, state]) => {
+            if (storeName !== name) {
+                newState[name] = state;
+            }
+            return newState;
+        }, {});
+        for (const tracker of this.#trackers) {
+            tracker.removeStore(id);
+        }
+    }
+    renameStore(oldName, newName) {
+        const storeNames = Object.values(this.#stores).map((store) => store.name);
+        const id = throwIfNull(Object.keys(this.#stores).find((id) => this.#stores[id].name === oldName));
+        if (storeNames.includes(newName)) {
+            throw new Error(`NgRx Toolkit/DevTools: cannot rename from ${oldName} to ${newName}. ${newName} is already assigned to another SignalStore instance.`);
+        }
+        this.#stores = Object.entries(this.#stores).reduce((newStore, [id, value]) => {
+            if (value.name === oldName) {
+                newStore[id] = { ...value, name: newName };
+            }
+            else {
+                newStore[id] = value;
+            }
+            return newStore;
+        }, {});
+        // we don't rename in #currentState but wait for tracker to notify
+        // us with a changed state that contains that name.
+        this.#currentState = Object.entries(this.#currentState).reduce((newState, [storeName, state]) => {
+            if (storeName !== oldName) {
+                newState[storeName] = state;
+            }
+            return newState;
+        }, {});
+        this.#trackers.forEach((tracker) => tracker.notifyRenamedStore(id));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DevtoolsSyncer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DevtoolsSyncer, providedIn: 'root' }); }
 }
-function getValueFromSymbol(obj, symbol) {
-    if (typeof obj === 'object' && obj && symbol in obj) {
-        return obj[symbol];
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DevtoolsSyncer, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class DefaultTracker {
+    #stores = signal({});
+    get stores() {
+        return this.#stores();
     }
+    #trackCallback;
+    #trackingEffect = effect(() => {
+        if (this.#trackCallback === undefined) {
+            throw new Error('no callback function defined');
+        }
+        const stores = this.#stores();
+        const fullState = Object.entries(stores).reduce((acc, [id, store]) => {
+            return { ...acc, [id]: getState(store) };
+        }, {});
+        this.#trackCallback(fullState);
+    });
+    track(id, store) {
+        this.#stores.update((value) => ({
+            ...value,
+            [id]: store,
+        }));
+    }
+    onChange(callback) {
+        this.#trackCallback = callback;
+    }
+    removeStore(id) {
+        this.#stores.update((stores) => Object.entries(stores).reduce((newStore, [storeId, state]) => {
+            if (storeId !== id) {
+                newStore[storeId] = state;
+            }
+            return newStore;
+        }, {}));
+    }
+    notifyRenamedStore(id) {
+        if (this.#stores()[id]) {
+            this.#stores.update((stores) => {
+                return { ...stores };
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DefaultTracker, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DefaultTracker, providedIn: 'root' }); }
 }
-function getStoreSignal(store) {
-    const [signalStateKey] = Object.getOwnPropertySymbols(store);
-    if (!signalStateKey) {
-        throw new Error('Cannot find State Signal');
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DefaultTracker, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const existingNames = new Map();
+const renameDevtoolsMethodName = '___renameDevtoolsName';
+const uniqueDevtoolsId = '___uniqueDevtoolsId';
+/**
+ * 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
+ */
+function withDevtools(name, ...features) {
+    if (existingNames.has(name)) {
+        throw new Error(`The store "${name}" has already been registered in the DevTools. Duplicate registration is not allowed.`);
     }
-    return getValueFromSymbol(store, signalStateKey);
+    existingNames.set(name, true);
+    return signalStoreFeature(withMethods(() => {
+        const syncer = inject(DevtoolsSyncer);
+        const id = syncer.getNextId();
+        // TODO: use withProps and symbols
+        return {
+            [renameDevtoolsMethodName]: (newName) => {
+                syncer.renameStore(name, newName);
+            },
+            [uniqueDevtoolsId]: () => id,
+        };
+    }), withHooks((store) => {
+        const syncer = inject(DevtoolsSyncer);
+        const id = String(store[uniqueDevtoolsId]());
+        return {
+            onInit() {
+                const id = String(store[uniqueDevtoolsId]());
+                const finalOptions = {
+                    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);
+            },
+        };
+    }));
+}
+
+const DEVTOOLS_FEATURE = Symbol('DEVTOOLS_FEATURE');
+function createDevtoolsFeature(options) {
+    return {
+        [DEVTOOLS_FEATURE]: true,
+        ...options,
+    };
+}
+
+/**
+ * If multiple instances of the same SignalStore class
+ * exist, their devtool names are indexed.
+ *
+ * For example:
+ *
+ * ```typescript
+ * const Store = signalStore(
+ *   withDevtools('flights')
+ * )
+ *
+ * const store1 = new Store(); // will show up as 'flights'
+ * const store2 = new Store(); // will show up as 'flights-1'
+ * ```
+ *
+ * With adding `withDisabledNameIndices` to the store:
+ * ```typescript
+ * const Store = signalStore(
+ *   withDevtools('flights', withDisabledNameIndices())
+ * )
+ *
+ * const store1 = new Store(); // will show up as 'flights'
+ * const store2 = new Store(); //💥 throws an error
+ * ```
+ *
+ */
+function withDisabledNameIndices() {
+    return createDevtoolsFeature({ indexNames: false });
 }
-let connection;
+
 /**
- * required for testing. is not exported during build
+ * Allows you to define a function to map the state.
+ *
+ * It is needed for huge states, that slows down the Devtools and where
+ * you don't need to see the whole state or other reasons.
+ *
+ * Example:
+ *
+ * ```typescript
+ * const initialState = {
+ *   id: 1,
+ *   email: 'john.list@host.com',
+ *   name: 'John List',
+ *   enteredPassword: ''
+ * }
+ *
+ * const Store = signalStore(
+ *   withState(initialState),
+ *   withDevtools(
+ *     'user',
+ *     withMapper(state => ({...state, enteredPassword: '***' }))
+ *   )
+ * )
+ * ```
+ *
+ * @param map function which maps the state
  */
-function reset() {
-    connection = undefined;
-    synchronizationInitialized = false;
-    storeRegistry.set({});
+function withMapper(map) {
+    return createDevtoolsFeature({ map: map });
 }
+
 /**
- * @param name store's name as it should appear in the DevTools
+ * Internal Service used by {@link withGlitchTracking}. It does not rely
+ * on `effect` as {@link DefaultTracker} does but uses the NgRx function
+ * `watchState` to track all state changes.
  */
-function withDevtools(name) {
-    return (store) => {
-        const isServer = isPlatformServer(inject(PLATFORM_ID));
-        if (isServer) {
-            return store;
-        }
-        const extensions = window.__REDUX_DEVTOOLS_EXTENSION__;
-        if (!extensions) {
-            return store;
-        }
-        if (!connection) {
-            connection = extensions.connect({
-                name: 'NgRx Signal Store',
-            });
-        }
-        const storeSignal = getStoreSignal(store);
-        storeRegistry.update((value) => ({
-            ...value,
-            [name]: storeSignal,
-        }));
-        if (!synchronizationInitialized) {
-            initSynchronization();
-            synchronizationInitialized = true;
+class GlitchTrackerService {
+    #stores = {};
+    #callback;
+    get stores() {
+        return Object.entries(this.#stores).reduce((acc, [id, { store }]) => {
+            acc[id] = store;
+            return acc;
+        }, {});
+    }
+    onChange(callback) {
+        this.#callback = callback;
+    }
+    removeStore(id) {
+        this.#stores = Object.entries(this.#stores).reduce((newStore, [storeId, value]) => {
+            if (storeId !== id) {
+                newStore[storeId] = value;
+            }
+            else {
+                value.destroyWatcher();
+            }
+            return newStore;
+        }, {});
+        throwIfNull(this.#callback)({});
+    }
+    track(id, store) {
+        const watcher = watchState(store, (state) => {
+            throwIfNull(this.#callback)({ [id]: state });
+        });
+        this.#stores[id] = { destroyWatcher: watcher.destroy, store };
+    }
+    notifyRenamedStore(id) {
+        if (Object.keys(this.#stores).includes(id) && this.#callback) {
+            this.#callback({ [id]: getState(this.#stores[id].store) });
         }
-        return store;
-    };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: GlitchTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: GlitchTrackerService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: GlitchTrackerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * It tracks all state changes of the State, including intermediary updates
+ * that are typically suppressed by Angular's glitch-free mechanism.
+ *
+ * This feature is especially useful for debugging.
+ *
+ * Example:
+ *
+ * ```typescript
+ * const Store = signalStore(
+ *   { providedIn: 'root' },
+ *   withState({ count: 0 }),
+ *   withDevtools('counter', withGlitchTracking()),
+ *   withMethods((store) => ({
+ *     increase: () =>
+ *       patchState(store, (value) => ({ count: value.count + 1 })),
+ *   }))
+ * );
+ *
+ * // would show up in the DevTools with value 0
+ * const store = inject(Store);
+ *
+ * store.increase(); // would show up in the DevTools with value 1
+ * store.increase(); // would show up in the DevTools with value 2
+ * store.increase(); // would show up in the DevTools with value 3
+ * ```
+ *
+ * Without `withGlitchTracking`, the DevTools would only show the final value of 3.
+ */
+function withGlitchTracking() {
+    return createDevtoolsFeature({ tracker: GlitchTrackerService });
+}
+
 /**
  * @deprecated Has been renamed to `updateState`
  */
@@ -93,6 +441,19 @@ function updateState(stateSource, action, ...updaters) {
     return patchState$1(stateSource, ...updaters);
 }
 
+/**
+ * Renames the name of a store how it appears in the Devtools.
+ * @param store instance of the SignalStore
+ * @param newName new name for the Devtools
+ */
+function renameDevtoolsName(store, newName) {
+    const renameMethod = store[renameDevtoolsMethodName];
+    if (!renameMethod) {
+        throw new Error("Devtools extensions haven't been added to this store.");
+    }
+    renameMethod(newName);
+}
+
 function assertActionFnSpecs(obj) {
     if (!obj || typeof obj !== 'object') {
         throw new Error('%o is not an Action Specification');
@@ -325,7 +686,6 @@ function getDataServiceKeys(options) {
         deleteKey,
     };
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function withDataService(options) {
     const { dataServiceType, filter, collection: prefix } = options;
     const { entitiesKey, filterKey, loadKey, selectedEntitiesKey, selectedIdsKey, updateFilterKey, updateSelectedKey, currentKey, createKey, updateKey, updateAllKey, deleteKey, loadByIdKey, setCurrentKey, } = getDataServiceKeys(options);
@@ -356,28 +716,30 @@ function withDataService(options) {
             },
             [loadKey]: async () => {
                 const filter = store[filterKey];
-                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
                 try {
                     const result = await dataService.load(filter());
                     patchState$1(store, prefix
                         ? setAllEntities(result, { collection: prefix })
                         : setAllEntities(result));
-                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
                 }
                 catch (e) {
-                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
                     throw e;
                 }
             },
             [loadByIdKey]: async (id) => {
-                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
                 try {
                     const current = await dataService.loadById(id);
-                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
                     patchState$1(store, { [currentKey]: current });
                 }
                 catch (e) {
-                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
                     throw e;
                 }
             },
@@ -386,23 +748,24 @@ function withDataService(options) {
             },
             [createKey]: async (entity) => {
                 patchState$1(store, { [currentKey]: entity });
-                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
                 try {
                     const created = await dataService.create(entity);
                     patchState$1(store, { [currentKey]: created });
                     patchState$1(store, prefix
                         ? addEntity(created, { collection: prefix })
                         : addEntity(created));
-                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
                 }
                 catch (e) {
-                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
                     throw e;
                 }
             },
             [updateKey]: async (entity) => {
                 patchState$1(store, { [currentKey]: entity });
-                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
                 try {
                     const updated = await dataService.update(entity);
                     patchState$1(store, { [currentKey]: updated });
@@ -412,40 +775,43 @@ function withDataService(options) {
                     };
                     const updater = (collection) => updateEntity(updateArg, { collection });
                     patchState$1(store, prefix ? updater(prefix) : updateEntity(updateArg));
-                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
                 }
                 catch (e) {
-                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
                     throw e;
                 }
             },
             [updateAllKey]: async (entities) => {
-                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
                 try {
                     const result = await dataService.updateAll(entities);
                     patchState$1(store, prefix
                         ? setAllEntities(result, { collection: prefix })
                         : setAllEntities(result));
-                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
                 }
                 catch (e) {
-                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
                     throw e;
                 }
             },
             [deleteKey]: async (entity) => {
                 patchState$1(store, { [currentKey]: entity });
-                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
                 try {
                     await dataService.delete(entity);
                     patchState$1(store, { [currentKey]: undefined });
                     patchState$1(store, prefix
                         ? removeEntity(entity.id, { collection: prefix })
                         : removeEntity(entity.id));
-                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
                 }
                 catch (e) {
-                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
                     throw e;
                 }
             },
@@ -517,6 +883,11 @@ function withUndoRedo(options) {
             }
             updateInternal();
         },
+        clearStack() {
+            undoStack.splice(0);
+            redoStack.splice(0);
+            updateInternal();
+        },
     })), withHooks({
         onInit(store) {
             effect(() => {
@@ -563,7 +934,7 @@ function withUndoRedo(options) {
     }));
 }
 
-const NOOP = () => { };
+const NOOP = () => void true;
 const StorageSyncStub = {
     clearStorage: NOOP,
     readFromStorage: NOOP,
@@ -822,9 +1193,47 @@ function createPageArray(currentPage, itemsPerPage, totalItems, paginationRange)
     return pages;
 }
 
+/**
+ * Adds a `resetState` method to the store, which resets the state
+ * to the initial state.
+ *
+ * If you want to set a custom initial state, you can use {@link setResetState}.
+ */
+function withReset() {
+    return signalStoreFeature(withProps(() => ({ _resetState: { value: {} } })), withMethods((store) => {
+        // workaround to TS excessive property check
+        const methods = {
+            resetState() {
+                patchState$1(store, store._resetState.value);
+            },
+            __setResetState__(state) {
+                store._resetState.value = state;
+            },
+        };
+        return methods;
+    }), withHooks((store) => ({
+        onInit() {
+            store._resetState.value = getState(store);
+        },
+    })));
+}
+/**
+ * Sets the reset state of the store to the given state.
+ *
+ * Throws an error if the store is not configured with {@link withReset}.
+ * @param store the instance of a SignalStore
+ * @param state the state to set as the reset state
+ */
+function setResetState(store, state) {
+    if (!('__setResetState__' in store)) {
+        throw new Error('Cannot set reset state, since store is not configured with withReset()');
+    }
+    store.__setResetState__(state);
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { capitalize, createPageArray, firstPage, getCallStateKeys, getDataServiceKeys, getUndoRedoKeys, gotoPage, nextPage, noPayload, patchState, payload, previousPage, setError, setLoaded, setLoading, setMaxPageNavigationArrayItems, setPageSize, updateState, withCallState, withDataService, withDevtools, withPagination, withRedux, withStorageSync, withUndoRedo };
+export { capitalize, createPageArray, firstPage, getCallStateKeys, getDataServiceKeys, getUndoRedoKeys, gotoPage, nextPage, noPayload, patchState, payload, previousPage, renameDevtoolsName, setError, setLoaded, setLoading, setMaxPageNavigationArrayItems, setPageSize, setResetState, updateState, withCallState, withDataService, withDevToolsStub, withDevtools, withDisabledNameIndices, withGlitchTracking, withMapper, withPagination, withRedux, withReset, withStorageSync, withUndoRedo };
 //# sourceMappingURL=angular-architects-ngrx-toolkit.mjs.map