redux-persist#persistReducer TypeScript Examples

persistedReducer = fsReducer(
  'ustaxes_save.json',
  persistReducer<CombinedState<YearsTaxesState>, Actions>(
    {
      key: 'root',
      // Changing the version here will set the version used
      // in the app. When the data is rehydrated the version
      // number will be compared and all migrations between
      // the persisted version and the version here will be
      // applied in order
      version: 1,
      storage,
      migrate: createMigrate(migrations, { debug: false }),
      transforms: [dateStringTransform]
    },
    rootReducer
  )
)

beforeCombineRootReducers(reducers: ReducersMapObject): ReducersMapObject {
    for (const [_, set] of this.storageSettingMap) {
      set();
    }
    Object.keys(reducers).forEach((key) => {
      const isTempIdentifier = /^@@reactant\//.test(key);
      if (isTempIdentifier) {
        this.blacklist.push(key);
      }
      const persistConfig = this.persistConfig[key];
      if (persistConfig) {
        const reducer = persistReducer(persistConfig, reducers[key]);
        Object.assign(reducers, {
          [key]: reducer,
        });
      } else if (this.persistRootConfig.blacklist) {
        // use blacklist mode
        if (isTempIdentifier) {
          if (__DEV__) {
            console.warn(
              `For state persistence, The '@injectable({ name })' in the ${key} module has not been set yet.`
            );
          }
        }
      }
    });
    return reducers;
  }

store = createStore(
	persistReducer(
		{
			key: "root",
			storage,
			whitelist: ["user"]
		},
		contestReducer
	),
	{
		contestsById: {},
		musicPlayer: {
			playing: false,
			videoId: null
		},
	} as IState as any,
	composeEnhancers(),
)

rootReducer = combineReducers({
	auth: persistReducer(
		{
			keyPrefix: "com.unidy2002.thuinfo.persist.auth.",
			storage: KeychainStorage,
			key: "auth",
		},
		auth,
	),
	schedule,
	config,
	credentials: persistReducer(
		{
			keyPrefix: "com.unidy2002.thuinfo.persist.credentials.",
			storage: KeychainStorage,
			key: "credentials",
		},
		credentials,
	),
	top5,
	reservation,
})

afterCombineRootReducers(rootReducer: Reducer) {
    return persistReducer(
      {
        blacklist: [...Object.keys(this.persistConfig), ...this.blacklist],
        ...this.persistRootConfig,
      },
      rootReducer
    );
  }

persistedReducer = persistReducer(persistConfig, reducers)

export default function configureStore(
  preloadedState: Partial<SliceMachineStoreType> = {}
): { store: Store<SliceMachineStoreType>; persistor: Persistor } {
  const middlewares = [sagaMiddleware, routerMiddleware];
  const enhancers = [applyMiddleware(...middlewares)];

  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
  const composeEnhancers =
    process.env.NODE_ENV !== "production" &&
    typeof window === "object" &&
    window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
      ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
      : compose;

  const rootReducer = createReducer();

  const persistedReducer = persistReducer(persistConfig, rootReducer);
  const store: Store<SliceMachineStoreType> = createStore(
    persistedReducer,
    preloadedState,
    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call
    composeEnhancers(...enhancers)
  );
  const persistor = persistStore(store);
  sagaMiddleware.run(rootSaga);

  return { store, persistor };
}

storeConfig = {
  models,
  redux: {
    // @ts-ignore
    combineReducers: reducers => {
      return combineReducers({
        ...reducers,
        components: persistReducer(
          persistConfig,
          undoable(reducers.components, {
            limit: 10,
            filter: filterUndoableActions,
          }),
        ),
      })
    },
  },
  plugins: [persistPlugin],
}

rootReducer = combineReducers({
  general: persistReducer(generalPersistConfig, generalReducer),
  redeem,
  issue,
  vault
})

persistedReducers2 = persistReducer(persistConfig2, reducers)

persistedReducer = persistReducer({
    key: "root",
    storage,
    whitelist: ["authResourceReducer"]
}, combineReducers({ authResourceReducer }))

persistedReducer = persistReducer(persistConfig, rootReducer)

persistedReducer = persistReducer(persistConfig, rootReducer)

persistedReducer = persistReducer(persistConfig, rootReducer)

persistedReducer = persistReducer(persistConfig, rootReducer)

persistedReducer = persistReducer(persistConfig, reducers)

persistedReducer = persistReducer(persistConfig, reducer)

persistedReducer = persistReducer(persistConfig, reducers)

persistedReducer = persistReducer(persistConfig, rootReducer)

persistedReducers = persistReducer(persistConfig, reducers)

persistedReducer = persistReducer(persistConfig, rootReducer)

createPersistReducer = (config: any) =>
  persistReducer(config, rootReducer)

persistedWalletReducer = persistReducer<ReturnType<typeof walletReducer>>(
  persistConfig,
  walletReducer
)

persistedValidatorsReducer = persistReducer<ReturnType<typeof validatorsReducer>>(
  persistConfig,
  validatorsReducer
)

persistedTokensReducer = persistReducer<ReturnType<typeof tokenReducer>>(
  persistConfig,
  tokenReducer
)

persistedTokenPriceReducer = persistReducer<ReturnType<typeof tokenPriceReducer>>(
  persistConfig,
  tokenPriceReducer
)

persistedSettingsReducer = persistReducer<ReturnType<typeof settingsReducer>>(
  persistConfig,
  settingsReducer
)

persistedNftReducer = persistReducer<ReturnType<typeof nftReducer>>(
  persistConfig,
  nftReducer
)

persistedContactsReducer = persistReducer<ReturnType<typeof contactsReducer>>(
  persistConfig,
  contactsReducer
)