@angular-architects/ngrx-toolkit 20.4.1 → 20.5.0

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

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { Injectable, InjectionToken, signal, effect, inject, PLATFORM_ID, computed, isSignal, untracked, isDevMode as isDevMode$1, DestroyRef } 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 { isPlatformBrowser, isPlatformServer } from '@angular/common';
 import { Subject, switchMap, mergeMap, concatMap, exhaustMap, defer, tap, catchError, EMPTY, finalize, filter, map } from 'rxjs';
@@ -270,11 +270,11 @@ class DevtoolsSyncer {
      */
     #currentState = {};
     #currentId = 1;
-    #connection = this.#isBrowser
+    #connection = inject(NgZone).runOutsideAngular(() => this.#isBrowser
         ? window.__REDUX_DEVTOOLS_EXTENSION__
             ? window.__REDUX_DEVTOOLS_EXTENSION__.connect(this.#devtoolsConfig)
             : dummyConnection
-        : dummyConnection;
+        : dummyConnection);
     constructor() {
         if (!this.#isBrowser) {
             return;
@@ -1969,41 +1969,6 @@ function rxMutation(optionsOrOperation) {
     return mutation;
 }
 
-function withMutations(mutationsFactory) {
-    return (store) => {
-        // TODO: Is this the correct usage?
-        const source = store;
-        const mutations = mutationsFactory({
-            ...source,
-            ...store.props,
-            ...store.methods,
-            ...store.stateSignals,
-        });
-        const feature = createMutationsFeature(mutations);
-        return feature(store);
-    };
-}
-function createMutationsFeature(mutations) {
-    const keys = Object.keys(mutations);
-    const feature = signalStoreFeature(withMethods(() => keys.reduce((acc, key) => ({
-        ...acc,
-        [key]: async (params) => {
-            const mutation = mutations[key];
-            if (!mutation) {
-                throw new Error(`Mutation ${key} not found`);
-            }
-            const result = await mutation(params);
-            return result;
-        },
-    }), {})), withComputed(() => keys.reduce((acc, key) => ({
-        ...acc,
-        [`${key}IsPending`]: mutations[key].isPending,
-        [`${key}Status`]: mutations[key].status,
-        [`${key}Error`]: mutations[key].error,
-    }), {})));
-    return feature;
-}
-
 //** Types for `withResource` */
 function withResource(resourceFactory) {
     return (store) => {
@@ -2103,6 +2068,125 @@ function mapToResource(store, name) {
     };
 }
 
+function withEntityResources(entityResourceFactory) {
+    return (store) => {
+        const resourceOrDict = entityResourceFactory({
+            ...store.stateSignals,
+            ...store.props,
+            ...store.methods,
+        });
+        if (isResourceRef(resourceOrDict)) {
+            return createUnnamedEntityResource(resourceOrDict)(store);
+        }
+        return createNamedEntityResources(resourceOrDict)(store);
+    };
+}
+function createUnnamedEntityResource(resource) {
+    const { idsLinked, entityMapLinked, entitiesSignal } = createEntityDerivations(resource.value);
+    return signalStoreFeature(withResource(() => resource), withLinkedState(() => ({
+        entityMap: entityMapLinked,
+        ids: idsLinked,
+    })), withComputed(() => ({
+        entities: entitiesSignal,
+    })));
+}
+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;
+    });
+    return signalStoreFeature(withResource(() => dictionary), withLinkedState(() => linkedState), withComputed(() => computedProps));
+}
+/**
+ * @internal
+ * @description
+ *
+ * Creates the three entity-related signals (`ids`, `entityMap`, `entities`) 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
+ *   writable state signals in the store (updaters like `addEntity` can mutate them).
+ * - `entities` is a pure `computed` derived from `ids` and `entityMap`, matching
+ *   the pattern in `withEntities` where `entities` is computed from the two bases.
+ *
+ * Why not `watchState` or `effect`?
+ * - `watchState` would fire for any state change in the store, not just changes
+ *   to the underlying resource value. That would cause unnecessary recomputation
+ *   and make it harder to reason about updates.
+ * - `effect` would introduce side-effects and lifecycle management for syncing,
+ *   which is heavier and not aligned with this feature's goal to be purely
+ *   derived from signals. Using linked signals keeps the data flow declarative
+ *   and avoids imperative syncing code.
+ */
+function createEntityDerivations(source) {
+    const idsLinked = linkedSignal({
+        source,
+        computation: (list) => (list ?? []).map((e) => e.id),
+    });
+    const entityMapLinked = linkedSignal({
+        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 };
+}
+
+function withMutations(mutationsFactory) {
+    return (store) => {
+        // TODO: Is this the correct usage?
+        const source = store;
+        const mutations = mutationsFactory({
+            ...source,
+            ...store.props,
+            ...store.methods,
+            ...store.stateSignals,
+        });
+        const feature = createMutationsFeature(mutations);
+        return feature(store);
+    };
+}
+function createMutationsFeature(mutations) {
+    const keys = Object.keys(mutations);
+    const feature = signalStoreFeature(withMethods(() => keys.reduce((acc, key) => ({
+        ...acc,
+        [key]: async (params) => {
+            const mutation = mutations[key];
+            if (!mutation) {
+                throw new Error(`Mutation ${key} not found`);
+            }
+            const result = await mutation(params);
+            return result;
+        },
+    }), {})), withComputed(() => keys.reduce((acc, key) => ({
+        ...acc,
+        [`${key}IsPending`]: mutations[key].isPending,
+        [`${key}Status`]: mutations[key].status,
+        [`${key}Error`]: mutations[key].error,
+    }), {})));
+    return feature;
+}
+
 /**
  * Creates an HTTP mutation.
  *
@@ -2205,5 +2289,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, withFeatureFactory, withGlitchTracking, withImmutableState, withIndexedDB, withIndexedDB as withIndexeddb, withLocalStorage, withMapper, withMutations, withPagination, withRedux, withReset, withResource, withSessionStorage, withStorageSync, withUndoRedo };
+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 };
 //# sourceMappingURL=angular-architects-ngrx-toolkit.mjs.map