@angular-architects/ngrx-toolkit 19.4.0 → 19.4.2

package/{src/lib/with-conditional.ts → lib/with-conditional.d.ts}

@@ -1,11 +1,4 @@
-import {
-  signalStoreFeature,
-  SignalStoreFeature,
-  SignalStoreFeatureResult,
-  StateSignals,
-  withState,
-} from '@ngrx/signals';
-
+import { SignalStoreFeature, SignalStoreFeatureResult, StateSignals } from '@ngrx/signals';
 /**
  * `withConditional` activates a feature based on a given condition.
  *
@@ -49,26 +42,9 @@ import {
  * @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 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> {
-  return (store) => {
-    const conditionStore = {
-      ...store['stateSignals'],
-      ...store['props'],
-      ...store['methods'],
-    };
-    return condition(conditionStore)
-      ? featureIfTrue(store)
-      : featureIfFalse(store);
-  };
-}
-
-export const emptyFeature = signalStoreFeature(withState({}));
+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

@@ -0,0 +1,109 @@
+import { ProviderToken, Signal } from '@angular/core';
+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;
+};
+export interface DataService<E extends Entity, F extends Filter> {
+    load(filter: F): Promise<E[]>;
+    loadById(id: EntityId): Promise<E>;
+    create(entity: E): Promise<E>;
+    update(entity: E): Promise<E>;
+    updateAll(entity: E[]): Promise<E[]>;
+    delete(entity: E): Promise<void>;
+}
+export declare function capitalize(str: string): string;
+export declare function getDataServiceKeys(options: {
+    collection?: string;
+}): {
+    filterKey: string;
+    selectedIdsKey: string;
+    selectedEntitiesKey: string;
+    updateFilterKey: string;
+    updateSelectedKey: string;
+    loadKey: string;
+    entitiesKey: string;
+    entityMapKey: string;
+    idsKey: string;
+    currentKey: string;
+    loadByIdKey: string;
+    setCurrentKey: string;
+    createKey: string;
+    updateKey: string;
+    updateAllKey: string;
+    deleteKey: string;
+};
+export type NamedDataServiceState<E extends Entity, F extends Filter, Collection extends string> = {
+    [K in Collection as `${K}Filter`]: F;
+} & {
+    [K in Collection as `selected${Capitalize<K>}Ids`]: Record<EntityId, boolean>;
+} & {
+    [K in Collection as `current${Capitalize<K>}`]: E;
+};
+export type DataServiceState<E extends Entity, F extends Filter> = {
+    filter: F;
+    selectedIds: Record<EntityId, boolean>;
+    current: E;
+};
+export type DataServiceComputed<E extends Entity> = {
+    selectedEntities: Signal<E[]>;
+};
+export type NamedDataServiceComputed<E extends Entity, Collection extends string> = {
+    [K in Collection as `selected${Capitalize<K>}Entities`]: Signal<E[]>;
+};
+export type NamedDataServiceMethods<E extends Entity, F extends Filter, Collection extends string> = {
+    [K in Collection as `update${Capitalize<K>}Filter`]: (filter: F) => void;
+} & {
+    [K in Collection as `updateSelected${Capitalize<K>}Entities`]: (id: EntityId, selected: boolean) => void;
+} & {
+    [K in Collection as `load${Capitalize<K>}Entities`]: () => Promise<void>;
+} & {
+    [K in Collection as `setCurrent${Capitalize<K>}`]: (entity: E) => void;
+} & {
+    [K in Collection as `load${Capitalize<K>}ById`]: (id: EntityId) => Promise<void>;
+} & {
+    [K in Collection as `create${Capitalize<K>}`]: (entity: E) => Promise<void>;
+} & {
+    [K in Collection as `update${Capitalize<K>}`]: (entity: E) => Promise<void>;
+} & {
+    [K in Collection as `updateAll${Capitalize<K>}`]: (entity: E[]) => Promise<void>;
+} & {
+    [K in Collection as `delete${Capitalize<K>}`]: (entity: E) => Promise<void>;
+};
+export type DataServiceMethods<E extends Entity, F extends Filter> = {
+    updateFilter: (filter: F) => void;
+    updateSelected: (id: EntityId, selected: boolean) => void;
+    load: () => Promise<void>;
+    setCurrent(entity: E): void;
+    loadById(id: EntityId): Promise<void>;
+    create(entity: E): Promise<void>;
+    update(entity: E): Promise<void>;
+    updateAll(entities: E[]): Promise<void>;
+    delete(entity: E): Promise<void>;
+};
+export declare function withDataService<E extends Entity, F extends Filter, Collection extends string>(options: {
+    dataServiceType: ProviderToken<DataService<E, F>>;
+    filter: F;
+    collection: Collection;
+}): SignalStoreFeature<EmptyFeatureResult & {
+    state: NamedCallStateSlice<Collection> & NamedEntityState<E, Collection>;
+}, {
+    state: NamedDataServiceState<E, F, Collection>;
+    props: NamedDataServiceComputed<E, Collection>;
+    methods: NamedDataServiceMethods<E, F, Collection>;
+}>;
+export declare function withDataService<E extends Entity, F extends Filter>(options: {
+    dataServiceType: ProviderToken<DataService<E, F>>;
+    filter: F;
+}): SignalStoreFeature<EmptyFeatureResult & {
+    state: {
+        callState: CallState;
+    } & EntityState<E>;
+}, {
+    state: DataServiceState<E, F>;
+    props: DataServiceComputed<E>;
+    methods: DataServiceMethods<E, F>;
+}>;

package/{src/lib/with-feature-factory.ts → lib/with-feature-factory.d.ts}

@@ -1,15 +1,5 @@
-import {
-  SignalStoreFeature,
-  SignalStoreFeatureResult,
-  StateSignals,
-} from '@ngrx/signals';
-
-type StoreForFactory<Input extends SignalStoreFeatureResult> = StateSignals<
-  Input['state']
-> &
-  Input['props'] &
-  Input['methods'];
-
+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
  *
@@ -34,23 +24,5 @@ type StoreForFactory<Input extends SignalStoreFeatureResult> = StateSignals<
  * ```
  * @param factoryFn
  */
-export function withFeatureFactory<
-  Input extends SignalStoreFeatureResult,
-  Output extends SignalStoreFeatureResult,
->(
-  factoryFn: (
-    store: StoreForFactory<Input>,
-  ) => SignalStoreFeature<Input, Output>,
-): SignalStoreFeature<Input, Output> {
-  return (store) => {
-    const storeForFactory = {
-      ...store['stateSignals'],
-      ...store['props'],
-      ...store['methods'],
-    } as StoreForFactory<Input>;
-
-    const feature = factoryFn(storeForFactory);
-
-    return feature(store);
-  };
-}
+export declare function withFeatureFactory<Input extends SignalStoreFeatureResult, Output extends SignalStoreFeatureResult>(factoryFn: (store: StoreForFactory<Input>) => SignalStoreFeature<Input, Output>): SignalStoreFeature<Input, Output>;
+export {};

package/lib/with-mutations.d.ts

@@ -0,0 +1,51 @@
+import { Signal } from '@angular/core';
+import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult, StateSignals, WritableStateSource } from '@ngrx/signals';
+import { Mutation, MutationStatus } from './mutation/mutation';
+type MutationsDictionary = Record<string, Mutation<any, any>>;
+export type MethodsDictionary = Record<string, Function>;
+type NamedMutationProps<T extends MutationsDictionary> = {
+    [Prop in keyof T as `${Prop & string}IsPending`]: Signal<boolean>;
+} & {
+    [Prop in keyof T as `${Prop & string}Status`]: Signal<MutationStatus>;
+} & {
+    [Prop in keyof T as `${Prop & string}Error`]: Signal<Error | undefined>;
+};
+type NamedMutationMethods<T extends MutationsDictionary> = {
+    [Prop in keyof T as `${Prop & string}`]: T[Prop] extends Mutation<infer P, infer R> ? Mutation<P, R> : never;
+};
+export type NamedMutationResult<T extends MutationsDictionary> = EmptyFeatureResult & {
+    props: NamedMutationProps<T>;
+    methods: NamedMutationMethods<T>;
+};
+/**
+ * Adds mutation methods to the store. Also, for each mutation method, several
+ * Signals are added informing about the mutation's status and errors.
+ *
+ * ```typescript
+ * export type Params = {
+ *   value: number;
+ * };
+ *
+ * export const CounterStore = signalStore(
+ *   { providedIn: 'root' },
+ *   withState({ counter: 0 }),
+ *   withMutations((store) => ({
+ *     increment: rxMutation({ ... }),
+ *   })),
+ * );
+ * ```
+ *
+ * There are several types of mutations. In the example shown, an {@link module:rx-mutation.rxMutation | rxMutation}
+ * leveraging RxJS is used
+ *
+ * For the defined `increment` mutation, several the following properties and
+ * methods are added to the store:
+ * - `increment(params: Params): Promise<MutationResult<number>>`: The mutation method.
+ * - `incrementIsPending`: A signal indicating if the mutation is in progress.
+ * - `incrementStatus`: A signal representing the current status of the mutation.
+ * - `incrementError`: A signal containing any error that occurred during the mutation.
+ *
+ * @param mutationsFactory
+ */
+export declare function withMutations<Input extends SignalStoreFeatureResult, Result extends MutationsDictionary>(mutationsFactory: (store: Input['props'] & Input['methods'] & WritableStateSource<Input['state']> & StateSignals<Input['state']>) => Result): SignalStoreFeature<Input, NamedMutationResult<Result>>;
+export {};

package/lib/with-pagination.d.ts

@@ -0,0 +1,98 @@
+/** 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.
+ */
+import { Signal } from '@angular/core';
+import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
+export type Page = {
+    label: string | number;
+    value: number;
+};
+export type NamedPaginationServiceState<E, Collection extends string> = {
+    [K in Collection as `selectedPage${Capitalize<K>}Entities`]: Array<E>;
+} & {
+    [K in Collection as `${Lowercase<K>}CurrentPage`]: number;
+} & {
+    [K in Collection as `${Lowercase<K>}PageSize`]: number;
+} & {
+    [K in Collection as `${Lowercase<K>}TotalCount`]: number;
+} & {
+    [K in Collection as `${Lowercase<K>}PageCount`]: number;
+} & {
+    [K in Collection as `${Lowercase<K>}PageNavigationArray`]: number;
+} & {
+    [K in Collection as `${Lowercase<K>}PageNavigationArrayMax`]: number;
+};
+export type NamedPaginationServiceSignals<E, Collection extends string> = {
+    [K in Collection as `selectedPage${Capitalize<K>}Entities`]: Signal<E[]>;
+} & {
+    [K in Collection as `${Lowercase<K>}CurrentPage`]: Signal<number>;
+} & {
+    [K in Collection as `${Lowercase<K>}PageSize`]: Signal<number>;
+} & {
+    [K in Collection as `${Lowercase<K>}TotalCount`]: Signal<number>;
+} & {
+    [K in Collection as `${Lowercase<K>}PageCount`]: Signal<number>;
+} & {
+    [K in Collection as `${Lowercase<K>}PageNavigationArray`]: Signal<Page[]>;
+} & {
+    [K in Collection as `${Lowercase<K>}PageNavigationArrayMax`]: Signal<number>;
+} & {
+    [K in Collection as `hasNext${Capitalize<K>}Page`]: Signal<boolean>;
+} & {
+    [K in Collection as `hasPrevious${Capitalize<K>}Page`]: Signal<boolean>;
+};
+export type PaginationServiceState<E> = {
+    selectedPageEntities: Array<E>;
+    currentPage: number;
+    pageSize: number;
+    totalCount: number;
+    pageCount: number;
+    pageNavigationArray: Page[];
+    pageNavigationArrayMax: number;
+};
+export type PaginationServiceSignals<E> = {
+    selectedPageEntities: Signal<E[]>;
+    currentPage: Signal<number>;
+    pageSize: Signal<number>;
+    totalCount: Signal<number>;
+    pageCount: Signal<number>;
+    pageNavigationArray: Signal<Page[]>;
+    pageNavigationArrayMax: Signal<number>;
+    hasNextPage: Signal<boolean>;
+    hasPreviousPage: Signal<boolean>;
+};
+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, EmptyFeatureResult & {
+    state: NamedPaginationServiceState<E, Collection>;
+    props: NamedPaginationServiceSignals<E, Collection>;
+}>;
+export declare function withPagination<E>(): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: PaginationServiceState<E>;
+    props: PaginationServiceSignals<E>;
+}>;
+export declare function gotoPage<E, Collection extends string>(page: number, options?: {
+    collection: Collection;
+}): Partial<SetPaginationState<E, Collection>>;
+export declare function setPageSize<E, Collection extends string>(pageSize: number, options?: {
+    collection: Collection;
+}): Partial<SetPaginationState<E, Collection>>;
+export declare function nextPage<E, Collection extends string>(options?: {
+    collection: Collection;
+}): Partial<SetPaginationState<E, Collection>>;
+export declare function previousPage<E, Collection extends string>(options?: {
+    collection: Collection;
+}): Partial<SetPaginationState<E, Collection>>;
+export declare function firstPage<E, Collection extends string>(options?: {
+    collection: Collection;
+}): Partial<SetPaginationState<E, Collection>>;
+export declare function setMaxPageNavigationArrayItems<E, Collection extends string>(maxPageNavigationArrayItems: number, options?: {
+    collection: Collection;
+}): Partial<SetPaginationState<E, Collection>>;
+export declare function createPageArray(currentPage: number, itemsPerPage: number, totalItems: number, paginationRange: number): Page[];

package/lib/with-redux.d.ts

@@ -0,0 +1,147 @@
+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 & {
+    type: Type;
+}) & {
+    type: Type;
+};
+type ActionFns = Record<string, ActionFn>;
+export type ActionsFnSpecs = Record<string, Payload>;
+type ActionFnCreator<Spec extends ActionsFnSpecs> = {
+    [ActionName in keyof Spec]: (Record<never, never> extends Spec[ActionName] ? () => Spec[ActionName] & {
+        type: ActionName;
+    } : (payload: Spec[ActionName]) => Spec[ActionName] & {
+        type: ActionName;
+    }) & {
+        type: ActionName & string;
+    };
+};
+type ActionFnPayload<Action> = Action extends (payload: infer Payload) => void ? Payload : never;
+type ActionFnsCreator<Spec extends ActionsFnSpecs> = Spec extends {
+    private: Record<string, Payload>;
+    public: Record<string, Payload>;
+} ? ActionFnCreator<Spec['private']> & ActionFnCreator<Spec['public']> : ActionFnCreator<Spec>;
+type PublicActionFns<Spec extends ActionsFnSpecs> = Spec extends {
+    public: Record<string, Payload>;
+} ? ActionFnCreator<Spec['public']> : ActionFnCreator<Spec>;
+export declare function payload<Type extends Payload>(): Type;
+export declare const noPayload: {};
+/** Reducer **/
+type ReducerFunction<ReducerAction, State> = (state: State, action: ActionFnPayload<ReducerAction>) => void;
+type ReducerFactory<StateActionFns extends ActionFns, State> = (actions: StateActionFns, on: <ReducerAction extends {
+    type: string;
+}>(action: ReducerAction, reducerFn: ReducerFunction<ReducerAction, State>) => void) => void;
+/**
+ * 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
+ */
+export declare function createReducer<State extends object, Actions extends ActionsFnSpecs>(reducerFactory: ReducerFactory<ActionFnsCreator<Actions>, WritableStateSource<State>>): ReducerFactory<ActionFnsCreator<Actions>, WritableStateSource<State>>;
+/** Effect **/
+type EffectsFactory<StateActionFns extends ActionFns> = (actions: StateActionFns, create: <EffectAction extends {
+    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
+ * 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
+ */
+export declare function createEffects<Actions extends ActionsFnSpecs>(actions: Actions, effectsFactory: EffectsFactory<ActionFnsCreator<Actions>>): EffectsFactory<ActionFnsCreator<Actions>>;
+/**
+ * @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
+ */
+export declare function withRedux<Spec extends ActionsFnSpecs, Input extends SignalStoreFeatureResult, StateActionFns extends ActionFnsCreator<Spec> = ActionFnsCreator<Spec>, PublicStoreActionFns extends PublicActionFns<Spec> = PublicActionFns<Spec>>(redux: {
+    actions: Spec;
+    reducer: ReducerFactory<StateActionFns, WritableStateSource<Input['state']>>;
+    effects: EffectsFactory<StateActionFns>;
+}): SignalStoreFeature<Input, EmptyFeatureResult & {
+    methods: PublicStoreActionFns;
+}>;
+export {};

package/lib/with-reset.d.ts

@@ -0,0 +1,29 @@
+import { StateSource } from '@ngrx/signals';
+export type PublicMethods = {
+    resetState(): void;
+};
+/**
+ * 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}.
+ */
+export declare function withReset(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
+    state: {};
+    props: {
+        _resetState: {
+            value: {};
+        };
+    };
+    methods: {
+        resetState: () => void;
+    };
+}>;
+/**
+ * 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
+ */
+export declare function setResetState<State extends object>(store: StateSource<State>, state: State): void;

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

@@ -0,0 +1,31 @@
+import { Signal } from '@angular/core';
+import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult } from '@ngrx/signals';
+export type StackItem = Record<string, unknown>;
+export type NormalizedUndoRedoOptions = {
+    maxStackSize: number;
+    collections?: string[];
+    keys: string[];
+    skip: number;
+};
+export declare function getUndoRedoKeys(collections?: string[]): string[];
+type NonNever<T> = T extends never ? never : T;
+type ExtractEntityCollection<T> = T extends `${infer U}Entities` ? U : never;
+type ExtractEntityCollections<Store extends SignalStoreFeatureResult> = NonNever<{
+    [K in keyof Store['props']]: ExtractEntityCollection<K>;
+}[keyof Store['props']]>;
+type OptionsForState<Store extends SignalStoreFeatureResult> = Partial<Omit<NormalizedUndoRedoOptions, 'collections' | 'keys'>> & {
+    collections?: ExtractEntityCollections<Store>[];
+    keys?: (keyof Store['state'])[];
+};
+export declare function withUndoRedo<Input extends EmptyFeatureResult>(options?: OptionsForState<Input>): SignalStoreFeature<Input, EmptyFeatureResult & {
+    props: {
+        canUndo: Signal<boolean>;
+        canRedo: Signal<boolean>;
+    };
+    methods: {
+        undo: () => void;
+        redo: () => void;
+        clearStack: () => void;
+    };
+}>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-architects/ngrx-toolkit",
-  "version": "19.4.0",
+  "version": "19.4.2",
   "license": "MIT",
   "repository": {
     "type": "GitHub",
@@ -18,6 +18,23 @@
       "optional": true
     }
   },
-  "dependencies": {},
-  "sideEffects": false
-}
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/angular-architects-ngrx-toolkit.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/angular-architects-ngrx-toolkit.mjs"
+    },
+    "./redux-connector": {
+      "types": "./redux-connector/index.d.ts",
+      "default": "./fesm2022/angular-architects-ngrx-toolkit-redux-connector.mjs"
+    }
+  }
+}

package/redux-connector/index.d.ts

@@ -0,0 +1,2 @@
+export { createReduxState, mapAction, withActionMappers, } from './src/lib/create-redux';
+export { reduxMethod } from './src/lib/rxjs-interop/redux-method';

package/redux-connector/src/lib/create-redux.d.ts

@@ -0,0 +1,13 @@
+import { ActionCreator, ActionType } from '@ngrx/store/src/models';
+import { CreateReduxState, MapperTypes, Store } from './model';
+export declare function mapAction<Creators extends readonly ActionCreator[]>(...args: [
+    ...creators: Creators,
+    storeMethod: (action: ActionType<Creators[number]>) => unknown
+]): MapperTypes<Creators>;
+export declare function mapAction<Creators extends readonly ActionCreator[], T>(...args: [
+    ...creators: Creators,
+    storeMethod: (action: ActionType<Creators[number]>, resultMethod: (input: T) => unknown) => unknown,
+    resultMethod: (input: T) => unknown
+]): MapperTypes<Creators>;
+export declare function withActionMappers(...mappers: MapperTypes<ActionCreator[]>[]): MapperTypes<ActionCreator[]>[];
+export declare function createReduxState<StoreName extends string, STORE extends Store>(storeName: StoreName, signalStore: STORE, withActionMappers: (store: InstanceType<STORE>) => MapperTypes<ActionCreator[]>[]): CreateReduxState<StoreName, STORE>;

package/redux-connector/src/lib/model.d.ts

@@ -0,0 +1,40 @@
+import { EnvironmentProviders, Signal, Type } from '@angular/core';
+import { DeepSignal } from '@ngrx/signals/src/deep-signal';
+import { SignalStoreFeatureResult, StateSignals } from '@ngrx/signals/src/signal-store-models';
+import { Action, ActionCreator, ActionType, Prettify } from '@ngrx/store/src/models';
+import { Observable, Unsubscribable } from 'rxjs';
+export type IncludePropType<T, V, WithNevers = {
+    [K in keyof T]: Exclude<T[K], undefined> extends V ? T[K] extends Record<string, unknown> ? IncludePropType<T[K], V> : T[K] : never;
+}> = Prettify<Pick<WithNevers, {
+    [K in keyof WithNevers]: WithNevers[K] extends never ? never : K extends string ? K : never;
+}[keyof WithNevers]>>;
+export type Store = Type<Record<string, unknown> & StateSignals<SignalStoreFeatureResult['state']>>;
+export type CreateReduxState<StoreName extends string, STORE extends Store> = {
+    [K in StoreName as `provide${Capitalize<K>}Store`]: (connectReduxDevtools?: boolean) => EnvironmentProviders;
+} & {
+    [K in StoreName as `inject${Capitalize<K>}Store`]: () => InjectableReduxSlice<STORE>;
+};
+export type Selectors<STORE extends Store> = IncludePropType<InstanceType<STORE>, Signal<unknown> | DeepSignal<unknown>>;
+export type Dispatch = {
+    dispatch: (input: Action | Observable<Action> | Signal<Action>) => Unsubscribable;
+};
+export type InjectableReduxSlice<STORE extends Store> = Selectors<STORE> & Dispatch;
+export type ExtractActionTypes<Creators extends readonly ActionCreator[]> = {
+    [Key in keyof Creators]: Creators[Key] extends ActionCreator<infer T> ? T : never;
+};
+export interface ActionMethod<T, V extends Action = Action> {
+    (action: V): T;
+}
+export interface StoreMethod<Creators extends readonly ActionCreator[], ResultState = unknown> {
+    (action: ActionType<Creators[number]>): ResultState;
+}
+export interface MapperTypes<Creators extends readonly ActionCreator[]> {
+    types: ExtractActionTypes<Creators>;
+    storeMethod: StoreMethod<Creators>;
+    resultMethod?: (...args: unknown[]) => unknown;
+}
+export type ServiceWithDecorator = {
+    ɵprov?: {
+        providedIn?: string;
+    };
+};

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

@@ -0,0 +1,14 @@
+import { Injector, Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+type RxMethodInput<Input> = Input | Observable<Input> | Signal<Input>;
+type RxMethodRef = {
+    destroy: () => void;
+};
+type RxMethod<Input, MethodInput = Input, MethodResult = unknown> = ((input: RxMethodInput<Input>, resultMethod: (input: MethodInput) => MethodResult) => RxMethodRef) & RxMethodRef;
+export declare function reduxMethod<Input, MethodInput = Input>(generator: (source$: Observable<Input>) => Observable<MethodInput>, config?: {
+    injector?: Injector;
+}): RxMethod<Input, MethodInput>;
+export declare function reduxMethod<Input, MethodInput = Input, MethodResult = unknown>(generator: (source$: Observable<Input>) => Observable<MethodInput>, resultMethod: (input: MethodInput) => MethodResult, config?: {
+    injector?: Injector;
+}): RxMethod<Input, MethodInput, MethodResult>;
+export {};