@angular-architects/ngrx-toolkit 20.6.0 → 20.7.0

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

@@ -1,10 +1,11 @@
 import * as i0 from '@angular/core';
-import { Injectable, InjectionToken, signal, effect, inject, PLATFORM_ID, NgZone, computed, isSignal, untracked, isDevMode as isDevMode$1, DestroyRef, linkedSignal } from '@angular/core';
-import { watchState, getState, signalStoreFeature, withMethods, withHooks, patchState as patchState$1, withState, withComputed, withProps, withLinkedState } from '@ngrx/signals';
+import { Injectable, InjectionToken, signal, effect, inject, PLATFORM_ID, NgZone, untracked, computed, isSignal, isDevMode as isDevMode$1, DestroyRef, linkedSignal } from '@angular/core';
+import { watchState, getState, signalStoreFeature, withMethods, withProps, withHooks, patchState as patchState$1, type, withState, withComputed, withLinkedState } from '@ngrx/signals';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
-import { Subject, switchMap, mergeMap, concatMap, exhaustMap, defer, tap, catchError, EMPTY, finalize, filter, map } from 'rxjs';
-import { removeEntity, setAllEntities, updateEntity, addEntity } from '@ngrx/signals/entities';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Dispatcher } from '@ngrx/signals/events';
+import { tap, merge, Subject, switchMap, mergeMap, concatMap, exhaustMap, defer, catchError, EMPTY, finalize, filter, map } from 'rxjs';
+import { removeEntity, setAllEntities, updateEntity, addEntity } from '@ngrx/signals/entities';
 import { HttpClient, HttpEventType, HttpResponse } from '@angular/common/http';
 
 const DEVTOOLS_FEATURE = Symbol('DEVTOOLS_FEATURE');
@@ -100,6 +101,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
+const GLITCH_TRACKING_FEATURE = 'GLITCH_TRACKING_FEATURE';
 /**
  * It tracks all state changes of the State, including intermediary updates
  * that are typically suppressed by Angular's glitch-free mechanism.
@@ -130,7 +132,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
  * Without `withGlitchTracking`, the DevTools would only show the final value of 3.
  */
 function withGlitchTracking() {
-    return createDevtoolsFeature({ tracker: GlitchTrackerService });
+    return createDevtoolsFeature({
+        name: GLITCH_TRACKING_FEATURE,
+        tracker: GlitchTrackerService,
+    });
 }
 
 /**
@@ -398,7 +403,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
 
 const renameDevtoolsMethodName = '___renameDevtoolsName';
 const uniqueDevtoolsId = '___uniqueDevtoolsId';
-const EXISTING_NAMES = new InjectionToken('Array contain existing names for the signal stores', { factory: () => [], providedIn: 'root' });
+// Used to declare the existence of the devtools extension
+const DEVTOOL_FEATURE_NAMES = Symbol('DEVTOOL_PROP');
 /**
  * Adds this store as a feature state to the Redux DevTools.
  *
@@ -423,12 +429,13 @@ function withDevtools(name, ...features) {
             },
             [uniqueDevtoolsId]: () => id,
         };
-    }), withHooks((store) => {
+    }), withProps(() => ({
+        [DEVTOOL_FEATURE_NAMES]: features.filter(Boolean).map((f) => f.name),
+    })), 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),
@@ -477,7 +484,55 @@ function updateState(stateSource, action, ...updaters) {
 /**
  * Stub for DevTools integration. Can be used to disable DevTools in production.
  */
-const withDevToolsStub = () => (store) => store;
+const withDevToolsStub = () => signalStoreFeature(withProps(() => ({
+    [DEVTOOL_FEATURE_NAMES]: [GLITCH_TRACKING_FEATURE],
+})));
+
+function withTrackedReducer(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+...caseReducers) {
+    return signalStoreFeature({
+        state: type(),
+    }, withHooks((store) => ({
+        onInit() {
+            if (!(DEVTOOL_FEATURE_NAMES in store)) {
+                throw new Error(`In order to use withTrackedReducer, you must first enable the devtools feature via withDevtools('[your store name]', withGlitchTracking())`);
+            }
+            if (!store[DEVTOOL_FEATURE_NAMES].includes(GLITCH_TRACKING_FEATURE)) {
+                throw new Error(`In order to use withTrackedReducer, you must first enable the glitch tracking devtools feature via withDevtools('[your store name]', withGlitchTracking())`);
+            }
+            const events = getReducerEvents();
+            const updates = caseReducers.map((caseReducer) => events.on(...caseReducer.events).pipe(tap((event) => {
+                const state = untracked(() => getState(store));
+                const result = caseReducer.reducer(event, state);
+                const updaters = Array.isArray(result) ? result : [result];
+                updateState(store, event.type, ...updaters);
+            })));
+            merge(...updates)
+                .pipe(takeUntilDestroyed())
+                .subscribe();
+        },
+    })));
+}
+/**
+ * Returns the synchronous reducer event stream exposed by the dispatcher.
+ *
+ * NgRx's `Dispatcher` delivers events to `ReducerEvents` immediately but feeds
+ * the public `Events` stream via `queueScheduler`, which keeps work in a FIFO
+ * queue and executes scheduled tasks only after the current task completes
+ * ([rxjs.dev](https://rxjs.dev/api/index/const/queueScheduler)). When
+ * `GlitchTrackerService` captures the state change synchronously, that queued
+ * `Events` emission is processed afterward and DevTools records the update as
+ * `Store Update`. Tapping into the reducer stream keeps event names and state
+ * changes aligned.
+ *
+ * TODO(@ngrx): expose a synchronous events API (similar to what `withReducer` uses)
+ * so consumers do not need to reach into dispatcher internals.
+ */
+function getReducerEvents() {
+    const dispatcher = inject(Dispatcher);
+    return dispatcher.reducerEvents;
+}
 
 function assertActionFnSpecs(obj) {
     if (!obj || typeof obj !== 'object') {
@@ -677,6 +732,24 @@ function withRedux(redux) {
     };
 }
 
+function clearUndoRedo(store, opts) {
+    if (canClearUndoRedo(store)) {
+        store.__clearUndoRedo__(opts);
+    }
+    else {
+        throw new Error('Cannot clear undoRedo, since store is not configured with withUndoRedo()');
+    }
+}
+function canClearUndoRedo(store) {
+    if ('__clearUndoRedo__' in store &&
+        typeof store.__clearUndoRedo__ === 'function') {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
 function deriveCallStateKeys(collection) {
     return {
         callStateKey: collection ? `${collection}CallState` : 'callState',
@@ -978,6 +1051,129 @@ function withDataService(options) {
     }));
 }
 
+const defaultOptions$1 = {
+    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 lastRecord = null;
+    let skipOnce = false;
+    const normalized = {
+        ...defaultOptions$1,
+        ...options,
+    };
+    //
+    // Design Decision: This feature has its own
+    // internal state.
+    //
+    const undoStack = [];
+    const redoStack = [];
+    const canUndo = signal(false, ...(ngDevMode ? [{ debugName: "canUndo" }] : []));
+    const canRedo = signal(false, ...(ngDevMode ? [{ debugName: "canRedo" }] : []));
+    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 && lastRecord) {
+                redoStack.push(lastRecord);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState$1(store, item);
+                lastRecord = item;
+            }
+            updateInternal();
+        },
+        redo() {
+            const item = redoStack.pop();
+            if (item && lastRecord) {
+                undoStack.push(lastRecord);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState$1(store, item);
+                lastRecord = item;
+            }
+            updateInternal();
+        },
+        __clearUndoRedo__(opts) {
+            undoStack.splice(0);
+            redoStack.splice(0);
+            if (opts) {
+                lastRecord = opts.lastRecord;
+            }
+            updateInternal();
+        },
+    })), withMethods((store) => ({
+        /** @deprecated Use {@link clearUndoRedo} instead. */
+        clearStack() {
+            store.__clearUndoRedo__();
+        },
+    })), withHooks({
+        onInit(store) {
+            watchState(store, () => {
+                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(lastRecord)) {
+                    return;
+                }
+                // Clear redoStack after recorded action
+                redoStack.splice(0);
+                if (lastRecord) {
+                    undoStack.push(lastRecord);
+                }
+                if (redoStack.length > normalized.maxStackSize) {
+                    undoStack.unshift();
+                }
+                lastRecord = cand;
+                // Don't propogate current reactive context
+                untracked(() => updateInternal());
+            });
+        },
+    }));
+}
+
 /** 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
@@ -1174,122 +1370,6 @@ 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, ...(ngDevMode ? [{ debugName: "canUndo" }] : []));
-    const canRedo = signal(false, ...(ngDevMode ? [{ debugName: "canRedo" }] : []));
-    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) {
-            watchState(store, () => {
-                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.
@@ -1970,7 +2050,14 @@ function rxMutation(optionsOrOperation) {
 }
 
 //** Types for `withResource` */
-function withResource(resourceFactory) {
+const defaultOptions = {
+    errorHandling: 'undefined value',
+};
+function withResource(resourceFactory, resourceOptions) {
+    const options = {
+        ...defaultOptions,
+        ...(resourceOptions || {}),
+    };
     return (store) => {
         const resourceOrDictionary = resourceFactory({
             ...store.stateSignals,
@@ -1978,18 +2065,20 @@ function withResource(resourceFactory) {
             ...store.methods,
         });
         if (isResourceRef(resourceOrDictionary)) {
-            return createUnnamedResource(resourceOrDictionary)(store);
+            return createUnnamedResource(resourceOrDictionary, options.errorHandling)(store);
         }
         else {
-            return createNamedResource(resourceOrDictionary)(store);
+            return createNamedResource(resourceOrDictionary, options.errorHandling)(store);
         }
     };
 }
-function createUnnamedResource(resource) {
+function createUnnamedResource(resource, errorHandling) {
     function hasValue() {
         return resource.hasValue();
     }
-    return signalStoreFeature(withLinkedState(() => ({ value: resource.value })), withProps(() => ({
+    return signalStoreFeature(withLinkedState(() => ({
+        value: valueSignalForErrorHandling(resource, errorHandling),
+    })), withProps(() => ({
         status: resource.status,
         error: resource.error,
         isLoading: resource.isLoading,
@@ -1998,11 +2087,11 @@ function createUnnamedResource(resource) {
         _reload: () => resource.reload(),
     })));
 }
-function createNamedResource(dictionary) {
+function createNamedResource(dictionary, errorHandling) {
     const keys = Object.keys(dictionary);
     const state = keys.reduce((state, resourceName) => ({
         ...state,
-        [`${resourceName}Value`]: dictionary[resourceName].value,
+        [`${resourceName}Value`]: valueSignalForErrorHandling(dictionary[resourceName], errorHandling),
     }), {});
     const props = keys.reduce((props, resourceName) => ({
         ...props,
@@ -2067,6 +2156,65 @@ function mapToResource(store, name) {
         hasValue,
     };
 }
+function valueSignalForErrorHandling(res, errorHandling) {
+    const originalSignal = res.value;
+    switch (errorHandling) {
+        case 'native':
+            return originalSignal;
+        case 'undefined value': {
+            return new Proxy(originalSignal, {
+                apply(target) {
+                    const status = untracked(() => res.status());
+                    try {
+                        // Always call the underlying signal to ensure reactivity.
+                        const value = target();
+                        if (status === 'error') {
+                            return undefined;
+                        }
+                        return value;
+                    }
+                    catch (error) {
+                        if (status === 'error') {
+                            return undefined;
+                        }
+                        throw error;
+                    }
+                },
+            });
+        }
+        case 'previous value': {
+            let previousValue = undefined;
+            let hasPreviousValue = false;
+            return new Proxy(originalSignal, {
+                apply(target) {
+                    const status = untracked(() => res.status());
+                    try {
+                        // Always call the underlying signal to ensure reactivity.
+                        const value = target();
+                        if (status === 'error') {
+                            if (!hasPreviousValue) {
+                                throw new Error('Impossible state: previous value is not available -> resource was initialized with error');
+                            }
+                            return previousValue;
+                        }
+                        previousValue = value;
+                        hasPreviousValue = true;
+                        return value;
+                    }
+                    catch (error) {
+                        if (status === 'error') {
+                            if (!hasPreviousValue) {
+                                throw new Error('Impossible state: previous value is not available -> resource was initialized with error');
+                            }
+                            return previousValue;
+                        }
+                        throw error;
+                    }
+                },
+            });
+        }
+    }
+}
 
 function withEntityResources(entityResourceFactory) {
     return (store) => {
@@ -2081,38 +2229,67 @@ function withEntityResources(entityResourceFactory) {
         return createNamedEntityResources(resourceOrDict)(store);
     };
 }
+/**
+ * We cannot use the value of `resource` directly, but
+ * have to use the one created through {@link withResource}
+ * because {@link withResource} creates a Proxy around the resource value
+ * to avoid the error throwing behavior of the Resource API.
+ */
 function createUnnamedEntityResource(resource) {
-    const { idsLinked, entityMapLinked, entitiesSignal } = createEntityDerivations(resource.value);
-    return signalStoreFeature(withResource(() => resource), withLinkedState(() => ({
-        entityMap: entityMapLinked,
-        ids: idsLinked,
-    })), withComputed(() => ({
-        entities: entitiesSignal,
+    return signalStoreFeature(withResource(() => resource), withLinkedState(({ value }) => {
+        const { ids, entityMap } = createEntityDerivations(value);
+        return {
+            entityMap,
+            ids,
+        };
+    }), withComputed(({ ids, entityMap }) => ({
+        entities: createComputedEntities(ids, entityMap),
     })));
 }
+/**
+ * See {@link createUnnamedEntityResource} for why we cannot use the value of `resource` directly.
+ */
 function createNamedEntityResources(dictionary) {
     const keys = Object.keys(dictionary);
-    const linkedState = {};
-    const computedProps = {};
-    keys.forEach((name) => {
-        const ref = dictionary[name];
-        const { idsLinked, entityMapLinked, entitiesSignal } = createEntityDerivations(ref.value);
-        linkedState[`${String(name)}EntityMap`] = entityMapLinked;
-        linkedState[`${String(name)}Ids`] = idsLinked;
-        computedProps[`${String(name)}Entities`] = entitiesSignal;
+    const stateFactories = keys.map((name) => {
+        return (store) => {
+            const resourceValue = store[`${name}Value`];
+            if (!isSignal(resourceValue)) {
+                throw new Error(`Resource's value ${name}Value does not exist`);
+            }
+            const { ids, entityMap } = createEntityDerivations(resourceValue);
+            return {
+                [`${name}EntityMap`]: entityMap,
+                [`${name}Ids`]: ids,
+            };
+        };
     });
-    return signalStoreFeature(withResource(() => dictionary), withLinkedState(() => linkedState), withComputed(() => computedProps));
+    const computedFactories = keys.map((name) => {
+        return (store) => {
+            const ids = store[`${name}Ids`];
+            const entityMap = store[`${name}EntityMap`];
+            if (!isSignal(ids)) {
+                throw new Error(`Entity Resource's ids ${name}Ids does not exist`);
+            }
+            if (!isSignal(entityMap)) {
+                throw new Error(`Entity Resource's entityMap ${name}EntityMap does not exist`);
+            }
+            return {
+                [`${name}Entities`]: createComputedEntities(ids, entityMap),
+            };
+        };
+    });
+    return signalStoreFeature(withResource(() => dictionary), withLinkedState((store) => stateFactories.reduce((acc, factory) => ({ ...acc, ...factory(store) }), {})), withComputed((store) => computedFactories.reduce((acc, factory) => ({ ...acc, ...factory(store) }), {})));
 }
 /**
  * @internal
  * @description
  *
- * Creates the three entity-related signals (`ids`, `entityMap`, `entities`) from
+ * Creates the two entity-related state properties (`ids`, `entityMap`) from
  * a single source signal of entities. This mirrors the public contract of
  * `withEntities()`:
  * - `ids`: derived list of entity ids
  * - `entityMap`: map of id -> entity
- * - `entities`: projection of `ids` through `entityMap`
  *
  * Implementation details:
  * - Uses `withLinkedState` + `linkedSignal` for `ids` and `entityMap` so they are
@@ -2130,11 +2307,11 @@ function createNamedEntityResources(dictionary) {
  *   and avoids imperative syncing code.
  */
 function createEntityDerivations(source) {
-    const idsLinked = linkedSignal({
+    const ids = linkedSignal({
         source,
         computation: (list) => (list ?? []).map((e) => e.id),
     });
-    const entityMapLinked = linkedSignal({
+    const entityMap = linkedSignal({
         source,
         computation: (list) => {
             const map = {};
@@ -2144,12 +2321,12 @@ function createEntityDerivations(source) {
             return map;
         },
     });
-    const entitiesSignal = computed(() => {
-        const ids = idsLinked();
-        const map = entityMapLinked();
-        return ids.map((id) => map[id]);
-    }, ...(ngDevMode ? [{ debugName: "entitiesSignal" }] : []));
-    return { idsLinked, entityMapLinked, entitiesSignal };
+    return { ids, entityMap };
+}
+function createComputedEntities(ids, entityMap) {
+    return () => {
+        return ids().map((id) => entityMap()[id]);
+    };
 }
 
 function withMutations(mutationsFactory) {
@@ -2289,5 +2466,5 @@ function httpMutation(optionsOrRequest) {
  * Generated bundle index. Do not edit.
  */
 
-export { capitalize, concatOp, createEffects, createPageArray, createReducer, deriveCallStateKeys, emptyFeature, exhaustOp, firstPage, getCallStateKeys, getCollectionArray, getDataServiceKeys, getUndoRedoKeys, gotoPage, httpMutation, mapToResource, mergeOp, nextPage, noPayload, patchState, payload, previousPage, provideDevtoolsConfig, renameDevtoolsName, rxMutation, setError, setLoaded, setLoading, setMaxPageNavigationArrayItems, setPageSize, setResetState, switchOp, updateState, withCallState, withConditional, withDataService, withDevToolsStub, withDevtools, withDisabledNameIndices, withEntityResources, withFeatureFactory, withGlitchTracking, withImmutableState, withIndexedDB, withIndexedDB as withIndexeddb, withLocalStorage, withMapper, withMutations, withPagination, withRedux, withReset, withResource, withSessionStorage, withStorageSync, withUndoRedo };
+export { capitalize, clearUndoRedo, concatOp, createEffects, createPageArray, createReducer, deriveCallStateKeys, emptyFeature, exhaustOp, firstPage, getCallStateKeys, getCollectionArray, getDataServiceKeys, getUndoRedoKeys, gotoPage, httpMutation, mapToResource, mergeOp, nextPage, noPayload, patchState, payload, previousPage, provideDevtoolsConfig, renameDevtoolsName, rxMutation, setError, setLoaded, setLoading, setMaxPageNavigationArrayItems, setPageSize, setResetState, switchOp, updateState, withCallState, withConditional, withDataService, withDevToolsStub, withDevtools, withDisabledNameIndices, withEntityResources, withFeatureFactory, withGlitchTracking, withImmutableState, withIndexedDB, withIndexedDB as withIndexeddb, withLocalStorage, withMapper, withMutations, withPagination, withRedux, withReset, withResource, withSessionStorage, withStorageSync, withTrackedReducer, withUndoRedo };
 //# sourceMappingURL=angular-architects-ngrx-toolkit.mjs.map