@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/polyfills/objectValues.d.ts

@@ -0,0 +1,2 @@
+declare const _default: true;
+export default _default;

package/dist/polyfills/objectValues.js

@@ -0,0 +1,5 @@
+const objectToValuesPolyfill = (object) => {
+    return Object.keys(object).map((key) => object[key]);
+};
+Object.values = Object.values || objectToValuesPolyfill;
+export default true;

package/dist/polyfills/prepend.d.ts

@@ -0,0 +1,2 @@
+declare const _default: true;
+export default _default;

package/dist/polyfills/prepend.js

@@ -0,0 +1,22 @@
+(function (arr) {
+    arr.forEach(function (item) {
+        if (item.hasOwnProperty('prepend')) {
+            return;
+        }
+        Object.defineProperty(item, 'prepend', {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: function prepend() {
+                const argArr = Array.prototype.slice.call(arguments);
+                const docFrag = document.createDocumentFragment();
+                argArr.forEach(function (argItem) {
+                    const isNode = argItem instanceof Node;
+                    docFrag.appendChild(isNode ? argItem : document.createTextNode(String(argItem)));
+                });
+                this.insertBefore(docFrag, this.firstChild);
+            },
+        });
+    });
+})([Element.prototype, Document.prototype, DocumentFragment.prototype]);
+export default true;

package/dist/polyfills/stringRepeat.d.ts

@@ -0,0 +1,2 @@
+declare const _default: true;
+export default _default;

package/dist/polyfills/stringRepeat.js

@@ -0,0 +1,28 @@
+if (!String.prototype.repeat) {
+    String.prototype.repeat = function (count) {
+        if (this === null)
+            throw new TypeError(`can't convert ${this} to object`);
+        let str = `${this}`;
+        count = +count;
+        if (isNaN(count))
+            count = 0;
+        if (count < 0)
+            throw new RangeError('repeat count must be non-negative');
+        if (count === Infinity)
+            throw new RangeError('repeat count must be less than infinity');
+        count = Math.floor(count);
+        if (str.length === 0 || count === 0)
+            return '';
+        if (str.length * count >= 1 << 28)
+            throw new RangeError('repeat count must not overflow maximum string size');
+        const maxCount = str.length * count;
+        count = Math.floor(Math.log(count) / Math.log(2));
+        while (count) {
+            str += str;
+            count--;
+        }
+        str += str.substring(0, maxCount - str.length);
+        return str;
+    };
+}
+export default true;

package/dist/redux/actions/app.d.ts

@@ -0,0 +1,26 @@
+import type { ModelV3 } from '@legalplace/models-v3-types';
+import { StateType } from '../../types/State.type';
+import { ActionsType } from '../../types/Actions.type';
+export declare const initMetaAction: (meta: Omit<StateType.App.Meta, 'fetchStatus'>) => ActionsType.App.initMeta;
+export declare const setModelUuidAction: (modelUuid: StateType.App.Meta['modelUuid']) => ActionsType.App.setModelUuid;
+export declare const fetchModelSucceededAction: () => ActionsType.App.fetchModelSucceeded;
+export declare const fetchModelNonBlockingAction: () => ActionsType.App.fetchModelNonBlocking;
+export declare const fetchModelUnhealthyAction: (report: StateType.App.Meta['report']) => ActionsType.App.fetchModelUnhealthy;
+export declare const fetchModelUserLockedAction: () => ActionsType.App.fetchModelUserLocked;
+export declare const fetchModelFailedAction: () => ActionsType.App.fetchModelFailed;
+export declare const setDataStatus: (dataStatus: 'saved' | 'unsaved' | 'saving' | 'failed') => ActionsType.App.setDataStatus;
+export declare const setFetchStatus: (fetchStatus: 'waiting' | 'succeeded' | 'failed' | 'unhealthy' | 'userLocked') => ActionsType.App.setFetchStatus;
+export declare const initInstanceAction: (instance: StateType.App.Instance) => ActionsType.App.initInstance;
+export declare const updateInstanceAction: (instance: Partial<StateType.App.Instance>) => ActionsType.App.updateInstance;
+export declare const updateInstancePaidAction: (isPaid: boolean) => ActionsType.App.updateInstancePaid;
+export declare type initPaginationActionPropsType = Omit<ActionsType.App.initPagination, 'type'>;
+export declare const initPaginationAction: (pagination: initPaginationActionPropsType) => ActionsType.App.initPagination;
+export declare const updateAvailableAppStatesAction: (availableAppStates: StateType.App.Pagination['availableAppStates'], ingorePluginAppStateReset?: boolean) => ActionsType.App.updateAvailableAppStates;
+export declare const goPageAction: (page: number, pushHistory?: boolean) => ActionsType.App.goPage;
+export declare const goNextPageAction: () => ActionsType.App.goNextPage;
+export declare const goPreviousPageAction: () => ActionsType.App.goPreviousPage;
+export declare const updateCurrentAppStateAction: (currentAppState: string) => ActionsType.App.updateCurrentAppState;
+export declare const updateAvailableSectionsAction: (availableSections: number[]) => ActionsType.App.updateAvailableSections;
+export declare const updateCurrentSectionIdAction: (currentSectionId: number) => ActionsType.App.updateCurrentSectionId;
+export declare const initCustomizationMetaAction: (meta: Exclude<ModelV3['customization']['meta'], undefined>) => ActionsType.App.initCustomizationMeta;
+export declare const initCustomizationAutoDefaultAction: (disableAutoDefault: StateType.App.Customization['disableAutoDefault']) => ActionsType.App.initCustomizationAutoDefault;

package/dist/redux/actions/app.js

@@ -0,0 +1,73 @@
+import { INIT_META, INIT_INSTANCE, UPDATE_INSTANCE_PAID, INIT_PAGINATION, GO_PAGE, GO_NEXT_PAGE, GO_PREVIOUS_PAGE, UPDATE_AVAILABLE_SECTIONS, UPDATE_CURRENT_APPSTATE, UPDATE_CURRENT_SECTION_ID, FETCH_MODEL_SUCCEEDED, FETCH_MODEL_FAILED, SET_DATA_STATUS, UPDATE_AVAILABLE_APPSTATES, INIT_CUSTOMIZATION_META, FETCH_MODEL_UNHEALTHY, FETCH_MODEL_USER_LOCKED, INIT_CUSTOMIZATION_AUTO_DEFAULT, UPDATE_INSTANCE, SET_FETCH_STATUS, FETCH_MODEL_NONBLOCKING, SET_MODEL_UUID, } from '../constants/app';
+export const initMetaAction = (meta) => (Object.assign({ type: INIT_META }, meta));
+export const setModelUuidAction = (modelUuid) => ({
+    type: SET_MODEL_UUID,
+    modelUuid,
+});
+export const fetchModelSucceededAction = () => ({
+    type: FETCH_MODEL_SUCCEEDED,
+});
+export const fetchModelNonBlockingAction = () => ({
+    type: FETCH_MODEL_NONBLOCKING,
+});
+export const fetchModelUnhealthyAction = (report) => ({
+    type: FETCH_MODEL_UNHEALTHY,
+    report,
+});
+export const fetchModelUserLockedAction = () => ({
+    type: FETCH_MODEL_USER_LOCKED,
+});
+export const fetchModelFailedAction = () => ({
+    type: FETCH_MODEL_FAILED,
+});
+export const setDataStatus = (dataStatus) => ({
+    type: SET_DATA_STATUS,
+    dataStatus,
+});
+export const setFetchStatus = (fetchStatus) => ({
+    type: SET_FETCH_STATUS,
+    fetchStatus,
+});
+export const initInstanceAction = (instance) => (Object.assign({ type: INIT_INSTANCE }, instance));
+export const updateInstanceAction = (instance) => (Object.assign({ type: UPDATE_INSTANCE }, instance));
+export const updateInstancePaidAction = (isPaid) => ({
+    type: UPDATE_INSTANCE_PAID,
+    isPaid,
+});
+export const initPaginationAction = (pagination) => (Object.assign({ type: INIT_PAGINATION }, pagination));
+export const updateAvailableAppStatesAction = (availableAppStates, ingorePluginAppStateReset = false) => ({
+    type: UPDATE_AVAILABLE_APPSTATES,
+    availableAppStates,
+    ingorePluginAppStateReset,
+});
+export const goPageAction = (page, pushHistory = true) => ({
+    type: GO_PAGE,
+    currentPage: page,
+    pushHistory,
+});
+export const goNextPageAction = () => ({
+    type: GO_NEXT_PAGE,
+});
+export const goPreviousPageAction = () => ({
+    type: GO_PREVIOUS_PAGE,
+});
+export const updateCurrentAppStateAction = (currentAppState) => ({
+    type: UPDATE_CURRENT_APPSTATE,
+    currentAppState,
+});
+export const updateAvailableSectionsAction = (availableSections) => ({
+    type: UPDATE_AVAILABLE_SECTIONS,
+    availableSections,
+});
+export const updateCurrentSectionIdAction = (currentSectionId) => ({
+    type: UPDATE_CURRENT_SECTION_ID,
+    currentSectionId,
+});
+export const initCustomizationMetaAction = (meta) => ({
+    type: INIT_CUSTOMIZATION_META,
+    meta,
+});
+export const initCustomizationAutoDefaultAction = (disableAutoDefault) => ({
+    type: INIT_CUSTOMIZATION_AUTO_DEFAULT,
+    disableAutoDefault,
+});

package/dist/redux/actions/app.test.d.ts

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

package/dist/redux/actions/app.test.js

@@ -0,0 +1,90 @@
+import { initMetaAction, initInstanceAction, updateInstancePaidAction, initPaginationAction, goPageAction, goNextPageAction, goPreviousPageAction, updateAvailableSectionsAction, } from './app';
+describe('App actions test suit', () => {
+    it('initMeta Action', () => {
+        const action = initMetaAction({
+            id: 123,
+            prefix: '',
+            permalink: 'document-permalink',
+            title: 'Title',
+            modelVersion: 1,
+            productType: 'demarche',
+        });
+        return expect(action).toStrictEqual({
+            type: 'INIT_META',
+            id: 123,
+            prefix: '',
+            permalink: 'document-permalink',
+            title: 'Title',
+            modelVersion: 1,
+            productType: 'demarche',
+        });
+    });
+    it('initInstance Action', () => {
+        const action = initInstanceAction({
+            dataStatus: 'saved',
+            uniqid: 'ubsd989ded3',
+            isPaid: false,
+            steps: '*',
+        });
+        return expect(action).toStrictEqual({
+            type: 'INIT_INSTANCE',
+            dataStatus: 'saved',
+            uniqid: 'ubsd989ded3',
+            isPaid: false,
+            steps: '*',
+        });
+    });
+    it('updateInstancePaid Action', () => {
+        const action = updateInstancePaidAction(true);
+        return expect(action).toStrictEqual({
+            type: 'UPDATE_INSTANCE_PAID',
+            isPaid: true,
+        });
+    });
+    it('initPagination Action', () => {
+        const action = initPaginationAction({
+            currentSectionId: 1,
+            currentPage: 1,
+            greatestPage: 1,
+            availableSections: [1, 2, 3],
+            availableAppStates: ['wizard'],
+            currentAppState: 'wizard',
+        });
+        return expect(action).toStrictEqual({
+            type: 'INIT_PAGINATION',
+            currentSectionId: 1,
+            currentPage: 1,
+            greatestPage: 1,
+            availableSections: [1, 2, 3],
+            availableAppStates: ['wizard'],
+            currentAppState: 'wizard',
+        });
+    });
+    it('goPage Action', () => {
+        const action = goPageAction(9);
+        return expect(action).toStrictEqual({
+            type: 'GO_PAGE',
+            currentPage: 9,
+            pushHistory: true,
+        });
+    });
+    it('goNextPage Action', () => {
+        const action = goNextPageAction();
+        return expect(action).toStrictEqual({
+            type: 'GO_NEXT_PAGE',
+        });
+    });
+    it('goPreviousPage Action', () => {
+        const action = goPreviousPageAction();
+        return expect(action).toStrictEqual({
+            type: 'GO_PREVIOUS_PAGE',
+        });
+    });
+    it('updateAvailableSections Action', () => {
+        const action = updateAvailableSectionsAction([1, 2, 3]);
+        return expect(action).toStrictEqual({
+            type: 'UPDATE_AVAILABLE_SECTIONS',
+            availableSections: [1, 2, 3],
+        });
+    });
+});

package/dist/redux/actions/conditions.d.ts

@@ -0,0 +1,10 @@
+import { ActionsType } from '../../types/Actions.type';
+import { StateType } from '../../types/State.type';
+export declare const initConditionsAction: (conditions: StateType.Conditions) => ActionsType.Conditions.initConditions;
+export declare const updateOptionConditionsAction: (id: number, index: number, value: boolean) => ActionsType.Conditions.updateOptionCondition;
+export declare const updateVariableConditionsAction: (id: number, index: number, value: boolean) => ActionsType.Conditions.updateVariableCondition;
+export declare const updateDocumentConditionsAction: (name: string, index: number, value: boolean) => ActionsType.Conditions.updateDocumentCondition;
+export declare const updateSectionConditionsAction: (id: number, document: string, value: boolean) => ActionsType.Conditions.updateSectionCondition;
+export declare const updatePrefillersConditionsAction: (id: number, index: number, value: boolean[]) => ActionsType.Conditions.updatePrefillerCondition;
+export declare const updateOptionValidatorConditionsAction: (id: number, index: number, value: boolean) => ActionsType.Conditions.updateOptionValidatorCondition;
+export declare const updateVariableValidatorConditionsAction: (id: number, index: number, value: boolean) => ActionsType.Conditions.updateVariableValidatorCondition;

package/dist/redux/actions/conditions.js

@@ -0,0 +1,43 @@
+import { UPDATE_OPTION_CONDITION, INIT_CONDITIONS, UPDATE_VARIABLE_CONDITION, UPDATE_SECTION_CONDITION, UPDATE_PREFILLER_CONDITION, UPDATE_OPTION_VALIDATOR_CONDITION, UPDATE_VARIABLE_VALIDATOR_CONDITION, UPDATE_DOCUMENT_CONDITION, } from '../constants/conditions';
+export const initConditionsAction = (conditions) => (Object.assign({ type: INIT_CONDITIONS }, conditions));
+export const updateOptionConditionsAction = (id, index, value) => ({
+    type: UPDATE_OPTION_CONDITION,
+    id,
+    index,
+    value,
+});
+export const updateVariableConditionsAction = (id, index, value) => ({
+    type: UPDATE_VARIABLE_CONDITION,
+    id,
+    index,
+    value,
+});
+export const updateDocumentConditionsAction = (name, index, value) => ({
+    type: UPDATE_DOCUMENT_CONDITION,
+    name,
+    value,
+});
+export const updateSectionConditionsAction = (id, document, value) => ({
+    type: UPDATE_SECTION_CONDITION,
+    document,
+    id,
+    value,
+});
+export const updatePrefillersConditionsAction = (id, index, value) => ({
+    type: UPDATE_PREFILLER_CONDITION,
+    id,
+    index,
+    value,
+});
+export const updateOptionValidatorConditionsAction = (id, index, value) => ({
+    type: UPDATE_OPTION_VALIDATOR_CONDITION,
+    id,
+    index,
+    value,
+});
+export const updateVariableValidatorConditionsAction = (id, index, value) => ({
+    type: UPDATE_VARIABLE_VALIDATOR_CONDITION,
+    id,
+    index,
+    value,
+});

package/dist/redux/actions/conditions.test.d.ts

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

package/dist/redux/actions/conditions.test.js

@@ -0,0 +1,68 @@
+import { initConditionsAction, updateOptionConditionsAction, updateVariableConditionsAction, updateSectionConditionsAction, updatePrefillersConditionsAction, } from './conditions';
+describe('Conditions actions test suit', () => {
+    it('initConditions Action', () => {
+        const action = initConditionsAction({
+            options: {},
+            variables: {},
+            prefillers: {},
+            validators: {
+                options: {},
+                variables: {},
+            },
+            sections: {
+                main: {},
+            },
+            documents: {},
+        });
+        expect(action).toEqual({
+            type: 'INIT_CONDITIONS',
+            options: {},
+            variables: {},
+            prefillers: {},
+            validators: {
+                options: {},
+                variables: {},
+            },
+            sections: {
+                main: {},
+            },
+            documents: {},
+        });
+    });
+    it('updateOptionConditions Action', () => {
+        const action = updateOptionConditionsAction(1, 0, true);
+        expect(action).toEqual({
+            type: 'UPDATE_OPTION_CONDITION',
+            id: 1,
+            index: 0,
+            value: true,
+        });
+    });
+    it('updateVariableConditions Action', () => {
+        const action = updateVariableConditionsAction(1, 0, true);
+        expect(action).toEqual({
+            type: 'UPDATE_VARIABLE_CONDITION',
+            id: 1,
+            index: 0,
+            value: true,
+        });
+    });
+    it('updateSectionConditions Action', () => {
+        const action = updateSectionConditionsAction(1, 'main', true);
+        expect(action).toEqual({
+            type: 'UPDATE_SECTION_CONDITION',
+            id: 1,
+            document: 'main',
+            value: true,
+        });
+    });
+    it('updatePrefillersConditions Action', () => {
+        const action = updatePrefillersConditionsAction(1, 0, [true]);
+        expect(action).toEqual({
+            type: 'UPDATE_PREFILLER_CONDITION',
+            id: 1,
+            index: 0,
+            value: [true],
+        });
+    });
+});

package/dist/redux/actions/index.d.ts

@@ -0,0 +1,8 @@
+export * from './app';
+export * from './conditions';
+export * from './inputs';
+export * from './mandatories';
+export * from './references';
+export * from './smartscript';
+export * from './user';
+export * from './sagas';

package/dist/redux/actions/index.js

@@ -0,0 +1,8 @@
+export * from './app';
+export * from './conditions';
+export * from './inputs';
+export * from './mandatories';
+export * from './references';
+export * from './smartscript';
+export * from './user';
+export * from './sagas';

package/dist/redux/actions/inputs.d.ts

@@ -0,0 +1,7 @@
+import { ActionsType } from '../../types/Actions.type';
+export declare const initOptionAction: (id: number, values: boolean[]) => ActionsType.Inputs.initOption;
+export declare const updateOptionAction: (id: number, value: boolean, index: number) => ActionsType.Inputs.updateOptionInput;
+export declare const initVariableAction: (id: number, values: (string | number)[]) => ActionsType.Inputs.initVariable;
+export declare const updateVariableAction: (id: number, value: string | number, index: number) => ActionsType.Inputs.updateVariableInput;
+export declare const addMultipleOccurencyAction: (id: number) => ActionsType.Inputs.addMultipleOccurency;
+export declare const deleteMultipleOccurencyAction: (id: number, index: number) => ActionsType.Inputs.deleteMultipleOccurency;

package/dist/redux/actions/inputs.js

@@ -0,0 +1,32 @@
+import { INIT_OPTION, INIT_VARIABLE, UPDATE_OPTION_INPUT, UPDATE_VARIABLE_INPUT, ADD_MULTIPLE_OCCURENCY, DELETE_MULTIPLE_OCCURENCY, } from '../constants/inputs';
+export const initOptionAction = (id, values) => ({
+    type: INIT_OPTION,
+    id,
+    values,
+});
+export const updateOptionAction = (id, value, index) => ({
+    type: UPDATE_OPTION_INPUT,
+    id,
+    value,
+    index,
+});
+export const initVariableAction = (id, values) => ({
+    type: INIT_VARIABLE,
+    id,
+    values,
+});
+export const updateVariableAction = (id, value, index) => ({
+    type: UPDATE_VARIABLE_INPUT,
+    id,
+    value,
+    index,
+});
+export const addMultipleOccurencyAction = (id) => ({
+    type: ADD_MULTIPLE_OCCURENCY,
+    id,
+});
+export const deleteMultipleOccurencyAction = (id, index) => ({
+    type: DELETE_MULTIPLE_OCCURENCY,
+    id,
+    index,
+});

package/dist/redux/actions/inputs.test.d.ts

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

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

@@ -0,0 +1,53 @@
+import { initOptionAction, initVariableAction, updateOptionAction, updateVariableAction, addMultipleOccurencyAction, deleteMultipleOccurencyAction, } from './inputs';
+import { UPDATE_OPTION_INPUT, INIT_VARIABLE, INIT_OPTION, UPDATE_VARIABLE_INPUT, ADD_MULTIPLE_OCCURENCY, DELETE_MULTIPLE_OCCURENCY, } from '../constants/inputs';
+describe('Inputs actions test suit', () => {
+    it('initOption Action', () => {
+        const action = initOptionAction(123, [true]);
+        return expect(action).toStrictEqual({
+            type: INIT_OPTION,
+            id: 123,
+            values: [true],
+        });
+    });
+    it('initVariable Action', () => {
+        const action = initVariableAction(123, ['']);
+        return expect(action).toStrictEqual({
+            type: INIT_VARIABLE,
+            id: 123,
+            values: [''],
+        });
+    });
+    it('updateOption Action', () => {
+        const action = updateOptionAction(123, true, 3);
+        return expect(action).toStrictEqual({
+            type: UPDATE_OPTION_INPUT,
+            id: 123,
+            value: true,
+            index: 3,
+        });
+    });
+    it('updateVariable Action', () => {
+        const action = updateVariableAction(123, 'Hello', 1);
+        return expect(action).toStrictEqual({
+            type: UPDATE_VARIABLE_INPUT,
+            id: 123,
+            value: 'Hello',
+            index: 1,
+        });
+    });
+    it('addMultipleOccurency Action', () => {
+        const action = addMultipleOccurencyAction(123);
+        return expect(action).toStrictEqual({
+            type: ADD_MULTIPLE_OCCURENCY,
+            id: 123,
+        });
+    });
+    it('deleteMultipleOccurency Action', () => {
+        const action = deleteMultipleOccurencyAction(123, 1);
+        return expect(action).toStrictEqual({
+            type: DELETE_MULTIPLE_OCCURENCY,
+            id: 123,
+            index: 1,
+        });
+    });
+});

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

@@ -0,0 +1,7 @@
+import { ActionsType } from '../../types/Actions.type';
+export declare const initMandatoryOptionAction: (id: number, value: boolean[]) => ActionsType.Mandatories.initMandatoryOption;
+export declare const initMandatoryVariableAction: (id: number, value: boolean[]) => ActionsType.Mandatories.initMandatoryVariable;
+export declare const setMandatoryIgnoreAction: (value: boolean) => ActionsType.Mandatories.setMandatoryIgnore;
+export declare const setMandatorySectionAction: (id: number, value: boolean) => ActionsType.Mandatories.setMandatorySection;
+export declare const setMandatoryOptionAction: (id: number, index: number, value: boolean) => ActionsType.Mandatories.setMandatoryOption;
+export declare const setMandatoryVariableAction: (id: number, index: number, value: boolean) => ActionsType.Mandatories.setMandatoryVariable;

package/dist/redux/actions/mandatories.js

@@ -0,0 +1,32 @@
+import { SET_MANDATORY_IGNORE, SET_MANDATORY_SECTION, SET_MANDATORY_OPTION, SET_MANDATORY_VARIABLE, INIT_MANDATORY_OPTION, INIT_MANDATORY_VARIABLE, } from '../constants/mandatories';
+export const initMandatoryOptionAction = (id, value) => ({
+    type: INIT_MANDATORY_OPTION,
+    id,
+    value,
+});
+export const initMandatoryVariableAction = (id, value) => ({
+    type: INIT_MANDATORY_VARIABLE,
+    id,
+    value,
+});
+export const setMandatoryIgnoreAction = (value) => ({
+    type: SET_MANDATORY_IGNORE,
+    value,
+});
+export const setMandatorySectionAction = (id, value) => ({
+    type: SET_MANDATORY_SECTION,
+    id,
+    value,
+});
+export const setMandatoryOptionAction = (id, index, value) => ({
+    type: SET_MANDATORY_OPTION,
+    id,
+    index,
+    value,
+});
+export const setMandatoryVariableAction = (id, index, value) => ({
+    type: SET_MANDATORY_VARIABLE,
+    id,
+    index,
+    value,
+});

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

@@ -0,0 +1,5 @@
+import { StateType } from '../../types/State.type';
+import { ActionsType } from '../../types/Actions.type';
+export declare const initReferencesAction: (references: StateType.References) => ActionsType.References.initReferences;
+export declare const updateVariableMetaAction: (id: number, meta: ActionsType.References.updateVariableMeta['meta']) => ActionsType.References.updateVariableMeta;
+export declare const updateOptionMetaAction: (id: number, meta: ActionsType.References.updateOptionMeta['meta']) => ActionsType.References.updateOptionMeta;

package/dist/redux/actions/references.js

@@ -0,0 +1,12 @@
+import { INIT_REFERENCES, UPDATE_OPTION_META, UPDATE_VARIABLE_META, } from '../constants/references';
+export const initReferencesAction = (references) => (Object.assign({ type: INIT_REFERENCES }, references));
+export const updateVariableMetaAction = (id, meta) => ({
+    type: UPDATE_VARIABLE_META,
+    id,
+    meta,
+});
+export const updateOptionMetaAction = (id, meta) => ({
+    type: UPDATE_OPTION_META,
+    id,
+    meta,
+});

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

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

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

@@ -0,0 +1,41 @@
+import { initReferencesAction } from './references';
+describe('References actions test suit', () => {
+    it('initReferences Action', () => {
+        const _obj = {
+            options: {},
+            variables: {},
+            relations: {
+                options: {},
+                variables: {},
+                sections: {},
+            },
+            conditions: {
+                options: {},
+                variables: {},
+                prefillers: {},
+                validators: {
+                    options: {},
+                    variables: {},
+                },
+                sections: {},
+                documents: {},
+            },
+            sections: {
+                main: {
+                    '1': {
+                        id: 1,
+                        label: 'Some label',
+                        options: [],
+                    },
+                },
+            },
+            documents: {},
+            defaults: {},
+            outputs: {},
+            evaluations: {},
+            boxes: {},
+        };
+        const action = initReferencesAction(_obj);
+        expect(action).toEqual(Object.assign({ type: 'INIT_REFERENCES' }, _obj));
+    });
+});

package/dist/redux/actions/sagas/data.d.ts

@@ -0,0 +1,2 @@
+import { ActionsType } from '../../../types/Actions.type';
+export declare const saveDataAction: (redirect?: boolean, confirmAnswer?: boolean | undefined, redirectFallback?: string | undefined, additionalProperties?: Record<string, string | number> | undefined) => ActionsType.Sagas.Data.saveData;

package/dist/redux/actions/sagas/data.js

@@ -0,0 +1,8 @@
+import { SAVE_DATA } from '../../constants/sagas/data';
+export const saveDataAction = (redirect = false, confirmAnswer, redirectFallback, additionalProperties) => ({
+    type: SAVE_DATA,
+    confirmAnswer,
+    redirect,
+    redirectFallback,
+    additionalProperties,
+});

package/dist/redux/actions/sagas/data.test.d.ts

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

package/dist/redux/actions/sagas/data.test.js

@@ -0,0 +1,10 @@
+import { saveDataAction } from './data';
+it('Returns saveData action properkt', () => {
+    expect(saveDataAction()).toStrictEqual({
+        confirmAnswer: undefined,
+        additionalProperties: undefined,
+        type: 'SAVE_DATA',
+        redirect: false,
+        redirectFallback: undefined,
+    });
+});

package/dist/redux/actions/sagas/index.d.ts

@@ -0,0 +1,3 @@
+export * from './data';
+export * from './model';
+export * from './user';

package/dist/redux/actions/sagas/index.js

@@ -0,0 +1,3 @@
+export * from './data';
+export * from './model';
+export * from './user';