@redux-multipurpose/core
Version:
## Installation Redux Multipurpose core is available as a package on NPM:
299 lines (292 loc) • 12.5 kB
JavaScript
import { persistReducer, FLUSH, REHYDRATE, PAUSE, PERSIST, PURGE, REGISTER, persistStore } from 'redux-persist';
import { encryptTransform } from 'redux-persist-transform-encrypt';
import { createAsyncThunk, createSelector, getDefaultMiddleware, configureStore, combineReducers } from '@reduxjs/toolkit';
import { BehaviorSubject, Observable } from 'rxjs';
import { switchMap, map, distinctUntilChanged } from 'rxjs/operators';
import { createEpicMiddleware } from 'redux-observable-es6-compat';
import createSagaMiddleware from 'redux-saga';
import { createResponsiveStateReducer, responsiveStateReducer, responsiveStoreEnhancer, calculateResponsiveState } from 'redux-responsive';
import { createLogger } from 'redux-logger';
const createStoredReducer = (key, storage, reducer, stateReconciler) => {
return persistReducer({ key, storage, stateReconciler }, reducer);
};
const createSecureStoredReducer = (key, encryptKey, storage, reducer, stateReconciler) => {
const encryptor = encryptTransform({
secretKey: encryptKey,
onError: (error) => {
console.log("An error occured during secure data save: ", error);
}
});
const secureStoragePersistConfig = {
key,
storage,
transforms: [encryptor],
stateReconciler
};
return persistReducer(secureStoragePersistConfig, reducer);
};
const DEFAULT_INITIAL_SUBSTATE = { data: null, loading: false, error: null };
class WsState {
}
let initialState;
const createWsInitialState = (substates) => {
let state = {};
for (let substate of substates) {
if (typeof substate == 'string')
state[substate] = DEFAULT_INITIAL_SUBSTATE;
else {
let key = Object.keys(substate)[0];
state[key] = Object.assign(Object.assign({}, substate[key]), { loading: substate[key].loading ? substate[key].loading : false, data: substate[key].data ? substate[key].data : null, error: substate[key].error ? substate[key].error : null });
}
}
initialState = state;
return state;
};
////////////////// Actions utils
//Thunk creator helper
const prepareThunk = (state, id, callback) => {
return createAsyncThunk(state + '/' + id, callback);
};
const prepareThunkActionReducers = (thunksWithStates) => {
let reducers = {};
for (let storeInfos of thunksWithStates) {
let { thunk, substate, adapter } = storeInfos;
reducers = Object.assign(Object.assign({}, reducers), { [thunk.pending.toString()]: state => {
return Object.assign(Object.assign({}, state), { [substate]: Object.assign(Object.assign({}, initialState[substate]), { loading: true }) });
}, [thunk.fulfilled.toString()]: (state, action) => {
state[substate].loading = false;
if (adapter != null && adapter != undefined) {
adapter.setAll(state[substate].data, action.payload);
if (typeof state[substate].data.available !== 'undefined')
state[substate].data.available = true;
}
else
state[substate].data = action.payload;
}, [thunk.rejected.toString()]: (state, action) => {
state[substate].loading = false;
state[substate].error = action.error;
} });
}
return reducers;
};
const genericSelector = (paths) => {
return createSelector([state => {
let nestedState = state;
for (let path of paths)
if (nestedState[path] != null && nestedState[path] != undefined)
nestedState = nestedState[path];
else {
nestedState = null;
break;
}
return nestedState;
}], items => items);
};
const ɵ0 = genericSelector;
const initializeWithDefaultMiddleware = (options) => {
return options ?
[...getDefaultMiddleware(options)] :
[...getDefaultMiddleware()];
};
const ɵ1 = initializeWithDefaultMiddleware;
//Store instance
var reduxStore;
var staticReducers = {};
var dynamicReducers = {};
var epics$;
const initializeStore = (options) => {
if (reduxStore)
throw Error("A redux store is initialized yet. Cannot initialize another one");
const { reducers, devTools, middlewares, enhancers, preloadedState, defaultMiddlewareOptions, sagas, epics, enablePersistence, enableResponsiveness, router, logLevel } = options;
let enhancer = enhancers;
let middleware = [];
let sagaMiddleware;
let epicMiddleware;
let middlewareOptions = defaultMiddlewareOptions;
if (enablePersistence) {
if (!middlewareOptions)
middlewareOptions = {};
if (!middlewareOptions.serializableCheck || typeof middlewareOptions === 'boolean')
middlewareOptions.serializableCheck = {};
if (typeof middlewareOptions.serializableCheck === 'object') {
if (!middlewareOptions.serializableCheck.ignoredActions)
middlewareOptions.serializableCheck.ignoredActions = [];
if (middlewareOptions.serializableCheck.ignoredActions.indexOf(FLUSH) < 0)
middlewareOptions.serializableCheck.ignoredActions.push(FLUSH);
if (middlewareOptions.serializableCheck.ignoredActions.indexOf(REHYDRATE) < 0)
middlewareOptions.serializableCheck.ignoredActions.push(REHYDRATE);
if (middlewareOptions.serializableCheck.ignoredActions.indexOf(PAUSE) < 0)
middlewareOptions.serializableCheck.ignoredActions.push(PAUSE);
if (middlewareOptions.serializableCheck.ignoredActions.indexOf(PERSIST) < 0)
middlewareOptions.serializableCheck.ignoredActions.push(PERSIST);
if (middlewareOptions.serializableCheck.ignoredActions.indexOf(PURGE) < 0)
middlewareOptions.serializableCheck.ignoredActions.push(PURGE);
if (middlewareOptions.serializableCheck.ignoredActions.indexOf(REGISTER) < 0)
middlewareOptions.serializableCheck.ignoredActions.push(REGISTER);
}
}
if (enableResponsiveness) {
if (!middlewareOptions)
middlewareOptions = {};
if (!middlewareOptions.serializableCheck || typeof middlewareOptions === 'boolean')
middlewareOptions.serializableCheck = {};
if (typeof middlewareOptions.serializableCheck === 'object') {
if (!middlewareOptions.serializableCheck.ignoredActions)
middlewareOptions.serializableCheck.ignoredActions = [];
if (middlewareOptions.serializableCheck.ignoredActions.indexOf("redux-responsive/CALCULATE_RESPONSIVE_STATE") < 0)
middlewareOptions.serializableCheck.ignoredActions.push("redux-responsive/CALCULATE_RESPONSIVE_STATE");
}
}
middleware = initializeWithDefaultMiddleware(middlewareOptions);
if (middleware)
middleware = [...middleware, ...middlewares];
if (epics) {
epicMiddleware = createEpicMiddleware();
middleware = [...middleware, epicMiddleware];
}
if (sagas) {
sagaMiddleware = createSagaMiddleware();
middleware = [...middleware, sagaMiddleware];
}
if (logLevel) {
const loggerMiddleware = createLogger({ level: logLevel });
middleware = [...middleware, loggerMiddleware];
}
if (enableResponsiveness) {
let browserReducer;
if (typeof enableResponsiveness === 'object' && enableResponsiveness.breakpoints)
browserReducer = createResponsiveStateReducer(enableResponsiveness.breakpoints, enableResponsiveness.options);
else
browserReducer = responsiveStateReducer;
if (!reducers['browser'])
reducers['browser'] = browserReducer;
else
throw ("A browser reducer already exists. Cannot enable redux-responsive module");
if (!enhancer)
enhancer = [responsiveStoreEnhancer];
else
enhancer = [...enhancer, responsiveStoreEnhancer];
}
staticReducers = reducers;
const newStore = configureStore({
reducer: combineReducers(reducers),
devTools,
preloadedState,
middleware,
enhancers: enhancer
});
epics$ = new BehaviorSubject(epics);
const hotReloadingEpics = (action$, state$, dependencies) => epics$.pipe(switchMap((epic) => epic(action$, state$, dependencies)));
//Executing epics
if (epicMiddleware)
epicMiddleware.run(hotReloadingEpics);
//Executing sagas
if (sagaMiddleware)
sagaMiddleware.run(sagas);
if (enablePersistence)
persistStore(newStore);
//Finally save store instance
reduxStore = newStore;
if (router) {
store.addReducer(router.key, router.reducer);
router.service.init();
}
if (enableResponsiveness)
window.addEventListener('resize', () => store.dispatch(calculateResponsiveState(window)));
};
const ɵ2 = () => {
return new Observable(function (observer) {
observer.next(reduxStore.getState());
const unsubscribe = reduxStore.subscribe(function () {
observer.next(reduxStore.getState());
});
return unsubscribe;
});
}, ɵ3 = () => {
return reduxStore.getState();
}, ɵ4 = (selector) => {
return new Observable(subscriber => {
const state$ = store.getState$();
const unsubscribe = state$.pipe(map(state => selector(state)), distinctUntilChanged()).subscribe(data => subscriber.next(data));
return unsubscribe;
});
}, ɵ5 = (selector) => {
return selector(reduxStore.getState());
}, ɵ6 = (action) => {
reduxStore.dispatch(action);
}, ɵ7 = (key, reducer) => {
if (!key || dynamicReducers[key])
throw (`A reducer with key '${key}' is already injected. Injection aborted`);
dynamicReducers[key] = reducer;
reduxStore.replaceReducer(combineReducers(Object.assign(Object.assign({}, staticReducers), dynamicReducers)));
}, ɵ8 = (key) => {
if (!key || !dynamicReducers[key])
throw (`No reducer with key '${key}' found. Remove aborted`);
delete dynamicReducers[key];
reduxStore.replaceReducer(combineReducers(Object.assign(Object.assign({}, staticReducers), dynamicReducers)));
}, ɵ9 = (newRootEpic) => {
epics$.next(newRootEpic);
};
const store = {
getState$: ɵ2,
getState: ɵ3,
select: ɵ4,
selectSync: ɵ5,
dispatch: ɵ6,
addReducer: ɵ7,
removeReducer: ɵ8,
replaceEpics: ɵ9
};
const select = (selector) => {
if (selector)
return (target, key) => {
Object.defineProperty(target, key, {
get: () => selector instanceof Array ? store.select(genericSelector(selector)) : store.select(selector),
enumerable: true,
configurable: true,
});
};
};
const get = (selector) => {
if (selector)
return (target, key) => {
Object.defineProperty(target, key, {
get: () => selector instanceof Array ? store.selectSync(genericSelector(selector)) : store.selectSync(selector),
enumerable: true,
configurable: true,
});
};
};
const dispatch = () => {
return (target, key, descriptor) => {
let originalMethod;
const wrapped = (...args) => {
const result = originalMethod.apply(this, args);
if (result !== undefined && store)
store.dispatch(result);
return result;
};
descriptor = descriptor || Object.getOwnPropertyDescriptor(target, key);
if (descriptor === undefined) {
const dispatchDescriptor = {
get: () => wrapped,
set: setMethod => (originalMethod = setMethod),
};
Object.defineProperty(target, key, dispatchDescriptor);
return dispatchDescriptor;
}
else {
originalMethod = descriptor.value;
descriptor.value = wrapped;
return descriptor;
}
};
};
/*
* Public API Surface of core
*/
/**
* Generated bundle index. Do not edit.
*/
export { WsState, createSecureStoredReducer, createStoredReducer, createWsInitialState, dispatch, get, initializeStore, prepareThunk, prepareThunkActionReducers, select, store, ɵ0, ɵ1, ɵ2, ɵ3, ɵ4, ɵ5, ɵ6, ɵ7, ɵ8, ɵ9 };
//# sourceMappingURL=redux-multipurpose-core.js.map