@angular-architects/ngrx-toolkit 19.0.2 → 19.2.0

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

@@ -1,16 +1,47 @@
-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 { Injectable, InjectionToken, signal, effect, inject, PLATFORM_ID, computed, isSignal, untracked, isDevMode as isDevMode$1 } from '@angular/core';
+import { watchState, getState, signalStoreFeature, withMethods, withHooks, patchState as patchState$1, withState, withComputed, withProps } from '@ngrx/signals';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
 import { Subject } from 'rxjs';
-import { setAllEntities, addEntity, updateEntity, removeEntity } from '@ngrx/signals/entities';
+import { removeEntity, setAllEntities, updateEntity, addEntity } from '@ngrx/signals/entities';
+
+const DEVTOOLS_FEATURE = Symbol('DEVTOOLS_FEATURE');
+function createDevtoolsFeature(options) {
+    return {
+        [DEVTOOLS_FEATURE]: true,
+        ...options,
+    };
+}
 
 /**
- * Stub for DevTools integration. Can be used to disable DevTools in production.
+ * 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
+ * ```
+ *
  */
-const withDevToolsStub = () => (store) => store;
-
-const currentActionNames = new Set();
+function withDisabledNameIndices() {
+    return createDevtoolsFeature({ indexNames: false });
+}
 
 function throwIfNull(obj) {
     if (obj === null || obj === undefined) {
@@ -19,6 +50,182 @@ function throwIfNull(obj) {
     return obj;
 }
 
+/**
+ * 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.
+ */
+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) });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: GlitchTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: GlitchTrackerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", 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 });
+}
+
+/**
+ * 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 withMapper(map) {
+    return createDevtoolsFeature({ map: map });
+}
+
+/**
+ * Provides the configuration options for connecting to the Redux DevTools Extension.
+ */
+function provideDevtoolsConfig(config) {
+    return {
+        provide: REDUX_DEVTOOLS_CONFIG,
+        useValue: config,
+    };
+}
+/**
+ * Injection token for the configuration options for connecting to the Redux DevTools Extension.
+ */
+const REDUX_DEVTOOLS_CONFIG = new InjectionToken('ReduxDevtoolsConfig');
+
+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.2.14", ngImport: i0, type: DefaultTracker, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DefaultTracker, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DefaultTracker, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const currentActionNames = new Set();
+
 const dummyConnection = {
     send: () => void true,
 };
@@ -41,6 +248,10 @@ class DevtoolsSyncer {
     #stores = {};
     #isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
     #trackers = [];
+    #devtoolsConfig = {
+        name: 'NgRx SignalStore',
+        ...inject(REDUX_DEVTOOLS_CONFIG, { optional: true }),
+    };
     /**
      * Maintains the current states of all stores to avoid conflicts
      * between glitch-free and glitched trackers when used simultaneously.
@@ -59,19 +270,13 @@ class DevtoolsSyncer {
     #currentId = 1;
     #connection = this.#isBrowser
         ? window.__REDUX_DEVTOOLS_EXTENSION__
-            ? window.__REDUX_DEVTOOLS_EXTENSION__.connect({
-                name: 'NgRx SignalStore',
-            })
+            ? window.__REDUX_DEVTOOLS_EXTENSION__.connect(this.#devtoolsConfig)
             : dummyConnection
         : dummyConnection;
     constructor() {
         if (!this.#isBrowser) {
             return;
         }
-        const isToolkitAvailable = Boolean(window.__REDUX_DEVTOOLS_EXTENSION__);
-        if (!isToolkitAvailable) {
-            console.info('NgRx Toolkit/DevTools: Redux DevTools Extension is not available.');
-        }
     }
     ngOnDestroy() {
         currentActionNames.clear();
@@ -106,7 +311,9 @@ class DevtoolsSyncer {
         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));
+            // 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.`);
@@ -166,65 +373,17 @@ Enable automatic indexing via withDevTools('${storeName}', { indexNames: true })
         }, {});
         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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DevtoolsSyncer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DevtoolsSyncer, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DevtoolsSyncer, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", 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' }); }
-}
-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';
+const EXISTING_NAMES = new InjectionToken('Array contain existing names for the signal stores', { factory: () => [], providedIn: 'root' });
 /**
  * Adds this store as a feature state to the Redux DevTools.
  *
@@ -239,10 +398,6 @@ const uniqueDevtoolsId = '___uniqueDevtoolsId';
  * @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.`);
-    }
-    existingNames.set(name, true);
     return signalStoreFeature(withMethods(() => {
         const syncer = inject(DevtoolsSyncer);
         const id = syncer.getNextId();
@@ -273,154 +428,17 @@ function withDevtools(name, ...features) {
     }));
 }
 
-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 });
-}
-
-/**
- * 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 withMapper(map) {
-    return createDevtoolsFeature({ map: map });
-}
-
 /**
- * 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.
+ * 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
  */
-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) });
-        }
+function renameDevtoolsName(store, newName) {
+    const renameMethod = store[renameDevtoolsMethodName];
+    if (!renameMethod) {
+        throw new Error("Devtools extensions haven't been added to this 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 });
+    renameMethod(newName);
 }
 
 /**
@@ -442,17 +460,9 @@ function updateState(stateSource, action, ...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
+ * Stub for DevTools integration. Can be used to disable DevTools in production.
  */
-function renameDevtoolsName(store, newName) {
-    const renameMethod = store[renameDevtoolsMethodName];
-    if (!renameMethod) {
-        throw new Error("Devtools extensions haven't been added to this store.");
-    }
-    renameMethod(newName);
-}
+const withDevToolsStub = () => (store) => store;
 
 function assertActionFnSpecs(obj) {
     if (!obj || typeof obj !== 'object') {
@@ -510,6 +520,8 @@ function createReducer(reducerFactory) {
     return reducerFactory;
 }
 /**
+ * @deprecated Use NgRx's `@ngrx/signals/events` starting in 19.2
+ *
  * Creates the effects function to separate the effects logic into another file.
  *
  * ```typescript
@@ -645,23 +657,63 @@ function withRedux(redux) {
         const { methods } = processRedux(redux.actions, redux.reducer, redux.effects, store);
         return {
             ...store,
-            methods,
+            methods: { ...store.methods, ...methods },
         };
     };
 }
 
-function getCallStateKeys(config) {
-    const prop = config?.collection;
+function deriveCallStateKeys(collection) {
     return {
-        callStateKey: prop ? `${config.collection}CallState` : 'callState',
-        loadingKey: prop ? `${config.collection}Loading` : 'loading',
-        loadedKey: prop ? `${config.collection}Loaded` : 'loaded',
-        errorKey: prop ? `${config.collection}Error` : 'error',
+        callStateKey: collection ? `${collection}CallState` : 'callState',
+        loadingKey: collection ? `${collection}Loading` : 'loading',
+        loadedKey: collection ? `${collection}Loaded` : 'loaded',
+        errorKey: collection ? `${collection}Error` : 'error',
     };
 }
+function getCallStateKeys(config) {
+    const prop = config?.collection;
+    return deriveCallStateKeys(prop);
+}
+function getCollectionArray(config) {
+    return 'collections' in config
+        ? config.collections
+        : 'collection' in config && config.collection
+            ? [config.collection]
+            : undefined;
+}
 function withCallState(config) {
-    const { callStateKey, errorKey, loadedKey, loadingKey } = getCallStateKeys(config);
-    return signalStoreFeature(withState({ [callStateKey]: 'init' }), withComputed((state) => {
+    return signalStoreFeature(withState(() => {
+        if (!config) {
+            return { callState: 'init' };
+        }
+        const collections = getCollectionArray(config);
+        if (collections) {
+            return collections.reduce((acc, cur) => ({
+                ...acc,
+                ...{ [cur ? `${cur}CallState` : 'callState']: 'init' },
+            }), {});
+        }
+        return { callState: 'init' };
+    }), withComputed((state) => {
+        if (config) {
+            const collections = getCollectionArray(config);
+            if (collections) {
+                return collections.reduce((acc, cur) => {
+                    const { callStateKey, errorKey, loadedKey, loadingKey } = deriveCallStateKeys(cur);
+                    const callState = state[callStateKey];
+                    return {
+                        ...acc,
+                        [loadingKey]: computed(() => callState() === 'loading'),
+                        [loadedKey]: computed(() => callState() === 'loaded'),
+                        [errorKey]: computed(() => {
+                            const v = callState();
+                            return typeof v === 'object' ? v.error : null;
+                        }),
+                    };
+                }, {});
+            }
+        }
+        const { callStateKey, errorKey, loadedKey, loadingKey } = deriveCallStateKeys();
         const callState = state[callStateKey];
         return {
             [loadingKey]: computed(() => callState() === 'loading'),
@@ -911,252 +963,60 @@ function withDataService(options) {
     }));
 }
 
-const defaultOptions = {
-    maxStackSize: 100,
-    keys: [],
-    skip: 0,
-};
-function getUndoRedoKeys(collections) {
-    if (collections) {
-        return collections.flatMap((c) => [
-            `${c}EntityMap`,
-            `${c}Ids`,
-            `selected${capitalize(c)}Ids`,
-            `${c}Filter`,
-        ]);
-    }
-    return ['entityMap', 'ids', 'selectedIds', 'filter'];
+/** With pagination comes in two flavors the first one is local pagination or in memory pagination. For example we have 2000 items which we want
+ * to display in a table and the response payload is small enough to be stored in the memory. But we can not display all 2000 items at once
+ * so we need to paginate the data. The second flavor is server side pagination where the response payload is too large to be stored in the memory
+ * and we need to fetch the data from the server in chunks. In the second case we 'could' also cache the data in the memory but that could lead to
+ * other problems like memory leaks and stale data. So we will not cache the data in the memory in the second case.
+ * This feature implements the local pagination.
+ */
+function withPagination(options) {
+    const { pageKey, pageSizeKey, entitiesKey, selectedPageEntitiesKey, totalCountKey, pageCountKey, pageNavigationArrayMaxKey, pageNavigationArrayKey, hasNextPageKey, hasPreviousPageKey, } = createPaginationKeys(options);
+    return signalStoreFeature(withState({
+        [pageKey]: 0,
+        [pageSizeKey]: 10,
+        [pageNavigationArrayMaxKey]: 7,
+    }), withComputed((store) => {
+        const entities = store[entitiesKey];
+        const page = store[pageKey];
+        const pageSize = store[pageSizeKey];
+        const pageNavigationArrayMax = store[pageNavigationArrayMaxKey];
+        return {
+            // The derived enitites which are displayed on the current page
+            [selectedPageEntitiesKey]: computed(() => {
+                const pageSizeValue = pageSize();
+                const pageValue = page();
+                return entities().slice(pageValue * pageSizeValue, (pageValue + 1) * pageSizeValue);
+            }),
+            [totalCountKey]: computed(() => entities().length),
+            [pageCountKey]: computed(() => {
+                const totalCountValue = entities().length;
+                const pageSizeValue = pageSize();
+                if (totalCountValue === 0) {
+                    return 0;
+                }
+                return Math.ceil(totalCountValue / pageSizeValue);
+            }),
+            [pageNavigationArrayKey]: computed(() => createPageArray(page(), pageSize(), entities().length, pageNavigationArrayMax())),
+            [hasNextPageKey]: computed(() => {
+                return page() < pageSize();
+            }),
+            [hasPreviousPageKey]: computed(() => {
+                return page() > 1;
+            }),
+        };
+    }));
 }
-function withUndoRedo(options) {
-    let previous = null;
-    let skipOnce = false;
-    const normalized = {
-        ...defaultOptions,
-        ...options,
+function gotoPage(page, options) {
+    const { pageKey } = createPaginationKeys(options);
+    return {
+        [pageKey]: page,
     };
-    //
-    // Design Decision: This feature has its own
-    // internal state.
-    //
-    const undoStack = [];
-    const redoStack = [];
-    const canUndo = signal(false);
-    const canRedo = signal(false);
-    const updateInternal = () => {
-        canUndo.set(undoStack.length !== 0);
-        canRedo.set(redoStack.length !== 0);
-    };
-    const keys = [...getUndoRedoKeys(normalized.collections), ...normalized.keys];
-    return signalStoreFeature(withComputed(() => ({
-        canUndo: canUndo.asReadonly(),
-        canRedo: canRedo.asReadonly(),
-    })), withMethods((store) => ({
-        undo() {
-            const item = undoStack.pop();
-            if (item && previous) {
-                redoStack.push(previous);
-            }
-            if (item) {
-                skipOnce = true;
-                patchState$1(store, item);
-                previous = item;
-            }
-            updateInternal();
-        },
-        redo() {
-            const item = redoStack.pop();
-            if (item && previous) {
-                undoStack.push(previous);
-            }
-            if (item) {
-                skipOnce = true;
-                patchState$1(store, item);
-                previous = item;
-            }
-            updateInternal();
-        },
-        clearStack() {
-            undoStack.splice(0);
-            redoStack.splice(0);
-            updateInternal();
-        },
-    })), withHooks({
-        onInit(store) {
-            effect(() => {
-                const cand = keys.reduce((acc, key) => {
-                    const s = store[key];
-                    if (s && isSignal(s)) {
-                        return {
-                            ...acc,
-                            [key]: s(),
-                        };
-                    }
-                    return acc;
-                }, {});
-                if (normalized.skip > 0) {
-                    normalized.skip--;
-                    return;
-                }
-                if (skipOnce) {
-                    skipOnce = false;
-                    return;
-                }
-                //
-                // Deep Comparison to prevent duplicated entries
-                // on the stack. This can e.g. happen after an undo
-                // if the component sends back the undone filter
-                // to the store.
-                //
-                if (JSON.stringify(cand) === JSON.stringify(previous)) {
-                    return;
-                }
-                // Clear redoStack after recorded action
-                redoStack.splice(0);
-                if (previous) {
-                    undoStack.push(previous);
-                }
-                if (redoStack.length > normalized.maxStackSize) {
-                    undoStack.unshift();
-                }
-                previous = cand;
-                // Don't propogate current reactive context
-                untracked(() => updateInternal());
-            });
-        },
-    }));
-}
-
-const NOOP = () => void true;
-const StorageSyncStub = {
-    clearStorage: NOOP,
-    readFromStorage: NOOP,
-    writeToStorage: NOOP,
-};
-function withStorageSync(configOrKey) {
-    const { key, autoSync = true, select = (state) => state, parse = JSON.parse, stringify = JSON.stringify, storage: storageFactory = () => localStorage, } = typeof configOrKey === 'string' ? { key: configOrKey } : configOrKey;
-    return signalStoreFeature(withMethods((store, platformId = inject(PLATFORM_ID)) => {
-        if (isPlatformServer(platformId)) {
-            console.warn(`'withStorageSync' provides non-functional implementation due to server-side execution`);
-            return StorageSyncStub;
-        }
-        const storage = storageFactory();
-        return {
-            /**
-             * Removes the item stored in storage.
-             */
-            clearStorage() {
-                storage.removeItem(key);
-            },
-            /**
-             * Reads item from storage and patches the state.
-             */
-            readFromStorage() {
-                const stateString = storage.getItem(key);
-                if (stateString) {
-                    patchState$1(store, parse(stateString));
-                }
-            },
-            /**
-             * Writes selected portion to storage.
-             */
-            writeToStorage() {
-                const slicedState = select(getState(store));
-                storage.setItem(key, stringify(slicedState));
-            },
-        };
-    }), withHooks({
-        onInit(store, platformId = inject(PLATFORM_ID)) {
-            if (isPlatformServer(platformId)) {
-                return;
-            }
-            if (autoSync) {
-                store.readFromStorage();
-                effect(() => {
-                    store.writeToStorage();
-                });
-            }
-        },
-    }));
-}
-
-/** With pagination comes in two flavors the first one is local pagination or in memory pagination. For example we have 2000 items which we want
- * to display in a table and the response payload is small enough to be stored in the memory. But we can not display all 2000 items at once
- * so we need to paginate the data. The second flavor is server side pagination where the response payload is too large to be stored in the memory
- * and we need to fetch the data from the server in chunks. In the second case we 'could' also cache the data in the memory but that could lead to
- * other problems like memory leaks and stale data. So we will not cache the data in the memory in the second case.
- * This feature implements the local pagination.
- */
-function withPagination(options) {
-    const { pageKey, pageSizeKey, entitiesKey, selectedPageEntitiesKey, totalCountKey, pageCountKey, pageNavigationArrayMaxKey, pageNavigationArrayKey, setPageSizeKey, nextPageKey, previousPageKey, lastPageKey, firstPageKey, gotoPageKey, hasNextPageKey, hasPreviousPageKey, } = createPaginationKeys(options);
-    return signalStoreFeature(withState({
-        [pageKey]: 0,
-        [pageSizeKey]: 10,
-        [pageNavigationArrayMaxKey]: 7,
-    }), withComputed((store) => {
-        const entities = store[entitiesKey];
-        const page = store[pageKey];
-        const pageSize = store[pageSizeKey];
-        const pageNavigationArrayMax = store[pageNavigationArrayMaxKey];
-        return {
-            // The derived enitites which are displayed on the current page
-            [selectedPageEntitiesKey]: computed(() => {
-                const pageSizeValue = pageSize();
-                const pageValue = page();
-                return entities().slice(pageValue * pageSizeValue, (pageValue + 1) * pageSizeValue);
-            }),
-            [totalCountKey]: computed(() => entities().length),
-            [pageCountKey]: computed(() => {
-                const totalCountValue = entities().length;
-                const pageSizeValue = pageSize();
-                if (totalCountValue === 0) {
-                    return 0;
-                }
-                return Math.ceil(totalCountValue / pageSizeValue);
-            }),
-            [pageNavigationArrayKey]: computed(() => createPageArray(page(), pageSize(), entities().length, pageNavigationArrayMax())),
-            [hasNextPageKey]: computed(() => {
-                return page() < pageSize();
-            }),
-            [hasPreviousPageKey]: computed(() => {
-                return page() > 1;
-            }),
-        };
-    }), withMethods((store) => {
-        return {
-            [setPageSizeKey]: (size) => {
-                patchState$1(store, setPageSize(size, options));
-            },
-            [nextPageKey]: () => {
-                patchState$1(store, nextPage(options));
-            },
-            [previousPageKey]: () => {
-                patchState$1(store, previousPage(options));
-            },
-            [lastPageKey]: () => {
-                const lastPage = store[pageCountKey]();
-                if (lastPage === 0)
-                    return;
-                patchState$1(store, gotoPage(lastPage - 1, options));
-            },
-            [firstPageKey]: () => {
-                patchState$1(store, firstPage());
-            },
-            [gotoPageKey]: (page) => {
-                patchState$1(store, gotoPage(page, options));
-            },
-        };
-    }));
-}
-function gotoPage(page, options) {
-    const { pageKey } = createPaginationKeys(options);
-    return {
-        [pageKey]: page,
-    };
-}
-function setPageSize(pageSize, options) {
-    const { pageSizeKey } = createPaginationKeys(options);
-    return {
-        [pageSizeKey]: pageSize,
+}
+function setPageSize(pageSize, options) {
+    const { pageSizeKey } = createPaginationKeys(options);
+    return {
+        [pageSizeKey]: pageSize,
     };
 }
 function nextPage(options) {
@@ -1208,24 +1068,6 @@ function createPaginationKeys(options) {
     const pageNavigationArrayKey = options?.collection
         ? `${options.collection}PageNavigationArray`
         : 'pageNavigationArray';
-    const setPageSizeKey = options?.collection
-        ? `set${capitalize(options.collection)}PageSize`
-        : 'setPageSize';
-    const nextPageKey = options?.collection
-        ? `next${capitalize(options.collection)}Page`
-        : 'nextPage';
-    const previousPageKey = options?.collection
-        ? `previous${capitalize(options.collection)}Page`
-        : 'previousPage';
-    const lastPageKey = options?.collection
-        ? `last${capitalize(options.collection)}Page`
-        : 'lastPage';
-    const firstPageKey = options?.collection
-        ? `first${capitalize(options.collection)}Page`
-        : 'firstPage';
-    const gotoPageKey = options?.collection
-        ? `goto${capitalize(options.collection)}Page`
-        : 'gotoPage';
     const hasNextPageKey = options?.collection
         ? `hasNext${capitalize(options.collection)}Page`
         : 'hasNextPage';
@@ -1241,12 +1083,6 @@ function createPaginationKeys(options) {
         pageCountKey,
         pageNavigationArrayKey,
         pageNavigationArrayMaxKey,
-        setPageSizeKey,
-        nextPageKey,
-        previousPageKey,
-        lastPageKey,
-        firstPageKey,
-        gotoPageKey,
         hasNextPageKey,
         hasPreviousPageKey,
     };
@@ -1323,9 +1159,620 @@ function setResetState(store, state) {
     store.__setResetState__(state);
 }
 
+const defaultOptions = {
+    maxStackSize: 100,
+    keys: [],
+    skip: 0,
+};
+function getUndoRedoKeys(collections) {
+    if (collections) {
+        return collections.flatMap((c) => [
+            `${c}EntityMap`,
+            `${c}Ids`,
+            `selected${capitalize(c)}Ids`,
+            `${c}Filter`,
+        ]);
+    }
+    return ['entityMap', 'ids', 'selectedIds', 'filter'];
+}
+function withUndoRedo(options) {
+    let previous = null;
+    let skipOnce = false;
+    const normalized = {
+        ...defaultOptions,
+        ...options,
+    };
+    //
+    // Design Decision: This feature has its own
+    // internal state.
+    //
+    const undoStack = [];
+    const redoStack = [];
+    const canUndo = signal(false);
+    const canRedo = signal(false);
+    const updateInternal = () => {
+        canUndo.set(undoStack.length !== 0);
+        canRedo.set(redoStack.length !== 0);
+    };
+    const keys = [...getUndoRedoKeys(normalized.collections), ...normalized.keys];
+    return signalStoreFeature(withComputed(() => ({
+        canUndo: canUndo.asReadonly(),
+        canRedo: canRedo.asReadonly(),
+    })), withMethods((store) => ({
+        undo() {
+            const item = undoStack.pop();
+            if (item && previous) {
+                redoStack.push(previous);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState$1(store, item);
+                previous = item;
+            }
+            updateInternal();
+        },
+        redo() {
+            const item = redoStack.pop();
+            if (item && previous) {
+                undoStack.push(previous);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState$1(store, item);
+                previous = item;
+            }
+            updateInternal();
+        },
+        clearStack() {
+            undoStack.splice(0);
+            redoStack.splice(0);
+            previous = null;
+            updateInternal();
+        },
+    })), withHooks({
+        onInit(store) {
+            effect(() => {
+                const cand = keys.reduce((acc, key) => {
+                    const s = store[key];
+                    if (s && isSignal(s)) {
+                        return {
+                            ...acc,
+                            [key]: s(),
+                        };
+                    }
+                    return acc;
+                }, {});
+                if (normalized.skip > 0) {
+                    normalized.skip--;
+                    return;
+                }
+                if (skipOnce) {
+                    skipOnce = false;
+                    return;
+                }
+                //
+                // Deep Comparison to prevent duplicated entries
+                // on the stack. This can e.g. happen after an undo
+                // if the component sends back the undone filter
+                // to the store.
+                //
+                if (JSON.stringify(cand) === JSON.stringify(previous)) {
+                    return;
+                }
+                // Clear redoStack after recorded action
+                redoStack.splice(0);
+                if (previous) {
+                    undoStack.push(previous);
+                }
+                if (redoStack.length > normalized.maxStackSize) {
+                    undoStack.unshift();
+                }
+                previous = cand;
+                // Don't propogate current reactive context
+                untracked(() => updateInternal());
+            });
+        },
+    }));
+}
+
+/**
+ * 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.
+ */
+function deepFreeze(target, 
+// if empty all properties will be frozen
+propertyNamesToBeFrozen, 
+// also means that we are on the first level
+isRoot = true) {
+    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) {
+    return typeof target === 'object' && target !== null;
+}
+
+// necessary wrapper function to test prod mode
+function isDevMode() {
+    return isDevMode$1();
+}
+
+function withImmutableState(stateOrFactory, options) {
+    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);
+            });
+        },
+    })));
+}
+
+const keyPath = 'ngrxToolkitKeyPath';
+const dbName = 'ngrxToolkitDb';
+const storeName = 'ngrxToolkitStore';
+const VERSION = 1;
+class IndexedDBService {
+    /**
+     * write to indexedDB
+     * @param key
+     * @param data
+     */
+    async setItem(key, data) {
+        const db = await this.openDB();
+        const tx = db.transaction(storeName, 'readwrite');
+        const store = tx.objectStore(storeName);
+        store.put({
+            [keyPath]: key,
+            value: data,
+        });
+        return new Promise((resolve, reject) => {
+            tx.oncomplete = () => {
+                db.close();
+                resolve();
+            };
+            tx.onerror = () => {
+                db.close();
+                reject();
+            };
+        });
+    }
+    /**
+     * read from indexedDB
+     * @param key
+     */
+    async getItem(key) {
+        const db = await this.openDB();
+        const tx = db.transaction(storeName, 'readonly');
+        const store = tx.objectStore(storeName);
+        const request = store.get(key);
+        return new Promise((resolve, reject) => {
+            request.onsuccess = () => {
+                db.close();
+                // localStorage(sessionStorage) returns null if the key does not exist
+                // Similarly, indexedDB should return null
+                if (request.result === undefined) {
+                    resolve(null);
+                }
+                resolve(request.result?.['value']);
+            };
+            request.onerror = () => {
+                db.close();
+                reject();
+            };
+        });
+    }
+    /**
+     * delete indexedDB
+     * @param key
+     */
+    async clear(key) {
+        const db = await this.openDB();
+        const tx = db.transaction(storeName, 'readwrite');
+        const store = tx.objectStore(storeName);
+        const request = store.delete(key);
+        return new Promise((resolve, reject) => {
+            request.onsuccess = () => {
+                db.close();
+                resolve();
+            };
+            request.onerror = () => {
+                db.close();
+                reject();
+            };
+        });
+    }
+    /**
+     * open indexedDB
+     */
+    async openDB() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(dbName, VERSION);
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains(storeName)) {
+                    db.createObjectStore(storeName, { keyPath });
+                }
+            };
+            request.onsuccess = () => {
+                resolve(request.result);
+            };
+            request.onerror = () => {
+                reject(request.error);
+            };
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: IndexedDBService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: IndexedDBService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: IndexedDBService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const SYNC_STATUS = Symbol('SYNC_STATUS');
+
+function withIndexedDB() {
+    function factory({ key, parse, select, stringify }, store, useStubs) {
+        if (useStubs) {
+            return {
+                clearStorage: () => Promise.resolve(),
+                readFromStorage: () => Promise.resolve(),
+                writeToStorage: () => Promise.resolve(),
+            };
+        }
+        const indexeddbService = inject(IndexedDBService);
+        function warnOnSyncing(mode) {
+            if (store[SYNC_STATUS]() === 'syncing') {
+                const prettyMode = mode === 'read' ? 'Reading' : 'Writing';
+                console.warn(`${prettyMode} to Store (${key}) happened during an ongoing synchronization process.`, 'Please ensure that the store is not in syncing state via `store.whenSynced()`.', 'Alternatively, you can disable the autoSync by passing `autoSync: false` in the config.');
+            }
+        }
+        return {
+            /**
+             * Removes the item stored in storage.
+             */
+            async clearStorage() {
+                warnOnSyncing('write');
+                store[SYNC_STATUS].set('syncing');
+                patchState$1(store, {});
+                await indexeddbService.clear(key);
+                store[SYNC_STATUS].set('synced');
+            },
+            /**
+             * Reads item from storage and patches the state.
+             */
+            async readFromStorage() {
+                warnOnSyncing('read');
+                store[SYNC_STATUS].set('syncing');
+                const stateString = await indexeddbService.getItem(key);
+                if (stateString) {
+                    patchState$1(store, parse(stateString));
+                }
+                store[SYNC_STATUS].set('synced');
+            },
+            /**
+             * Writes selected portion to storage.
+             */
+            async writeToStorage() {
+                warnOnSyncing('write');
+                store[SYNC_STATUS].set('syncing');
+                const slicedState = select(getState(store));
+                await indexeddbService.setItem(key, stringify(slicedState));
+                store[SYNC_STATUS].set('synced');
+            },
+        };
+    }
+    factory.type = 'async';
+    return factory;
+}
+
+class LocalStorageService {
+    getItem(key) {
+        return localStorage.getItem(key);
+    }
+    setItem(key, data) {
+        return localStorage.setItem(key, data);
+    }
+    clear(key) {
+        return localStorage.removeItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LocalStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class SessionStorageService {
+    getItem(key) {
+        return sessionStorage.getItem(key);
+    }
+    setItem(key, data) {
+        return sessionStorage.setItem(key, data);
+    }
+    clear(key) {
+        return sessionStorage.removeItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SessionStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SessionStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SessionStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+function withLocalStorage() {
+    return createSyncMethods(LocalStorageService);
+}
+function withSessionStorage() {
+    return createSyncMethods(SessionStorageService);
+}
+function createSyncMethods(Storage) {
+    function factory({ key, parse, select, stringify }, store, useStubs) {
+        if (useStubs) {
+            return {
+                clearStorage: () => undefined,
+                readFromStorage: () => undefined,
+                writeToStorage: () => undefined,
+            };
+        }
+        const storage = inject(Storage);
+        return {
+            clearStorage() {
+                storage.clear(key);
+            },
+            readFromStorage() {
+                const stateString = storage.getItem(key);
+                if (stateString) {
+                    patchState$1(store, parse(stateString));
+                }
+            },
+            writeToStorage() {
+                const slicedState = select(getState(store));
+                storage.setItem(key, stringify(slicedState));
+            },
+        };
+    }
+    factory.type = 'sync';
+    return factory;
+}
+
+function withStorageSync(configOrKey, storageStrategy) {
+    if (typeof configOrKey !== 'string' &&
+        configOrKey.storage &&
+        storageStrategy) {
+        throw new Error('You can either pass a storage strategy or a config with storage, but not both.');
+    }
+    const config = {
+        autoSync: true,
+        select: (state) => state,
+        parse: JSON.parse,
+        stringify: JSON.stringify,
+        storage: () => localStorage,
+        ...(typeof configOrKey === 'string' ? { key: configOrKey } : configOrKey),
+    };
+    const factory = storageStrategy ??
+        (config.storage() === localStorage
+            ? withLocalStorage()
+            : withSessionStorage());
+    if (factory.type === 'sync') {
+        return createSyncStorageSync(factory, config);
+    }
+    else {
+        return createAsyncStorageSync(factory, config);
+    }
+}
+function createSyncStorageSync(factory, config) {
+    return signalStoreFeature(withMethods((store, platformId = inject(PLATFORM_ID)) => {
+        return factory(config, store, isPlatformServer(platformId));
+    }), withHooks({
+        onInit(store, platformId = inject(PLATFORM_ID)) {
+            if (isPlatformServer(platformId)) {
+                return;
+            }
+            if (config.autoSync) {
+                store.readFromStorage();
+                watchState(store, () => store.writeToStorage());
+            }
+        },
+    }));
+}
+function createAsyncStorageSync(factory, config) {
+    return signalStoreFeature(withProps(() => {
+        const props = {
+            /*
+            // we need to have that as property (and not state)
+            // Otherwise the state watcher fires when updating the sync status
+            */
+            [SYNC_STATUS]: signal('idle'),
+        };
+        const resolves = [];
+        effect(() => {
+            const syncStatus = props[SYNC_STATUS]();
+            if (syncStatus === 'synced') {
+                resolves.forEach((resolve) => resolve());
+                resolves.splice(0, resolves.length);
+            }
+        });
+        return {
+            ...props,
+            isSynced: computed(() => props[SYNC_STATUS]() === 'synced'),
+            whenSynced: () => new Promise((resolve) => {
+                if (props[SYNC_STATUS]() === 'synced') {
+                    resolve();
+                }
+                else {
+                    resolves.push(resolve);
+                }
+            }),
+        };
+    }), withMethods((store, platformId = inject(PLATFORM_ID)) => {
+        return factory(config, store, isPlatformServer(platformId));
+    }), withHooks({
+        async onInit(store, platformId = inject(PLATFORM_ID)) {
+            if (isPlatformServer(platformId)) {
+                return;
+            }
+            const initialState = getState(store);
+            if (config.autoSync) {
+                let startWatching = false;
+                watchState(store, () => {
+                    if (!startWatching) {
+                        if (getState(store) === initialState) {
+                            return;
+                        }
+                        console.warn(`Writing to Store (${config.key}) happened before the state was initially read from storage.`, 'Please ensure that the store is not in syncing state via `store.whenSynced()` before writing to the state.', 'Alternatively, you can disable autoSync by passing `autoSync: false` in the config.');
+                        return;
+                    }
+                    return store.writeToStorage();
+                });
+                await store.readFromStorage();
+                startWatching = true;
+            }
+        },
+    }));
+}
+
+/**
+ * `withConditional` activates a feature based on a given condition.
+ *
+ * **Use Cases**
+ * - Conditionally activate features based on the **store state** or other criteria.
+ * - Choose between **two different implementations** of a feature.
+ *
+ * **Type Constraints**
+ * Both features must have **exactly the same state, props, and methods**.
+ * Otherwise, a type error will occur.
+ *
+ *
+ * **Usage**
+ *
+ * ```typescript
+ * const withUser = signalStoreFeature(
+ *   withState({ id: 1, name: 'Konrad' }),
+ *   withHooks(store => ({
+ *     onInit() {
+ *       // user loading logic
+ *     }
+ *   }))
+ * );
+ *
+ * function withFakeUser() {
+ *   return signalStoreFeature(
+ *     withState({ id: 0, name: 'anonymous' })
+ *   );
+ * }
+ *
+ * signalStore(
+ *   withMethods(() => ({
+ *     useRealUser: () => true
+ *   })),
+ *   withConditional((store) => store.useRealUser(), withUser, withFakeUser)
+ * )
+ * ```
+ *
+ * @param condition - A function that determines which feature to activate based on the store state.
+ * @param featureIfTrue - The feature to activate if the condition evaluates to `true`.
+ * @param featureIfFalse - The feature to activate if the condition evaluates to `false`.
+ * @returns A `SignalStoreFeature` that applies the selected feature based on the condition.
+ */
+function withConditional(condition, featureIfTrue, featureIfFalse) {
+    return (store) => {
+        const conditionStore = {
+            ...store['stateSignals'],
+            ...store['props'],
+            ...store['methods'],
+        };
+        return condition(conditionStore)
+            ? featureIfTrue(store)
+            : featureIfFalse(store);
+    };
+}
+const emptyFeature = signalStoreFeature(withState({}));
+
+/**
+ * @deprecated Use `import { withFeature } from '@ngrx/signals'` instead, starting with `ngrx/signals` 19.1: https://ngrx.io/guide/signals/signal-store/custom-store-features#connecting-a-custom-feature-with-the-store
+ *
+ * Allows to pass properties, methods, or signals from a SignalStore
+ * to a feature.
+ *
+ * Typically, a `signalStoreFeature` can have input constraints on
+ *
+ * ```typescript
+ * function withSum(a: Signal<number>, b: Signal<number>) {
+ *   return signalStoreFeature(
+ *     withComputed(() => ({
+ *       sum: computed(() => a() + b())
+ *     }))
+ *   );
+ * }
+ *
+ * signalStore(
+ *   withState({ a: 1, b: 2 }),
+ *   withFeatureFactory((store) => withSum(store.a, store.b))
+ * );
+ * ```
+ * @param factoryFn
+ */
+function withFeatureFactory(factoryFn) {
+    return (store) => {
+        const storeForFactory = {
+            ...store['stateSignals'],
+            ...store['props'],
+            ...store['methods'],
+        };
+        const feature = factoryFn(storeForFactory);
+        return feature(store);
+    };
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { capitalize, createEffects, createPageArray, createReducer, 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 };
+export { capitalize, createEffects, createPageArray, createReducer, deriveCallStateKeys, emptyFeature, firstPage, getCallStateKeys, getCollectionArray, getDataServiceKeys, getUndoRedoKeys, gotoPage, nextPage, noPayload, patchState, payload, previousPage, provideDevtoolsConfig, renameDevtoolsName, setError, setLoaded, setLoading, setMaxPageNavigationArrayItems, setPageSize, setResetState, updateState, withCallState, withConditional, withDataService, withDevToolsStub, withDevtools, withDisabledNameIndices, withFeatureFactory, withGlitchTracking, withImmutableState, withIndexedDB, withIndexedDB as withIndexeddb, withLocalStorage, withMapper, withPagination, withRedux, withReset, withSessionStorage, withStorageSync, withUndoRedo };
 //# sourceMappingURL=angular-architects-ngrx-toolkit.mjs.map