@nlabs/arkhamjs-middleware-redux
Version:
Integrate ArkhamJS state management within Redux
46 lines (45 loc) • 7.2 kB
JavaScript
/**
* Copyright (c) 2018-Present, Nitrogen Labs, Inc.
* Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
*/ import { Flux } from '@nlabs/arkhamjs';
import { isPlainObject } from '@nlabs/utils/checks/isPlainObject';
import { merge } from '@nlabs/utils/objects/merge';
import { applyMiddleware, createStore } from 'redux';
import { arkhamMiddleware } from './middleware/arkhamMiddleware.js';
import { ReduxMiddleware } from './middleware/ReduxMiddleware.js';
export const createArkhamStore = (configuration)=>{
const { arkhamMiddleware: middleware = [], flux, reducers, sagas, statePath = '', reduxMiddleware = [], devTools } = configuration;
// Save initial state tree
const { storage } = Flux.getOptions();
let store;
if (storage) {
const cachedState = Flux.getState(statePath);
if (devTools) {
store = createStore(devTools(reducers, cachedState), applyMiddleware(...reduxMiddleware, arkhamMiddleware(statePath, flux)));
} else {
store = createStore(reducers, cachedState, applyMiddleware(...reduxMiddleware, arkhamMiddleware(statePath, flux)));
}
if (cachedState === undefined) {
const stateTree = store.getState();
const updatedState = isPlainObject(stateTree) ? merge(stateTree, cachedState) : stateTree;
Flux.setState(statePath, updatedState);
}
} else {
store = createStore(reducers, devTools, applyMiddleware(...reduxMiddleware, arkhamMiddleware(statePath, flux)));
Flux.setState(statePath, store.getState());
}
// If saga is being added, run.
reduxMiddleware.every((item)=>{
if (sagas) {
item.run(sagas);
return false;
}
return true;
});
// Add redux middleware to Arkham to relay dispatches to Redux
middleware.push(new ReduxMiddleware(store, statePath));
// Initialize ArkhamJS
Flux.addMiddleware(middleware);
return store;
};
//# sourceMappingURL=data:application/json;base64,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