@angular-architects/ngrx-toolkit 20.5.0 → 21.0.0

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

@@ -1,8 +1,10 @@
 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 { withEventHandlers, ReducerEvents } from '@ngrx/signals/events';
+import { tap } from 'rxjs/operators';
+import { Subject, switchMap, mergeMap, concatMap, exhaustMap, defer, tap as tap$1, catchError, EMPTY, finalize, filter, map } from 'rxjs';
 import { removeEntity, setAllEntities, updateEntity, addEntity } from '@ngrx/signals/entities';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { HttpClient, HttpEventType, HttpResponse } from '@angular/common/http';
@@ -92,14 +94,15 @@ class GlitchTrackerService {
             this.#callback({ [id]: getState(this.#stores[id].store) });
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: GlitchTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: GlitchTrackerService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: GlitchTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: GlitchTrackerService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: GlitchTrackerService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: GlitchTrackerService, decorators: [{
             type: Injectable,
             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 +133,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,
+    });
 }
 
 /**
@@ -218,10 +224,10 @@ class DefaultTracker {
             });
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: DefaultTracker, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: DefaultTracker, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: DefaultTracker, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: DefaultTracker, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: DefaultTracker, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: DefaultTracker, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -388,17 +394,18 @@ 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: "20.1.3", ngImport: i0, type: DevtoolsSyncer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: DevtoolsSyncer, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: DevtoolsSyncer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: DevtoolsSyncer, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: DevtoolsSyncer, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: DevtoolsSyncer, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
 
 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 +430,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 +485,31 @@ 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(),
+    }, withEventHandlers((store, events = inject(ReducerEvents)) => 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);
+    })))), 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())`);
+            }
+        },
+    })));
+}
 
 function assertActionFnSpecs(obj) {
     if (!obj || typeof obj !== 'object') {
@@ -677,6 +709,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 +1028,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 +1347,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.
@@ -1455,10 +1512,10 @@ class IndexedDBService {
             };
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: IndexedDBService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: IndexedDBService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: IndexedDBService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: IndexedDBService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: IndexedDBService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: IndexedDBService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -1539,10 +1596,10 @@ class LocalStorageService {
     clear(key) {
         return localStorage.removeItem(key);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: LocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: LocalStorageService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: LocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: LocalStorageService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: LocalStorageService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: LocalStorageService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -1559,10 +1616,10 @@ class SessionStorageService {
     clear(key) {
         return sessionStorage.removeItem(key);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: SessionStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: SessionStorageService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: SessionStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: SessionStorageService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: SessionStorageService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: SessionStorageService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -1910,7 +1967,7 @@ function rxMutation(optionsOrOperation) {
         .pipe(flatteningOp.rxJsOperator((input) => defer(() => {
         callCount.update((c) => c + 1);
         idle.set(false);
-        return options.operation(input.param).pipe(tap((result) => {
+        return options.operation(input.param).pipe(tap$1((result) => {
             options.onSuccess?.(result, input.param);
             innerStatus = 'success';
             errorSignal.set(undefined);
@@ -1970,7 +2027,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 +2042,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 +2064,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 +2133,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 +2206,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,
+            };
+        };
+    });
+    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(() => linkedState), withComputed(() => computedProps));
+    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,26 +2284,22 @@ function createNamedEntityResources(dictionary) {
  *   and avoids imperative syncing code.
  */
 function createEntityDerivations(source) {
-    const idsLinked = linkedSignal({
-        source,
-        computation: (list) => (list ?? []).map((e) => e.id),
-    });
-    const entityMapLinked = linkedSignal({
-        source,
+    const ids = linkedSignal({ ...(ngDevMode ? { debugName: "ids" } : {}), source,
+        computation: (list) => (list ?? []).map((e) => e.id) });
+    const entityMap = linkedSignal({ ...(ngDevMode ? { debugName: "entityMap" } : {}), source,
         computation: (list) => {
             const map = {};
             for (const item of list ?? []) {
                 map[item.id] = item;
             }
             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) {
@@ -2264,14 +2414,14 @@ function httpMutation(optionsOrRequest) {
                     observe: 'events',
                     responseType: 'json',
                 })
-                    .pipe(tap((response) => {
+                    .pipe(tap$1((response) => {
                     if (response.type === HttpEventType.UploadProgress) {
                         uploadProgress.set(response);
                     }
                     else if (response.type === HttpEventType.DownloadProgress) {
                         downloadProgress.set(response);
                     }
-                }), filter((event) => event instanceof HttpResponse), tap((response) => {
+                }), filter((event) => event instanceof HttpResponse), tap$1((response) => {
                     headers.set(response.headers);
                     statusCode.set(response.status.toString());
                 }), map((event) => parse(event.body)));
@@ -2289,5 +2439,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