@angular-architects/ngrx-toolkit 19.4.0 → 19.4.2

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

@@ -0,0 +1,2108 @@
+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 { watchState, getState, signalStoreFeature, withMethods, withHooks, patchState as patchState$1, withState, withComputed, withProps } 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 { HttpClient, HttpEventType, HttpResponse } from '@angular/common/http';
+
+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 });
+}
+
+function throwIfNull(obj) {
+    if (obj === null || obj === undefined) {
+        throw new Error('');
+    }
+    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,
+};
+/**
+ * A service provided by the root injector is
+ * required because the synchronization runs
+ * globally.
+ *
+ * The SignalStore could be provided in a component.
+ * If the effect starts in the injection
+ * context of the SignalStore, the complete sync
+ * process would shut down once the component gets
+ * destroyed.
+ */
+class DevtoolsSyncer {
+    /**
+     * Stores all SignalStores that are connected to the
+     * DevTools along their options, names and id.
+     */
+    #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.
+     *
+     * The challenge lies in ensuring that glitched trackers do not
+     * interfere with the synchronization process of glitch-free trackers.
+     * Specifically, glitched trackers could cause the synchronization to
+     * read the current state of stores managed by glitch-free trackers.
+     *
+     * Therefore, the synchronization process doesn't read the state from
+     * each store, but relies on #currentState.
+     *
+     * Please note, that here the key is the name and not the id.
+     */
+    #currentState = {};
+    #currentId = 1;
+    #connection = this.#isBrowser
+        ? window.__REDUX_DEVTOOLS_EXTENSION__
+            ? window.__REDUX_DEVTOOLS_EXTENSION__.connect(this.#devtoolsConfig)
+            : dummyConnection
+        : dummyConnection;
+    constructor() {
+        if (!this.#isBrowser) {
+            return;
+        }
+    }
+    ngOnDestroy() {
+        currentActionNames.clear();
+    }
+    syncToDevTools(changedStatePerId) {
+        const mappedChangedStatePerName = Object.entries(changedStatePerId).reduce((acc, [id, store]) => {
+            const { options, name } = this.#stores[id];
+            acc[name] = options.map(store);
+            return acc;
+        }, {});
+        this.#currentState = {
+            ...this.#currentState,
+            ...mappedChangedStatePerName,
+        };
+        const names = Array.from(currentActionNames);
+        const type = names.length ? names.join(', ') : 'Store Update';
+        currentActionNames.clear();
+        this.#connection.send({ type }, this.#currentState);
+    }
+    getNextId() {
+        return String(this.#currentId++);
+    }
+    /**
+     * Consumer provides the id. That is because we can only start
+     * tracking the store in the init hook.
+     * Unfortunately, methods for renaming having the final id
+     * need to be defined already before.
+     * That's why `withDevtools` requests first the id and
+     * then registers itself later.
+     */
+    addStore(id, name, store, options) {
+        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)
+            // );
+            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.`);
+            }
+        }
+        for (let i = 1; names.includes(storeName); i++) {
+            storeName = `${name}-${i}`;
+        }
+        this.#stores[id] = { name: storeName, options };
+        const tracker = options.tracker;
+        if (!this.#trackers.includes(tracker)) {
+            this.#trackers.push(tracker);
+        }
+        tracker.onChange((changedState) => this.syncToDevTools(changedState));
+        tracker.track(id, store);
+    }
+    removeStore(id) {
+        const name = this.#stores[id].name;
+        this.#stores = Object.entries(this.#stores).reduce((newStore, [storeId, value]) => {
+            if (storeId !== id) {
+                newStore[storeId] = value;
+            }
+            return newStore;
+        }, {});
+        this.#currentState = Object.entries(this.#currentState).reduce((newState, [storeName, state]) => {
+            if (storeName !== name) {
+                newState[storeName] = state;
+            }
+            return newState;
+        }, {});
+        for (const tracker of this.#trackers) {
+            tracker.removeStore(id);
+        }
+    }
+    /**
+     * Renames a store identified by its internal id. If the store has already
+     * been removed (e.g. due to component destruction), this is a no-op.
+     */
+    renameStore(id, newName) {
+        const storeEntry = this.#stores[id];
+        if (!storeEntry) {
+            return;
+        }
+        const oldName = storeEntry.name;
+        if (oldName === newName) {
+            return;
+        }
+        const otherStoreNames = Object.entries(this.#stores)
+            .filter(([entryId]) => entryId !== id)
+            .map(([, s]) => s.name);
+        if (otherStoreNames.includes(newName)) {
+            throw new Error(`NgRx Toolkit/DevTools: cannot rename from ${oldName} to ${newName}. ${newName} is already assigned to another SignalStore instance.`);
+        }
+        this.#stores = Object.entries(this.#stores).reduce((newStore, [entryId, value]) => {
+            if (entryId === id) {
+                newStore[entryId] = { ...value, name: newName };
+            }
+            else {
+                newStore[entryId] = value;
+            }
+            return newStore;
+        }, {});
+        // we don't rename in #currentState but wait for tracker to notify
+        // us with a changed state that contains that name.
+        this.#currentState = Object.entries(this.#currentState).reduce((newState, [storeName, state]) => {
+            if (storeName !== oldName) {
+                newState[storeName] = state;
+            }
+            return newState;
+        }, {});
+        this.#trackers.forEach((tracker) => tracker.notifyRenamedStore(id));
+    }
+    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.2.14", 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' });
+/**
+ * Adds this store as a feature state to the Redux DevTools.
+ *
+ * By default, the action name is 'Store Update'. You can
+ * change that via the {@link updateState} method, which has as second
+ * parameter the action name.
+ *
+ * The standalone function {@link renameDevtoolsName} can rename
+ * the store name.
+ *
+ * @param name name of the store as it should appear in the DevTools
+ * @param features features to extend or modify the behavior of the Devtools
+ */
+function withDevtools(name, ...features) {
+    return signalStoreFeature(withMethods(() => {
+        const syncer = inject(DevtoolsSyncer);
+        const id = syncer.getNextId();
+        // TODO: use withProps and symbols
+        return {
+            [renameDevtoolsMethodName]: (newName) => {
+                syncer.renameStore(id, newName);
+            },
+            [uniqueDevtoolsId]: () => id,
+        };
+    }), 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),
+                    tracker: inject(features.find((f) => f.tracker)?.tracker || DefaultTracker),
+                };
+                syncer.addStore(id, name, store, finalOptions);
+            },
+            onDestroy() {
+                syncer.removeStore(id);
+            },
+        };
+    }));
+}
+
+/**
+ * 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
+ */
+function renameDevtoolsName(store, newName) {
+    const renameMethod = store[renameDevtoolsMethodName];
+    if (!renameMethod) {
+        throw new Error("Devtools extensions haven't been added to this store.");
+    }
+    renameMethod(newName);
+}
+
+/**
+ * @deprecated Has been renamed to `updateState`
+ */
+const patchState = (state, action, ...rest) => {
+    updateState(state, action, ...rest);
+};
+/**
+ * Wrapper of `patchState` for DevTools integration. Next to updating the state,
+ * it also sends the action to the DevTools.
+ * @param stateSource state of Signal Store
+ * @param action name of action how it will show in DevTools
+ * @param updaters updater functions or objects
+ */
+function updateState(stateSource, action, ...updaters) {
+    currentActionNames.add(action);
+    return patchState$1(stateSource, ...updaters);
+}
+
+/**
+ * Stub for DevTools integration. Can be used to disable DevTools in production.
+ */
+const withDevToolsStub = () => (store) => store;
+
+function assertActionFnSpecs(obj) {
+    if (!obj || typeof obj !== 'object') {
+        throw new Error('%o is not an Action Specification');
+    }
+}
+
+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;
+}
+/**
+ * @deprecated Use NgRx's `@ngrx/signals/events` starting in 19.2
+ *
+ * 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) {
+        const actionFn = (payload) => {
+            const fullPayload = { ...payload, type };
+            const reducer = reducerRegistry[type];
+            if (reducer) {
+                reducer(state, fullPayload);
+            }
+            const effectSubjects = effectsRegistry[type];
+            if (effectSubjects?.length) {
+                for (const effectSubject of effectSubjects) {
+                    effectSubject.next(fullPayload);
+                }
+            }
+            return fullPayload;
+        };
+        actionFn.type = type.toString();
+        actionFns[type] = actionFn;
+    }
+    return actionFns;
+}
+function createPublicAndAllActionsFns(actionFnSpecs, reducerRegistry, effectsRegistry, state) {
+    if ('public' in actionFnSpecs || 'private' in actionFnSpecs) {
+        const privates = actionFnSpecs['private'] || {};
+        const publics = actionFnSpecs['public'] || {};
+        assertActionFnSpecs(privates);
+        assertActionFnSpecs(publics);
+        const privateActionFns = createActionFns(privates, reducerRegistry, effectsRegistry, state);
+        const publicActionFns = createActionFns(publics, reducerRegistry, effectsRegistry, state);
+        return {
+            all: { ...privateActionFns, ...publicActionFns },
+            publics: publicActionFns,
+        };
+    }
+    const actionFns = createActionFns(actionFnSpecs, reducerRegistry, effectsRegistry, state);
+    return { all: actionFns, publics: actionFns };
+}
+function fillReducerRegistry(reducer, actionFns, reducerRegistry) {
+    function on(action, reducerFn) {
+        reducerRegistry[action.type] = reducerFn;
+    }
+    reducer(actionFns, on);
+    return reducerRegistry;
+}
+function fillEffects(effects, actionFns, effectsRegistry = {}) {
+    function create(action) {
+        const subject = new Subject();
+        if (!(action.type in effectsRegistry)) {
+            effectsRegistry[action.type] = [];
+        }
+        effectsRegistry[action.type].push(subject);
+        return subject.asObservable();
+    }
+    const effectObservables = effects(actionFns, create);
+    return Object.values(effectObservables);
+}
+function startSubscriptions(observables) {
+    return observables.map((observable) => observable.subscribe());
+}
+function processRedux(actionFnSpecs, reducer, effects, store) {
+    const reducerRegistry = {};
+    const effectsRegistry = {};
+    const actionsMap = createPublicAndAllActionsFns(actionFnSpecs, reducerRegistry, effectsRegistry, store);
+    const actionFns = actionsMap.all;
+    const publicActionsFns = actionsMap.publics;
+    fillReducerRegistry(reducer, actionFns, reducerRegistry);
+    const effectObservables = fillEffects(effects, actionFns, effectsRegistry);
+    const subscriptions = startSubscriptions(effectObservables);
+    return {
+        methods: publicActionsFns,
+        subscriptions: subscriptions,
+    };
+}
+/**
+ * @param redux redux
+ *
+ * properties do not start with `with` since they are not extension functions on their own.
+ *
+ * no dependency to NgRx
+ *
+ * actions are passed to reducer and effects, but it is also possible to use other actions.
+ * effects provide forAction and do not return anything. that is important because effects should stay inaccessible
+ */
+function withRedux(redux) {
+    return (store) => {
+        const { methods } = processRedux(redux.actions, redux.reducer, redux.effects, store);
+        return {
+            ...store,
+            methods: { ...store.methods, ...methods },
+        };
+    };
+}
+
+function deriveCallStateKeys(collection) {
+    return {
+        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) {
+    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'),
+            [loadedKey]: computed(() => callState() === 'loaded'),
+            [errorKey]: computed(() => {
+                const v = callState();
+                return typeof v === 'object' ? v.error : null;
+            }),
+        };
+    }));
+}
+function setLoading(prop) {
+    if (prop) {
+        return { [`${prop}CallState`]: 'loading' };
+    }
+    return { callState: 'loading' };
+}
+function setLoaded(prop) {
+    if (prop) {
+        return { [`${prop}CallState`]: 'loaded' };
+    }
+    else {
+        return { callState: 'loaded' };
+    }
+}
+function setError(error, prop) {
+    let errorMessage;
+    if (!error) {
+        errorMessage = '';
+    }
+    else if (typeof error === 'object' && 'message' in error) {
+        errorMessage = String(error.message);
+    }
+    else {
+        errorMessage = String(error);
+    }
+    if (prop) {
+        return {
+            [`${prop}CallState`]: { error: errorMessage },
+        };
+    }
+    else {
+        return { callState: { error: errorMessage } };
+    }
+}
+
+function capitalize(str) {
+    return str ? str[0].toUpperCase() + str.substring(1) : str;
+}
+function getDataServiceKeys(options) {
+    const filterKey = options.collection
+        ? `${options.collection}Filter`
+        : 'filter';
+    const selectedIdsKey = options.collection
+        ? `selected${capitalize(options.collection)}Ids`
+        : 'selectedIds';
+    const selectedEntitiesKey = options.collection
+        ? `selected${capitalize(options.collection)}Entities`
+        : 'selectedEntities';
+    const updateFilterKey = options.collection
+        ? `update${capitalize(options.collection)}Filter`
+        : 'updateFilter';
+    const updateSelectedKey = options.collection
+        ? `updateSelected${capitalize(options.collection)}Entities`
+        : 'updateSelected';
+    const loadKey = options.collection
+        ? `load${capitalize(options.collection)}Entities`
+        : 'load';
+    const currentKey = options.collection
+        ? `current${capitalize(options.collection)}`
+        : 'current';
+    const loadByIdKey = options.collection
+        ? `load${capitalize(options.collection)}ById`
+        : 'loadById';
+    const setCurrentKey = options.collection
+        ? `setCurrent${capitalize(options.collection)}`
+        : 'setCurrent';
+    const createKey = options.collection
+        ? `create${capitalize(options.collection)}`
+        : 'create';
+    const updateKey = options.collection
+        ? `update${capitalize(options.collection)}`
+        : 'update';
+    const updateAllKey = options.collection
+        ? `updateAll${capitalize(options.collection)}`
+        : 'updateAll';
+    const deleteKey = options.collection
+        ? `delete${capitalize(options.collection)}`
+        : 'delete';
+    // TODO: Take these from @ngrx/signals/entities, when they are exported
+    const entitiesKey = options.collection
+        ? `${options.collection}Entities`
+        : 'entities';
+    const entityMapKey = options.collection
+        ? `${options.collection}EntityMap`
+        : 'entityMap';
+    const idsKey = options.collection ? `${options.collection}Ids` : 'ids';
+    return {
+        filterKey,
+        selectedIdsKey,
+        selectedEntitiesKey,
+        updateFilterKey,
+        updateSelectedKey,
+        loadKey,
+        entitiesKey,
+        entityMapKey,
+        idsKey,
+        currentKey,
+        loadByIdKey,
+        setCurrentKey,
+        createKey,
+        updateKey,
+        updateAllKey,
+        deleteKey,
+    };
+}
+function withDataService(options) {
+    const { dataServiceType, filter, collection: prefix } = options;
+    const { entitiesKey, filterKey, loadKey, selectedEntitiesKey, selectedIdsKey, updateFilterKey, updateSelectedKey, currentKey, createKey, updateKey, updateAllKey, deleteKey, loadByIdKey, setCurrentKey, } = getDataServiceKeys(options);
+    const { callStateKey } = getCallStateKeys({ collection: prefix });
+    return signalStoreFeature(withState(() => ({
+        [filterKey]: filter,
+        [selectedIdsKey]: {},
+        [currentKey]: undefined,
+    })), withComputed((store) => {
+        const entities = store[entitiesKey];
+        const selectedIds = store[selectedIdsKey];
+        return {
+            [selectedEntitiesKey]: computed(() => entities().filter((e) => selectedIds()[e.id])),
+        };
+    }), withMethods((store) => {
+        const dataService = inject(dataServiceType);
+        return {
+            [updateFilterKey]: (filter) => {
+                patchState$1(store, { [filterKey]: filter });
+            },
+            [updateSelectedKey]: (id, selected) => {
+                patchState$1(store, (state) => ({
+                    [selectedIdsKey]: {
+                        ...state[selectedIdsKey],
+                        [id]: selected,
+                    },
+                }));
+            },
+            [loadKey]: async () => {
+                const filter = store[filterKey];
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
+                try {
+                    const result = await dataService.load(filter());
+                    patchState$1(store, prefix
+                        ? setAllEntities(result, { collection: prefix })
+                        : setAllEntities(result));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
+                }
+                catch (e) {
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
+                    throw e;
+                }
+            },
+            [loadByIdKey]: async (id) => {
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
+                try {
+                    const current = await dataService.loadById(id);
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
+                    patchState$1(store, { [currentKey]: current });
+                }
+                catch (e) {
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
+                    throw e;
+                }
+            },
+            [setCurrentKey]: (current) => {
+                patchState$1(store, { [currentKey]: current });
+            },
+            [createKey]: async (entity) => {
+                patchState$1(store, { [currentKey]: entity });
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
+                try {
+                    const created = await dataService.create(entity);
+                    patchState$1(store, { [currentKey]: created });
+                    patchState$1(store, prefix
+                        ? addEntity(created, { collection: prefix })
+                        : addEntity(created));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
+                }
+                catch (e) {
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
+                    throw e;
+                }
+            },
+            [updateKey]: async (entity) => {
+                patchState$1(store, { [currentKey]: entity });
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
+                try {
+                    const updated = await dataService.update(entity);
+                    patchState$1(store, { [currentKey]: updated });
+                    const updateArg = {
+                        id: updated.id,
+                        changes: updated,
+                    };
+                    const updater = (collection) => updateEntity(updateArg, { collection });
+                    patchState$1(store, prefix ? updater(prefix) : updateEntity(updateArg));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
+                }
+                catch (e) {
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
+                    throw e;
+                }
+            },
+            [updateAllKey]: async (entities) => {
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
+                try {
+                    const result = await dataService.updateAll(entities);
+                    patchState$1(store, prefix
+                        ? setAllEntities(result, { collection: prefix })
+                        : setAllEntities(result));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
+                }
+                catch (e) {
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
+                    throw e;
+                }
+            },
+            [deleteKey]: async (entity) => {
+                patchState$1(store, { [currentKey]: entity });
+                (() => store[callStateKey] && patchState$1(store, setLoading(prefix)))();
+                try {
+                    await dataService.delete(entity);
+                    patchState$1(store, { [currentKey]: undefined });
+                    patchState$1(store, prefix
+                        ? removeEntity(entity.id, { collection: prefix })
+                        : removeEntity(entity.id));
+                    (() => store[callStateKey] && patchState$1(store, setLoaded(prefix)))();
+                }
+                catch (e) {
+                    (() => store[callStateKey] &&
+                        patchState$1(store, setError(e, prefix)))();
+                    throw e;
+                }
+            },
+        };
+    }));
+}
+
+/** 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 gotoPage(page, options) {
+    const { pageKey } = createPaginationKeys(options);
+    return {
+        [pageKey]: page,
+    };
+}
+function setPageSize(pageSize, options) {
+    const { pageSizeKey } = createPaginationKeys(options);
+    return {
+        [pageSizeKey]: pageSize,
+    };
+}
+function nextPage(options) {
+    const { pageKey } = createPaginationKeys(options);
+    return {
+        [pageKey]: (currentPage) => currentPage + 1,
+    };
+}
+function previousPage(options) {
+    const { pageKey } = createPaginationKeys(options);
+    return {
+        [pageKey]: (currentPage) => Math.max(currentPage - 1, 1),
+    };
+}
+function firstPage(options) {
+    const { pageKey } = createPaginationKeys(options);
+    return {
+        [pageKey]: 1,
+    };
+}
+function setMaxPageNavigationArrayItems(maxPageNavigationArrayItems, options) {
+    const { pageNavigationArrayMaxKey } = createPaginationKeys(options);
+    return {
+        [pageNavigationArrayMaxKey]: maxPageNavigationArrayItems,
+    };
+}
+function createPaginationKeys(options) {
+    const entitiesKey = options?.collection
+        ? `${options.collection}Entities`
+        : 'entities';
+    const selectedPageEntitiesKey = options?.collection
+        ? `selectedPage${capitalize(options?.collection)}Entities`
+        : 'selectedPageEntities';
+    const pageKey = options?.collection
+        ? `${options.collection}CurrentPage`
+        : 'currentPage';
+    const pageSizeKey = options?.collection
+        ? `${options.collection}PageSize`
+        : 'pageSize';
+    const totalCountKey = options?.collection
+        ? `${options.collection}TotalCount`
+        : 'totalCount';
+    const pageCountKey = options?.collection
+        ? `${options.collection}PageCount`
+        : 'pageCount';
+    const pageNavigationArrayMaxKey = options?.collection
+        ? `${options.collection}PageNavigationArrayMax`
+        : 'pageNavigationArrayMax';
+    const pageNavigationArrayKey = options?.collection
+        ? `${options.collection}PageNavigationArray`
+        : 'pageNavigationArray';
+    const hasNextPageKey = options?.collection
+        ? `hasNext${capitalize(options.collection)}Page`
+        : 'hasNextPage';
+    const hasPreviousPageKey = options?.collection
+        ? `hasPrevious${capitalize(options.collection)}Page`
+        : 'hasPreviousPage';
+    return {
+        pageKey,
+        pageSizeKey,
+        entitiesKey,
+        selectedPageEntitiesKey,
+        totalCountKey,
+        pageCountKey,
+        pageNavigationArrayKey,
+        pageNavigationArrayMaxKey,
+        hasNextPageKey,
+        hasPreviousPageKey,
+    };
+}
+function createPageArray(currentPage, itemsPerPage, totalItems, paginationRange) {
+    // Convert paginationRange to number in case it's a string
+    paginationRange = +paginationRange;
+    // Calculate total number of pages
+    const totalPages = Math.max(Math.ceil(totalItems / itemsPerPage), 1);
+    const halfWay = Math.ceil(paginationRange / 2);
+    const isStart = currentPage <= halfWay;
+    const isEnd = totalPages - halfWay < currentPage;
+    const isMiddle = !isStart && !isEnd;
+    const ellipsesNeeded = paginationRange < totalPages;
+    const pages = [];
+    for (let i = 1; i <= totalPages && i <= paginationRange; i++) {
+        let pageNumber = i;
+        if (i === paginationRange) {
+            pageNumber = totalPages;
+        }
+        else if (ellipsesNeeded) {
+            if (isEnd) {
+                pageNumber = totalPages - paginationRange + i;
+            }
+            else if (isMiddle) {
+                pageNumber = currentPage - halfWay + i;
+            }
+        }
+        const openingEllipsesNeeded = i === 2 && (isMiddle || isEnd);
+        const closingEllipsesNeeded = i === paginationRange - 1 && (isMiddle || isStart);
+        const label = ellipsesNeeded && (openingEllipsesNeeded || closingEllipsesNeeded)
+            ? '...'
+            : pageNumber;
+        pages.push({ label, value: pageNumber });
+    }
+    return pages;
+}
+
+/**
+ * Adds a `resetState` method to the store, which resets the state
+ * to the initial state.
+ *
+ * If you want to set a custom initial state, you can use {@link setResetState}.
+ */
+function withReset() {
+    return signalStoreFeature(withProps(() => ({ _resetState: { value: {} } })), withMethods((store) => {
+        // workaround to TS excessive property check
+        const methods = {
+            resetState() {
+                patchState$1(store, store._resetState.value);
+            },
+            __setResetState__(state) {
+                store._resetState.value = state;
+            },
+        };
+        return methods;
+    }), withHooks((store) => ({
+        onInit() {
+            store._resetState.value = getState(store);
+        },
+    })));
+}
+/**
+ * Sets the reset state of the store to the given state.
+ *
+ * Throws an error if the store is not configured with {@link withReset}.
+ * @param store the instance of a SignalStore
+ * @param state the state to set as the reset state
+ */
+function setResetState(store, state) {
+    if (!('__setResetState__' in store)) {
+        throw new Error('Cannot set reset state, since store is not configured with withReset()');
+    }
+    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' }]
+        }] });
+
+/**
+ * AsyncFeatureResult is used as the public interface that users interact with
+ * when calling `withIndexedDB`. It intentionally omits the internal SYNC_STATUS
+ * property to avoid TypeScript error TS4058 (return type of public method
+ * includes private type).
+ *
+ * For internal implementation, we use AsyncStoreForFactory which includes
+ * the SYNC_STATUS property needed for state management.
+ */
+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);
+    };
+}
+
+const switchOp = {
+    rxJsOperator: switchMap,
+    exhaustSemantics: false,
+};
+const mergeOp = {
+    rxJsOperator: mergeMap,
+    exhaustSemantics: false,
+};
+const concatOp = {
+    rxJsOperator: concatMap,
+    exhaustSemantics: false,
+};
+const exhaustOp = {
+    rxJsOperator: exhaustMap,
+    exhaustSemantics: true,
+};
+
+/**
+ * Creates a mutation that leverages RxJS.
+ *
+ * For each mutation the following options can be defined:
+ * - `operation`: A function that defines the mutation logic. It returns an Observable.
+ * - `onSuccess`: A callback that is called when the mutation is successful.
+ * - `onError`: A callback that is called when the mutation fails.
+ * - `operator`: An optional wrapper of an RxJS flattening operator. By default `concat` sematics are used.
+ * - `injector`: An optional Angular injector to use for dependency injection.
+ *
+ * The `operation` is the only mandatory option.
+ *
+ * The returned mutation can be called as an async function and returns a Promise.
+ * This promise informs about whether the mutation was successful, failed, or aborted
+ * (due to switchMap or exhaustMap semantics).
+ *
+ * The mutation also provides several Signals such as error, status or isPending (see below).
+ *
+ * Example usage without Store:
+ *
+ * ```typescript
+ * const counterSignal = signal(0);
+ *
+ * const increment = rxMutation({
+ *   operation: (param: Param) => {
+ *     return calcSum(this.counterSignal(), param.value);
+ *   },
+ *   operator: concatOp,
+ *   onSuccess: (result) => {
+ *     this.counterSignal.set(result);
+ *   },
+ *   onError: (error) => {
+ *     console.error('Error occurred:', error);
+ *   },
+ * });
+ *
+ * const error = increment.error;
+ * const isPending = increment.isPending;
+ * const status = increment.status;
+ * const value = increment.value;
+ * const hasValue = increment.hasValue;
+ *
+ * async function incrementCounter() {
+ *     const result = await increment({ value: 1 });
+ *     if (result.status === 'success') {
+ *       console.log('Success:', result.value);
+ *     }
+ *     if (result.status === 'error') {
+ *       console.log('Error:', result.error);
+ *     }
+ *     if (result.status === 'aborted') {
+ *       console.log('Operation aborted');
+ *     }
+ * }
+ *
+ * function calcSum(a: number, b: number): Observable<number> {
+ *   return of(result).pipe(delay(500));
+ * }
+ * ```
+ *
+ * @param options
+ * @returns the actual mutation function along tracking data as properties/methods
+ */
+function rxMutation(optionsOrOperation) {
+    const inputSubject = new Subject();
+    const options = typeof optionsOrOperation === 'function'
+        ? { operation: optionsOrOperation }
+        : optionsOrOperation;
+    const flatteningOp = options.operator ?? concatOp;
+    const destroyRef = options.injector?.get(DestroyRef) ?? inject(DestroyRef);
+    const callCount = signal(0);
+    const errorSignal = signal(undefined);
+    const idle = signal(true);
+    const isPending = computed(() => callCount() > 0);
+    const value = signal(undefined);
+    const isSuccess = computed(() => !idle() && !isPending() && !errorSignal());
+    const hasValue = function () {
+        return typeof value() !== 'undefined';
+    };
+    const status = computed(() => {
+        if (idle()) {
+            return 'idle';
+        }
+        if (callCount() > 0) {
+            return 'pending';
+        }
+        if (errorSignal()) {
+            return 'error';
+        }
+        return 'success';
+    });
+    const initialInnerStatus = 'idle';
+    let innerStatus = initialInnerStatus;
+    inputSubject
+        .pipe(flatteningOp.rxJsOperator((input) => defer(() => {
+        callCount.update((c) => c + 1);
+        idle.set(false);
+        return options.operation(input.param).pipe(tap((result) => {
+            options.onSuccess?.(result, input.param);
+            innerStatus = 'success';
+            errorSignal.set(undefined);
+            value.set(result);
+        }), catchError((error) => {
+            options.onError?.(error, input.param);
+            errorSignal.set(error);
+            value.set(undefined);
+            innerStatus = 'error';
+            return EMPTY;
+        }), finalize(() => {
+            callCount.update((c) => c - 1);
+            if (innerStatus === 'success') {
+                input.resolve({
+                    status: 'success',
+                    value: value(),
+                });
+            }
+            else if (innerStatus === 'error') {
+                input.resolve({
+                    status: 'error',
+                    error: errorSignal(),
+                });
+            }
+            else {
+                input.resolve({
+                    status: 'aborted',
+                });
+            }
+            innerStatus = initialInnerStatus;
+        }));
+    })), takeUntilDestroyed(destroyRef))
+        .subscribe();
+    const mutationFn = (param) => {
+        return new Promise((resolve) => {
+            if (callCount() > 0 && flatteningOp.exhaustSemantics) {
+                resolve({
+                    status: 'aborted',
+                });
+            }
+            else {
+                inputSubject.next({
+                    param,
+                    resolve,
+                });
+            }
+        });
+    };
+    const mutation = mutationFn;
+    mutation.status = status;
+    mutation.isPending = isPending;
+    mutation.error = errorSignal;
+    mutation.value = value;
+    mutation.hasValue = hasValue;
+    mutation.isSuccess = isSuccess;
+    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;
+}
+
+/**
+ * Creates an HTTP mutation.
+ *
+ * export type Params = {
+ *   value: number;
+ * };
+ *
+ * export type CounterResponse = {
+ *   // httpbin.org echos the request using the
+ *   // json property
+ *   json: { counter: number };
+ * };
+ *
+ * const simpleSaveUser = httpMutation({
+ *   request: (userData: AddUserEntry) => ({
+ *     url: 'api/users',
+ *     body: userData,
+ *   }),
+ *   parse: Boolean,
+ * })
+ *
+ * const saveUser = httpMutation({
+ *   request: (p: Params) => ({
+ *     url: `https://httpbin.org/post`,
+ *     method: 'POST',
+ *     body: { counter: p.value },
+ *     headers: { 'Content-Type': 'application/json' },
+ *   }),
+ *   onSuccess: (response: CounterResponse) => {
+ *     console.log('Counter sent to server:', response);
+ *   },
+ *   onError: (error) => {
+ *     console.error('Failed to send counter:', error);
+ *   },
+ * });
+ *
+ * ...
+ *
+ * const result = await this.saveUser({ value: 17 });
+ * if (result.status === 'success') {
+ *   console.log('Successfully saved to server:', result.value);
+ * }
+ * else if (result.status === 'error') {
+ *   console.log('Failed to save:', result.error);
+ * }
+ * else {
+ *   console.log('Operation aborted');
+ * }
+ *
+ * @param options The options for the HTTP mutation.
+ * @returns The HTTP mutation.
+ */
+function httpMutation(optionsOrRequest) {
+    const httpClient = inject(HttpClient);
+    const options = typeof optionsOrRequest === 'function'
+        ? { request: optionsOrRequest }
+        : optionsOrRequest;
+    const parse = options.parse ?? ((raw) => raw);
+    const uploadProgress = signal(undefined);
+    const downloadProgress = signal(undefined);
+    const headers = signal(undefined);
+    const statusCode = signal(undefined);
+    const mutation = rxMutation({
+        ...options,
+        operation: (param) => {
+            const httpRequest = options.request(param);
+            return defer(() => {
+                uploadProgress.set(undefined);
+                downloadProgress.set(undefined);
+                headers.set(undefined);
+                statusCode.set(undefined);
+                return httpClient
+                    .request(httpRequest.method, httpRequest.url, {
+                    ...httpRequest,
+                    observe: 'events',
+                    responseType: 'json',
+                })
+                    .pipe(tap((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) => {
+                    headers.set(response.headers);
+                    statusCode.set(response.status.toString());
+                }), map((event) => parse(event.body)));
+            });
+        },
+    });
+    mutation.uploadProgress = uploadProgress;
+    mutation.downloadProgress = downloadProgress;
+    mutation.statusCode = statusCode;
+    mutation.headers = headers;
+    return mutation;
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { capitalize, concatOp, createEffects, createPageArray, createReducer, deriveCallStateKeys, emptyFeature, exhaustOp, firstPage, getCallStateKeys, getCollectionArray, getDataServiceKeys, getUndoRedoKeys, gotoPage, httpMutation, 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, withSessionStorage, withStorageSync, withUndoRedo };
+//# sourceMappingURL=angular-architects-ngrx-toolkit.mjs.map