const configureStore = (initialState, resourcePath) => {
const middleware = [];
middleware.push(thunk);
const enhancer = compose(
applyMiddleware(...middleware),
electronEnhancer({
dispatchProxy: a => store.dispatch(a),
})
);
const persistedReducer = persistReducer(persistConfig, rootReducer);
const store = createStore(persistedReducer, initialState, enhancer);
const persistor = persistStore(store, null, () => {
// Destroy any invalid settings that may have made its way into persistant storage
store.dispatch({
type: types.RESET_INVALID_SETTINGS
});
// Configure localization after the store has rehydrated to get the language from settings
configureLocalization(resourcePath, store.getState());
});
if (module.hot) {
module.hot.accept('../../reducers', () =>
store.replaceReducer(require('../../reducers'))); // eslint-disable-line global-require
}
return { store, persistor };
};
const persistEnhancer = () => createStore => (reducer, initialState, enhancer) => {
const store = createStore(persistReducer(persistConfig, reducer), initialState, enhancer);
const persist = persistStore(store, null);
return {
persist,
...store,
};
};
export default () => {
const persistedReducer = persistReducer(persistConfig, reducers);
const store = createStore(
persistedReducer,
undefined,
applyMiddleware(thunk)
);
const persistor = persistStore(store);
return { store, persistor };
}
function configureStore(initialState, resourcePath) {
const enhancer = compose(
applyMiddleware(thunk),
electronEnhancer({
dispatchProxy: a => store.dispatch(a)
})
);
const persistedReducer = persistReducer(persistConfig, rootReducer);
const store = createStore(persistedReducer, initialState, enhancer);
const persistor = persistStore(store, null, () => {
// Destroy any invalid settings that may have made its way into persistant storage
store.dispatch({
type: types.RESET_INVALID_SETTINGS
});
// Configure localization after the store has rehydrated to get the language from settings
configureLocalization(resourcePath, store.getState());
});
return { store, persistor };
}
import { createStore, applyMiddleware, compose } from 'redux';
import createSagaMiddleware from 'redux-saga';
import { persistStore, persistReducer } from 'redux-persist';
import rootReducer from './reducers/rootReducer';
import rootSaga from './sagas/rootSaga';
import { storagePersistConfig } from '../config/storagePersist';
const sagaMiddleware = createSagaMiddleware();
// eslint-disable-next-line
const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;
const middleware = composeEnhancers(applyMiddleware(sagaMiddleware));
const persistedReducer = persistReducer(storagePersistConfig, rootReducer);
const store = createStore(persistedReducer, middleware);
const persistor = persistStore(store);
sagaMiddleware.run(rootSaga);
export { store, persistor };
import { createStore, applyMiddleware } from 'redux'
import rootReducers from './appReducer'
// import loggerMiddleware from 'redux-logger'
import { navMiddleware } from './AppWithNavigationState'
import createSagaMiddleware from 'redux-saga'
import saga from './appSagas'
import { persistStore, persistReducer } from 'redux-persist'
import storage from 'redux-persist/lib/storage' // defaults to localStorage for web and AsyncStorage for react-native
const persistConfig = {
key: 'root',
storage,
blacklist: ['nav'],
}
const persistedReducer = persistReducer(persistConfig, rootReducers)
const sagaMiddleware = createSagaMiddleware()
export default () => {
let store = createStore(
persistedReducer,
applyMiddleware(
// loggerMiddleware,
navMiddleware,
sagaMiddleware)
)
let persistor = persistStore(store)
sagaMiddleware.run(saga)
const isProd: boolean = String(process.env.NODE_ENV) === 'production';
const composeEnhancers: Function = isProd ? compose : composeWithDevTools;
const epicMiddleware: Object = createEpicMiddleware();
export const history: Object = createHistory();
const persistConfig: Object = {
key: 'root',
storage,
whitelist: ['auth'],
};
const middlewares: Array<any> = [
epicMiddleware,
routerMiddleware(history),
];
const persistedReducer: Object = persistReducer(persistConfig, reducers);
export function configureStore(): Object {
const store: Object = createStore(
persistedReducer,
composeEnhancers(applyMiddleware(...middlewares)),
);
epicMiddleware.run(epics);
return store;
}
const configureStore = router => {
const middlewares = [];
// NOTE: Order is very important for middlewares - downstream can only intercept
// upstream events
// Thunks: async side effects
middlewares.push(thunkMiddleware);
// Persist (on client side) certain pieces of data
const analyticsPersistConfig = {
key: "analytics",
storage,
version: 0,
migrate: createMigrate({ 0: state => ({ ...state }) }, { debug: false })
};
const authPersistConfig = {
key: "auth",
storage,
version: 0,
migrate: createMigrate({ 0: state => ({ ...state }) }, { debug: false })
};
const persistedReducer = combineReducers({
...rootReducerObject,
analytics: persistReducer(
analyticsPersistConfig,
rootReducerObject.analytics
),
auth: persistReducer(authPersistConfig, rootReducerObject.auth)
});
// Authentication middleware
middlewares.push(createAuthMiddleware());
// Analytics middleware
/* eslint-disable no-undef */
if (ANALYTICS === "yes") {
/* eslint-enable no-undef */
middlewares.push(createAnalyticsMiddleware());
}
// Router middleware
middlewares.push(createRouter5Middleware(router));
// Logging middleware - for debug purposes
/* eslint-disable global-require */
/* eslint-disable no-undef */
if (NODE_ENV === "development") {
/* eslint-enable no-undef */
const { logger } = require("redux-logger");
middlewares.push(logger);
}
/* eslint-enable global-require */
const store = createStore(persistedReducer, applyMiddleware(...middlewares));
// Sync router navigations to redux store
router.usePlugin(router5ReduxPlugin(store.dispatch));
return store;
};
// #region constants
export const history = createHistory();
// #endregion
// #region createStore : enhancer
const enhancer = composeWithDevTools(
applyMiddleware(thunkMiddleware, fetchMiddleware, routerMiddleware(history)),
);
// #endregion
// #region persisted reducer
const persistConfig = {
key: 'root',
storage,
blacklist: ['router'],
// whitelist: ['userAuth'],
};
const persistedReducer = persistReducer(
persistConfig,
connectRouter(history)(reducer),
);
// #endregion
export default function configureStore(initialState: any = {}) {
// $FlowIgnore
const store = createStore(persistedReducer, initialState, enhancer);
const persistor = persistStore(store);
return { store, persistor };
}
...token,
id: uuid.v4(),
})),
}),
};
const storage = createSensitiveStorage({
encrypt: true,
keychainService: 'eltwallet',
sharedPreferencesName: 'eltwallet',
});
const persistConfig = {
key: 'eltwallet',
version: 1,
storage,
migrate: createMigrate(migrations, { debug: false }),
};
const store = createStore(
persistReducer(persistConfig, rootReducer),
defaultState,
process.env.NODE_ENV === 'production'
? undefined
: applyMiddleware(createLogger()),
);
const persistor = persistStore(store);
export { persistor, store };
import { createLogger } from 'redux-logger';
import { persistStore, persistReducer } from 'redux-persist'
import storage from 'redux-persist/lib/storage'
// import { getToken, setAuthorizationToken } from 'src/actions/authentication/auth.js';
const initialState = {};
const persistConfig = {
key: 'root',
storage: storage,
whitelist: ['auth']
}
const persistedReducer = persistReducer(persistConfig, combineReducers({
...reducers,
routing: routerReducer
}));
export default () => {
let store = createStore(
persistedReducer,
applyMiddleware(
thunk,
createLogger({ predicate: () => process.env.NODE_ENV === 'development' })
)
)
let persistor = persistStore(store)
return { store, persistor }
}
});
});
} else {
return Promise.resolve(state);
}
},
serialize: false,
storage: localStorage,
// Disable redux-persist timeout functionality so it never erroneously wipes out the store. That's
// never desired no matter how long the timeout lasts.
//
// See https://github.com/rt2zz/redux-persist/issues/809#issuecomment-437589932
timeout: 0,
version: 2,
};
const rootReducer = combineReducers({
localStorage: persistReducer(localStoragePersistConfig, localStorageReducer),
tempStorage: tempStorageReducer,
});
export default function() {
// $FlowFixMe
const store = createStore(rootReducer, applyMiddleware(thunk));
return {
persistor: persistStore(store),
store,
};
}