From 31b955003fb55c9a7cbd0ded8a4ccb42d86ca9c3 Mon Sep 17 00:00:00 2001 From: Stephane Rufer Date: Thu, 2 Jun 2016 13:56:29 -0700 Subject: [PATCH 1/7] Add support for non object top level state --- src/autoRehydrate.js | 47 ++++++++++++++++++++++++------------------ src/createPersistor.js | 31 +++++++++++++++++++++------- 2 files changed, 50 insertions(+), 28 deletions(-) diff --git a/src/autoRehydrate.js b/src/autoRehydrate.js index 13a10e71e..bffa557f7 100644 --- a/src/autoRehydrate.js +++ b/src/autoRehydrate.js @@ -2,6 +2,8 @@ import { REHYDRATE } from './constants' import isStatePlainEnough from './utils/isStatePlainEnough' export default function autoRehydrate (config = {}) { + config.stateReconciler = config.stateReconciler || defaultStateReconciler + return (next) => (reducer, initialState, enhancer) => { return next(createRehydrationReducer(reducer), initialState, enhancer) } @@ -19,26 +21,8 @@ export default function autoRehydrate (config = {}) { let inboundState = action.payload let reducedState = reducer(state, action) - let newState = {...reducedState} - - Object.keys(inboundState).forEach((key) => { - // if initialState does not have key, skip auto rehydration - if (!state.hasOwnProperty(key)) return - - // if reducer modifies substate, skip auto rehydration - if (state[key] !== reducedState[key]) { - if (config.log) console.log('redux-persist/autoRehydrate: sub state for key `%s` modified, skipping autoRehydrate.', key) - newState[key] = reducedState[key] - return - } - - // otherwise take the inboundState - if (isStatePlainEnough(inboundState[key]) && isStatePlainEnough(state[key])) newState[key] = {...state[key], ...inboundState[key]} // shallow merge - else newState[key] = inboundState[key] // hard set - - if (config.log) console.log('redux-persist/autoRehydrate: key `%s`, rehydrated to ', key, newState[key]) - }) - return newState + + return config.stateReconciler(state, inboundState, reducedState, config.log) } } } @@ -53,3 +37,26 @@ function logPreRehydrate (preRehydrateActions) { `, preRehydrateActions.length) } } + +function defaultStateReconciler (state, inboundState, reducedState, logger) { + let newState = {...reducedState} + + Object.keys(inboundState).forEach((key) => { + // if initialState does not have key, skip auto rehydration + if (!state.hasOwnProperty(key)) return + + // if reducer modifies substate, skip auto rehydration + if (state[key] !== reducedState[key]) { + if (logger) console.log('redux-persist/autoRehydrate: sub state for key `%s` modified, skipping autoRehydrate.', key) + newState[key] = reducedState[key] + return + } + + // otherwise take the inboundState + if (isStatePlainEnough(inboundState[key]) && isStatePlainEnough(state[key])) newState[key] = {...state[key], ...inboundState[key]} // shallow merge + else newState[key] = inboundState[key] // hard set + + if (logger) console.log('redux-persist/autoRehydrate: key `%s`, rehydrated to ', key, newState[key]) + }) + return newState +} diff --git a/src/createPersistor.js b/src/createPersistor.js index afcbaea80..d59b69ae8 100644 --- a/src/createPersistor.js +++ b/src/createPersistor.js @@ -6,6 +6,10 @@ import { forEach } from 'lodash' export default function createPersistor (store, config) { // defaults + const lastStateInit = config.lastStateInit || {} + const stateIterator = config.stateIterator || defaultStateIterator + const stateGetter = config.stateGetter || defaultStateGetter + const stateSetter = config.stateSetter || defaultStateSetter const serialize = config.serialize || defaultSerialize const deserialize = config.deserialize || defaultDeserialize const blacklist = config.blacklist || [] @@ -18,7 +22,7 @@ export default function createPersistor (store, config) { if (storage.keys && !storage.getAllKeys) storage = {...storage, getAllKeys: storage.keys} // initialize stateful values - let lastState = {} + let lastState = lastStateInit let paused = false let purgeMode = false let storesToProcess = [] @@ -28,13 +32,10 @@ export default function createPersistor (store, config) { if (paused) return let state = store.getState() - if (process.env.NODE_ENV !== 'production') { - if (!isStatePlainEnough(state)) console.warn('redux-persist: State is not plain enough to persist. Can only persist plain objects.') - } - forEach(state, (subState, key) => { + stateIterator(state, (subState, key) => { if (!passWhitelistBlacklist(key)) return - if (lastState[key] === state[key]) return + if (stateGetter(lastState, key) === stateGetter(state, key)) return if (storesToProcess.indexOf(key) !== -1) return storesToProcess.push(key) }) @@ -50,7 +51,7 @@ export default function createPersistor (store, config) { let key = storesToProcess[0] let storageKey = createStorageKey(key) - let endState = transforms.reduce((subState, transformer) => transformer.in(subState, key), store.getState()[storesToProcess[0]]) + let endState = transforms.reduce((subState, transformer) => transformer.in(subState, key), stateGetter(store.getState(), key)) if (typeof endState !== 'undefined') storage.setItem(storageKey, serialize(endState), warnIfSetError(key)) storesToProcess.shift() }, debounce) @@ -71,9 +72,10 @@ export default function createPersistor (store, config) { forEach(incoming, (subState, key) => { try { let data = deserialize(subState) - state[key] = transforms.reduceRight((interState, transformer) => { + let value = transforms.reduceRight((interState, transformer) => { return transformer.out(interState, key) }, data) + state = defaultStateSetter(state, key, value) } catch (err) { if (process.env.NODE_ENV !== 'production') console.warn(`Error rehydrating data for key "${key}"`, subState, err) } @@ -152,3 +154,16 @@ function rehydrateAction (data) { payload: data } } + +function defaultStateIterator (collection, callback) { + return forEach(collection, callback) +} + +function defaultStateGetter (state, key) { + return state[key] +} + +function defaultStateSetter(state, key, value) { + state[key] = value + return state +} From 9d5138b5ceebd5b520bfaad3d5a5d1bf742bfd1e Mon Sep 17 00:00:00 2001 From: Stephane Rufer Date: Wed, 8 Jun 2016 15:31:56 -0700 Subject: [PATCH 2/7] Fix stateSetter for adhockReydrate --- src/createPersistor.js | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/createPersistor.js b/src/createPersistor.js index d59b69ae8..06d28fcb5 100644 --- a/src/createPersistor.js +++ b/src/createPersistor.js @@ -1,6 +1,5 @@ import * as constants from './constants' import createAsyncLocalStorage from './defaults/asyncLocalStorage' -import isStatePlainEnough from './utils/isStatePlainEnough' import stringify from 'json-stringify-safe' import { forEach } from 'lodash' @@ -75,7 +74,7 @@ export default function createPersistor (store, config) { let value = transforms.reduceRight((interState, transformer) => { return transformer.out(interState, key) }, data) - state = defaultStateSetter(state, key, value) + state = stateSetter(state, key, value) } catch (err) { if (process.env.NODE_ENV !== 'production') console.warn(`Error rehydrating data for key "${key}"`, subState, err) } @@ -163,7 +162,7 @@ function defaultStateGetter (state, key) { return state[key] } -function defaultStateSetter(state, key, value) { +function defaultStateSetter (state, key, value) { state[key] = value return state } From 5e8b5c4ed4221d375be5fa5189c0e7677fa9d176 Mon Sep 17 00:00:00 2001 From: Stephane Rufer Date: Mon, 13 Jun 2016 10:24:43 -0700 Subject: [PATCH 3/7] Update README.md --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index 8479ff772..99668a14c 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,6 @@ +# What about redux-persist? +This is a fork of redux-persist published as `redux-persist-2` until the PR https://github.com/rt2zz/redux-persist/pull/113 gets merged. + # Redux Persist Persist and rehydrate a redux store. From b6e2be084413cb9a9a324e606c416909407eae20 Mon Sep 17 00:00:00 2001 From: Zack Story Date: Sat, 27 Aug 2016 20:48:02 -0700 Subject: [PATCH 4/7] prefix state utils with _ to indicate protected status --- src/autoRehydrate.js | 12 ++++++------ src/createPersistor.js | 16 +++++++++------- 2 files changed, 15 insertions(+), 13 deletions(-) diff --git a/src/autoRehydrate.js b/src/autoRehydrate.js index 268f6fa01..036a56ce8 100644 --- a/src/autoRehydrate.js +++ b/src/autoRehydrate.js @@ -2,7 +2,7 @@ import { REHYDRATE } from './constants' import isStatePlainEnough from './utils/isStatePlainEnough' export default function autoRehydrate (config = {}) { - config.stateReconciler = config.stateReconciler || defaultStateReconciler + const stateReconciler = config._stateReconciler || defaultStateReconciler return (next) => (reducer, initialState, enhancer) => { return next(createRehydrationReducer(reducer), initialState, enhancer) @@ -22,7 +22,7 @@ export default function autoRehydrate (config = {}) { let inboundState = action.payload let reducedState = reducer(state, action) - return config.stateReconciler(state, inboundState, reducedState, config.log) + return stateReconciler(state, inboundState, reducedState, config.log) } } } @@ -38,7 +38,7 @@ function logPreRehydrate (preRehydrateActions) { } } -function defaultStateReconciler (state, inboundState, reducedState, logger) { +function defaultStateReconciler (state, inboundState, reducedState, log) { let newState = {...reducedState} Object.keys(inboundState).forEach((key) => { @@ -47,13 +47,13 @@ function defaultStateReconciler (state, inboundState, reducedState, logger) { // if initial state is an object but inbound state is null/undefined, skip if (typeof state[key] === 'object' && !inboundState[key]) { - if (logger) console.log('redux-persist/autoRehydrate: sub state for key `%s` is falsy but initial state is an object, skipping autoRehydrate.', key) + if (log) console.log('redux-persist/autoRehydrate: sub state for key `%s` is falsy but initial state is an object, skipping autoRehydrate.', key) return } // if reducer modifies substate, skip auto rehydration if (state[key] !== reducedState[key]) { - if (logger) console.log('redux-persist/autoRehydrate: sub state for key `%s` modified, skipping autoRehydrate.', key) + if (log) console.log('redux-persist/autoRehydrate: sub state for key `%s` modified, skipping autoRehydrate.', key) newState[key] = reducedState[key] return } @@ -62,7 +62,7 @@ function defaultStateReconciler (state, inboundState, reducedState, logger) { if (isStatePlainEnough(inboundState[key]) && isStatePlainEnough(state[key])) newState[key] = {...state[key], ...inboundState[key]} // shallow merge else newState[key] = inboundState[key] // hard set - if (logger) console.log('redux-persist/autoRehydrate: key `%s`, rehydrated to ', key, newState[key]) + if (log) console.log('redux-persist/autoRehydrate: key `%s`, rehydrated to ', key, newState[key]) }) return newState } diff --git a/src/createPersistor.js b/src/createPersistor.js index 4c1865fe0..bddb89682 100644 --- a/src/createPersistor.js +++ b/src/createPersistor.js @@ -5,10 +5,6 @@ import { forEach } from 'lodash' export default function createPersistor (store, config) { // defaults - const lastStateInit = config.lastStateInit || {} - const stateIterator = config.stateIterator || defaultStateIterator - const stateGetter = config.stateGetter || defaultStateGetter - const stateSetter = config.stateSetter || defaultStateSetter const serialize = config.serialize || defaultSerialize const deserialize = config.deserialize || defaultDeserialize const blacklist = config.blacklist || [] @@ -16,13 +12,19 @@ export default function createPersistor (store, config) { const transforms = config.transforms || [] const debounce = config.debounce || false const keyPrefix = config.keyPrefix || KEY_PREFIX - let storage = config.storage || createAsyncLocalStorage('local') - // fallback getAllKeys to `keys` if present (LocalForage compatability) + // pluggable state shape (e.g. immutablejs) + const stateInit = config._stateInit || {} + const stateIterator = config._stateIterator || defaultStateIterator + const stateGetter = config._stateGetter || defaultStateGetter + const stateSetter = config._stateSetter || defaultStateSetter + + // storage with keys -> getAllKeys for localForage support + let storage = config.storage || createAsyncLocalStorage('local') if (storage.keys && !storage.getAllKeys) storage = {...storage, getAllKeys: storage.keys} // initialize stateful values - let lastState = lastStateInit + let lastState = stateInit let paused = false let storesToProcess = [] let timeIterator = null From 1f82f6b270d10edcec934ec136265dae466b81e9 Mon Sep 17 00:00:00 2001 From: Zack Story Date: Sat, 27 Aug 2016 21:13:25 -0700 Subject: [PATCH 5/7] [purgeStoredState] add purgeStoredState as a export --- src/createPersistor.js | 26 ++++++-------------------- src/index.js | 17 ++++++++--------- src/purgeStoredState.js | 23 +++++++++++++++++++++++ 3 files changed, 37 insertions(+), 29 deletions(-) create mode 100644 src/purgeStoredState.js diff --git a/src/createPersistor.js b/src/createPersistor.js index bddb89682..76ec0ddc8 100644 --- a/src/createPersistor.js +++ b/src/createPersistor.js @@ -1,5 +1,6 @@ import { KEY_PREFIX, REHYDRATE } from './constants' import createAsyncLocalStorage from './defaults/asyncLocalStorage' +import purgeStoredState from './purgeStoredState' import stringify from 'json-stringify-safe' import { forEach } from 'lodash' @@ -87,24 +88,6 @@ export default function createPersistor (store, config) { return state } - function purge (keys) { - if (typeof keys === 'undefined') { - purgeAll() - } else { - forEach(keys, (key) => { - storage.removeItem(createStorageKey(key), warnIfRemoveError(key)) - }) - } - } - - function purgeAll () { - // @TODO deprecate - storage.getAllKeys((err, allKeys) => { - if (err && process.env.NODE_ENV !== 'production') { console.warn('Error in storage.getAllKeys') } - purge(allKeys.filter((key) => key.indexOf(keyPrefix) === 0).map((key) => key.slice(keyPrefix.length))) - }) - } - function createStorageKey (key) { return `${keyPrefix}${key}` } @@ -114,8 +97,11 @@ export default function createPersistor (store, config) { rehydrate: adhocRehydrate, pause: () => { paused = true }, resume: () => { paused = false }, - purge, - purgeAll + purge: (keys) => purgeStoredState({storage, keyPrefix}, keys), + purgeAll: () => { + console.warn('redux-persist: purgeAll is deprecated. use `persistor.purge()` instead') + purgeStoredState({storage, keyPrefix}) + } } } diff --git a/src/index.js b/src/index.js index ca3615c36..95ce47bb5 100644 --- a/src/index.js +++ b/src/index.js @@ -1,13 +1,12 @@ -import autoRehydrate from './autoRehydrate' -import createPersistor from './createPersistor' -import createTransform from './createTransform' -import getStoredState from './getStoredState' -import persistStore from './persistStore' - import createAsyncLocalStorage from './defaults/asyncLocalStorage' -const storages = { + +export autoRehydrate from './autoRehydrate' +export createPersistor from './createPersistor' +export createTransform from './createTransform' +export getStoredState from './getStoredState' +export persistStore from './persistStore' +export purgeState from './purgeState' +export const storages = { asyncLocalStorage: createAsyncLocalStorage('local'), asyncSessionStorage: createAsyncLocalStorage('session') } - -export { autoRehydrate, createPersistor, createTransform, getStoredState, persistStore, storages } diff --git a/src/purgeStoredState.js b/src/purgeStoredState.js new file mode 100644 index 000000000..ff9779ba1 --- /dev/null +++ b/src/purgeStoredState.js @@ -0,0 +1,23 @@ +export function purgeStoredState (config, keys) { + const storage = config.storage + const keyPrefix = config.keyPrefix + + // basic validation + if (Array.isArray(config)) throw new Error('redux-persist: purgeStoredState requires config as a first argument (found array). An array of keys is the optional second argument.') + if (!storage) throw new Error('redux-persist: config.storage required in purgeStoredState') + if (!keyPrefix) throw new Error('redux-persist: config.keyPrefix required in purgeStoredState') + + // if keys is not defined, purge all keys + if (typeof keys === 'undefined') { + storage.getAllKeys((err, allKeys) => { + if (err && process.env.NODE_ENV !== 'production') { console.warn('redux-persist: error during purgeStoredState in storage.getAllKeys') } + return purgeStoredState(config, allKeys.filter((key) => key.indexOf(keyPrefix) === 0).map((key) => key.slice(keyPrefix.length))) + }) + } + // otherwise purge specified keys + else { + return Promise.all(keys.map((key) => { + return storage.removeItem(`${keyPrefix}${key}`, warnIfRemoveError(key)) + })) + } +} From 0716550d68e44f2072723bc8acadc673299a1acd Mon Sep 17 00:00:00 2001 From: Zack Story Date: Sat, 27 Aug 2016 21:40:42 -0700 Subject: [PATCH 6/7] [purgeStoredState] return promise --- src/createPersistor.js | 6 --- src/defaults/asyncLocalStorage.js | 90 ++++++++++++++++++------------- src/index.js | 12 ++--- src/purgeStoredState.js | 22 ++++++-- test/purgeStoredState.spec.js | 19 +++++++ 5 files changed, 95 insertions(+), 54 deletions(-) create mode 100644 test/purgeStoredState.spec.js diff --git a/src/createPersistor.js b/src/createPersistor.js index 76ec0ddc8..cf89cd45c 100644 --- a/src/createPersistor.js +++ b/src/createPersistor.js @@ -105,12 +105,6 @@ export default function createPersistor (store, config) { } } -function warnIfRemoveError (key) { - return function removeError (err) { - if (err && process.env.NODE_ENV !== 'production') { console.warn('Error storing data for key:', key, err) } - } -} - function warnIfSetError (key) { return function setError (err) { if (err && process.env.NODE_ENV !== 'production') { console.warn('Error storing data for key:', key, err) } diff --git a/src/defaults/asyncLocalStorage.js b/src/defaults/asyncLocalStorage.js index 84adb0b22..85d0ef5b4 100644 --- a/src/defaults/asyncLocalStorage.js +++ b/src/defaults/asyncLocalStorage.js @@ -35,48 +35,64 @@ function getStorage (type) { export default function (type) { let storage = getStorage(type) return { - getItem: function (key, cb) { - try { - var s = storage.getItem(key) - nextTick(() => { - cb(null, s) - }) - } catch (e) { - cb(e) - } + getItem (key, cb) { + return new Promise((resolve, reject) => { + try { + var s = storage.getItem(key) + nextTick(() => { + cb && cb(null, s) + resolve(s) + }) + } catch (e) { + cb && cb(e) + reject(e) + } + }) }, - setItem: function (key, string, cb) { - try { - storage.setItem(key, string) - nextTick(() => { - cb(null) - }) - } catch (e) { - cb(e) - } + setItem (key, string, cb) { + return new Promise((resolve, reject) => { + try { + storage.setItem(key, string) + nextTick(() => { + cb && cb(null) + resolve() + }) + } catch (e) { + cb && cb(e) + reject(e) + } + }) }, - removeItem: function (key, cb) { - try { - storage.removeItem(key) - nextTick(() => { - cb(null) - }) - } catch (e) { - cb(e) - } + removeItem (key, cb) { + return new Promise((resolve, reject) => { + try { + storage.removeItem(key) + nextTick(() => { + cb && cb(null) + resolve() + }) + } catch (e) { + cb && cb(e) + reject(e) + } + }) }, getAllKeys: function (cb) { - try { - var keys = [] - for (var i = 0; i < storage.length; i++) { - keys.push(storage.key(i)) + return new Promise((resolve, reject) => { + try { + var keys = [] + for (var i = 0; i < storage.length; i++) { + keys.push(storage.key(i)) + } + nextTick(() => { + cb && cb(null, keys) + resolve(keys) + }) + } catch (e) { + cb && cb(e) + reject(e) } - nextTick(() => { - cb(null, keys) - }) - } catch (e) { - cb(e) - } + }) } } } diff --git a/src/index.js b/src/index.js index 95ce47bb5..db4c8324e 100644 --- a/src/index.js +++ b/src/index.js @@ -1,11 +1,11 @@ import createAsyncLocalStorage from './defaults/asyncLocalStorage' -export autoRehydrate from './autoRehydrate' -export createPersistor from './createPersistor' -export createTransform from './createTransform' -export getStoredState from './getStoredState' -export persistStore from './persistStore' -export purgeState from './purgeState' +export { autoRehydrate } from './autoRehydrate' +export { createPersistor } from './createPersistor' +export { createTransform } from './createTransform' +export { getStoredState } from './getStoredState' +export { persistStore } from './persistStore' +export { purgeStoredState } from './purgeStoredState' export const storages = { asyncLocalStorage: createAsyncLocalStorage('local'), asyncSessionStorage: createAsyncLocalStorage('session') diff --git a/src/purgeStoredState.js b/src/purgeStoredState.js index ff9779ba1..784c2a73b 100644 --- a/src/purgeStoredState.js +++ b/src/purgeStoredState.js @@ -1,17 +1,23 @@ +import { KEY_PREFIX } from './constants' + export function purgeStoredState (config, keys) { const storage = config.storage - const keyPrefix = config.keyPrefix + const keyPrefix = config.keyPrefix || KEY_PREFIX // basic validation if (Array.isArray(config)) throw new Error('redux-persist: purgeStoredState requires config as a first argument (found array). An array of keys is the optional second argument.') if (!storage) throw new Error('redux-persist: config.storage required in purgeStoredState') - if (!keyPrefix) throw new Error('redux-persist: config.keyPrefix required in purgeStoredState') // if keys is not defined, purge all keys if (typeof keys === 'undefined') { - storage.getAllKeys((err, allKeys) => { - if (err && process.env.NODE_ENV !== 'production') { console.warn('redux-persist: error during purgeStoredState in storage.getAllKeys') } - return purgeStoredState(config, allKeys.filter((key) => key.indexOf(keyPrefix) === 0).map((key) => key.slice(keyPrefix.length))) + return new Promise((resolve, reject) => { + storage.getAllKeys((err, allKeys) => { + if (err && process.env.NODE_ENV !== 'production') { + console.warn('redux-persist: error during purgeStoredState in storage.getAllKeys') + reject(err) + } + else resolve(purgeStoredState(config, allKeys.filter((key) => key.indexOf(keyPrefix) === 0).map((key) => key.slice(keyPrefix.length)))) + }) }) } // otherwise purge specified keys @@ -21,3 +27,9 @@ export function purgeStoredState (config, keys) { })) } } + +function warnIfRemoveError (key) { + return function removeError (err) { + if (err && process.env.NODE_ENV !== 'production') { console.warn('Error storing data for key:', key, err) } + } +} diff --git a/test/purgeStoredState.spec.js b/test/purgeStoredState.spec.js new file mode 100644 index 000000000..369132811 --- /dev/null +++ b/test/purgeStoredState.spec.js @@ -0,0 +1,19 @@ +import test from 'ava' + +import { purgeStoredState, storages } from '../src' + +test('purgeStoredState (all) returns a promise', t => { + let purgeResult = purgeStoredState({ storage: storages.asyncLocalStorage }) + t.true(isPromise(purgeResult)) + return purgeResult +}) + +test('purgeStoredState (whitelist) returns a promise', t => { + let purgeResult = purgeStoredState({ storage: storages.asyncLocalStorage }, ['foo']) + t.true(isPromise(purgeResult)) + return purgeResult +}) + +function isPromise (something) { + return typeof something === 'object' && typeof something.then === 'function' +} From c7fc4dc13d6a6baab79e0b4741541db630c2f2a2 Mon Sep 17 00:00:00 2001 From: Zack Story Date: Sat, 27 Aug 2016 22:00:11 -0700 Subject: [PATCH 7/7] fix imports/exports --- src/createPersistor.js | 2 +- src/index.js | 17 ++++++++++------- src/purgeStoredState.js | 12 +++++------- 3 files changed, 16 insertions(+), 15 deletions(-) diff --git a/src/createPersistor.js b/src/createPersistor.js index cf89cd45c..d66edc443 100644 --- a/src/createPersistor.js +++ b/src/createPersistor.js @@ -100,7 +100,7 @@ export default function createPersistor (store, config) { purge: (keys) => purgeStoredState({storage, keyPrefix}, keys), purgeAll: () => { console.warn('redux-persist: purgeAll is deprecated. use `persistor.purge()` instead') - purgeStoredState({storage, keyPrefix}) + return purgeStoredState({storage, keyPrefix}) } } } diff --git a/src/index.js b/src/index.js index db4c8324e..9a231ee94 100644 --- a/src/index.js +++ b/src/index.js @@ -1,12 +1,15 @@ import createAsyncLocalStorage from './defaults/asyncLocalStorage' -export { autoRehydrate } from './autoRehydrate' -export { createPersistor } from './createPersistor' -export { createTransform } from './createTransform' -export { getStoredState } from './getStoredState' -export { persistStore } from './persistStore' -export { purgeStoredState } from './purgeStoredState' -export const storages = { +import autoRehydrate from './autoRehydrate' +import createPersistor from './createPersistor' +import createTransform from './createTransform' +import getStoredState from './getStoredState' +import persistStore from './persistStore' +import purgeStoredState from './purgeStoredState' + +const storages = { asyncLocalStorage: createAsyncLocalStorage('local'), asyncSessionStorage: createAsyncLocalStorage('session') } + +export { autoRehydrate, createPersistor, createTransform, getStoredState, persistStore, purgeStoredState, storages } diff --git a/src/purgeStoredState.js b/src/purgeStoredState.js index 784c2a73b..5b88c581d 100644 --- a/src/purgeStoredState.js +++ b/src/purgeStoredState.js @@ -1,6 +1,6 @@ import { KEY_PREFIX } from './constants' -export function purgeStoredState (config, keys) { +export default function purgeStoredState (config, keys) { const storage = config.storage const keyPrefix = config.keyPrefix || KEY_PREFIX @@ -8,20 +8,18 @@ export function purgeStoredState (config, keys) { if (Array.isArray(config)) throw new Error('redux-persist: purgeStoredState requires config as a first argument (found array). An array of keys is the optional second argument.') if (!storage) throw new Error('redux-persist: config.storage required in purgeStoredState') - // if keys is not defined, purge all keys - if (typeof keys === 'undefined') { + if (typeof keys === 'undefined') { // if keys is not defined, purge all keys return new Promise((resolve, reject) => { storage.getAllKeys((err, allKeys) => { if (err && process.env.NODE_ENV !== 'production') { console.warn('redux-persist: error during purgeStoredState in storage.getAllKeys') reject(err) + } else { + resolve(purgeStoredState(config, allKeys.filter((key) => key.indexOf(keyPrefix) === 0).map((key) => key.slice(keyPrefix.length)))) } - else resolve(purgeStoredState(config, allKeys.filter((key) => key.indexOf(keyPrefix) === 0).map((key) => key.slice(keyPrefix.length)))) }) }) - } - // otherwise purge specified keys - else { + } else { // otherwise purge specified keys return Promise.all(keys.map((key) => { return storage.removeItem(`${keyPrefix}${key}`, warnIfRemoveError(key)) }))