@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/redux/selectors/references.js

@@ -0,0 +1,180 @@
+import { createSelector } from './selectors';
+export const selectOutputReference = createSelector((state, id) => {
+    if (typeof state.references === 'undefined')
+        return undefined;
+    return state.references.outputs[id];
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectBoxReference = createSelector((state, id) => {
+    if (state.references.boxes[id] === undefined)
+        throw new Error(`Box ${id} does not exist`);
+    return state.references.boxes[id];
+}, () => Math.random());
+export const isOptionMultiple = createSelector((state, id) => {
+    var _a;
+    if (typeof state.references === 'undefined')
+        return undefined;
+    return ((_a = state.references.options[id].meta.multiple) === null || _a === void 0 ? void 0 : _a.enabled) === true;
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectOptionReference = createSelector((state, id) => {
+    if (state.references.options[id] === undefined)
+        throw new Error(`Option ${id} does not exist`);
+    return state.references.options[id];
+}, () => Math.random());
+export const selectOptionRelations = createSelector((state, id) => {
+    if (state.references.relations.options[id] === undefined)
+        throw new Error(`Option ${id} relations do not exist`);
+    return state.references.relations.options[id];
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectSectionRelations = createSelector((state, id) => {
+    if (state.references.relations.sections[id] === undefined)
+        throw new Error(`Section ${id} relations do not exist`);
+    return state.references.relations.sections[id];
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectOptionParents = createSelector((state, id) => {
+    if (state.references.relations.options[id].parents === undefined)
+        throw new Error(`Option ${id} parent relations are undefined`);
+    return state.references.relations.options[id].parents;
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectRadioSiblings = createSelector((state, id) => {
+    if (state.references.relations.options[id] === undefined)
+        throw new Error(`Option ${id} relations do not exist`);
+    const { radioSiblings } = state.references.relations.options[id];
+    return radioSiblings;
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectVariableReference = createSelector((state, id, noThrow = false) => {
+    if (state.references.variables[id] === undefined && noThrow === false)
+        throw new Error(`Variable ${id} does not exist`);
+    return state.references.variables[id];
+}, () => Math.random());
+export const selectVariableRelations = createSelector((state, id) => {
+    if (state.references.relations.variables[id] === undefined)
+        throw new Error(`Variable ${id} relations do not exist`);
+    return state.references.relations.variables[id];
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectVariableParents = createSelector((state, id) => {
+    if (state.references.relations.variables[id] === undefined)
+        throw new Error(`Variable ${id} parents relations is undefined`);
+    return state.references.relations.variables[id].parents;
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectAllDocumentsReferences = createSelector((state) => {
+    if (state.references.documents === undefined)
+        throw new Error(`Documents references do not exist`);
+    return state.references.documents;
+}, (state) => (!state.references ? Math.random() : 1));
+export const selectDocumentReference = createSelector((state, document) => {
+    if (state.references.documents === undefined)
+        throw new Error(`Documents references do not exist`);
+    return state.references.documents[document];
+}, (state) => (!state.references ? Math.random() : 1));
+export const selectAllSectionsReferences = createSelector((state, document = 'main') => {
+    if (typeof state.references === 'undefined')
+        return undefined;
+    return state.references.sections[document];
+}, (state, document = 'main') => !state.references ? Math.random() : document);
+export const selectSectionReference = createSelector((state, id, document = 'main') => {
+    if (state.references.sections[document] === undefined)
+        throw new Error(`Document ${document} does not exist`);
+    if (state.references.sections[document][id] === undefined) {
+        throw new Error(`Section ${id} does not exist in document ${document}`);
+    }
+    return state.references.sections[document][id];
+}, (state, id, document = 'main') => !state.references ? Math.random() : `${id}-${document}`);
+export const selectSectionDefaults = createSelector((state, id) => {
+    if (typeof state.references === 'undefined')
+        return undefined;
+    return state.references.defaults[id];
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectOptionConditionsObject = createSelector((state, id) => {
+    if (typeof state.references === 'undefined')
+        return undefined;
+    return state.references.conditions.options[id];
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectVariableConditionsObject = createSelector((state, id) => {
+    if (typeof state.references === 'undefined')
+        return undefined;
+    return state.references.conditions.variables[id];
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectDocumentConditionsObject = createSelector((state, name) => {
+    if (typeof state.references === 'undefined')
+        return undefined;
+    return state.references.conditions.documents[name];
+}, (state, name) => (!state.references ? Math.random() : name));
+export const selectSectionConditionsObject = createSelector((state, id, document = 'main') => {
+    return state.references.conditions.sections[document][id];
+}, (state, id, document = 'main') => !state.references ? Math.random() : `${id}-${document}`);
+export const selectPrefillerConditionsObject = createSelector((state, id) => {
+    if (typeof state.references === 'undefined')
+        return undefined;
+    return state.references.conditions.prefillers[id];
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectOptionValidatorConditionsObject = createSelector((state, id) => {
+    if (typeof state.references === 'undefined')
+        return undefined;
+    return state.references.conditions.validators.options[id];
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectVariableValidatorConditionsObject = createSelector((state, id) => {
+    if (typeof state.references === 'undefined')
+        return undefined;
+    return state.references.conditions.validators.variables[id];
+}, (state, id) => (!state.references ? Math.random() : id));
+export const areVariablesSiblings = createSelector((state, ...args) => {
+    if (typeof state.references === 'undefined')
+        return undefined;
+    const rootParents = args
+        .map((variableId) => {
+        const parents = selectVariableParents(variableId);
+        if (parents === undefined)
+            return null;
+        return parents[parents.length - 1];
+    })
+        .filter((a) => a !== null);
+    const comparator = rootParents.length > 0 ? rootParents[0] : -1;
+    return rootParents.every((c) => c === comparator);
+}, (state, ...args) => args.reduce((p, c) => p + c.toString(), ''));
+export const selectVariablesByTag = createSelector((state, tag) => {
+    const ids = [];
+    Object.keys(state.references.variables).forEach((id) => {
+        const variable = state.references.variables[id];
+        if (Array.isArray(variable.tags) && variable.tags.includes(tag))
+            ids.push(parseInt(id, 10));
+    });
+    return ids;
+});
+export const selectOptionsByTag = createSelector((state, tag) => {
+    const ids = [];
+    Object.keys(state.references.options).forEach((id) => {
+        const option = state.references.options[id];
+        if (Array.isArray(option.meta.tags) && option.meta.tags.includes(tag))
+            ids.push(parseInt(id, 10));
+    });
+    return ids;
+});
+export const selectOptionParentSection = createSelector((state, id) => {
+    const { parents } = state.references.relations.options[id];
+    if (parents === undefined)
+        throw new Error(`Option ${id} parent relations are undefined`);
+    const rootId = parents.length > 0 ? parents[parents.length - 1] : id;
+    const sections = Object.values(state.references.sections.main);
+    for (let i = 0; i < sections.length; i += 1) {
+        if (sections[i].options.includes(rootId))
+            return sections[i].id;
+    }
+    throw new Error(`Cannot find parent section for option ${id} (Root option id: ${rootId})`);
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectVariableParentSection = createSelector((state, id) => {
+    const { parents } = state.references.relations.variables[id];
+    if (parents === undefined)
+        throw new Error(`Variable ${id} parent relations are undefined`);
+    const rootId = parents[parents.length - 1];
+    const sections = Object.values(state.references.sections.main);
+    for (let i = 0; i < sections.length; i += 1) {
+        if (sections[i].options.includes(rootId))
+            return sections[i].id;
+    }
+    throw new Error(`Cannot find parent section for variable ${id} (Root option id: ${rootId})`);
+}, (state, id) => (!state.references ? Math.random() : id));
+export const selectUserEmailSectionVariableIds = createSelector((state, sectionId) => {
+    const { variables } = state.references;
+    const userEmailVariables = Object.keys(variables).filter((variableId) => variables[variableId].type === 'user_email');
+    return userEmailVariables.filter((variableId) => selectVariableParentSection(parseInt(variableId, 10)) === sectionId);
+}, (state, sectionId) => !state.references ? Math.random() : sectionId);

package/dist/redux/selectors/references.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/selectors/references.test.js

@@ -0,0 +1,469 @@
+import { createAppStore, getStore } from '../store';
+import { initReferencesAction } from '../actions/references';
+import { isOptionMultiple, selectOptionReference, selectOptionRelations, selectOptionParents, selectRadioSiblings, selectVariableReference, selectVariableRelations, selectVariableParents, selectAllSectionsReferences, selectSectionReference, selectSectionDefaults, selectOptionConditionsObject, selectVariableConditionsObject, selectSectionConditionsObject, selectPrefillerConditionsObject, } from './references';
+createAppStore('memory');
+const store = getStore();
+const initialState = {
+    options: {},
+    variables: {},
+    relations: {
+        options: {},
+        variables: {},
+        sections: {},
+    },
+    conditions: {
+        options: {},
+        variables: {},
+        prefillers: {},
+        validators: {
+            options: {},
+            variables: {},
+        },
+        sections: {},
+        documents: {},
+    },
+    sections: {},
+    documents: {},
+    defaults: {},
+    outputs: {},
+    evaluations: {},
+    boxes: {},
+};
+describe('Inputs selectors test suit', () => {
+    it('isOptionMultiple returns undefined when references are not set', () => {
+        expect(() => isOptionMultiple(4)).toThrowError();
+    });
+    it('selectOptionReference returns undefined when references are not set', () => {
+        expect(() => selectOptionReference(4)).toThrowError();
+    });
+    it('selectOptionRelations returns undefined when references are not set', () => {
+        expect(() => selectOptionRelations(4)).toThrowError();
+    });
+    it('selectOptionParents returns undefined when references are not set', () => {
+        expect(() => selectOptionParents(4)).toThrowError();
+    });
+    it('selectRadioSiblings returns undefined when references are not set', () => {
+        expect(() => selectRadioSiblings(4)).toThrowError();
+    });
+    it('selectVariableReference returns undefined when references are not set', () => {
+        expect(() => selectVariableReference(4)).toThrowError();
+    });
+    it('selectVariableRelations returns undefined when references are not set', () => {
+        expect(() => selectVariableRelations(4)).toThrowError();
+    });
+    it('selectVariableParents returns undefined when references are not set', () => {
+        expect(() => selectVariableParents(4)).toThrowError();
+    });
+    it('selectAllSectionsReferences returns undefined when references are not set', () => {
+        expect(() => selectAllSectionsReferences('main')).toThrowError();
+    });
+    it('selectSectionReference returns undefined when references are not set', () => {
+        expect(() => selectSectionReference(4)).toThrowError();
+    });
+    it('selectSectionDefaults returns undefined when references are not set', () => {
+        expect(() => selectSectionDefaults(4)).toThrowError();
+    });
+    it('selectOptionConditionsObject returns undefined when references are not set', () => {
+        expect(() => selectOptionConditionsObject(4)).toThrowError();
+    });
+    it('selectVariableConditionsObject returns undefined when references are not set', () => {
+        expect(() => selectVariableConditionsObject(4)).toThrowError();
+    });
+    it('selectSectionConditionsObject returns undefined when references are not set', () => {
+        expect(() => selectSectionConditionsObject(4, 'main')).toThrowError();
+    });
+    it('selectPrefillerConditionsObject returns undefined when references are not set', () => {
+        expect(() => selectPrefillerConditionsObject(4)).toThrowError();
+    });
+    it('Checks if an option is multiple', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { options: {
+                '3': {
+                    meta: {
+                        id: 3,
+                        label: '',
+                        type: 'static',
+                        multiple: { enabled: true },
+                        step: '*',
+                    },
+                    options: [],
+                    variables: [],
+                },
+            } })));
+        const selector = isOptionMultiple(3);
+        expect(selector).toBeTruthy();
+    });
+    it('Returns option refrence', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { options: {
+                '34': {
+                    meta: {
+                        id: 34,
+                        label: '',
+                        type: 'static',
+                        multiple: { enabled: true },
+                        step: '*',
+                    },
+                    options: [],
+                    variables: [],
+                },
+            } })));
+        const selector = selectOptionReference(34);
+        expect(selector).toEqual({
+            meta: {
+                id: 34,
+                label: '',
+                step: '*',
+                type: 'static',
+                multiple: {
+                    enabled: true,
+                },
+            },
+            options: [],
+            variables: [],
+        });
+    });
+    it('Returns option relations', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { relations: Object.assign(Object.assign({}, initialState.relations), { options: {
+                    '5': {
+                        options: [1],
+                        variables: [4],
+                        prefillers: [5],
+                        sections: { main: [6] },
+                        children: {
+                            options: [1],
+                            variables: [32],
+                        },
+                        parents: [43],
+                        validators: {
+                            options: [34],
+                            variables: [53],
+                        },
+                        dependants: [434],
+                        documents: [],
+                    },
+                } }) })));
+        const selector = selectOptionRelations(5);
+        expect(selector).toEqual({
+            options: [1],
+            variables: [4],
+            prefillers: [5],
+            sections: {
+                main: [6],
+            },
+            children: {
+                options: [1],
+                variables: [32],
+            },
+            parents: [43],
+            validators: {
+                options: [34],
+                variables: [53],
+            },
+            dependants: [434],
+            documents: [],
+        });
+    });
+    it('Returns option parents', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { relations: Object.assign(Object.assign({}, initialState.relations), { options: {
+                    '5': {
+                        options: [1],
+                        variables: [4],
+                        prefillers: [5],
+                        sections: { main: [6] },
+                        children: {
+                            options: [1],
+                            variables: [32],
+                        },
+                        parents: [43, 32, 432],
+                        validators: {
+                            options: [34],
+                            variables: [53],
+                        },
+                        dependants: [434],
+                        documents: [],
+                    },
+                } }) })));
+        const selector = selectOptionParents(5);
+        expect(selector).toEqual([43, 32, 432]);
+    });
+    it('Returns option radio siblings', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { relations: Object.assign(Object.assign({}, initialState.relations), { options: {
+                    '5': {
+                        options: [1],
+                        variables: [4],
+                        prefillers: [5],
+                        sections: { main: [6] },
+                        children: {
+                            options: [1],
+                            variables: [32],
+                        },
+                        parents: [43, 32, 432],
+                        validators: {
+                            options: [34],
+                            variables: [53],
+                        },
+                        dependants: [434],
+                        radioSiblings: [32, 4, 53],
+                        documents: [],
+                    },
+                } }) })));
+        const selector = selectRadioSiblings(5);
+        expect(selector).toEqual([32, 4, 53]);
+    });
+    it('Returns variable reference', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { variables: {
+                '3': {
+                    id: 3,
+                    type: 'text',
+                    label: 'Variable',
+                    step: '*',
+                },
+            } })));
+        const selector = selectVariableReference(3);
+        expect(selector).toEqual({
+            id: 3,
+            type: 'text',
+            label: 'Variable',
+            step: '*',
+        });
+    });
+    it('Returns variable relations', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { relations: Object.assign(Object.assign({}, initialState.relations), { variables: {
+                    '5': {
+                        options: [1],
+                        variables: [4],
+                        prefillers: [5],
+                        prefillingsContents: [],
+                        sections: { main: [6] },
+                        parents: [43],
+                        validators: {
+                            options: [34],
+                            variables: [53],
+                        },
+                        documents: [],
+                    },
+                } }) })));
+        const selector = selectVariableRelations(5);
+        expect(selector).toEqual({
+            options: [1],
+            variables: [4],
+            prefillers: [5],
+            prefillingsContents: [],
+            sections: { main: [6] },
+            parents: [43],
+            validators: {
+                options: [34],
+                variables: [53],
+            },
+            documents: [],
+        });
+    });
+    it('Returns variable parents', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { relations: Object.assign(Object.assign({}, initialState.relations), { variables: {
+                    '5': {
+                        options: [1],
+                        variables: [4],
+                        prefillers: [5],
+                        prefillingsContents: [],
+                        sections: { main: [6] },
+                        parents: [4, 3],
+                        validators: {
+                            options: [34],
+                            variables: [53],
+                        },
+                        documents: [],
+                    },
+                } }) })));
+        const selector = selectVariableParents(5);
+        expect(selector).toEqual([4, 3]);
+    });
+    it('Returns all sections references', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { sections: {
+                main: {
+                    1: {
+                        id: 1,
+                        label: 'Some label 1',
+                        options: [],
+                    },
+                    2: {
+                        id: 2,
+                        label: 'Some label 2',
+                        options: [],
+                    },
+                },
+            } })));
+        const selector = selectAllSectionsReferences();
+        expect(selector).toEqual({
+            '1': {
+                id: 1,
+                label: 'Some label 1',
+                options: [],
+            },
+            '2': {
+                id: 2,
+                label: 'Some label 2',
+                options: [],
+            },
+        });
+    });
+    it('Returns sections references', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { sections: {
+                main: {
+                    '1': {
+                        id: 1,
+                        label: 'Some label 1',
+                        options: [],
+                    },
+                    '2': {
+                        id: 2,
+                        label: 'Some label 2',
+                        options: [],
+                    },
+                },
+            } })));
+        const selector = selectSectionReference(2);
+        expect(selector).toEqual({
+            id: 2,
+            label: 'Some label 2',
+            options: [],
+        });
+    });
+    it('Returns sections defaults', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { defaults: Object.assign(Object.assign({}, initialState.defaults), { '3': {
+                    '4': {
+                        isDefault: true,
+                        children: {
+                            '5': {
+                                isDefault: true,
+                                children: {},
+                            },
+                        },
+                    },
+                } }) })));
+        const selector = selectSectionDefaults(3);
+        expect(selector).toEqual({
+            '4': {
+                isDefault: true,
+                children: {
+                    '5': {
+                        isDefault: true,
+                        children: {},
+                    },
+                },
+            },
+        });
+    });
+    it('Returns option conditions object', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { conditions: {
+                options: {
+                    '4': {
+                        dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
+                        conditions: {
+                            selected: [{ var: 'o.1' }],
+                        },
+                    },
+                },
+                variables: {},
+                sections: {},
+                prefillers: {},
+                validators: {
+                    options: {},
+                    variables: {},
+                },
+                documents: {},
+            } })));
+        const selector = selectOptionConditionsObject(4);
+        expect(selector).toEqual({
+            dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
+            conditions: {
+                selected: [{ var: 'o.1' }],
+            },
+        });
+    });
+    it('Returns variable conditions object', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { conditions: {
+                options: {},
+                variables: {
+                    '2': {
+                        dataMap: { o: [], v: [1], c: { o: [], v: [], s: [] } },
+                        conditions: {
+                            selected: [{ var: 'v.1' }],
+                        },
+                    },
+                },
+                sections: {},
+                prefillers: {},
+                validators: {
+                    options: {},
+                    variables: {},
+                },
+                documents: {},
+            } })));
+        const selector = selectVariableConditionsObject(2);
+        expect(selector).toEqual({
+            dataMap: { o: [], v: [1], c: { o: [], v: [], s: [] } },
+            conditions: {
+                selected: [{ var: 'v.1' }],
+            },
+        });
+    });
+    it('Returns section conditions object', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { conditions: {
+                options: {},
+                variables: {},
+                sections: {
+                    main: {
+                        '10': {
+                            dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
+                            conditions: {
+                                selected: [{ var: 'o.1' }],
+                            },
+                        },
+                    },
+                },
+                documents: {},
+                prefillers: {},
+                validators: {
+                    options: {},
+                    variables: {},
+                },
+            } })));
+        const selector = selectSectionConditionsObject(10);
+        expect(selector).toEqual({
+            dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
+            conditions: {
+                selected: [{ var: 'o.1' }],
+            },
+        });
+    });
+    it('Returns prefiller conditions object', () => {
+        store.dispatch(initReferencesAction(Object.assign(Object.assign({}, initialState), { conditions: {
+                options: {},
+                variables: {},
+                sections: {},
+                prefillers: {
+                    '9': [
+                        {
+                            dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
+                            conditions: {
+                                selected: [{ var: 'o.4' }],
+                            },
+                        },
+                    ],
+                },
+                validators: {
+                    options: {},
+                    variables: {},
+                },
+                documents: {},
+            } })));
+        const selector = selectPrefillerConditionsObject(9);
+        expect(selector).toEqual([
+            {
+                dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
+                conditions: {
+                    selected: [{ var: 'o.4' }],
+                },
+            },
+        ]);
+    });
+});

package/dist/redux/selectors/selectors.d.ts

@@ -0,0 +1,8 @@
+import { Action, MiddlewareAPI, Dispatch } from 'redux';
+import { StateType } from '../../types/State.type';
+export declare type SelectorFunction = (state: StateType, ...args: any[]) => any;
+export declare type SelectorArguments<F extends SelectorFunction> = F extends (state: StateType, ...a: infer A) => any ? A : never;
+export declare type SelectorReturn<F extends SelectorFunction> = F extends (state: StateType, ...a: any[]) => infer R ? R : never;
+export declare type SelectorEqualityFn<T extends SelectorFunction> = (state: StateType, ...a: SelectorArguments<T>) => string | number;
+export declare function createSelector<T extends SelectorFunction, R = SelectorReturn<T>>(selector: T, equalityFn?: SelectorEqualityFn<T>): (...args: SelectorArguments<T>) => Readonly<R>;
+export declare const selectorsMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: Action) => Action<any>;

package/dist/redux/selectors/selectors.js

@@ -0,0 +1,29 @@
+let SelectorsStateTrack = -1;
+let globalMPI;
+export function createSelector(selector, equalityFn) {
+    const cache = {};
+    return (...args) => {
+        let state;
+        if (SelectorsStateTrack === -1)
+            throw new Error(`State hasn't beed initiated yet`);
+        try {
+            state = globalMPI.getState();
+        }
+        catch (e) {
+            throw new Error('You may not use selectors while the reducer is executing. (Try sagas or middlewares)');
+        }
+        const currentKey = typeof equalityFn === 'function'
+            ? equalityFn(state, ...args)
+            : [SelectorsStateTrack, ...args].reduce((v, c) => v + c);
+        if (!Object.prototype.hasOwnProperty.call(cache, currentKey)) {
+            cache[currentKey] = selector(state, ...args);
+        }
+        return cache[currentKey];
+    };
+}
+export const selectorsMiddleware = (mpi) => (next) => (action) => {
+    const result = next(action);
+    globalMPI = mpi;
+    SelectorsStateTrack += 1;
+    return result;
+};