TypeScript redux-persist.persistReducer函数代码示例

export const configureStore = () => {
  const sagaMiddleware = createSagaMiddleware()
  const logger = createLogger()
  const store = createStore(
    persistReducer({ key: 'reversi', storage, whitelist: ['history'] }, reducer),
    compose(
      applyMiddleware(sagaMiddleware, logger),
      getDevtools()
    )
  )
  const persistor = persistStore(store)

  if (module.hot) {
    module.hot.accept('./reducer', () => {
      store.replaceReducer(require('./reducer').default)
    })
  }

  return {
    store,
    persistor,
    runSaga: sagaMiddleware.run,
    close () {
      store.dispatch(END as any)
    }
  }
}

const persistEnhancer = () => (createStore) => (
  reducer,
  initialState,
  enhancer,
) => {
  const store = createStore(
    persistReducer(persistConfig, reducer),
    initialState,
    enhancer,
  );
  const persist = persistStore(store, null);
  return {
    persist,
    ...store,
  };
};

/**
 * Wrapper function around persistReducer from Redux Persist.
 */
export default function persistReducer(
  key: string,
  reducer: Reducer<any, any>,
  options: Pick<
    PersistConfig,
    Exclude<keyof PersistConfig, keyof { key: string; storage: Record<string, any> }>
  > = {},
) {
  return basePersistReducer<any, any>(
    {
      key,
      storage,
      debug: process.env.NODE_ENV !== 'production',
      ...options,
    },
    reducer,
  );
}

import {combineReducers} from "redux";
import {persistReducer} from "redux-persist";
import auth from "./authReducer";
import app from "./appReducer";
import {IState} from "@/models/State";
import storage from "redux-persist/lib/storage";
import {reducer as form} from "redux-form";
import wallets from "./walletReducer";
import transactions from "./transactionReducer";

const rootReducer = combineReducers<IState>({
    auth,
    wallets,
    transactions,
    app,
    form
});

const persistConfig = {
    key: "root",
    storage,
    whitelist: ["auth"]
};

export const persistedReducer = persistReducer(persistConfig, rootReducer);

import { applyMiddleware, createStore } from 'redux';
import { persistReducer } from 'redux-persist';
import thunk from 'redux-thunk';
import logger from 'redux-logger';

import createChromeStorage from 'redux-persist-chrome-storage';
import { PersistConfig } from 'redux-persist/es/types';
import immutableTransform from 'redux-persist-transform-immutable';

import reducers, { STATE_HELPER, STATE_UI } from './reducers';
import { STORAGE_KEY_REDUX } from '../constants';

// Create a ChromeStorage instance using the chrome runtime and the local StorageArea.
const storage = createChromeStorage(window.chrome, 'local');

const config: PersistConfig = {
  storage,
  transforms: [immutableTransform()],
  key: STORAGE_KEY_REDUX,
  blacklist: [STATE_UI, STATE_HELPER],
};

const persistedReducer = persistReducer(config, reducers);
const createStoreWithMiddleware = applyMiddleware(thunk, logger)(createStore);

export { createStoreWithMiddleware as createStore, persistedReducer as reducer };

import me, { State as MeState } from 'store/me'
import users, { State as UsersState } from 'store/users'

// Type definitions
export interface State {
  me: MeState
  users: UsersState
}

// Reducers
const reducers = {
  me,
  users
}

// Middleware
const middleware: Middleware[] = [thunk]
if (process.env.NODE_ENV !== 'production') {
  middleware.push(logger)
}

// Store
const store = createStore(
  persistReducer({ key: 'persistStore', storage }, combineReducers(reducers)),
  applyMiddleware(...middleware)
)

// Exports
export default store
export const persistor = persistStore(store)

import items, { IState as ItemsState } from './items'

// Type definitions
export interface IState {
  items: ItemsState
}

// Reducers
const reducers = {
  items
}

// Middleware
const middleware: Middleware[] = [thunk]
if (process.env.NODE_ENV !== 'production') {
  middleware.push(logger)
}

// Store
const store = createStore(
  persistReducer<IState, Action<any>>(
    { key: 'persistStore', storage },
    combineReducers<any, Action<any>>(reducers)
  ),
  applyMiddleware(...middleware)
)

// Exports
export default store
export const persistor = persistStore(store)