@reduxjs/toolkit#configureStore TypeScript Examples

reduxStore = configureStore({
  reducer: rootReducer,
  devTools: false,
  enhancers:
    process.env.NODE_ENV === 'development'
      ? [
          devToolsEnhancer({
            realtime: true,
            name: 'Overwolf ',
            hostname: 'localhost',
            port: 8000,
          }),
        ]
      : [],
})

export function configureAppStore(state?: Partial<RootState>) {
  const sagaMiddleware = createSagaMiddleware({
    onError: (error, info) => {
      store.dispatch(
        fatalErrorActions.setError({
          message: error.toString(),
          stack: error.stack,
          sagaStack: info.sagaStack,
        }),
      )
    },
  })

  // Create the store with saga middleware
  const middlewares = [sagaMiddleware]

  const store = configureStore({
    reducer: createReducer(),
    middleware: getDefaultMiddleware => getDefaultMiddleware().concat(middlewares),
    devTools:
      /* istanbul ignore next line */
      process.env.NODE_ENV !== 'production',
    preloadedState: state,
  })

  sagaMiddleware.run(rootSagas)

  return store
}

store = configureStore({
  reducer: {
    application,
    user,
    transactions,
    swap,
    mint,
    burn,
    multicall,
    lists
  },
  middleware: [...getDefaultMiddleware({ thunk: false }), save({ states: PERSISTED_KEYS })],
  preloadedState: load({ states: PERSISTED_KEYS })
})

store = configureStore({
  reducer: {
    application,
    user,
    transactions,
    swap,
    mint,
    burn,
    multicall,
    lists
  },
  middleware: [...getDefaultMiddleware({ thunk: false }), save({ states: PERSISTED_KEYS })],
  preloadedState: load({ states: PERSISTED_KEYS })
})

projectStore = configureStore({
    reducer,
    middleware: [
        (store) => (next) => (action) => {
            const ret = next(action);

            const state = store.getState();

            if (CANVAS_SAVE_ACTIONS.includes(action.type)) {
                QueuedDataWriter.enqueueCanvasWrite();
            }

            if (SIMVAR_CONTROL_SAVE_ACTIONS.includes(action.type)) {
                handleSaveSimVarControlState(state);
            }

            if (SIMVAR_VALUES_SAVE_ACTIONS.includes(action.type)) {
                QueuedDataWriter.enqueueSimVarValuesWrite();
            }

            if (PERSISTENT_STORAGE_SAVE_ACTIONS.includes(action.type)) {
                QueuedDataWriter.enqueuePersistentDataWrite();
            }

            return ret;
        },
    ],
})

store = configureStore({
  devTools: process.env.NODE_ENV !== 'production',
  reducer: {
    // achievements: achievementsReducer,
    block: blockReducer,
    farms: farmsReducer,
    pools: poolsReducer,
    community: communityReducer,
    info: infoReducer,
    // predictions: predictionsReducer,
    // profile: profileReducer,
    // teams: teamsReducer,
    collectibles: collectiblesReducer,
    // voting: votingReducer,
    // lottery: lotteryReducer,

    // Exchange
    application,
    user,
    transactions,
    swap,
    bridge,
    mint,
    burn,
    multicall,
    lists,
  },
  middleware: [...getDefaultMiddleware({ thunk: true }), save({ states: PERSISTED_KEYS })],
  preloadedState: load({ states: PERSISTED_KEYS }),
})

store = configureStore({
  reducer: {
    application,
    user,
    transactions,
    multicall,
    lists
  },
  middleware: [...getDefaultMiddleware({ thunk: false }), save({ states: PERSISTED_KEYS })],
  preloadedState: load({ states: PERSISTED_KEYS })
})

store = configureStore({
    reducer: {
        review: reviewReducer,
        ui: uiReducer,
        popup: popupReducer,
        roadmap: roadmapReducer,
        search: searchReducer,
    }
})

store = configureStore({
  middleware: (getDefaultMiddleware) =>
    getDefaultMiddleware().concat(process.env.NODE_ENV === 'production' ? [] : [logger]),
  reducer: {
    gameName: currentGameReducer,
    enabled: enabledReducer,
    active: activeConfigReducer,
    configs: configDetailsReducer,
    pending: pendingStatusesReducer,
  },
})

store = configureStore({
  reducer: {
    user: userReducer,
    computer: computerReducer,
    whiteboard: whiteboardReducer,
    chat: chatReducer,
    room: roomReducer,
  },
  // Temporary disable serialize check for redux as we store MediaStream in ComputerStore.
  // https://stackoverflow.com/a/63244831
  middleware: (getDefaultMiddleware) =>
    getDefaultMiddleware({
      serializableCheck: false,
    }),
})

store = configureStore({
  reducer: {
    events: eventsSlice.reducer,
    [coinbaseApi.reducerPath]: coinbaseApi.reducer,
    isPrefilling: isPrefillingSlice.reducer,
  },
  middleware: (getDefaultMiddleware) => [
    ...getDefaultMiddleware(),
    sagaMiddleware,
    coinbaseApi.middleware,
  ],
})

store = configureStore({
  reducer: {
    app: appReducer,
    meshtastic: meshtasticReducer,
    map: mapReducer,
  },
  middleware: (getDefaultMiddleware) =>
    getDefaultMiddleware({
      serializableCheck: false,
    }),
})

store = configureStore({
  reducer: {
    application,
    user,
    transactions,
    swap,
    mint,
    burn,
    multicall,
    lists,
    toasts
  },
  middleware: [...getDefaultMiddleware({ thunk: false }), save({ states: PERSISTED_KEYS })],
  preloadedState: loadedState,
})

export function createStore() {
  const store = configureStore({
    reducer: appReducer,
    middleware: (getDefaultMiddleware) => getDefaultMiddleware(),
    devTools: process.env.NODE_ENV !== 'production',
  });

  return store;
}

store = configureStore({
  reducer: {
    application,
    user,
    transactions,
    swap,
    mint,
    burn,
    multicall,
    lists,
    toasts
  },
  // @ts-ignore
  middleware: [...getDefaultMiddleware({ thunk: false }), save({ states: PERSISTED_KEYS })],
  // @ts-ignore
  preloadedState: loadedState,
})

store = configureStore({
  reducer: {
    application,
    user,
    transactions,
    swap,
    mint,
    burn,
    multicall,
    lists,
  },
  middleware: [...getDefaultMiddleware({ thunk: false }), save({ states: PERSISTED_KEYS })],
  preloadedState: loadedState,
})

configuredStore = (initialState?: RootState) => {
  // Create Store
  const store = configureStore({
    reducer: rootReducer,
    middleware,
    preloadedState: initialState,
  });

  if (process.env.NODE_ENV === 'development' && module.hot) {
    module.hot.accept(
      './rootReducer',
      // eslint-disable-next-line global-require
      () => store.replaceReducer(require('./rootReducer').default)
    );
  }
  return store;
}

export function configureAppStore() {
  const reduxSagaMonitorOptions = {};
  const sagaMiddleware = createSagaMiddleware(reduxSagaMonitorOptions);
  const { run: runSaga } = sagaMiddleware;

  // Create the store with saga middleware
  const middlewares = [sagaMiddleware];

  const enhancers = [
    createInjectorsEnhancer({
      createReducer,
      runSaga,
    }),
  ] as StoreEnhancer[];

  const store = configureStore({
    reducer: createReducer(),
    middleware: [...getDefaultMiddleware(), ...middlewares],
    devTools: process.env.NODE_ENV !== 'production',
    enhancers,
  });

  return store;
}

store = configureStore({
  reducer: {
    requestAuth: requestAuthReducer,
    requestBody: requestBodyReducer,
    requestHeader: requestHeaderReducer,
    requestMethod: requestMethodReducer,
    requestUrl: requestUrlReducer,
    response: responseReducer,
    codeGenOptions: codeGenOptionsReducer,
    requestOptions: requestOptionsReducer,
  },
  preloadedState,
})

export function configureAppStore() {
  const enhancers = [injectReducerEnhancer(createReducer)];

  const store = configureStore({
    reducer: createReducer(),
    middleware: getDefaultMiddleware =>
      getDefaultMiddleware({
        serializableCheck: false,
        // immutableCheck: false,
      }).prepend(rejectedErrorHandlerMiddleware.middleware),
    devTools:
      /* istanbul ignore next line */
      process.env.NODE_ENV !== 'production' ||
      process.env.PUBLIC_URL.length > 0,
    enhancers,
  });

  return store;
}

store = configureStore({
    reducer: {
        entityReducer,
        appReducer,
        contractCreatorReducer,
        simulationReducer,
        settingsReducer,
        modalReducer,
        dataReducer,
        walletReducer,
    },
    middleware: [thunk],
    devTools: true,
})

function setup(
  preloadedState: { counter: { value: number } } = { counter: { value: 1 } }
) {
  const store = configureStore({
    reducer: { counter: counterSlice.default },
    preloadedState,
  });

  const getWrapper = () =>
    mount(
      <Provider store={store}>
        <Router>
          <Counter />
        </Router>
      </Provider>
    );
  const component = getWrapper();
  return {
    store,
    component,
    buttons: component.find('button'),
    p: component.find('.counter'),
  };
}

store = configureStore({
  reducer: {
    application,
    user,
    transactions,
    swap,
    mint,
    burn,
    multicall,
    lists,
    waitmodal
  },
  middleware: [...getDefaultMiddleware({ thunk: false }), save({ states: PERSISTED_KEYS })],
  preloadedState: load({ states: PERSISTED_KEYS })
})

store = configureStore({
  reducer: {
    accountBalances: accountBalancesReducer,
    app: appReducers,
    banks: bankReducers,
    managedAccountBalances: managedAccountBalancesReducer,
    notifications: notificationsReducer,
    sockets: socketReducers,
    validators: validatorReducers,
  },
})

configureAppStore = (preloadedState:PartialRootState = {})=>{

    const store = configureStore({
        reducer: rootReducer,
        middleware:[ 
            ...getDefaultMiddleware<RootState>()
        ],
        preloadedState
    });

    return store
}

configureAppStore = (preloadedState: PartialRootState = {}) => {
    const store = configureStore({
        reducer: rootReducer,
        middleware: [...getDefaultMiddleware<RootState>()],
        preloadedState,
    });

    return store;
}

store = configureStore({
  devTools: process.env.NODE_ENV !== 'production',
  reducer: {
    // achievements: achievementsReducer,
    block: blockReducer,
    farms: farmsReducer,
    pools: poolsReducer,
    // predictions: predictionsReducer,
    profile: profileReducer,
    // teams: teamsReducer,
    // collectibles: collectiblesReducer,
    // voting: votingReducer,
    // lottery: lotteryReducer,
    info: infoReducer,

    // Exchange
    user,
    transactions,
    swap,
    mint,
    burn,
    multicall,
    lists,
  },
  middleware: [...getDefaultMiddleware({ thunk: true }), save({ states: PERSISTED_KEYS })],
  preloadedState: load({ states: PERSISTED_KEYS }),
})

store = configureStore({
  reducer: {
    application,
    user,
    transactions,
    swap,
    mint,
    burn,
    multicall,
    lists,
    toasts
  },
  // middleware: [...getDefaultMiddleware({ thunk: false }), save({ states: PERSISTED_KEYS })],
  middleware: getDefaultMiddleware({ thunk: false }).concat(save({ states: PERSISTED_KEYS })),
  preloadedState: loadedState,
})

store = configureStore({
  reducer: {
    user: userReducer,
    settings: settingsReducer,
    message: messageReducer,
    admin: adminReducer,
    import: importReducer,
  },
})