@ngrx/store

@ngrx/store

Version 12.4.0
Published 21 days ago
1.06 MB
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

Type Aliases

ActionCreator
ActionReducerMap
ActionType
Creator
DefaultProjectorFn
FunctionWithParametersType
MemoizedProjection
MemoizeFn
MetaReducer
NotAllowedCheck
Selector
SelectorWithProps

Variables

variable ACTIVE_RUNTIME_CHECKS

const ACTIVE_RUNTIME_CHECKS: any;

Runtime checks currently in use

variable FEATURE_REDUCERS

const FEATURE_REDUCERS: any;

variable INIT

const INIT: string;

variable INITIAL_REDUCERS

const INITIAL_REDUCERS: any;

variable INITIAL_STATE

const INITIAL_STATE: any;

variable META_REDUCERS

const META_REDUCERS: any;

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

variable ɵb

const ɵb: any[];

variable ɵc

const ɵc: any[];

variable ɵd

const ɵd: any[];

variable ɵe

const ɵe: any[];

variable ɵg

const ɵg: any[];

variable ɵh

const ɵh: any;

variable ɵi

const ɵi: any;

variable ɵj

const ɵj: any;

variable ɵk

const ɵk: any;

variable ɵl

const ɵl: any;

variable ɵm

const ɵm: any;

variable ɵn

const ɵn: any;

variable ɵo

const ɵo: any;

variable ɵp

const ɵp: any;

variable ɵq

const ɵq: any;

Concats the user provided meta reducers and the meta reducers provided on the multi injection token

variable ɵr

const ɵr: any;

Runtime checks defined by the user via forRoot()

variable ɵs

const ɵs: any;

variable REDUCER_FACTORY

const REDUCER_FACTORY: any;

variable STORE_FEATURES

const STORE_FEATURES: any;

variable UPDATE

const UPDATE: string;

variable USER_PROVIDED_META_REDUCERS

const USER_PROVIDED_META_REDUCERS: any;

User-defined meta reducers from StoreModule.forRoot()

variable USER_RUNTIME_CHECKS

const USER_RUNTIME_CHECKS: any;

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

Functions

function combineReducers

combineReducers: <T, V extends Action = Action>(
    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, () => TypedAction<T>>;
    <T extends string, P extends object>(
        type: T,
        config: ActionCreatorProps<P> & NotAllowedCheck<P>
    ): ActionCreator<T, (props: P & NotAllowedCheck<P>) => P & TypedAction<T>>;
    <T extends string, P extends any[], R extends object>(
        type: T,
        creator: Creator<P, R & NotAllowedCheck<R>>
    ): FunctionWithParametersType<P, R & TypedAction<T>> & TypedAction<T>;
};

function createFeature

createFeature: <
    AppState extends Record<string, any>,
    FeatureName extends keyof AppState & string = keyof AppState & string,
    FeatureState extends AppState[FeatureName] = AppState[FeatureName]
>(
    featureConfig: FeatureConfig<FeatureName, FeatureState> &
        NotAllowedFeatureStateCheck<FeatureState>
) => Feature<AppState, FeatureName, FeatureState>;

A function that accepts a feature name and a feature reducer, and creates a feature selector and a selector for each feature state property.

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, a the selector for each feature state property.

**With Application State**

interface AppState {
  products: ProductsState;
}

interface ProductsState {
  products: Product[];
  selectedId: string | null;
}

const initialState: ProductsState = {
  products: [],
  selectedId: null,
};

// AppState is passed as a generic argument
const productsFeature = createFeature<AppState>({
  name: 'products',
  reducer: createReducer(
    initialState,
    on(ProductsApiActions.loadSuccess(state, { products }) => ({
      ...state,
      products,
    }),
  ),
});

const {
  selectProductsState, // type: MemoizedSelector<AppState, ProductsState>
  selectProducts, // type: MemoizedSelector<AppState, Product[]>
  selectSelectedId, // type: MemoizedSelector<AppState, string | null>
} = productsFeature;

**Without Application State**

const productsFeature = createFeature({
  name: 'products',
  reducer: createReducer(initialState),
});

const {
  selectProductsState, // type: MemoizedSelector<Record<string, any>, ProductsState>
  selectProducts, // type: MemoizedSelector<Record<string, any>, Product[]>
  selectSelectedId, // type: MemoizedSelector<Record<string, any, string | null>
} = productsFeature;

function createFeatureSelector

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

function createReducer

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

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 should additionally be wrapped with another function, if you are using View Engine AOT. In case you are using Ivy (or only JIT View Engine) the extra wrapper function is not required.
**Declaring a reducer creator**
export const reducer = createReducer( initialState, on( featureActions.actionOne, featureActions.actionTwo, (state, { updatedValue }) => ({ ...state, prop: updatedValue }) ), on(featureActions.actionThree, () => initialState); );
**Declaring a reducer creator using a wrapper function (Only needed if using View Engine AOT)**
const featureReducer = createReducer( initialState, on( featureActions.actionOne, featureActions.actionTwo, (state, { updatedValue }) => ({ ...state, prop: updatedValue }) ), on(featureActions.actionThree, () => initialState); ); export function reducer(state: State | undefined, action: Action) { return featureReducer(state, action); }

function createReducerFactory

createReducerFactory: <T, V extends Action = Action>(
    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>;
    <State, Props, S1, Result>(
        s1: SelectorWithProps<State, Props, S1>,
        projector: (s1: S1, props: Props) => Result
    ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
    <State, S1, Result>(
        selectors: [Selector<State, S1>],
        projector: (s1: S1) => Result
    ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
    <State, Props, S1, Result>(
        selectors: [SelectorWithProps<State, Props, S1>],
        projector: (s1: S1, props: Props) => Result
    ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
    <State, S1, S2, Result>(
        s1: Selector<State, S1>,
        s2: Selector<State, S2>,
        projector: (s1: S1, s2: S2) => Result
    ): MemoizedSelector<State, Result, DefaultProjectorFn<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, DefaultProjectorFn<Result>>;
    <State, S1, S2, Result>(
        selectors: [Selector<State, S1>, Selector<State, S2>],
        projector: (s1: S1, s2: S2) => Result
    ): MemoizedSelector<State, Result, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<Result>>;
    <State, S1, S2, S3, Result>(
        selectors: [Selector<State, S1>, Selector<State, S2>, Selector<State, S3>],
        projector: (s1: S1, s2: S2, s3: S3) => Result
    ): MemoizedSelector<State, Result, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<Result>>;
    <State, S1, S2, S3, S4, Result>(
        selectors: [
            Selector<State, S1>,
            Selector<State, S2>,
            Selector<State, S3>,
            Selector<State, S4>
        ],
        projector: (s1: S1, s2: S2, s3: S3, s4: S4) => Result
    ): MemoizedSelector<State, Result, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<Result>>;
    <State, S1, S2, S3, S4, S5, Result>(
        selectors: [
            Selector<State, S1>,
            Selector<State, S2>,
            Selector<State, S3>,
            Selector<State, S4>,
            Selector<State, S5>
        ],
        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5) => Result
    ): MemoizedSelector<State, Result, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<Result>>;
    <State, S1, S2, S3, S4, S5, S6, Result>(
        selectors: [
            Selector<State, S1>,
            Selector<State, S2>,
            Selector<State, S3>,
            Selector<State, S4>,
            Selector<State, S5>,
            Selector<State, S6>
        ],
        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6) => Result
    ): MemoizedSelector<State, Result, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<Result>>;
    <State, S1, S2, S3, S4, S5, S6, S7, Result>(
        selectors: [
            Selector<State, S1>,
            Selector<State, S2>,
            Selector<State, S3>,
            Selector<State, S4>,
            Selector<State, S5>,
            Selector<State, S6>,
            Selector<State, S7>
        ],
        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6, s7: S7) => Result
    ): MemoizedSelector<State, Result, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<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, DefaultProjectorFn<Result>>;
    <State, S1, S2, S3, S4, S5, S6, S7, S8, Result>(
        selectors: [
            Selector<State, S1>,
            Selector<State, S2>,
            Selector<State, S3>,
            Selector<State, S4>,
            Selector<State, S5>,
            Selector<State, S6>,
            Selector<State, S7>,
            Selector<State, S8>
        ],
        projector: (
            s1: S1,
            s2: S2,
            s3: S3,
            s4: S4,
            s5: S5,
            s6: S6,
            s7: S7,
            s8: S8
        ) => Result
    ): MemoizedSelector<State, Result, DefaultProjectorFn<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, DefaultProjectorFn<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 isNgrxMockEnvironment

isNgrxMockEnvironment: () => boolean;

function on

on: <
    State,
    Creators extends readonly ActionCreator<string, Creator<any[], object>>[]
>(
    ...args: [
        ...creators: Creators,
        reducer: OnReducer<State extends infer S ? S : never, Creators>
    ]
) => ReducerTypes<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 ɵba

ɵba: ({
    strictActionSerializability,
    strictStateSerializability,
}: RuntimeChecks) => MetaReducer;

function ɵbb

ɵbb: ({
    strictActionImmutability,
    strictStateImmutability,
}: RuntimeChecks) => MetaReducer;

function ɵbc

ɵbc: ({ strictActionWithinNgZone }: RuntimeChecks) => MetaReducer;

function ɵbd

ɵbd: (runtimeChecks?: Partial<RuntimeChecks>) => Provider[];

function ɵbe

ɵbe: () => Provider[];

function ɵbf

ɵbf: (runtimeChecks: RuntimeChecks) => RuntimeChecks;

function ɵbg

ɵbg: (config: RuntimeChecks) => void;

function ɵf

ɵf: (a: any, b: any) => boolean;

function ɵt

ɵt: (injector: any, reducers: ActionReducerMap<any, any>) => unknown;

function ɵu

ɵu: (
    injector: any,
    configs: StoreConfig<any, any>[] | InjectionToken<StoreConfig<any, any>>[],
    featureStores: StoreFeature<any, any>[]
) => (
    | StoreFeature<any, any>
    | { key: string; reducerFactory: any; metaReducers: any; initialState: any }
)[];

function ɵv

ɵv: (
    injector: any,
    reducerCollection: ActionReducerMap<any, any>[]
) => unknown[];

function ɵw

ɵw: (initialState: any) => any;

function ɵx

ɵx: (
    metaReducers: MetaReducer[],
    userProvidedMetaReducers: MetaReducer[]
) => MetaReducer[];

function ɵy

ɵy: (store: Store<any>) => any;

function ɵz

ɵz: (runtimeChecks?: Partial<RuntimeChecks>) => RuntimeChecks;

function props

props: <P extends object>() => ActionCreatorProps<P>;

function reduceState

reduceState: <T, V extends Action = Action>(
    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$: any) => any;
    <T, Props, K>(mapFn: (state: T, props: Props) => K, props: Props): (
        source$: any
    ) => any;
    <T, a extends keyof T>(key: a): (source$: any) => any;
    <T, a extends keyof T, b extends keyof T[a]>(key1: a, key2: b): (
        source$: any
    ) => any;
    <T, a extends keyof T, b extends keyof T[a], c extends keyof T[a][b]>(
        key1: a,
        key2: b,
        key3: c
    ): (source$: any) => any;
    <
        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$: any) => any;
    <
        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$: any) => any;
    <
        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$: any) => any;
    <
        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$: any) => any;
};

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();

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>;

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 {}

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;

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
);

method addReducer

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

method complete

complete: () => void;

method dispatch

dispatch: <V extends Action = Action>(
    action: V &
        FunctionIsNotAllowed<
            V,
            'Functions are not allowed to be dispatched. Did you forget to call the action creator function?'
        >
) => void;

method error

error: (err: any) => void;

method lift

lift: <R>(operator: any) => 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): any;
    <K, Props = any>(mapFn: (state: T, props: Props) => K, props: Props): any;
    <a extends keyof T>(key: a): any;
    <a extends keyof T, b extends keyof T[a]>(key1: a, key2: b): any;
    <a extends keyof T, b extends keyof T[a], c extends keyof T[a][b]>(
        key1: a,
        key2: b,
        key3: c
    ): any;
    <
        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
    ): any;
    <
        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
    ): any;
    <
        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
    ): any;
    <
        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[]
    ): any;
};

Deprecated
Selectors with props are deprecated, for more info see

class StoreFeatureModule

class StoreFeatureModule implements OnDestroy {}

constructor

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

method ngOnDestroy

ngOnDestroy: () => void;

class StoreModule

class StoreModule {}

method forFeature

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

method forRoot

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

class StoreRootModule

class StoreRootModule {}

constructor

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

Interfaces

interface Action

interface Action {}

property type

type: string;

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

property clearResult

clearResult: () => void;

property projector

projector: ProjectorFn;

property setResult

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

method release

release: () => void;

interface ɵa

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

property initialState

initialState?: InitialState<T>;

property key

key: string;

property metaReducers

metaReducers?: MetaReducer<T, V>[];

property reducerFactory

reducerFactory: ActionReducerFactory<T, V>;

property reducers

reducers: ActionReducerMap<T, V> | ActionReducer<T, V>;

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<T, V>[];

property reducerFactory

reducerFactory?: ActionReducerFactory<T, V>;

Type Aliases

type ActionCreator

type ActionCreator<T extends string = string, C extends Creator = Creator> = C &
    TypedAction<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 (16)

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 day ago.
Package analyzed in 7945 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 INIT

variable INITIAL_REDUCERS

variable INITIAL_STATE

variable META_REDUCERS

variable ɵb

variable ɵc

variable ɵd

variable ɵe

variable ɵg

variable ɵh

variable ɵi

variable ɵj

variable ɵk

variable ɵl

variable ɵm

variable ɵn

variable ɵo

variable ɵp

variable ɵq

variable ɵr

variable ɵs

variable REDUCER_FACTORY

variable STORE_FEATURES

variable UPDATE

variable USER_PROVIDED_META_REDUCERS

variable USER_RUNTIME_CHECKS

Functions

function combineReducers

function compose

function createAction

function createFeature

Parameter featureConfig

Returns

function createFeatureSelector

function createReducer

Parameter initialState

Parameter ons

Returns

function createReducerFactory

function createSelector

Deprecated

function createSelectorFactory

Deprecated

function defaultMemoize

function defaultStateFn

function isNgrxMockEnvironment

function on

Parameter args

Returns

function ɵba

function ɵbb

function ɵbc

function ɵbd

function ɵbe

function ɵbf

function ɵbg

function ɵf

function ɵt

function ɵu

function ɵv

function ɵw

function ɵx

function ɵy

function ɵz

function props

function reduceState

function resultMemoize

function select