@angular-architects/ngrx-toolkit 19.0.1 → 19.1.0

package/README.md

@@ -9,6 +9,6 @@ NgRx Toolkit is a set of extensions to the NgRx Signals Store, like
 - Storage Sync: Synchronize the Store with Web Storage
 - Redux Connector: Map NgRx Store Actions to a present Signal Store
 
-For a more detailed guide on installation, setup, and usage, head to the [**Documentation**](https://angular-architects.github.io/ngrx-toolkit/).
+For a more detailed guide on installation, setup, and usage, head to the [**Documentation**](https://ngrx-toolkit.angulararchitects.io//).
 
-## https://angular-architects.github.io/ngrx-toolkit
+## https://ngrx-toolkit.angulararchitects.io/

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

@@ -42,10 +42,10 @@ class SignalReduxStore {
             resultMethod: mapper.resultMethod
         }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: SignalReduxStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: SignalReduxStore, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: SignalReduxStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: SignalReduxStore, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: SignalReduxStore, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: SignalReduxStore, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'

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

@@ -1,6 +1,6 @@
 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 { inject, PLATFORM_ID, Injectable, signal, effect, InjectionToken, computed, isSignal, untracked, isDevMode as isDevMode$1 } from '@angular/core';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
 import { Subject } from 'rxjs';
 import { setAllEntities, addEntity, updateEntity, removeEntity } from '@ngrx/signals/entities';
@@ -106,7 +106,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,10 +168,10 @@ 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.1.4", ngImport: i0, type: DevtoolsSyncer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", 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.1.4", ngImport: i0, type: DevtoolsSyncer, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
@@ -214,17 +216,17 @@ class DefaultTracker {
             });
         }
     }
-    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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: DefaultTracker, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: DefaultTracker, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DefaultTracker, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", 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 +241,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();
@@ -382,10 +380,10 @@ class GlitchTrackerService {
             this.#callback({ [id]: getState(this.#stores[id].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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: GlitchTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: GlitchTrackerService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: GlitchTrackerService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: GlitchTrackerService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -464,6 +462,98 @@ function payload() {
     return {};
 }
 const noPayload = {};
+/**
+ * Creates a reducer function to separate the reducer logic into another file.
+ *
+ * ```typescript
+ * interface FlightState {
+ *   flights: Flight[];
+ *   effect1: boolean;
+ *   effect2: boolean;
+ * }
+ *
+ * const initialState: FlightState = {
+ *   flights: [],
+ *   effect1: false,
+ *   effect2: false,
+ * };
+ *
+ * const actions = {
+ *   init: noPayload,
+ *   updateEffect1: payload<{ value: boolean }>(),
+ *   updateEffect2: payload<{ value: boolean }>(),
+ * };
+ *
+ * const reducer = createReducer<FlightState, typeof actions>((actions, on) => {
+ *   on(actions.updateEffect1, (state, { value }) => {
+ *     patchState(state, { effect1: value });
+ *   });
+ *
+ *   on(actions.updateEffect2, (state, { value }) => {
+ *     patchState(state, { effect2: value });
+ *   });
+ * });
+ *
+ * signalStore(
+ *   withState(initialState),
+ *   withRedux({
+ *     actions,
+ *     reducer,
+ *   })
+ * );
+ * ```
+ * @param reducerFactory
+ */
+function createReducer(reducerFactory) {
+    return reducerFactory;
+}
+/**
+ * Creates the effects function to separate the effects logic into another file.
+ *
+ * ```typescript
+ * interface FlightState {
+ *   flights: Flight[];
+ *   effect1: boolean;
+ *   effect2: boolean;
+ * }
+ *
+ * const initialState: FlightState = {
+ *   flights: [],
+ *   effect1: false,
+ *   effect2: false,
+ * };
+ *
+ * const actions = {
+ *   init: noPayload,
+ *   updateEffect1: payload<{ value: boolean }>(),
+ *   updateEffect2: payload<{ value: boolean }>(),
+ * };
+ *
+ * const effects = createEffects(actions, (actions, create) => {
+ *   return {
+ *     init1$: create(actions.init).pipe(
+ *       map(() => actions.updateEffect1({ value: true }))
+ *     ),
+ *     init2$: create(actions.init).pipe(
+ *       map(() => actions.updateEffect2({ value: true }))
+ *     ),
+ *   };
+ * });
+ *
+ * signalStore(
+ *   withState(initialState),
+ *   withRedux({
+ *     actions,
+ *     effects,
+ *   })
+ * );
+ * ```
+ * @param actions
+ * @param effectsFactory
+ */
+function createEffects(actions, effectsFactory) {
+    return effectsFactory;
+}
 function createActionFns(actionFnSpecs, reducerRegistry, effectsRegistry, state) {
     const actionFns = {};
     for (const type in actionFnSpecs) {
@@ -553,7 +643,7 @@ function withRedux(redux) {
         const { methods } = processRedux(redux.actions, redux.reducer, redux.effects, store);
         return {
             ...store,
-            methods,
+            methods: { ...store.methods, ...methods },
         };
     };
 }
@@ -995,7 +1085,7 @@ function withStorageSync(configOrKey) {
  * 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);
+    const { pageKey, pageSizeKey, entitiesKey, selectedPageEntitiesKey, totalCountKey, pageCountKey, pageNavigationArrayMaxKey, pageNavigationArrayKey, hasNextPageKey, hasPreviousPageKey, } = createPaginationKeys(options);
     return signalStoreFeature(withState({
         [pageKey]: 0,
         [pageSizeKey]: 10,
@@ -1029,30 +1119,6 @@ function withPagination(options) {
                 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) {
@@ -1116,24 +1182,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';
@@ -1149,12 +1197,6 @@ function createPaginationKeys(options) {
         pageCountKey,
         pageNavigationArrayKey,
         pageNavigationArrayMaxKey,
-        setPageSizeKey,
-        nextPageKey,
-        previousPageKey,
-        lastPageKey,
-        firstPageKey,
-        gotoPageKey,
         hasNextPageKey,
         hasPreviousPageKey,
     };
@@ -1231,9 +1273,171 @@ function setResetState(store, state) {
     store.__setResetState__(state);
 }
 
+/**
+ * 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);
+            });
+        },
+    })));
+}
+
+/**
+ * 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);
+    };
+}
+
+/**
+ * `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({}));
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { capitalize, createPageArray, firstPage, getCallStateKeys, getDataServiceKeys, getUndoRedoKeys, gotoPage, nextPage, noPayload, patchState, payload, previousPage, renameDevtoolsName, setError, setLoaded, setLoading, setMaxPageNavigationArrayItems, setPageSize, setResetState, updateState, withCallState, withDataService, withDevToolsStub, withDevtools, withDisabledNameIndices, withGlitchTracking, withMapper, withPagination, withRedux, withReset, withStorageSync, withUndoRedo };
+export { capitalize, createEffects, createPageArray, createReducer, emptyFeature, firstPage, getCallStateKeys, getDataServiceKeys, getUndoRedoKeys, gotoPage, nextPage, noPayload, patchState, payload, previousPage, renameDevtoolsName, setError, setLoaded, setLoading, setMaxPageNavigationArrayItems, setPageSize, setResetState, updateState, withCallState, withConditional, withDataService, withDevToolsStub, withDevtools, withDisabledNameIndices, withFeatureFactory, withGlitchTracking, withImmutableState, withMapper, withPagination, withRedux, withReset, withStorageSync, withUndoRedo };
 //# sourceMappingURL=angular-architects-ngrx-toolkit.mjs.map