@laserware/stasis
    Preparing search index...

    Interface ActionReducerMapBuilder<State>

    A builder for an action <-> reducer map.

    interface ActionReducerMapBuilder<State> {
        addCase<ActionCreator extends TypedActionCreator<string>>(
            actionCreator: ActionCreator,
            reducer: CaseReducer<State, ReturnType<ActionCreator>>,
        ): ActionReducerMapBuilder<State>;
        addCase<Type extends string, A extends Action<Type>>(
            type: Type,
            reducer: CaseReducer<State, A>,
        ): ActionReducerMapBuilder<State>;
        addDefaultCase(reducer: CaseReducer<State, Action>): {};
        addMatcher<A>(
            matcher: TypeGuard<A> | ((action: any) => boolean),
            reducer: CaseReducer<State, A extends Action ? A<A> : A & Action>,
        ): Omit<ActionReducerMapBuilder<State>, "addCase">;
    }

    Type Parameters

    • State
    Index

    Methods

    addCase addDefaultCase addMatcher

    Methods

    • Adds a "default case" reducer that is executed if no case reducer and no matcher reducer was executed for this action.

      Parameters

      Returns {}

      import { createReducer } from '@reduxjs/toolkit'
      const initialState = { otherActions: 0 }
      const reducer = createReducer(initialState, builder => {
      builder
       // .addCase(...)
       // .addMatcher(...)
       .addDefaultCase((state, action) => {
         state.otherActions++
       })
      })

    • Allows you to match your incoming actions against your own filter function instead of only the action.type property.

      Type Parameters

      • A

      Parameters

      Returns Omit<ActionReducerMapBuilder<State>, "addCase">

      If multiple matcher reducers match, all of them will be executed in the order they were defined in - even if a case reducer already matched. All calls to builder.addMatcher must come after any calls to builder.addCase and before any calls to builder.addDefaultCase.

      import {
      createAction,
      createReducer,
      AsyncThunk,
      UnknownAction,
      } from "@reduxjs/toolkit";

      type GenericAsyncThunk = AsyncThunk<unknown, unknown, any>;

      type PendingAction = ReturnType<GenericAsyncThunk["pending"]>;
      type RejectedAction = ReturnType<GenericAsyncThunk["rejected"]>;
      type FulfilledAction = ReturnType<GenericAsyncThunk["fulfilled"]>;

      const initialState: Record<string, string> = {};
      const resetAction = createAction("reset-tracked-loading-state");

      function isPendingAction(action: UnknownAction): action is PendingAction {
      return typeof action.type === "string" && action.type.endsWith("/pending");
      }

      const reducer = createReducer(initialState, (builder) => {
      builder
       .addCase(resetAction, () => initialState)
       // matcher can be defined outside as a type predicate function
       .addMatcher(isPendingAction, (state, action) => {
         state[action.meta.requestId] = "pending";
       })
       .addMatcher(
         // matcher can be defined inline as a type predicate function
         (action): action is RejectedAction => action.type.endsWith("/rejected"),
         (state, action) => {
           state[action.meta.requestId] = "rejected";
         }
       )
       // matcher can just return boolean and the matcher can receive a generic argument
       .addMatcher<FulfilledAction>(
         (action) => action.type.endsWith("/fulfilled"),
         (state, action) => {
           state[action.meta.requestId] = "fulfilled";
         }
       );
      });

    Settings

    Member Visibility

    On This Page

    Methods