@angular-architects/ngrx-toolkit 19.0.2 → 19.2.0

package/index.d.ts

@@ -1,14 +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';

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 {
@@ -5,7 +6,6 @@ declare global {
         __REDUX_DEVTOOLS_EXTENSION__: ReduxDevtoolsExtension | undefined;
     }
 }
-export declare const existingNames: Map<string, unknown>;
 export declare const renameDevtoolsMethodName = "___renameDevtoolsName";
 export declare const uniqueDevtoolsId = "___uniqueDevtoolsId";
 /**
@@ -21,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/immutable-state/deep-freeze.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+export declare function deepFreeze<T extends Record<string | symbol, unknown>>(target: T, propertyNamesToBeFrozen: (string | symbol)[], isRoot?: boolean): void;

package/lib/immutable-state/is-dev-mode.d.ts

@@ -0,0 +1 @@
+export declare function isDevMode(): boolean;

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

@@ -0,0 +1,60 @@
+import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult } from '@ngrx/signals';
+/**
+ * The implementation of this feature is a little bit tricky.
+ *
+ * `signalStore` does a shallow clone in the initial phase, in order to
+ * merge all different states together.
+ *
+ * Shallow cloning also happens in `patchState`.
+ *
+ * With shallow cloning, the root state object is replaced, which means,
+ * the freezing only stays for its nested properties but not for
+ * the primitive and immediate properties.
+ *
+ * For example:
+ *
+ * ```ts
+ * const state = {
+ *   id: 1,
+ *   address: {
+ *     street: 'Main St',
+ *     city: 'Springfield',
+ *   }
+ * }
+ * ```
+ *
+ * Running `Object.freeze` on `state` will freeze the `address` object, and
+ * the `id`. But since `state` is shallow cloned, the "frozing" state of the
+ * `id` is lost. `address`, being an object, is still frozen.
+ *
+ * To overcome that, we run `watchState` and run `deepFreeze`
+ * on every change.
+ */
+/**
+ * Prevents mutation of the state.
+ *
+ * This is done by deeply applying `Object.freeze`. Any mutable change within
+ * or outside the `SignalStore` will throw an error.
+ *
+ * @param state the state object
+ * @param options enable protection in production (default: false)
+ */
+export declare function withImmutableState<State extends object>(state: State, options?: {
+    enableInProduction?: boolean;
+}): SignalStoreFeature<SignalStoreFeatureResult, EmptyFeatureResult & {
+    state: State;
+}>;
+/**
+ * Prevents mutation of the state.
+ *
+ * This is done by deeply applying `Object.freeze`. Any mutable change within
+ * or outside the `SignalStore` will throw an error.
+ *
+ * @param stateFactory a function returning the state object
+ * @param options enable protection in production (default: false)
+ */
+export declare function withImmutableState<State extends object>(stateFactory: () => State, options?: {
+    enableInProduction?: boolean;
+}): SignalStoreFeature<SignalStoreFeatureResult, EmptyFeatureResult & {
+    state: State;
+}>;

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-conditional.d.ts

@@ -0,0 +1,50 @@
+import { SignalStoreFeature, SignalStoreFeatureResult, StateSignals } from '@ngrx/signals';
+/**
+ * `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.
+ */
+export declare function withConditional<Input extends SignalStoreFeatureResult, Output extends SignalStoreFeatureResult>(condition: (store: StateSignals<Input['state']> & Input['props'] & Input['methods']) => boolean, featureIfTrue: SignalStoreFeature<NoInfer<Input>, Output>, featureIfFalse: SignalStoreFeature<NoInfer<Input>, NoInfer<Output>>): SignalStoreFeature<Input, Output>;
+export declare const emptyFeature: SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
+    state: {};
+    props: {};
+    methods: {};
+}>;

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

@@ -0,0 +1,28 @@
+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.
+ *
+ * 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
+ */
+export declare function withFeatureFactory<Input extends SignalStoreFeatureResult, Output extends SignalStoreFeatureResult>(factoryFn: (store: StoreForFactory<Input>) => SignalStoreFeature<Input, Output>): SignalStoreFeature<Input, Output>;
+export {};

package/lib/with-pagination.d.ts

@@ -6,8 +6,8 @@
  * This feature implements the local pagination.
  */
 import { Signal } from '@angular/core';
-import { SignalStoreFeature, EmptyFeatureResult } from '@ngrx/signals';
-import { EntityComputed, EntityState, NamedEntityComputed } from './shared/signal-store-models';
+import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
+import { MethodsDictionary } from '@ngrx/signals/src/signal-store-models';
 export type Page = {
     label: string | number;
     value: number;
@@ -46,19 +46,6 @@ export type NamedPaginationServiceSignals<E, Collection extends string> = {
 } & {
     [K in Collection as `hasPrevious${Capitalize<K>}Page`]: Signal<boolean>;
 };
-export type NamedPaginationServiceMethods<Collection extends string> = {
-    [K in Collection as `set${Capitalize<K>}PageSize`]: (size: number) => void;
-} & {
-    [K in Collection as `next${Capitalize<K>}Page`]: () => void;
-} & {
-    [K in Collection as `previous${Capitalize<K>}Page`]: () => void;
-} & {
-    [K in Collection as `last${Capitalize<K>}Page`]: () => void;
-} & {
-    [K in Collection as `first${Capitalize<K>}Page`]: () => void;
-} & {
-    [K in Collection as `goto${Capitalize<K>}Page`]: (page: number) => void;
-};
 export type PaginationServiceState<E> = {
     selectedPageEntities: Array<E>;
     currentPage: number;
@@ -79,32 +66,19 @@ export type PaginationServiceSignals<E> = {
     hasNextPage: Signal<boolean>;
     hasPreviousPage: Signal<boolean>;
 };
-export type PaginationServiceMethods = {
-    setPageSize: (size: number) => void;
-    nextPageKey: () => void;
-    previousPage: () => void;
-    lastPage: () => void;
-    firstPage: () => void;
-    gotoPage: (page: number) => void;
-};
 export type SetPaginationState<E, Collection extends string | undefined> = Collection extends string ? NamedPaginationServiceState<E, Collection> : PaginationServiceState<E>;
 export declare function withPagination<E, Collection extends string>(options: {
     entity: E;
     collection: Collection;
-}): SignalStoreFeature<EmptyFeatureResult & {
-    props: NamedEntityComputed<E, Collection>;
-}, {
+}): SignalStoreFeature<EmptyFeatureResult, {
     state: NamedPaginationServiceState<E, Collection>;
     props: NamedPaginationServiceSignals<E, Collection>;
-    methods: NamedPaginationServiceMethods<Collection>;
+    methods: MethodsDictionary;
 }>;
-export declare function withPagination<E>(): SignalStoreFeature<EmptyFeatureResult & {
-    state: EntityState<E>;
-    props: EntityComputed<E>;
-}, {
+export declare function withPagination<E>(): SignalStoreFeature<EmptyFeatureResult, {
     state: PaginationServiceState<E>;
     props: PaginationServiceSignals<E>;
-    methods: PaginationServiceMethods;
+    methods: MethodsDictionary;
 }>;
 export declare function gotoPage<E, Collection extends string>(page: number, options?: {
     collection: Collection;

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.0.2",
+  "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>>;