@angular-architects/ngrx-toolkit 19.3.0 → 19.4.0

package/lib/with-redux.d.ts

@@ -1,147 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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/redux-connector/index.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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 {};

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

@@ -1,11 +0,0 @@
-import { Action, ActionCreator } from '@ngrx/store';
-import { MapperTypes } from './model';
-import * as i0 from "@angular/core";
-export declare class SignalReduxStore {
-    private mapperDict;
-    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(): import("@ngrx/signals/rxjs-interop").RxMethod<Action<string>>;

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

@@ -1,5 +0,0 @@
-import { ActionCreator } from '@ngrx/store';
-import { Unsubscribable } from 'rxjs';
-export declare function isUnsubscribable<F extends (...args: unknown[]) => unknown>(fn: F | (F & Unsubscribable)): fn is F & Unsubscribable;
-export declare function capitalize(str: string): string;
-export declare function isActionCreator(action: unknown): action is ActionCreator;