@angular-architects/ngrx-toolkit 19.1.0 → 19.2.0

package/index.d.ts

@@ -1,17 +1,24 @@
-export { withDevToolsStub } from './lib/devtools/with-dev-tools-stub';
-export { withDevtools } from './lib/devtools/with-devtools';
 export { withDisabledNameIndices } from './lib/devtools/features/with-disabled-name-indicies';
-export { withMapper } from './lib/devtools/features/with-mapper';
 export { withGlitchTracking } from './lib/devtools/features/with-glitch-tracking';
-export { patchState, updateState } from './lib/devtools/update-state';
+export { withMapper } from './lib/devtools/features/with-mapper';
+export { ReduxDevtoolsConfig, provideDevtoolsConfig, } from './lib/devtools/provide-devtools-config';
 export { renameDevtoolsName } from './lib/devtools/rename-devtools-name';
-export { withRedux, payload, noPayload, createReducer, createEffects, } from './lib/with-redux';
+export { patchState, updateState } from './lib/devtools/update-state';
+export { withDevToolsStub } from './lib/devtools/with-dev-tools-stub';
+export { withDevtools } from './lib/devtools/with-devtools';
+export { createEffects, createReducer, noPayload, payload, withRedux, } from './lib/with-redux';
 export * from './lib/with-call-state';
-export * from './lib/with-undo-redo';
 export * from './lib/with-data-service';
-export { withStorageSync, SyncConfig } from './lib/with-storage-sync';
 export * from './lib/with-pagination';
-export { withReset, setResetState } from './lib/with-reset';
+export { setResetState, withReset } from './lib/with-reset';
+export * from './lib/with-undo-redo';
 export { withImmutableState } from './lib/immutable-state/with-immutable-state';
+export { withIndexedDB } from './lib/storage-sync/features/with-indexed-db';
+/**
+ * @deprecated Use {@link withIndexedDB} instead.
+ */
+export { withIndexedDB as withIndexeddb } from './lib/storage-sync/features/with-indexed-db';
+export { withLocalStorage, withSessionStorage, } from './lib/storage-sync/features/with-local-storage';
+export { SyncConfig, withStorageSync, } from './lib/storage-sync/with-storage-sync';
+export { emptyFeature, withConditional } from './lib/with-conditional';
 export { withFeatureFactory } from './lib/with-feature-factory';
-export { withConditional, emptyFeature } from './lib/with-conditional';

package/lib/devtools/internal/glitch-tracker.service.d.ts

@@ -1,5 +1,5 @@
-import { Tracker, TrackerStores } from './models';
 import { StateSource } from '@ngrx/signals';
+import { Tracker, TrackerStores } from './models';
 import * as i0 from "@angular/core";
 /**
  * Internal Service used by {@link withGlitchTracking}. It does not rely

package/lib/devtools/internal/models.d.ts

@@ -1,4 +1,5 @@
 import { StateSource } from '@ngrx/signals';
+import { ReduxDevtoolsConfig } from '../provide-devtools-config';
 import { DevtoolsInnerOptions } from './devtools-feature';
 export type Action = {
     type: string;
@@ -7,9 +8,7 @@ export type Connection = {
     send: (action: Action, state: Record<string, unknown>) => void;
 };
 export type ReduxDevtoolsExtension = {
-    connect: (options: {
-        name: string;
-    }) => Connection;
+    connect: (options: ReduxDevtoolsConfig) => Connection;
 };
 export type StoreRegistry = Record<string, {
     options: DevtoolsInnerOptions;

package/lib/devtools/provide-devtools-config.d.ts

@@ -0,0 +1,20 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+/**
+ * Provides the configuration options for connecting to the Redux DevTools Extension.
+ */
+export declare function provideDevtoolsConfig(config: ReduxDevtoolsConfig): ValueProvider;
+/**
+ * Injection token for the configuration options for connecting to the Redux DevTools Extension.
+ */
+export declare const REDUX_DEVTOOLS_CONFIG: InjectionToken<ReduxDevtoolsConfig>;
+/**
+ * Options for connecting to the Redux DevTools Extension.
+ * @example
+ * const devToolsOptions: ReduxDevtoolsConfig = {
+ *   name: 'My App',
+ * };
+ */
+export type ReduxDevtoolsConfig = {
+    /** Optional name for the devtools instance. If empty, "NgRx SignalStore" will be used. */
+    name?: string;
+};

package/lib/devtools/update-state.d.ts

@@ -1,5 +1,4 @@
-import { patchState as originalPatchState } from '@ngrx/signals';
-import { PartialStateUpdater, WritableStateSource } from '@ngrx/signals';
+import { patchState as originalPatchState, PartialStateUpdater, WritableStateSource } from '@ngrx/signals';
 import { Prettify } from '../shared/prettify';
 type PatchFn = typeof originalPatchState extends (arg1: infer First, ...args: infer Rest) => infer Returner ? (state: First, action: string, ...rest: Rest) => Returner : never;
 /**

package/lib/devtools/with-devtools.d.ts

@@ -1,3 +1,4 @@
+import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
 import { DevtoolsFeature } from './internal/devtools-feature';
 import { ReduxDevtoolsExtension } from './internal/models';
 declare global {
@@ -20,10 +21,4 @@ export declare const uniqueDevtoolsId = "___uniqueDevtoolsId";
  * @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
  */
-export declare function withDevtools(name: string, ...features: DevtoolsFeature[]): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
-    state: {};
-    props: {};
-    methods: {
-        [x: string]: (newName?: unknown) => unknown;
-    };
-}>;
+export declare function withDevtools(name: string, ...features: DevtoolsFeature[]): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult>;

package/lib/storage-sync/features/with-indexed-db.d.ts

@@ -0,0 +1,2 @@
+import { AsyncStorageStrategy } from '../internal/models';
+export declare function withIndexedDB<State extends object>(): AsyncStorageStrategy<State>;

package/lib/storage-sync/features/with-local-storage.d.ts

@@ -0,0 +1,3 @@
+import { SyncStorageStrategy } from '../internal/models';
+export declare function withLocalStorage<State extends object>(): SyncStorageStrategy<State>;
+export declare function withSessionStorage<State extends object>(): SyncStorageStrategy<State>;

package/lib/storage-sync/internal/indexeddb.service.d.ts

@@ -0,0 +1,29 @@
+import * as i0 from "@angular/core";
+export declare const keyPath = "ngrxToolkitKeyPath";
+export declare const dbName = "ngrxToolkitDb";
+export declare const storeName = "ngrxToolkitStore";
+export declare const VERSION: number;
+export declare class IndexedDBService {
+    /**
+     * write to indexedDB
+     * @param key
+     * @param data
+     */
+    setItem(key: string, data: string): Promise<void>;
+    /**
+     * read from indexedDB
+     * @param key
+     */
+    getItem(key: string): Promise<string | null>;
+    /**
+     * delete indexedDB
+     * @param key
+     */
+    clear(key: string): Promise<void>;
+    /**
+     * open indexedDB
+     */
+    private openDB;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexedDBService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IndexedDBService>;
+}

package/lib/storage-sync/internal/local-storage.service.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class LocalStorageService {
+    getItem(key: string): string | null;
+    setItem(key: string, data: string): void;
+    clear(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
+}

package/lib/storage-sync/internal/models.d.ts

@@ -0,0 +1,34 @@
+import { Signal, WritableSignal } from '@angular/core';
+import { EmptyFeatureResult, WritableStateSource } from '@ngrx/signals';
+import { SyncConfig } from '../with-storage-sync';
+export type SyncMethods = {
+    clearStorage(): void;
+    readFromStorage(): void;
+    writeToStorage(): void;
+};
+export type SyncFeatureResult = EmptyFeatureResult & {
+    methods: SyncMethods;
+};
+export type SyncStoreForFactory<State extends object> = WritableStateSource<State>;
+export type SyncStorageStrategy<State extends object> = ((config: Required<SyncConfig<State>>, store: SyncStoreForFactory<State>, useStubs: boolean) => SyncMethods) & {
+    type: 'sync';
+};
+export type AsyncMethods = {
+    clearStorage(): Promise<void>;
+    readFromStorage(): Promise<void>;
+    writeToStorage(): Promise<void>;
+};
+export declare const SYNC_STATUS: unique symbol;
+export type SyncStatus = 'idle' | 'syncing' | 'synced';
+export type AsyncFeatureResult = EmptyFeatureResult & {
+    methods: AsyncMethods;
+    props: {
+        isSynced: Signal<boolean>;
+        whenSynced: () => Promise<void>;
+        [SYNC_STATUS]: WritableSignal<SyncStatus>;
+    };
+};
+export type AsyncStoreForFactory<State extends object> = WritableStateSource<State> & AsyncFeatureResult['props'];
+export type AsyncStorageStrategy<State extends object> = ((config: Required<SyncConfig<State>>, store: AsyncStoreForFactory<State>, useStubs: boolean) => AsyncMethods) & {
+    type: 'async';
+};

package/lib/storage-sync/internal/session-storage.service.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class SessionStorageService {
+    getItem(key: string): string | null;
+    setItem(key: string, data: string): void;
+    clear(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionStorageService>;
+}

package/lib/storage-sync/with-storage-sync.d.ts

@@ -0,0 +1,45 @@
+import { SignalStoreFeature, SignalStoreFeatureResult } from '@ngrx/signals';
+import { AsyncFeatureResult, AsyncStorageStrategy, SyncFeatureResult, SyncStorageStrategy } from './internal/models';
+export type SyncConfig<State> = {
+    /**
+     * The key which is used to access the storage.
+     */
+    key: string;
+    /**
+     * Flag indicating if the store should read from storage on init and write to storage on every state change.
+     *
+     * `true` by default
+     */
+    autoSync?: boolean;
+    /**
+     * Function to select that portion of the state which should be stored.
+     *
+     * Returns the whole state object by default
+     */
+    select?: (state: State) => unknown;
+    /**
+     * Function used to parse the state coming from storage.
+     *
+     * `JSON.parse()` by default
+     */
+    parse?: (stateString: string) => State;
+    /**
+     * Function used to transform the state into a string representation.
+     *
+     * `JSON.stringify()` by default
+     */
+    stringify?: (state: State) => string;
+    /**
+     * @deprecated Use {@link withSessionStorage} instead.
+     * Factory function used to switch to sessionStorage.
+     *
+     * `localStorage` by default
+     */
+    storage?: () => Storage;
+};
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string): SignalStoreFeature<Input, SyncFeatureResult>;
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string, storageStrategy: AsyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, AsyncFeatureResult>;
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string, storageStrategy: SyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>, storageStrategy: AsyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, AsyncFeatureResult>;
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>, storageStrategy: SyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;

package/lib/with-call-state.d.ts

@@ -7,7 +7,7 @@ export type CallStateSlice = {
     callState: CallState;
 };
 export type NamedCallStateSlice<Collection extends string> = {
-    [K in keyof CallStateSlice as `${Collection}${Capitalize<K>}`]: CallStateSlice[K];
+    [K in keyof CallStateSlice as Collection extends '' ? `${Collection}${K}` : `${Collection}${Capitalize<K>}`]: CallStateSlice[K];
 };
 export type CallStateSignals = {
     loading: Signal<boolean>;
@@ -15,9 +15,15 @@ export type CallStateSignals = {
     error: Signal<string | null>;
 };
 export type NamedCallStateSignals<Prop extends string> = {
-    [K in keyof CallStateSignals as `${Prop}${Capitalize<K>}`]: CallStateSignals[K];
+    [K in keyof CallStateSignals as Prop extends '' ? `${Prop}${K}` : `${Prop}${Capitalize<K>}`]: CallStateSignals[K];
 };
 export type SetCallState<Prop extends string | undefined> = Prop extends string ? NamedCallStateSlice<Prop> : CallStateSlice;
+export declare function deriveCallStateKeys<Collection extends string>(collection?: Collection): {
+    callStateKey: string;
+    loadingKey: string;
+    loadedKey: string;
+    errorKey: string;
+};
 export declare function getCallStateKeys(config?: {
     collection?: string;
 }): {
@@ -26,6 +32,17 @@ export declare function getCallStateKeys(config?: {
     loadedKey: string;
     errorKey: string;
 };
+export declare function getCollectionArray(config: {
+    collection?: string;
+} | {
+    collections?: string[];
+}): string[] | undefined;
+export declare function withCallState<Collection extends string>(config: {
+    collections: Collection[];
+}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: NamedCallStateSlice<Collection>;
+    props: NamedCallStateSignals<Collection>;
+}>;
 export declare function withCallState<Collection extends string>(config: {
     collection: Collection;
 }): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {

package/lib/with-data-service.d.ts

@@ -1,8 +1,8 @@
 import { ProviderToken, Signal } from '@angular/core';
-import { SignalStoreFeature, EmptyFeatureResult } from '@ngrx/signals';
-import { CallState } from './with-call-state';
-import { EntityId } from '@ngrx/signals/entities';
-import { EntityState, NamedEntityComputed } from './shared/signal-store-models';
+import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
+import { EntityId, NamedEntityState } from '@ngrx/signals/entities';
+import { EntityState } from './shared/signal-store-models';
+import { CallState, NamedCallStateSlice } from './with-call-state';
 export type Filter = Record<string, unknown>;
 export type Entity = {
     id: EntityId;
@@ -89,7 +89,7 @@ export declare function withDataService<E extends Entity, F extends Filter, Coll
     filter: F;
     collection: Collection;
 }): SignalStoreFeature<EmptyFeatureResult & {
-    props: NamedEntityComputed<E, Collection>;
+    state: NamedCallStateSlice<Collection> & NamedEntityState<E, Collection>;
 }, {
     state: NamedDataServiceState<E, F, Collection>;
     props: NamedDataServiceComputed<E, Collection>;

package/lib/with-feature-factory.d.ts

@@ -1,6 +1,8 @@
 import { SignalStoreFeature, SignalStoreFeatureResult, StateSignals } from '@ngrx/signals';
 type StoreForFactory<Input extends SignalStoreFeatureResult> = StateSignals<Input['state']> & Input['props'] & Input['methods'];
 /**
+ * @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.
  *

package/lib/with-pagination.d.ts

@@ -6,7 +6,7 @@
  * This feature implements the local pagination.
  */
 import { Signal } from '@angular/core';
-import { SignalStoreFeature, EmptyFeatureResult } from '@ngrx/signals';
+import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
 import { MethodsDictionary } from '@ngrx/signals/src/signal-store-models';
 export type Page = {
     label: string | number;

package/lib/with-redux.d.ts

@@ -1,5 +1,5 @@
-import { Observable } from 'rxjs';
 import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult, WritableStateSource } from '@ngrx/signals';
+import { Observable } from 'rxjs';
 /** Actions **/
 type Payload = Record<string, unknown>;
 type ActionFn<Type extends string = string, ActionPayload extends Payload = Payload> = ((payload: ActionPayload) => ActionPayload & {
@@ -81,6 +81,8 @@ type EffectsFactory<StateActionFns extends ActionFns> = (actions: StateActionFns
     type: string;
 }>(action: EffectAction) => Observable<ActionFnPayload<EffectAction>>) => Record<string, Observable<unknown>>;
 /**
+ * @deprecated Use NgRx's `@ngrx/signals/events` starting in 19.2
+ *
  * Creates the effects function to separate the effects logic into another file.
  *
  * ```typescript

package/lib/with-undo-redo.d.ts

@@ -1,5 +1,5 @@
-import { SignalStoreFeature, EmptyFeatureResult, SignalStoreFeatureResult } from '@ngrx/signals';
 import { Signal } from '@angular/core';
+import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult } from '@ngrx/signals';
 export type StackItem = Record<string, unknown>;
 export type NormalizedUndoRedoOptions = {
     maxStackSize: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-architects/ngrx-toolkit",
-  "version": "19.1.0",
+  "version": "19.2.0",
   "license": "MIT",
   "repository": {
     "type": "GitHub",
@@ -9,8 +9,8 @@
   "peerDependencies": {
     "@angular/core": "^19.0.0",
     "@angular/common": "^19.0.0",
-    "@ngrx/signals": "^19.0.0",
-    "@ngrx/store": "^19.0.0",
+    "@ngrx/signals": "19.2.1",
+    "@ngrx/store": "^19.2.1",
     "rxjs": "^7.0.0"
   },
   "peerDependenciesMeta": {

package/redux-connector/src/lib/rxjs-interop/redux-method.d.ts

@@ -1,5 +1,5 @@
-import { Injector, Signal } from "@angular/core";
-import { Observable } from "rxjs";
+import { Injector, Signal } from '@angular/core';
+import { Observable } from 'rxjs';
 type RxMethodInput<Input> = Input | Observable<Input> | Signal<Input>;
 type RxMethodRef = {
     destroy: () => void;

package/redux-connector/src/lib/signal-redux-store.d.ts

@@ -1,23 +1,11 @@
-import { Action, ActionCreator } from "@ngrx/store";
-import { MapperTypes } from "./model";
+import { Action, ActionCreator } from '@ngrx/store';
+import { MapperTypes } from './model';
 import * as i0 from "@angular/core";
 export declare class SignalReduxStore {
     private mapperDict;
-    dispatch: ((input: Action<string> | import("rxjs").Observable<Action<string>> | import("@angular/core").Signal<Action<string>>, config?: {
-        injector?: import("@angular/core").Injector;
-    }) => {
-        destroy: () => void;
-    }) & {
-        destroy: () => void;
-    };
+    dispatch: import("@ngrx/signals/rxjs-interop").RxMethod<Action<string>>;
     connectFeatureStore(mappers: MapperTypes<ActionCreator<any, any>[]>[]): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SignalReduxStore, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SignalReduxStore>;
 }
-export declare function injectReduxDispatch(): ((input: Action<string> | import("rxjs").Observable<Action<string>> | import("@angular/core").Signal<Action<string>>, config?: {
-    injector?: import("@angular/core").Injector;
-}) => {
-    destroy: () => void;
-}) & {
-    destroy: () => void;
-};
+export declare function injectReduxDispatch(): import("@ngrx/signals/rxjs-interop").RxMethod<Action<string>>;

package/lib/with-storage-sync.d.ts

@@ -1,52 +0,0 @@
-import { SignalStoreFeature, SignalStoreFeatureResult, EmptyFeatureResult } from '@ngrx/signals';
-type WithStorageSyncFeatureResult = EmptyFeatureResult & {
-    methods: {
-        clearStorage(): void;
-        readFromStorage(): void;
-        writeToStorage(): void;
-    };
-};
-export type SyncConfig<State> = {
-    /**
-     * The key which is used to access the storage.
-     */
-    key: string;
-    /**
-     * Flag indicating if the store should read from storage on init and write to storage on every state change.
-     *
-     * `true` by default
-     */
-    autoSync?: boolean;
-    /**
-     * Function to select that portion of the state which should be stored.
-     *
-     * Returns the whole state object by default
-     */
-    select?: (state: State) => Partial<State>;
-    /**
-     * Function used to parse the state coming from storage.
-     *
-     * `JSON.parse()` by default
-     */
-    parse?: (stateString: string) => State;
-    /**
-     * Function used to tranform the state into a string representation.
-     *
-     * `JSON.stringify()` by default
-     */
-    stringify?: (state: State) => string;
-    /**
-     * Factory function used to select the storage.
-     *
-     * `localstorage` by default
-     */
-    storage?: () => Storage;
-};
-/**
- * Enables store synchronization with storage.
- *
- * Only works on browser platform.
- */
-export declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string): SignalStoreFeature<Input, WithStorageSyncFeatureResult>;
-export declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>): SignalStoreFeature<Input, WithStorageSyncFeatureResult>;
-export {};