@ngrx/store

@ngrx/store

Version 19.2.1
Published 1 month ago
645 kB
1 dependency
MIT license

Install

npm i @ngrx/store

yarn add @ngrx/store

pnpm add @ngrx/store

Overview

RxJS powered Redux for Angular apps

Index

Variables

ACTIVE_RUNTIME_CHECKS
FEATURE_REDUCERS
FEATURE_STATE_PROVIDER
INIT
INITIAL_REDUCERS
INITIAL_STATE
META_REDUCERS
REDUCER_FACTORY
ROOT_STORE_PROVIDER
STORE_FEATURES
UPDATE
USER_PROVIDED_META_REDUCERS
USER_RUNTIME_CHECKS

Variables

variable ACTIVE_RUNTIME_CHECKS

const ACTIVE_RUNTIME_CHECKS: InjectionToken<RuntimeChecks>;

Runtime checks currently in use

variable FEATURE_REDUCERS

const FEATURE_REDUCERS: InjectionToken<unknown>;

variable FEATURE_STATE_PROVIDER

const FEATURE_STATE_PROVIDER: InjectionToken<void>;

InjectionToken that registers feature states. Mainly used to provide a hook that can be injected to ensure feature state is loaded before something that depends on it.

variable INIT

const INIT: string;

variable INITIAL_REDUCERS

const INITIAL_REDUCERS: InjectionToken<unknown>;

variable INITIAL_STATE

const INITIAL_STATE: InjectionToken<unknown>;

variable META_REDUCERS

const META_REDUCERS: InjectionToken<MetaReducer<any, Action<string>>[]>;

Meta reducers defined either internally by @ngrx/store or by library authors

variable REDUCER_FACTORY

const REDUCER_FACTORY: InjectionToken<unknown>;

variable ROOT_STORE_PROVIDER

const ROOT_STORE_PROVIDER: InjectionToken<void>;

InjectionToken that registers the global Store. Mainly used to provide a hook that can be injected to ensure the root state is loaded before something that depends on it.

variable STORE_FEATURES

const STORE_FEATURES: InjectionToken<unknown>;

variable UPDATE

const UPDATE: string;

variable USER_PROVIDED_META_REDUCERS

const USER_PROVIDED_META_REDUCERS: InjectionToken<
    MetaReducer<any, Action<string>>[]
>;

User-defined meta reducers from StoreModule.forRoot()

variable USER_RUNTIME_CHECKS

const USER_RUNTIME_CHECKS: InjectionToken<RuntimeChecks>;

Runtime checks defined by the user via an InjectionToken Defaults to _USER_RUNTIME_CHECKS

Functions

function combineReducers

combineReducers: <T, V extends Action<string> = Action<string>>(
    reducers: ActionReducerMap<T, V>,
    initialState?: Partial<T>
) => ActionReducer<T, V>;

function compose

compose: {
    <A>(): (i: A) => A;
    <A, B>(b: (i: A) => B): (i: A) => B;
    <A, B, C>(c: (i: B) => C, b: (i: A) => B): (i: A) => C;
    <A, B, C, D>(d: (i: C) => D, c: (i: B) => C, b: (i: A) => B): (i: A) => D;
    <A, B, C, D, E>(
        e: (i: D) => E,
        d: (i: C) => D,
        c: (i: B) => C,
        b: (i: A) => B
    ): (i: A) => E;
    <A, B, C, D, E, F>(
        f: (i: E) => F,
        e: (i: D) => E,
        d: (i: C) => D,
        c: (i: B) => C,
        b: (i: A) => B
    ): (i: A) => F;
    <A = any, F = any>(...functions: any[]): (i: A) => F;
};

function createAction

createAction: {
    <T extends string>(type: T): ActionCreator<T, () => Action<T>>;
    <T extends string, P extends object>(
        type: T,
        config: ActionCreatorProps<P> & NotAllowedCheck<P>
    ): ActionCreator<T, (props: P & NotAllowedCheck<P>) => P & Action<T>>;
    <T extends string, P extends any[], R extends object>(
        type: T,
        creator: Creator<P, R & NotAllowedCheck<R>>
    ): FunctionWithParametersType<P, R & Action<T>> & Action<T>;
};

Creates a configured Creator function that, when called, returns an object in the shape of the Action interface with no additional metadata.
Parameter type
Describes the action that will be dispatched
Declaring an action creator:
export const increment = createAction('[Counter] Increment');
Dispatching an action:
store.dispatch(increment());
Referencing the action in a reducer:
on(CounterActions.increment, (state) => ({ ...state, count: state.count + 1 }))
Referencing the action in an effect:
effectName$ = createEffect( () => this.actions$.pipe( ofType(CounterActions.increment), // ... ) );

Creates a configured Creator function that, when called, returns an object in the shape of the Action interface with metadata provided by the props or emptyProps functions.

Parameter type

Describes the action that will be dispatched

Declaring an action creator:

export const loginSuccess = createAction(
  '[Auth/API] Login Success',
  props<{ user: User }>()
);

Dispatching an action:

store.dispatch(loginSuccess({ user: newUser }));

Referencing the action in a reducer:

on(AuthApiActions.loginSuccess, (state, { user }) => ({ ...state, user }))

Referencing the action in an effect:

effectName$ = createEffect(
  () => this.actions$.pipe(
    ofType(AuthApiActions.loginSuccess),
    // ...
  )
);

function createActionGroup

createActionGroup: <
    Source extends string,
    Events extends Record<
        string,
        Creator<any[], object> | ActionCreatorProps<unknown>
    >
>(
    config: ActionGroupConfig<Source, Events>
) => ActionGroup<Source, Events>;

A function that creates a group of action creators with the same source.

Parameter config

An object that contains a source and dictionary of events. An event is a key-value pair of an event name and event props.

Returns

A dictionary of action creators. The name of each action creator is created by camel casing the event name. The type of each action is created using the "[Source] Event Name" pattern.

const authApiActions = createActionGroup({
  source: 'Auth API',
  events: {
    // defining events with payload using the `props` function
    'Login Success': props<{ userId: number; token: string }>(),
    'Login Failure': props<{ error: string }>(),

    // defining an event without payload using the `emptyProps` function
    'Logout Success': emptyProps(),

    // defining an event with payload using the props factory
    'Logout Failure': (error: Error) => ({ error }),
  },
});

// action type: "[Auth API] Login Success"
authApiActions.loginSuccess({ userId: 10, token: 'ngrx' });

// action type: "[Auth API] Login Failure"
authApiActions.loginFailure({ error: 'Login Failure!' });

// action type: "[Auth API] Logout Success"
authApiActions.logoutSuccess();

// action type: "[Auth API] Logout Failure";
authApiActions.logoutFailure(new Error('Logout Failure!'));

function createFeature

createFeature: {
    <
        FeatureName extends string,
        FeatureState,
        ExtraSelectors extends SelectorsDictionary
    >(
        featureConfig: FeatureConfig<FeatureName, FeatureState> & {
            extraSelectors: ExtraSelectorsFactory<
                FeatureName,
                FeatureState,
                ExtraSelectors
            >;
        } & NotAllowedFeatureStateCheck<FeatureState>
    ): Prettify<
        FeatureWithExtraSelectors<FeatureName, FeatureState, ExtraSelectors>
    >;
    <FeatureName extends string, FeatureState>(
        featureConfig: FeatureConfig<FeatureName, FeatureState> &
            NotAllowedFeatureStateCheck<FeatureState>
    ): {
        [K in keyof Feature<FeatureName, FeatureState>]: Feature<
            FeatureName,
            FeatureState
        >[K];
    };
};

Creates a feature object with extra selectors.
Parameter featureConfig
An object that contains a feature name, a feature reducer, and extra selectors factory.
Returns
An object that contains a feature name, a feature reducer, a feature selector, a selector for each feature state property, and extra selectors.
Creates a feature object.
Parameter featureConfig
An object that contains a feature name and a feature reducer.
Returns
An object that contains a feature name, a feature reducer, a feature selector, and a selector for each feature state property.

function createFeatureSelector

createFeatureSelector: {
    <T>(featureName: string): MemoizedSelector<object, T>;
    <T, V>(featureName: keyof T): MemoizedSelector<T, V, DefaultProjectorFn<V>>;
};

Deprecated
Feature selectors with a root state are deprecated, for more info see

function createReducer

createReducer: <
    S,
    A extends Action<string> = Action<string>,
    R extends ActionReducer<S, A> = ActionReducer<S, A>
>(
    initialState: S,
    ...ons: ReducerTypes<S, readonly ActionCreator[]>[]
) => R;

Creates a reducer function to handle state transitions.
Reducer creators reduce the explicitness of reducer functions with switch statements.
Parameter initialState
Provides a state value if the current state is undefined, as it is initially.
Parameter ons
Associations between actions and state changes.
Returns
A reducer function.
- Must be used with ActionCreator's (returned by createAction). Cannot be used with class-based action creators. - The returned ActionReducer does not require being wrapped with another function.
**Declaring a reducer creator**
export const reducer = createReducer( initialState, on( featureActions.actionOne, featureActions.actionTwo, (state, { updatedValue }) => ({ ...state, prop: updatedValue }) ), on(featureActions.actionThree, () => initialState); );

function createReducerFactory

createReducerFactory: <T, V extends Action<string> = Action<string>>(
    reducerFactory: ActionReducerFactory<T, V>,
    metaReducers?: MetaReducer<T, V>[]
) => ActionReducerFactory<T, V>;

function createSelector

createSelector: {
    <State, S1, Result>(
        s1: Selector<State, S1>,
        projector: (s1: S1) => Result
    ): MemoizedSelector<State, Result, typeof projector>;
    <State, S1, S2, Result>(
        s1: Selector<State, S1>,
        s2: Selector<State, S2>,
        projector: (s1: S1, s2: S2) => Result
    ): MemoizedSelector<State, Result, (s1: S1, s2: S2) => Result>;
    <State, S1, S2, S3, Result>(
        s1: Selector<State, S1>,
        s2: Selector<State, S2>,
        s3: Selector<State, S3>,
        projector: (s1: S1, s2: S2, s3: S3) => Result
    ): MemoizedSelector<State, Result, (s1: S1, s2: S2, s3: S3) => Result>;
    <State, S1, S2, S3, S4, Result>(
        s1: Selector<State, S1>,
        s2: Selector<State, S2>,
        s3: Selector<State, S3>,
        s4: Selector<State, S4>,
        projector: (s1: S1, s2: S2, s3: S3, s4: S4) => Result
    ): MemoizedSelector<State, Result, (s1: S1, s2: S2, s3: S3, s4: S4) => Result>;
    <State, S1, S2, S3, S4, S5, Result>(
        s1: Selector<State, S1>,
        s2: Selector<State, S2>,
        s3: Selector<State, S3>,
        s4: Selector<State, S4>,
        s5: Selector<State, S5>,
        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5) => Result
    ): MemoizedSelector<
        State,
        Result,
        (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5) => Result
    >;
    <State, S1, S2, S3, S4, S5, S6, Result>(
        s1: Selector<State, S1>,
        s2: Selector<State, S2>,
        s3: Selector<State, S3>,
        s4: Selector<State, S4>,
        s5: Selector<State, S5>,
        s6: Selector<State, S6>,
        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6) => Result
    ): MemoizedSelector<
        State,
        Result,
        (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6) => Result
    >;
    <State, S1, S2, S3, S4, S5, S6, S7, Result>(
        s1: Selector<State, S1>,
        s2: Selector<State, S2>,
        s3: Selector<State, S3>,
        s4: Selector<State, S4>,
        s5: Selector<State, S5>,
        s6: Selector<State, S6>,
        s7: Selector<State, S7>,
        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6, s7: S7) => Result
    ): MemoizedSelector<
        State,
        Result,
        (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6, s7: S7) => Result
    >;
    <State, S1, S2, S3, S4, S5, S6, S7, S8, Result>(
        s1: Selector<State, S1>,
        s2: Selector<State, S2>,
        s3: Selector<State, S3>,
        s4: Selector<State, S4>,
        s5: Selector<State, S5>,
        s6: Selector<State, S6>,
        s7: Selector<State, S7>,
        s8: Selector<State, S8>,
        projector: (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            s7: S7,
            s8: S8
        ) => Result
    ): MemoizedSelector<
        State,
        Result,
        (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6, s7: S7, s8: S8) => Result
    >;
    <
        Selectors extends Record<string, Selector<State, unknown>>,
        State = Selectors extends Record<string, Selector<infer S, unknown>>
            ? S
            : never,
        Result extends Record<string, unknown> = {
            [Key in keyof Selectors]: Selectors[Key] extends Selector<State, infer R>
                ? R
                : never;
        }
    >(
        selectors: Selectors
    ): MemoizedSelector<State, Result, never>;
    <State, Slices extends unknown[], Result>(
        ...args: [...slices: Selector<State, unknown>[], projector: unknown] &
            [
                ...slices: { [i in keyof Slices]: Selector<State, Slices[i]> },
                projector: (...s: Slices) => Result
            ]
    ): MemoizedSelector<State, Result, (...s: Slices) => Result>;
    <State, Props, S1, Result>(
        s1: SelectorWithProps<State, Props, S1>,
        projector: (s1: S1, props: Props) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, props: Props) => Result
    >;
    <State, Props, S1, S2, Result>(
        s1: SelectorWithProps<State, Props, S1>,
        s2: SelectorWithProps<State, Props, S2>,
        projector: (s1: S1, s2: S2, props: Props) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, s2: S2, props: Props) => Result
    >;
    <State, Props, S1, S2, S3, Result>(
        s1: SelectorWithProps<State, Props, S1>,
        s2: SelectorWithProps<State, Props, S2>,
        s3: SelectorWithProps<State, Props, S3>,
        projector: (s1: S1, s2: S2, s3: S3, props: Props) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, s2: S2, s3: S3, props: Props) => Result
    >;
    <State, Props, S1, S2, S3, S4, Result>(
        s1: SelectorWithProps<State, Props, S1>,
        s2: SelectorWithProps<State, Props, S2>,
        s3: SelectorWithProps<State, Props, S3>,
        s4: SelectorWithProps<State, Props, S4>,
        projector: (s1: S1, s2: S2, s3: S3, s4: S4, props: Props) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, s2: S2, s3: S3, s4: S4, props: Props) => Result
    >;
    <State, Props, S1, S2, S3, S4, S5, Result>(
        s1: SelectorWithProps<State, Props, S1>,
        s2: SelectorWithProps<State, Props, S2>,
        s3: SelectorWithProps<State, Props, S3>,
        s4: SelectorWithProps<State, Props, S4>,
        s5: SelectorWithProps<State, Props, S5>,
        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, props: Props) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, props: Props) => Result
    >;
    <State, Props, S1, S2, S3, S4, S5, S6, Result>(
        s1: SelectorWithProps<State, Props, S1>,
        s2: SelectorWithProps<State, Props, S2>,
        s3: SelectorWithProps<State, Props, S3>,
        s4: SelectorWithProps<State, Props, S4>,
        s5: SelectorWithProps<State, Props, S5>,
        s6: SelectorWithProps<State, Props, S6>,
        projector: (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            props: Props
        ) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6, props: Props) => Result
    >;
    <State, Props, S1, S2, S3, S4, S5, S6, S7, Result>(
        s1: SelectorWithProps<State, Props, S1>,
        s2: SelectorWithProps<State, Props, S2>,
        s3: SelectorWithProps<State, Props, S3>,
        s4: SelectorWithProps<State, Props, S4>,
        s5: SelectorWithProps<State, Props, S5>,
        s6: SelectorWithProps<State, Props, S6>,
        s7: SelectorWithProps<State, Props, S7>,
        projector: (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            s7: S7,
            props: Props
        ) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            s7: S7,
            props: Props
        ) => Result
    >;
    <State, Props, S1, S2, S3, S4, S5, S6, S7, S8, Result>(
        s1: SelectorWithProps<State, Props, S1>,
        s2: SelectorWithProps<State, Props, S2>,
        s3: SelectorWithProps<State, Props, S3>,
        s4: SelectorWithProps<State, Props, S4>,
        s5: SelectorWithProps<State, Props, S5>,
        s6: SelectorWithProps<State, Props, S6>,
        s7: SelectorWithProps<State, Props, S7>,
        s8: SelectorWithProps<State, Props, S8>,
        projector: (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            s7: S7,
            s8: S8,
            props: Props
        ) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            s7: S7,
            s8: S8,
            props: Props
        ) => Result
    >;
    <State, Slices extends unknown[], Result>(
        selectors: Selector<State, unknown>[] &
            [...{ [i in keyof Slices]: Selector<State, Slices[i]> }],
        projector: (...s: Slices) => Result
    ): MemoizedSelector<State, Result, (...s: Slices) => Result>;
    <State, Props, S1, Result>(
        selectors: [SelectorWithProps<State, Props, S1>],
        projector: (s1: S1, props: Props) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, props: Props) => Result
    >;
    <State, Props, S1, S2, Result>(
        selectors: [
            SelectorWithProps<State, Props, S1>,
            SelectorWithProps<State, Props, S2>
        ],
        projector: (s1: S1, s2: S2, props: Props) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, s2: S2, props: Props) => Result
    >;
    <State, Props, S1, S2, S3, Result>(
        selectors: [
            SelectorWithProps<State, Props, S1>,
            SelectorWithProps<State, Props, S2>,
            SelectorWithProps<State, Props, S3>
        ],
        projector: (s1: S1, s2: S2, s3: S3, props: Props) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, s2: S2, s3: S3, props: Props) => Result
    >;
    <State, Props, S1, S2, S3, S4, Result>(
        selectors: [
            SelectorWithProps<State, Props, S1>,
            SelectorWithProps<State, Props, S2>,
            SelectorWithProps<State, Props, S3>,
            SelectorWithProps<State, Props, S4>
        ],
        projector: (s1: S1, s2: S2, s3: S3, s4: S4, props: Props) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, s2: S2, s3: S3, s4: S4, props: Props) => Result
    >;
    <State, Props, S1, S2, S3, S4, S5, Result>(
        selectors: [
            SelectorWithProps<State, Props, S1>,
            SelectorWithProps<State, Props, S2>,
            SelectorWithProps<State, Props, S3>,
            SelectorWithProps<State, Props, S4>,
            SelectorWithProps<State, Props, S5>
        ],
        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, props: Props) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, props: Props) => Result
    >;
    <State, Props, S1, S2, S3, S4, S5, S6, Result>(
        selectors: [
            SelectorWithProps<State, Props, S1>,
            SelectorWithProps<State, Props, S2>,
            SelectorWithProps<State, Props, S3>,
            SelectorWithProps<State, Props, S4>,
            SelectorWithProps<State, Props, S5>,
            SelectorWithProps<State, Props, S6>
        ],
        projector: (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            props: Props
        ) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6, props: Props) => Result
    >;
    <State, Props, S1, S2, S3, S4, S5, S6, S7, Result>(
        selectors: [
            SelectorWithProps<State, Props, S1>,
            SelectorWithProps<State, Props, S2>,
            SelectorWithProps<State, Props, S3>,
            SelectorWithProps<State, Props, S4>,
            SelectorWithProps<State, Props, S5>,
            SelectorWithProps<State, Props, S6>,
            SelectorWithProps<State, Props, S7>
        ],
        projector: (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            s7: S7,
            props: Props
        ) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            s7: S7,
            props: Props
        ) => Result
    >;
    <State, Props, S1, S2, S3, S4, S5, S6, S7, S8, Result>(
        selectors: [
            SelectorWithProps<State, Props, S1>,
            SelectorWithProps<State, Props, S2>,
            SelectorWithProps<State, Props, S3>,
            SelectorWithProps<State, Props, S4>,
            SelectorWithProps<State, Props, S5>,
            SelectorWithProps<State, Props, S6>,
            SelectorWithProps<State, Props, S7>,
            SelectorWithProps<State, Props, S8>
        ],
        projector: (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            s7: S7,
            s8: S8,
            props: Props
        ) => Result
    ): MemoizedSelectorWithProps<
        State,
        Props,
        Result,
        (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            s7: S7,
            s8: S8,
            props: Props
        ) => Result
    >;
};

Deprecated
Selectors with props are deprecated, for more info see

function createSelectorFactory

createSelectorFactory: {
    <T = any, V = any>(memoize: MemoizeFn): (
        ...input: any[]
    ) => MemoizedSelector<T, V>;
    <T = any, V = any>(memoize: MemoizeFn, options: SelectorFactoryConfig<T, V>): (
        ...input: any[]
    ) => MemoizedSelector<T, V, DefaultProjectorFn<V>>;
    <T = any, Props = any, V = any>(memoize: MemoizeFn): (
        ...input: any[]
    ) => MemoizedSelectorWithProps<T, Props, V, DefaultProjectorFn<V>>;
    <T = any, Props = any, V = any>(
        memoize: MemoizeFn,
        options: SelectorFactoryConfig<T, V>
    ): (
        ...input: any[]
    ) => MemoizedSelectorWithProps<T, Props, V, DefaultProjectorFn<V>>;
};

Deprecated
Selectors with props are deprecated, for more info see

function defaultMemoize

defaultMemoize: (
    projectionFn: AnyFn,
    isArgumentsEqual?: typeof isEqualCheck,
    isResultEqual?: typeof isEqualCheck
) => MemoizedProjection;

function defaultStateFn

defaultStateFn: (
    state: any,
    selectors: Selector<any, any>[] | SelectorWithProps<any, any, any>[],
    props: any,
    memoizedProjector: MemoizedProjection
) => any;

function emptyProps

emptyProps: () => ActionCreatorProps<void>;

function isNgrxMockEnvironment

isNgrxMockEnvironment: () => boolean;

function on

on: <
    State,
    Creators extends readonly ActionCreator<string, Creator<any[], object>>[],
    InferredState = State
>(
    ...args: [
        ...creators: Creators,
        reducer: OnReducer<
            State extends infer S ? S : never,
            Creators,
            InferredState,
            unknown extends (State extends infer S ? S : never)
                ? InferredState
                : State extends infer S
                ? S
                : never
        >
    ]
) => ReducerTypes<unknown extends State ? InferredState : State, Creators>;

Associates actions with a given state change function. A state change function must be provided as the last parameter.
Parameter args
ActionCreator's followed by a state change function.
Returns
an association of action types with a state change function.
on(AuthApiActions.loginSuccess, (state, { user }) => ({ ...state, user }))

function props

props: <
    P extends SafeProps,
    SafeProps = NotAllowedInPropsCheck<P>
>() => ActionCreatorProps<P>;

function provideState

provideState: {
    <T, V extends Action<string> = Action<string>>(
        featureName: string,
        reducers: ActionReducerMap<T, V> | InjectionToken<ActionReducerMap<T, V>>,
        config?: StoreConfig<T, V> | InjectionToken<StoreConfig<T, V>>
    ): EnvironmentProviders;
    <T, V extends Action<string> = Action<string>>(
        featureName: string,
        reducer: any,
        config?: any
    ): EnvironmentProviders;
    <T, V extends Action<string> = Action<string>>(
        slice: FeatureSlice<T, V>
    ): EnvironmentProviders;
};

function provideStore

provideStore: <T, V extends Action<string> = Action<string>>(
    reducers?: ActionReducerMap<T, V> | InjectionToken<ActionReducerMap<T, V>>,
    config?: RootStoreConfig<T, V>
) => EnvironmentProviders;

Provides the global Store providers and initializes the Store. These providers cannot be used at the component level.
### Providing the Global Store
bootstrapApplication(AppComponent, { providers: [provideStore()], });

function reduceState

reduceState: <T, V extends Action<string> = Action<string>>(
    stateActionPair: StateActionPair<T, V> | undefined,
    [action, reducer]: [V, ActionReducer<T, V>]
) => StateActionPair<T, V>;

function resultMemoize

resultMemoize: (
    projectionFn: AnyFn,
    isResultEqual: ComparatorFn
) => MemoizedProjection;

function select

select: {
    <T, K>(mapFn: (state: T) => K): (source$: Observable<T>) => Observable<K>;
    <T, Props, K>(mapFn: (state: T, props: Props) => K, props: Props): (
        source$: Observable<T>
    ) => Observable<K>;
    <T, a extends keyof T>(key: a): (source$: Observable<T>) => Observable<T[a]>;
    <T, a extends keyof T, b extends keyof T[a]>(key1: a, key2: b): (
        source$: Observable<T>
    ) => Observable<T[a][b]>;
    <T, a extends keyof T, b extends keyof T[a], c extends keyof T[a][b]>(
        key1: a,
        key2: b,
        key3: c
    ): (source$: Observable<T>) => Observable<T[a][b][c]>;
    <
        T,
        a extends keyof T,
        b extends keyof T[a],
        c extends keyof T[a][b],
        d extends keyof T[a][b][c]
    >(
        key1: a,
        key2: b,
        key3: c,
        key4: d
    ): (source$: Observable<T>) => Observable<T[a][b][c][d]>;
    <
        T,
        a extends keyof T,
        b extends keyof T[a],
        c extends keyof T[a][b],
        d extends keyof T[a][b][c],
        e extends keyof T[a][b][c][d]
    >(
        key1: a,
        key2: b,
        key3: c,
        key4: d,
        key5: e
    ): (source$: Observable<T>) => Observable<T[a][b][c][d][e]>;
    <
        T,
        a extends keyof T,
        b extends keyof T[a],
        c extends keyof T[a][b],
        d extends keyof T[a][b][c],
        e extends keyof T[a][b][c][d],
        f extends keyof T[a][b][c][d][e]
    >(
        key1: a,
        key2: b,
        key3: c,
        key4: d,
        key5: e,
        key6: f
    ): (source$: Observable<T>) => Observable<T[a][b][c][d][e][f]>;
    <
        T,
        a extends keyof T,
        b extends keyof T[a],
        c extends keyof T[a][b],
        d extends keyof T[a][b][c],
        e extends keyof T[a][b][c][d],
        f extends keyof T[a][b][c][d][e],
        K = any
    >(
        key1: a,
        key2: b,
        key3: c,
        key4: d,
        key5: e,
        key6: f,
        ...paths: string[]
    ): (source$: Observable<T>) => Observable<K>;
};

Deprecated
Selectors with props are deprecated, for more info see

function setNgrxMockEnvironment

setNgrxMockEnvironment: (value: boolean) => void;

function union

union: <
    C extends { [key: string]: ActionCreator<string, Creator<any[], object>> }
>(
    creators: C
) => ReturnType<C[keyof C]>;

Classes

class ActionsSubject

class ActionsSubject extends BehaviorSubject<Action> implements OnDestroy {}

constructor

constructor();

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<ActionsSubject, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<ActionsSubject>;

method complete

complete: () => void;

method next

next: (action: Action) => void;

method ngOnDestroy

ngOnDestroy: () => void;

class ReducerManager

class ReducerManager
    extends BehaviorSubject<ActionReducer<any, any>>
    implements OnDestroy {}

constructor

constructor(
    dispatcher: ReducerManagerDispatcher,
    initialState: any,
    reducers: ActionReducerMap<any, any>,
    reducerFactory: ActionReducerFactory<any, any>
);

property currentReducers

readonly currentReducers: ActionReducerMap<any, any>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<ReducerManager, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<ReducerManager>;

method addFeature

addFeature: (feature: StoreFeature<any, any>) => void;

method addFeatures

addFeatures: (features: StoreFeature<any, any>[]) => void;

method addReducer

addReducer: (key: string, reducer: ActionReducer<any, any>) => void;

method addReducers

addReducers: (reducers: { [key: string]: ActionReducer<any, any> }) => void;

method ngOnDestroy

ngOnDestroy: () => void;

method removeFeature

removeFeature: (feature: StoreFeature<any, any>) => void;

method removeFeatures

removeFeatures: (features: StoreFeature<any, any>[]) => void;

method removeReducer

removeReducer: (featureKey: string) => void;

method removeReducers

removeReducers: (featureKeys: string[]) => void;

class ReducerManagerDispatcher

abstract class ReducerManagerDispatcher extends ActionsSubject {}

class ReducerObservable

abstract class ReducerObservable extends Observable<ActionReducer<any, any>> {}

class ScannedActionsSubject

class ScannedActionsSubject extends Subject<Action> implements OnDestroy {}

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<ScannedActionsSubject, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<ScannedActionsSubject>;

method ngOnDestroy

ngOnDestroy: () => void;

class State

class State<T> extends BehaviorSubject<any> implements OnDestroy {}

constructor

constructor(
    actions$: ActionsSubject,
    reducer$: ReducerObservable,
    scannedActions: ScannedActionsSubject,
    initialState: any
);

property INIT

static readonly INIT: string;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<State<any>, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<State<any>>;

method ngOnDestroy

ngOnDestroy: () => void;

class StateObservable

abstract class StateObservable extends Observable<any> {}

class Store

class Store<T = object> extends Observable<T> implements Observer<Action> {}

constructor

constructor(
    state$: StateObservable,
    actionsObserver: ActionsSubject,
    reducerManager: ReducerManager,
    injector?: any
);

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<Store<any>, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<Store<any>>;

method addReducer

addReducer: <State, Actions extends Action<string> = Action<string>>(
    key: string,
    reducer: ActionReducer<State, Actions>
) => void;

method complete

complete: () => void;

method dispatch

dispatch: {
    <V extends Action<string>>(action: V & CreatorsNotAllowedCheck<V>): void;
    <V extends () => Action<string>>(
        dispatchFn: V & CreatorsNotAllowedCheck<V>,
        config?: { injector: Injector }
    ): EffectRef;
};

method error

error: (err: any) => void;

method lift

lift: <R>(operator: Operator<T, R>) => Store<R>;

method next

next: (action: Action) => void;

method removeReducer

removeReducer: <Key extends Extract<keyof T, string>>(key: Key) => void;

method select

select: {
    <K>(mapFn: (state: T) => K): Observable<K>;
    <K, Props = any>(
        mapFn: (state: T, props: Props) => K,
        props: Props
    ): Observable<K>;
    <a extends keyof T>(key: a): Observable<T[a]>;
    <a extends keyof T, b extends keyof T[a]>(key1: a, key2: b): Observable<
        T[a][b]
    >;
    <a extends keyof T, b extends keyof T[a], c extends keyof T[a][b]>(
        key1: a,
        key2: b,
        key3: c
    ): Observable<T[a][b][c]>;
    <
        a extends keyof T,
        b extends keyof T[a],
        c extends keyof T[a][b],
        d extends keyof T[a][b][c]
    >(
        key1: a,
        key2: b,
        key3: c,
        key4: d
    ): Observable<T[a][b][c][d]>;
    <
        a extends keyof T,
        b extends keyof T[a],
        c extends keyof T[a][b],
        d extends keyof T[a][b][c],
        e extends keyof T[a][b][c][d]
    >(
        key1: a,
        key2: b,
        key3: c,
        key4: d,
        key5: e
    ): Observable<T[a][b][c][d][e]>;
    <
        a extends keyof T,
        b extends keyof T[a],
        c extends keyof T[a][b],
        d extends keyof T[a][b][c],
        e extends keyof T[a][b][c][d],
        f extends keyof T[a][b][c][d][e]
    >(
        key1: a,
        key2: b,
        key3: c,
        key4: d,
        key5: e,
        key6: f
    ): Observable<T[a][b][c][d][e][f]>;
    <
        a extends keyof T,
        b extends keyof T[a],
        c extends keyof T[a][b],
        d extends keyof T[a][b][c],
        e extends keyof T[a][b][c][d],
        f extends keyof T[a][b][c][d][e],
        K = any
    >(
        key1: a,
        key2: b,
        key3: c,
        key4: d,
        key5: e,
        key6: f,
        ...paths: string[]
    ): Observable<K>;
};

Deprecated
Selectors with props are deprecated, for more info see

method selectSignal

selectSignal: <K>(
    selector: (state: T) => K,
    options?: SelectSignalOptions<K>
) => Signal<K>;

Returns a signal of the provided selector.
Parameter selector
selector function
Parameter options
select signal options
Returns
Signal of the state selected by the provided selector
const count = this.store.selectSignal(state => state.count);
Or with a selector created by @ngrx/store!createSelector:function
const selectCount = createSelector( (state: State) => state.count, ); const count = this.store.selectSignal(selectCount);

class StoreFeatureModule

class StoreFeatureModule implements OnDestroy {}

constructor

constructor(
    features: StoreFeature<any, any>[],
    featureReducers: ActionReducerMap<any, Action<string>>[],
    reducerManager: ReducerManager,
    root: StoreRootModule,
    actionCheck: any
);

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<
    StoreFeatureModule,
    [null, null, null, null, { optional: true }]
>;

property ɵinj

static ɵinj: i0.ɵɵInjectorDeclaration<StoreFeatureModule>;

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<StoreFeatureModule, never, never, never>;

method ngOnDestroy

ngOnDestroy: () => void;

class StoreModule

class StoreModule {}

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<StoreModule, never>;

property ɵinj

static ɵinj: i0.ɵɵInjectorDeclaration<StoreModule>;

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<StoreModule, never, never, never>;

method forFeature

static forFeature: {
    <T, V extends Action<string> = Action<string>>(
        featureName: string,
        reducers:
            | ActionReducerMap<T, V>
            | InjectionToken<ActionReducerMap<T, V>>,
        config?: StoreConfig<T, V> | InjectionToken<StoreConfig<T, V>>
    ): ModuleWithProviders<StoreFeatureModule>;
    <T, V extends Action<string> = Action<string>>(
        featureName: string,
        reducer: any,
        config?: any
    ): ModuleWithProviders<StoreFeatureModule>;
    <T, V extends Action<string> = Action<string>>(
        slice: FeatureSlice<T, V>
    ): ModuleWithProviders<StoreFeatureModule>;
};

method forRoot

static forRoot: <T, V extends Action<string> = Action<string>>(
    reducers?: ActionReducerMap<T, V> | InjectionToken<ActionReducerMap<T, V>>,
    config?: RootStoreConfig<T, V>
) => ModuleWithProviders<StoreRootModule>;

class StoreRootModule

class StoreRootModule {}

constructor

constructor(
    actions$: ActionsSubject,
    reducer$: ReducerObservable,
    scannedActions$: ScannedActionsSubject,
    store: Store<any>,
    guard: any,
    actionCheck: any
);

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<
    StoreRootModule,
    [null, null, null, null, { optional: true }, { optional: true }]
>;

property ɵinj

static ɵinj: i0.ɵɵInjectorDeclaration<StoreRootModule>;

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<StoreRootModule, never, never, never>;

Interfaces

interface Action

interface Action<Type extends string = string> {}

property type

type: Type;

interface ActionCreatorProps

interface ActionCreatorProps<T> {}

interface ActionReducer

interface ActionReducer<T, V extends Action = Action> {}

A function that takes an Action and a State, and returns a State. See createReducer.

call signature

(state: T | undefined, action: V): T;

interface ActionReducerFactory

interface ActionReducerFactory<T, V extends Action = Action> {}

call signature

(
    reducerMap: ActionReducerMap<T, V>,
    initialState?: InitialState<T>
): ActionReducer<T, V>;

interface FeatureConfig

interface FeatureConfig<FeatureName extends string, FeatureState> {}

property name

name: FeatureName;

property reducer

reducer: ActionReducer<FeatureState>;

interface FeatureSlice

interface FeatureSlice<T, V extends Action = Action> {}

An object with the name and the reducer for the feature.

property name

name: string;

property reducer

reducer: ActionReducer<T, V>;

interface MemoizedSelector

interface MemoizedSelector<State, Result, ProjectorFn = DefaultProjectorFn<Result>>
    extends Selector<State, Result> {}

property clearResult

clearResult: () => void;

property projector

projector: ProjectorFn;

property setResult

setResult: (result?: Result) => void;

method release

release: () => void;

interface MemoizedSelectorWithProps

interface MemoizedSelectorWithProps<
    State,
    Props,
    Result,
    ProjectorFn = DefaultProjectorFn<Result>
> extends SelectorWithProps<State, Props, Result> {}

Deprecated
Selectors with props are deprecated, for more info see the

property clearResult

clearResult: () => void;

property projector

projector: ProjectorFn;

property setResult

setResult: (result?: Result) => void;

method release

release: () => void;

interface ReducerTypes

interface ReducerTypes<State, Creators extends readonly ActionCreator[]> {}

Return type of the on fn. Contains the action reducer coupled to one or more action types.

property reducer

reducer: OnReducer<State, Creators>;

property types

types: ExtractActionTypes<Creators>;

interface RootStoreConfig

interface RootStoreConfig<T, V extends Action = Action> extends StoreConfig<T, V> {}

property runtimeChecks

runtimeChecks?: Partial<RuntimeChecks>;

interface RuntimeChecks

interface RuntimeChecks {}

property strictActionImmutability

strictActionImmutability: boolean;

Verifies that actions aren't mutated

property strictActionSerializability

strictActionSerializability: boolean;

Verifies if the actions are serializable. Please note, you may not need to set it to true unless you are storing/replaying actions using external resources, for example localStorage.

property strictActionTypeUniqueness

strictActionTypeUniqueness?: boolean;

Verifies that action types are not registered more than once

property strictActionWithinNgZone

strictActionWithinNgZone: boolean;

Verifies that actions are dispatched within NgZone

property strictStateImmutability

strictStateImmutability: boolean;

Verifies that the state isn't mutated

property strictStateSerializability

strictStateSerializability: boolean;

Verifies if the state is serializable

interface StoreConfig

interface StoreConfig<T, V extends Action = Action> {}

property initialState

initialState?: InitialState<T>;

property metaReducers

metaReducers?: MetaReducer<
    {
        [P in keyof T]: T[P];
    },
    V
>[];

property reducerFactory

reducerFactory?: ActionReducerFactory<T, V>;

Type Aliases

type ActionCreator

type ActionCreator<T extends string = string, C extends Creator = Creator> = C &
    Action<T>;

See Creator.

type ActionReducerMap

type ActionReducerMap<T, V extends Action = Action> = {
    [p in keyof T]: ActionReducer<T[p], V>;
};

type ActionType

type ActionType<A> = A extends ActionCreator<infer T, infer C>
    ? ReturnType<C> & {
          type: T;
      }
    : never;

type Creator

type Creator<
    P extends any[] = any[],
    R extends object = object
> = FunctionWithParametersType<P, R>;

A function that returns an object in the shape of the Action interface. Configured using createAction.

type DefaultProjectorFn

type DefaultProjectorFn<T> = (...args: any[]) => T;

type FunctionWithParametersType

type FunctionWithParametersType<P extends unknown[], R = void> = (...args: P) => R;

type MemoizedProjection

type MemoizedProjection = {
    memoized: AnyFn;
    reset: () => void;
    setResult: (result?: any) => void;
    clearResult: () => void;
};

type MemoizeFn

type MemoizeFn = (t: AnyFn) => MemoizedProjection;

type MetaReducer

type MetaReducer<T = any, V extends Action = Action> = (
    reducer: ActionReducer<T, V>
) => ActionReducer<T, V>;

type NotAllowedCheck

type NotAllowedCheck<T extends object> = T extends any[]
    ? ArraysAreNotAllowed
    : T extends {
          type: any;
      }
    ? TypePropertyIsNotAllowed
    : keyof T extends never
    ? EmptyObjectsAreNotAllowed
    : unknown;

type Selector

type Selector<T, V> = (state: T) => V;

type SelectorWithProps

type SelectorWithProps<State, Props, Result> = (
    state: State,
    props: Props
) => Result;

Deprecated
Selectors with props are deprecated, for more info see

Package Files (18)

Dependencies (1)

tslib

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (2)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@ngrx/store.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@ngrx/store)

HTML

<a href="https://www.jsdocs.io/package/@ngrx/store"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 month ago.
Package analyzed in 6147 ms.
Missing or incorrect documentation? Open an issue for this package.

@ngrx/store

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable ACTIVE_RUNTIME_CHECKS

variable FEATURE_REDUCERS

variable FEATURE_STATE_PROVIDER

variable INIT

variable INITIAL_REDUCERS

variable INITIAL_STATE

variable META_REDUCERS

variable REDUCER_FACTORY

variable ROOT_STORE_PROVIDER

variable STORE_FEATURES

variable UPDATE

variable USER_PROVIDED_META_REDUCERS

variable USER_RUNTIME_CHECKS

Functions

function combineReducers

function compose

function createAction

Parameter type

Parameter type

function createActionGroup

Parameter config

Returns

function createFeature

Parameter featureConfig

Returns

Parameter featureConfig

Returns

function createFeatureSelector

Deprecated

function createReducer

Parameter initialState

Parameter ons

Returns

function createReducerFactory

function createSelector

Deprecated

function createSelectorFactory

Deprecated

function defaultMemoize

function defaultStateFn

function emptyProps

function isNgrxMockEnvironment

function on

Parameter args

Returns

function props

function provideState

function provideStore

function reduceState

function resultMemoize

function select

Deprecated

function setNgrxMockEnvironment

function union

Classes

class ActionsSubject

property ɵfac

property ɵprov

method complete

method next

method ngOnDestroy

class ReducerManager

property currentReducers

property ɵfac

property ɵprov

method addFeature

method addFeatures

method addReducer

method addReducers

method ngOnDestroy