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

const makeStore = (preloadedState = {}) => {
  // ======================================================
  // Middleware Configuration
  // ======================================================
  const middleware = [thunk, actionBuffer(REHYDRATE)]

  // ======================================================
  // Store Enhancers
  // ======================================================
  const enhancers = [autoRehydrate()]
  if (__DEBUG__) {
    const devToolsExtension = window.devToolsExtension
    if (typeof devToolsExtension === 'function') {
      enhancers.push(devToolsExtension())
    }
  }

  // ======================================================
  // Store Instantiation and HMR Setup
  // ======================================================
  const store = createStore(
    reducers(),
    preloadedState,
    compose(
      applyMiddleware(...middleware),
      ...enhancers
    )
  )

  persistState({ store })

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

  return store
}

  constructor(private appRef: ApplicationRef,
              private af: AngularFire,
              private ngRedux: NgRedux<StoreState>,
              private devTools: DevToolsExtension) {
    AppModule.angularFire = af;
    let enhancers = [];
    if (devTools.isEnabled()) {
      enhancers = [ ...enhancers, devTools.enhancer() ];
    }
    const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;
    const store: any = createStore(
      rootReducer,
      initialState,
      composeEnhancers(
        applyMiddleware(),
        autoRehydrate()
      )
      );
    persistStore(store);

    ngRedux.provideStore(store);
  }

  return new Promise((resolve, reject) => {
    try {
      const pages = pagesLoaders.map(Page => new Page())

      const initialState = bindInitialState(pages)
      const reducerList = bindReducers(pages)

      const enhancer: any =
        process.env.NODE_ENV === 'development' && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
          ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
          : compose
      const sagaMiddleware = createSagaMiddleware()

      const appReducer = combineReducers(reducerList)
      const signOutAction = Actions.SignOut.SIGN_OUT
      const rootReducer = (state: any, action: any) => appReducer(action.type === signOutAction ? {} : state, action)

      const store = createStore(rootReducer, initialState, enhancer(applyMiddleware(sagaMiddleware), autoRehydrate()))

      sagaMiddleware.run(bindSagas(pages))

      persistStore(store, {}, () => resolve({ store, pages }))
    } catch (e) {
      reject(e)
    }
  })

import * as localForage from 'localforage';
import { persistStore, autoRehydrate } from 'redux-persist';
import { createStore, applyMiddleware } from 'redux';
import thunk from 'redux-thunk';
import appReducer from '../reducers';

let middleware = [thunk];
let composer: any;

if (process.env.NODE_ENV === 'production') {
  composer = require('redux').compose;
} else {
  const reduxImmutableStateInvariant = require('redux-immutable-state-invariant').default();
  const logger = require('redux-logger').createLogger({
    // ...options
  });
  composer = require('redux-devtools-extension').composeWithDevTools;
  middleware = middleware.concat(reduxImmutableStateInvariant, logger);
}

const store = composer(
  applyMiddleware(...middleware),
  autoRehydrate(),
)(createStore)(appReducer);

persistStore(store, {storage: localForage});

export default store;

        )
      if (networkError) console.error(`[Network error]: ${networkError}`)
    }),
    link,
  ]),
  cache,
})

const reducer = combineReducers({
  mainScreen: mainScreenReducer,
  snackbar: snackbarReducer,
} as any)

const composeEnhancers =
  (window as any).__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose
export const store = createStore(reducer, {}, composeEnhancers(autoRehydrate()))

persistStore(store, {
  whitelist: ['mainScreen'],
})

// Subscribe to all status updates, Apollo will automatically update the store using the id.
client
  .subscribe({
    query: gql`
      subscription deviceUpdated {
        deviceUpdated {
          id
          name
          config
        }

const persistConfig: PersistConfig = {
    blacklist  : ["foo"],
    whitelist  : ["bar"],
    storage    : asyncLocalStorage,
    transforms : [transform],
    debounce   : 1000,
    keyPrefix  : KEY_PREFIX
}

const rehydrateOptions: PersistorRehydrateOptions = { serial : true }

const autoRehydrateConfig: PersistAutoRehydrateConfig<any, any, any> = {
    stateReconcile: (state: any, inboundState: any, reducedState: any, log: boolean) => ({})
}

const store: Store<any> = createStore(reducer, autoRehydrate(autoRehydrateConfig))
const persistor: Persistor = persistStore(store, persistConfig, persistCallback)

purgeStoredState({ whitelist : ["foo"] }, ["bar"])

getStoredState(persistConfig, (err: any, restoredState: any) => {
    const store: Store<any> = createStore(reducer, restoredState)
    const persistor: Persistor = createPersistor(store, persistConfig)
    const secondaryPersistor: Persistor = createPersistor(store, { storage : asyncSessionStorage })
    persistor.pause()
    persistor.resume()
    persistor.purge(["foo", "bar"])
    persistor.rehydrate(restoredState, rehydrateOptions)
})