function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); } function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); } function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); } function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } } function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } import { createStore } from 'redux'; import { FLUSH, PAUSE, PERSIST, PURGE, REGISTER, REHYDRATE } from './constants'; var initialState = { registry: [], bootstrapped: false }; var persistorReducer = function persistorReducer() { var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState; var action = arguments.length > 1 ? arguments[1] : undefined; switch (action.type) { case REGISTER: return _objectSpread({}, state, { registry: [].concat(_toConsumableArray(state.registry), [action.key]) }); case REHYDRATE: var firstIndex = state.registry.indexOf(action.key); var registry = _toConsumableArray(state.registry); registry.splice(firstIndex, 1); return _objectSpread({}, state, { registry: registry, bootstrapped: registry.length === 0 }); default: return state; } }; export default function persistStore(store, options, cb) { // help catch incorrect usage of passing PersistConfig in as PersistorOptions if (process.env.NODE_ENV !== 'production') { var optionsToTest = options || {}; var bannedKeys = ['blacklist', 'whitelist', 'transforms', 'storage', 'keyPrefix', 'migrate']; bannedKeys.forEach(function (k) { if (!!optionsToTest[k]) console.error("redux-persist: invalid option passed to persistStore: \"".concat(k, "\". You may be incorrectly passing persistConfig into persistStore, whereas it should be passed into persistReducer.")); }); } var boostrappedCb = cb || false; var _pStore = createStore(persistorReducer, initialState, options && options.enhancer ? options.enhancer : undefined); var register = function register(key) { _pStore.dispatch({ type: REGISTER, key: key }); }; var rehydrate = function rehydrate(key, payload, err) { var rehydrateAction = { type: REHYDRATE, payload: payload, err: err, key: key // dispatch to `store` to rehydrate and `persistor` to track result }; store.dispatch(rehydrateAction); _pStore.dispatch(rehydrateAction); if (boostrappedCb && persistor.getState().bootstrapped) { boostrappedCb(); boostrappedCb = false; } }; var persistor = _objectSpread({}, _pStore, { purge: function purge() { var results = []; store.dispatch({ type: PURGE, result: function result(purgeResult) { results.push(purgeResult); } }); return Promise.all(results); }, flush: function flush() { var results = []; store.dispatch({ type: FLUSH, result: function result(flushResult) { results.push(flushResult); } }); return Promise.all(results); }, pause: function pause() { store.dispatch({ type: PAUSE }); }, persist: function persist() { store.dispatch({ type: PERSIST, register: register, rehydrate: rehydrate }); } }); if (!(options && options.manualPersist)) { persistor.persist(); } return persistor; }