@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/redux/reducers/inputs.test.js

@@ -0,0 +1,171 @@
+import { initOptionReducer } from './inputs/initOption';
+import { updateOptionInputReducer } from './inputs/updateOptionInput';
+import { inputsReducer } from './inputs';
+import { initVariableReducer } from './inputs/initVariable';
+import { updateVariableInputReducer } from './inputs/updateVariableInput';
+describe('Inputs Options Reducer', () => {
+    it('initOption Reducer', () => {
+        const reducer = initOptionReducer({
+            variables: {},
+            options: {},
+        }, {
+            type: 'INIT_OPTION',
+            id: 123,
+            values: [false],
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {},
+            options: {
+                123: [false],
+            },
+        });
+    });
+    it('updateOptionInput Reducer', () => {
+        const reducer = updateOptionInputReducer({
+            variables: {},
+            options: {
+                123: [false, false, false],
+            },
+        }, {
+            type: 'UPDATE_OPTION_INPUT',
+            id: 123,
+            value: true,
+            index: 1,
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {},
+            options: {
+                123: [false, true, false],
+            },
+        });
+    });
+    it('updateOptionInput Reducer (When values did not change)', () => {
+        const initial = {
+            variables: {},
+            options: {
+                123: [false, false, false],
+            },
+        };
+        const reducer = updateOptionInputReducer(initial, {
+            type: 'UPDATE_OPTION_INPUT',
+            id: 123,
+            value: false,
+            index: 1,
+        });
+        return expect(reducer === initial).toBeTruthy();
+    });
+    it('initVariable Reducer', () => {
+        const reducer = initVariableReducer({
+            variables: {},
+            options: {},
+        }, {
+            type: 'INIT_VARIABLE',
+            id: 123,
+            values: [''],
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {
+                123: [''],
+            },
+            options: {},
+        });
+    });
+    it('updateVariableInput Reducer', () => {
+        const reducer = updateVariableInputReducer({
+            variables: {
+                123: ['', '', ''],
+            },
+            options: {},
+        }, {
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 123,
+            value: 232,
+            index: 2,
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {
+                123: ['', '', 232],
+            },
+            options: {},
+        });
+    });
+    it('updateVariableInput Reducer (Value did not change', () => {
+        const initial = {
+            variables: {
+                123: ['', 'Hello', ''],
+            },
+            options: {},
+        };
+        const reducer = updateVariableInputReducer(initial, {
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 123,
+            value: 'Hello',
+            index: 1,
+        });
+        return expect(reducer === initial).toBeTruthy();
+    });
+    it('inputsReducer INIT_OPTION ACTION', () => {
+        const reducer = inputsReducer(undefined, {
+            type: 'INIT_OPTION',
+            id: 323,
+            values: [true],
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {},
+            options: {
+                323: [true],
+            },
+        });
+    });
+    it('inputsReducer UPDATE_OPTION_INPUT ACTION', () => {
+        const reducer = inputsReducer({
+            variables: {},
+            options: {
+                123: [false, false, false],
+            },
+        }, {
+            type: 'UPDATE_OPTION_INPUT',
+            id: 123,
+            value: true,
+            index: 1,
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {},
+            options: {
+                123: [false, true, false],
+            },
+        });
+    });
+    it('inputsVariablesReducer INIT_VARIABLE ACTION', () => {
+        const reducer = inputsReducer(undefined, {
+            type: 'INIT_VARIABLE',
+            id: 323,
+            values: [''],
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {
+                323: [''],
+            },
+            options: {},
+        });
+    });
+    it('inputsVariablesReducer UPDATE_VARIABLE_INPUT ACTION', () => {
+        const reducer = inputsReducer({
+            variables: {
+                323: ['', '', ''],
+            },
+            options: {},
+        }, {
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 323,
+            value: 'John',
+            index: 0,
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {
+                323: ['John', '', ''],
+            },
+            options: {},
+        });
+    });
+});

package/dist/redux/reducers/mandatories/addMultipleOccurency.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const addMultipleOccurencyReducer: (state: StateType.Mandatories, action: ActionsType.Inputs.addMultipleOccurency) => StateType.Mandatories;

package/dist/redux/reducers/mandatories/addMultipleOccurency.js

@@ -0,0 +1,23 @@
+export const addMultipleOccurencyReducer = (state, action) => {
+    const { id, optionRelations, optionsReferences } = action;
+    if (optionRelations === undefined || optionsReferences === undefined)
+        throw new Error('ADD_MULTIPLE_OCCURENCY reducer did not recieve complete data when adding ' +
+            `occurency for ${id}, please make sure "multiplesActions" middleware is ` +
+            'plugged and working properly');
+    const optionsIds = [id, ...optionRelations.children.options];
+    const variablesIds = optionRelations.children.variables;
+    const options = {};
+    optionsIds.forEach((currentOptionId) => {
+        if (Object.prototype.hasOwnProperty.call(state.options, currentOptionId))
+            options[currentOptionId] = [...state.options[currentOptionId], false];
+    });
+    const variables = {};
+    variablesIds.forEach((currentVariableId) => {
+        if (Object.prototype.hasOwnProperty.call(state.variables, currentVariableId))
+            variables[currentVariableId] = [
+                ...state.variables[currentVariableId],
+                false,
+            ];
+    });
+    return Object.assign(Object.assign({}, state), { variables: Object.assign(Object.assign({}, state.variables), variables), options: Object.assign(Object.assign({}, state.options), options) });
+};

package/dist/redux/reducers/mandatories/deleteMultipleOccurency.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const deleteMultipleOccurencyReducer: (state: StateType.Mandatories, action: ActionsType.Inputs.deleteMultipleOccurency) => StateType.Mandatories;

package/dist/redux/reducers/mandatories/deleteMultipleOccurency.js

@@ -0,0 +1,26 @@
+export const deleteMultipleOccurencyReducer = (state, action) => {
+    const { id, index, optionRelations } = action;
+    if (optionRelations === undefined)
+        throw new Error('DELETE_MULTIPLE_OCCURENCY reducer did not recieve complete data when removing ' +
+            `occurency for ${id}, please make sure "multiplesActions" middleware is ` +
+            'plugged and working properly');
+    const optionsIds = [id, ...optionRelations.children.options];
+    const variablesIds = optionRelations.children.variables;
+    const options = {};
+    optionsIds.forEach((currentOptionId) => {
+        if (Object.prototype.hasOwnProperty.call(state.options, currentOptionId))
+            options[currentOptionId] = [
+                ...state.options[currentOptionId].slice(0, index),
+                ...state.options[currentOptionId].slice(index + 1),
+            ];
+    });
+    const variables = {};
+    variablesIds.forEach((currentVariableId) => {
+        if (Object.prototype.hasOwnProperty.call(state.variables, currentVariableId))
+            variables[currentVariableId] = [
+                ...state.variables[currentVariableId].slice(0, index),
+                ...state.variables[currentVariableId].slice(index + 1),
+            ];
+    });
+    return Object.assign(Object.assign({}, state), { variables: Object.assign(Object.assign({}, state.variables), variables), options: Object.assign(Object.assign({}, state.options), options) });
+};

package/dist/redux/reducers/mandatories/initMandatoryOption.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const initMandatoryOptionReducer: (state: StateType.Mandatories, action: ActionsType.Mandatories.initMandatoryOption) => StateType.Mandatories;

package/dist/redux/reducers/mandatories/initMandatoryOption.js

@@ -0,0 +1,4 @@
+export const initMandatoryOptionReducer = (state, action) => {
+    const { id, value } = action;
+    return Object.assign(Object.assign({}, state), { options: Object.assign(Object.assign({}, state.options), { [id]: value }) });
+};

package/dist/redux/reducers/mandatories/initMandatoryVariable.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const initMandatoryVariableReducer: (state: StateType.Mandatories, action: ActionsType.Mandatories.initMandatoryVariable) => StateType.Mandatories;

package/dist/redux/reducers/mandatories/initMandatoryVariable.js

@@ -0,0 +1,4 @@
+export const initMandatoryVariableReducer = (state, action) => {
+    const { id, value } = action;
+    return Object.assign(Object.assign({}, state), { variables: Object.assign(Object.assign({}, state.variables), { [id]: value }) });
+};

package/dist/redux/reducers/mandatories/setMandatoryIgnore.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const setMandatoryIgnoreReducer: (state: StateType.Mandatories, action: ActionsType.Mandatories.setMandatoryIgnore) => StateType.Mandatories;

package/dist/redux/reducers/mandatories/setMandatoryIgnore.js

@@ -0,0 +1,6 @@
+export const setMandatoryIgnoreReducer = (state, action) => {
+    const { value } = action;
+    if (state.ignore === value)
+        return state;
+    return Object.assign(Object.assign({}, state), { ignore: value });
+};

package/dist/redux/reducers/mandatories/setMandatoryOption.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const setMandatoryOptionReducer: (state: StateType.Mandatories, action: ActionsType.Mandatories.setMandatoryOption) => StateType.Mandatories;

package/dist/redux/reducers/mandatories/setMandatoryOption.js

@@ -0,0 +1,10 @@
+export const setMandatoryOptionReducer = (state, action) => {
+    const { id, index, value } = action;
+    if (state.options[id] && state.options[id][index] === value)
+        return state;
+    return Object.assign(Object.assign({}, state), { options: Object.assign(Object.assign({}, state.options), { [id]: [
+                ...state.options[id].slice(0, index),
+                value,
+                ...state.options[id].slice(index + 1),
+            ] }) });
+};

package/dist/redux/reducers/mandatories/setMandatorySection.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const setMandatorySectionReducer: (state: StateType.Mandatories, action: ActionsType.Mandatories.setMandatorySection) => StateType.Mandatories;

package/dist/redux/reducers/mandatories/setMandatorySection.js

@@ -0,0 +1,6 @@
+export const setMandatorySectionReducer = (state, action) => {
+    const { id, value } = action;
+    if (state.sections[id] === value)
+        return state;
+    return Object.assign(Object.assign({}, state), { sections: Object.assign(Object.assign({}, state.sections), { [id]: value }) });
+};

package/dist/redux/reducers/mandatories/setMandatoryVariable.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const setMandatoryVariableReducer: (state: StateType.Mandatories, action: ActionsType.Mandatories.setMandatoryVariable) => StateType.Mandatories;

package/dist/redux/reducers/mandatories/setMandatoryVariable.js

@@ -0,0 +1,10 @@
+export const setMandatoryVariableReducer = (state, action) => {
+    const { id, index, value } = action;
+    if (state.variables[id] && state.variables[id][index] === value)
+        return state;
+    return Object.assign(Object.assign({}, state), { variables: Object.assign(Object.assign({}, state.variables), { [id]: [
+                ...state.variables[id].slice(0, index),
+                value,
+                ...state.variables[id].slice(index + 1),
+            ] }) });
+};

package/dist/redux/reducers/mandatories.d.ts

@@ -0,0 +1,3 @@
+import { StateType } from '../../types/State.type';
+import { MandatoriesActions } from '../../types/Actions.type';
+export declare const mandatoriesReducer: (state: StateType.Mandatories | undefined, action: MandatoriesActions) => StateType.Mandatories;

package/dist/redux/reducers/mandatories.js

@@ -0,0 +1,32 @@
+import { ADD_MULTIPLE_OCCURENCY, DELETE_MULTIPLE_OCCURENCY, } from '../constants/inputs';
+import { addMultipleOccurencyReducer } from './mandatories/addMultipleOccurency';
+import { deleteMultipleOccurencyReducer } from './mandatories/deleteMultipleOccurency';
+import { INIT_MANDATORY_OPTION, INIT_MANDATORY_VARIABLE, SET_MANDATORY_IGNORE, SET_MANDATORY_SECTION, SET_MANDATORY_OPTION, SET_MANDATORY_VARIABLE, } from '../constants/mandatories';
+import { initMandatoryOptionReducer } from './mandatories/initMandatoryOption';
+import { initMandatoryVariableReducer } from './mandatories/initMandatoryVariable';
+import { setMandatoryIgnoreReducer } from './mandatories/setMandatoryIgnore';
+import { setMandatorySectionReducer } from './mandatories/setMandatorySection';
+import { setMandatoryOptionReducer } from './mandatories/setMandatoryOption';
+import { setMandatoryVariableReducer } from './mandatories/setMandatoryVariable';
+const initialState = {
+    ignore: true,
+    sections: {},
+    options: {},
+    variables: {},
+};
+const reducersEnum = {
+    [ADD_MULTIPLE_OCCURENCY]: addMultipleOccurencyReducer,
+    [DELETE_MULTIPLE_OCCURENCY]: deleteMultipleOccurencyReducer,
+    [INIT_MANDATORY_OPTION]: initMandatoryOptionReducer,
+    [INIT_MANDATORY_VARIABLE]: initMandatoryVariableReducer,
+    [SET_MANDATORY_IGNORE]: setMandatoryIgnoreReducer,
+    [SET_MANDATORY_SECTION]: setMandatorySectionReducer,
+    [SET_MANDATORY_OPTION]: setMandatoryOptionReducer,
+    [SET_MANDATORY_VARIABLE]: setMandatoryVariableReducer,
+};
+export const mandatoriesReducer = (state = initialState, action) => {
+    const reducer = reducersEnum[action.type];
+    if (typeof reducer === 'function')
+        return reducer.apply(null, [state, action]);
+    return state;
+};

package/dist/redux/reducers/references/initReferences.d.ts

@@ -0,0 +1,3 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+export declare const initReferencesReducer: (state: StateType.References, action: ActionsType.References.initReferences) => StateType.References;

package/dist/redux/reducers/references/initReferences.js

@@ -0,0 +1,13 @@
+export const initReferencesReducer = (state, action) => {
+    const { options, variables, conditions, relations, sections, defaults, evaluations, outputs, boxes, documents, } = action;
+    return Object.assign(Object.assign({}, state), { options,
+        variables,
+        conditions,
+        relations,
+        sections,
+        defaults,
+        evaluations,
+        outputs,
+        boxes,
+        documents });
+};

package/dist/redux/reducers/references/updateOptionMeta.d.ts

@@ -0,0 +1,3 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+export declare const updateOptionMetaReducer: (state: StateType.References, action: ActionsType.References.updateOptionMeta) => StateType.References;

package/dist/redux/reducers/references/updateOptionMeta.js

@@ -0,0 +1,27 @@
+export const updateOptionMetaReducer = (state, action) => {
+    var _a, _b;
+    const { id, meta } = action;
+    let boxes = Object.assign({}, state.boxes);
+    if (((_a = state.options[id]) === null || _a === void 0 ? void 0 : _a.meta.type) === 'box') {
+        const raw = ((_b = meta.box) === null || _b === void 0 ? void 0 : _b.content) || '';
+        let variables = [];
+        if (raw.trim().length > 0) {
+            const tagsMatch = raw.match(/\[var:([0-9]+)\]/gi);
+            if (tagsMatch !== null) {
+                const variablesTags = [...tagsMatch];
+                variables = variablesTags.map((current) => {
+                    const boxVariableMatch = current.match(/([0-9]+)/);
+                    if (boxVariableMatch === null)
+                        return 0;
+                    return parseInt(boxVariableMatch[0], 10);
+                });
+            }
+            variables = variables.filter((c, i) => variables.indexOf(c) === i);
+        }
+        boxes = Object.assign(Object.assign({}, boxes), { [id]: {
+                raw,
+                variables,
+            } });
+    }
+    return Object.assign(Object.assign({}, state), { boxes, options: Object.assign(Object.assign({}, state.options), { [id]: Object.assign(Object.assign({}, state.options[id]), { meta: Object.assign(Object.assign(Object.assign({}, state.options[id].meta), meta), { validator: Object.assign(Object.assign({}, state.options[id].meta.validator), meta.validator), multiple: Object.assign(Object.assign({}, state.options[id].meta.multiple), meta.multiple) }) }) }) });
+};

package/dist/redux/reducers/references/updateVariableMeta.d.ts

@@ -0,0 +1,3 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+export declare const updateVariableMetaReducer: (state: StateType.References, action: ActionsType.References.updateVariableMeta) => StateType.References;

package/dist/redux/reducers/references/updateVariableMeta.js

@@ -0,0 +1,33 @@
+export const updateVariableMetaReducer = (state, action) => {
+    var _a, _b;
+    const { id, meta } = action;
+    const evaluations = Object.assign({}, state.evaluations);
+    if (((_a = state.variables[id]) === null || _a === void 0 ? void 0 : _a.type) === 'eval') {
+        const formula = ((_b = meta.eval) === null || _b === void 0 ? void 0 : _b.formula) || '';
+        let variables = [];
+        if (formula.trim().length > 0) {
+            const tagsMatch = formula.match(/\[var:([0-9]+)\]/gi);
+            if (tagsMatch !== null) {
+                const variablesTags = [...tagsMatch];
+                variables = variablesTags.map((current) => {
+                    const boxVariableMatch = current.match(/([0-9]+)/);
+                    if (boxVariableMatch === null)
+                        return 0;
+                    return parseInt(boxVariableMatch[0], 10);
+                });
+            }
+            variables = variables.filter((c, i) => variables.indexOf(c) === i);
+        }
+        Object.keys(evaluations).forEach((hookedVariableId) => {
+            if (evaluations[hookedVariableId].includes(id)) {
+                evaluations[hookedVariableId].splice(evaluations[hookedVariableId].indexOf(id), 1);
+            }
+        });
+        variables.forEach((newHookVariableId) => {
+            if (!Array.isArray(evaluations[newHookVariableId]))
+                evaluations[newHookVariableId] = [];
+            evaluations[newHookVariableId].push(id);
+        });
+    }
+    return Object.assign(Object.assign({}, state), { evaluations, variables: Object.assign(Object.assign({}, state.variables), { [id]: Object.assign(Object.assign({}, state.variables[id]), meta) }) });
+};

package/dist/redux/reducers/references.d.ts

@@ -0,0 +1,3 @@
+import { StateType } from '../../types/State.type';
+import { ReferencesActions } from '../../types/Actions.type';
+export declare const referencesReducer: (state: StateType.References | undefined, action: ReferencesActions) => StateType.References;

package/dist/redux/reducers/references.js

@@ -0,0 +1,41 @@
+import { initReferencesReducer } from './references/initReferences';
+import { updateOptionMetaReducer } from './references/updateOptionMeta';
+import { updateVariableMetaReducer } from './references/updateVariableMeta';
+import { INIT_REFERENCES, UPDATE_OPTION_META, UPDATE_VARIABLE_META, } from '../constants/references';
+const initialState = {
+    options: {},
+    variables: {},
+    outputs: {},
+    boxes: {},
+    relations: {
+        options: {},
+        variables: {},
+        sections: {},
+    },
+    conditions: {
+        options: {},
+        variables: {},
+        prefillers: {},
+        validators: {
+            options: {},
+            variables: {},
+        },
+        sections: {},
+        documents: {},
+    },
+    documents: {},
+    sections: {},
+    defaults: {},
+    evaluations: {},
+};
+const reducersEnum = {
+    [INIT_REFERENCES]: initReferencesReducer,
+    [UPDATE_OPTION_META]: updateOptionMetaReducer,
+    [UPDATE_VARIABLE_META]: updateVariableMetaReducer,
+};
+export const referencesReducer = (state = initialState, action) => {
+    const reducer = reducersEnum[action.type];
+    if (typeof reducer === 'function')
+        return reducer.apply(null, [state, action]);
+    return state;
+};

package/dist/redux/reducers/smartscript/enableSmartScript.d.ts

@@ -0,0 +1,2 @@
+import { StateType } from '../../../types/State.type';
+export declare const enableSmartScriptReducer: (state: StateType.SmartScript) => StateType.SmartScript;

package/dist/redux/reducers/smartscript/enableSmartScript.js

@@ -0,0 +1,5 @@
+export const enableSmartScriptReducer = (state) => {
+    if (state.enabled === true)
+        return state;
+    return Object.assign(Object.assign({}, state), { enabled: true });
+};

package/dist/redux/reducers/smartscript/initSmartScriptTriggers.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const initSmartscriptTriggersReducer: (state: StateType.SmartScript, action: ActionsType.SmartScript.initSmartscriptTriggers) => StateType.SmartScript;

package/dist/redux/reducers/smartscript/initSmartScriptTriggers.js

@@ -0,0 +1,4 @@
+export const initSmartscriptTriggersReducer = (state, action) => {
+    const { triggers } = action;
+    return Object.assign(Object.assign({}, state), { triggers });
+};

package/dist/redux/reducers/smartscript/updateSmartscriptOptionHidden.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const updateSmartscriptOptionHiddenReducer: (state: StateType.SmartScript, action: ActionsType.SmartScript.updateSmartscriptOptionHidden) => StateType.SmartScript;

package/dist/redux/reducers/smartscript/updateSmartscriptOptionHidden.js

@@ -0,0 +1,13 @@
+export const updateSmartscriptOptionHiddenReducer = (state, action) => {
+    const { id, index, hide } = action;
+    const hiddenIndexes = Array.isArray(state.hidden.options[id])
+        ? [...state.hidden.options[id]]
+        : [];
+    if (hide === false && hiddenIndexes.includes(index)) {
+        hiddenIndexes.splice(hiddenIndexes.indexOf(index), 1);
+    }
+    else if (hide === true && !hiddenIndexes.includes(index)) {
+        hiddenIndexes.push(index);
+    }
+    return Object.assign(Object.assign({}, state), { hidden: Object.assign(Object.assign({}, state.hidden), { options: Object.assign(Object.assign({}, state.hidden.options), { [id]: hiddenIndexes }) }) });
+};

package/dist/redux/reducers/smartscript/updateSmartscriptVariableHidden.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const updateSmartscriptVariableHiddenReducer: (state: StateType.SmartScript, action: ActionsType.SmartScript.updateSmartscriptVariableHidden) => StateType.SmartScript;

package/dist/redux/reducers/smartscript/updateSmartscriptVariableHidden.js

@@ -0,0 +1,13 @@
+export const updateSmartscriptVariableHiddenReducer = (state, action) => {
+    const { id, index, hide } = action;
+    const hiddenIndexes = Array.isArray(state.hidden.variables[id])
+        ? [...state.hidden.variables[id]]
+        : [];
+    if (hide === false && hiddenIndexes.includes(index)) {
+        hiddenIndexes.splice(hiddenIndexes.indexOf(index), 1);
+    }
+    else if (hide === true && !hiddenIndexes.includes(index)) {
+        hiddenIndexes.push(index);
+    }
+    return Object.assign(Object.assign({}, state), { hidden: Object.assign(Object.assign({}, state.hidden), { variables: Object.assign(Object.assign({}, state.hidden.variables), { [id]: hiddenIndexes }) }) });
+};

package/dist/redux/reducers/smartscript.d.ts

@@ -0,0 +1,3 @@
+import { StateType } from '../../types/State.type';
+import { SmartScriptActions } from '../../types/Actions.type';
+export declare const smartscriptReducer: (state: StateType.SmartScript | undefined, action: SmartScriptActions) => StateType.SmartScript;

package/dist/redux/reducers/smartscript.js

@@ -0,0 +1,28 @@
+import { ENABLE_SMARTSCRIPT, INIT_SMARTSCRIPT_TRIGGERS, UPDATE_SMARTSCRIPT_OPTION_HIDDEN, UPDATE_SMARTSCRIPT_VARIABLE_HIDDEN, } from '../constants/smartscript';
+import { enableSmartScriptReducer } from './smartscript/enableSmartScript';
+import { initSmartscriptTriggersReducer } from './smartscript/initSmartScriptTriggers';
+import { updateSmartscriptOptionHiddenReducer } from './smartscript/updateSmartscriptOptionHidden';
+import { updateSmartscriptVariableHiddenReducer } from './smartscript/updateSmartscriptVariableHidden';
+const initialState = {
+    enabled: false,
+    triggers: {
+        options: [],
+        variables: [],
+    },
+    hidden: {
+        options: {},
+        variables: {},
+    },
+};
+const reducersEnum = {
+    [ENABLE_SMARTSCRIPT]: enableSmartScriptReducer,
+    [INIT_SMARTSCRIPT_TRIGGERS]: initSmartscriptTriggersReducer,
+    [UPDATE_SMARTSCRIPT_OPTION_HIDDEN]: updateSmartscriptOptionHiddenReducer,
+    [UPDATE_SMARTSCRIPT_VARIABLE_HIDDEN]: updateSmartscriptVariableHiddenReducer,
+};
+export const smartscriptReducer = (state = initialState, action) => {
+    const reducer = reducersEnum[action.type];
+    if (typeof reducer === 'function')
+        return reducer.apply(null, [state, action]);
+    return state;
+};

package/dist/redux/reducers/user/initUser.d.ts

@@ -0,0 +1,3 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+export declare const initUserReducer: (state: StateType.User, action: ActionsType.User.initUser) => StateType.User;

package/dist/redux/reducers/user/initUser.js

@@ -0,0 +1,6 @@
+export const initUserReducer = (state, action) => {
+    const { email, displayName, level } = action;
+    return Object.assign(Object.assign({}, state), { email,
+        displayName,
+        level });
+};

package/dist/redux/reducers/user/setUserStatus.d.ts

@@ -0,0 +1,3 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+export declare const setUserStatusReducer: (state: StateType.User, action: ActionsType.User.setUserStatus) => StateType.User;

package/dist/redux/reducers/user/setUserStatus.js

@@ -0,0 +1,4 @@
+export const setUserStatusReducer = (state, action) => {
+    const { status } = action;
+    return Object.assign(Object.assign({}, state), { status });
+};

package/dist/redux/reducers/user/setUserValidToken.d.ts

@@ -0,0 +1,3 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+export declare const setUserValidTokenReducer: (state: StateType.User, action: ActionsType.User.setUserValidToken) => StateType.User;

package/dist/redux/reducers/user/setUserValidToken.js

@@ -0,0 +1,4 @@
+export const setUserValidTokenReducer = (state, action) => {
+    const { validToken } = action;
+    return Object.assign(Object.assign({}, state), { validToken });
+};

package/dist/redux/reducers/user.d.ts

@@ -0,0 +1,3 @@
+import { UserActions } from '../../types/Actions.type';
+import { StateType } from '../../types/State.type';
+export declare const userReducer: (state: StateType.User | undefined, action: UserActions) => StateType.User;