@legalplace/wizardx-core 4.42.10-nightly.20251125120616 → 4.42.11

package/dist/hooks/useDispatch.d.ts

@@ -1 +1 @@
-export declare function useDispatch(): import("redux").Dispatch<any>;
+export declare function useDispatch(): import("redux").Dispatch<import("redux").AnyAction>;

package/dist/hooks/usePrevious.js

@@ -3,6 +3,6 @@ export const usePrevious = (value) => {
     const ref = useRef();
     useEffect(() => {
         ref.current = value;
-    }, []);
+    });
     return ref.current;
 };

package/dist/index.d.ts

@@ -1,8 +1,5 @@
 export { default as App } from "./App";
 export * from "./App";
-export { default as WizardCore } from "./WizardCore";
-export * from "./WizardCore";
-export * from "./routing";
 export * from "./config";
 export * from "./Globals";
 export * from "./PluginLoader";

package/dist/index.js

@@ -1,8 +1,5 @@
 export { default as App } from "./App";
 export * from "./App";
-export { default as WizardCore } from "./WizardCore";
-export * from "./WizardCore";
-export * from "./routing";
 export * from "./config";
 export * from "./Globals";
 export * from "./PluginLoader";

package/dist/libs/ConditionsRunner.d.ts

@@ -1,6 +1,6 @@
 import type { Dispatch } from "redux";
 import type { StateType, MAPPED_CONDITIONS } from "../types/State.type";
-export type AllConditions = StateType.Conditions.Options | StateType.Conditions.Variables | StateType.Conditions.Validators | StateType.Conditions.Prefillers | StateType.Conditions.Sections | any[];
+export declare type AllConditions = StateType.Conditions.Options | StateType.Conditions.Variables | StateType.Conditions.Validators | StateType.Conditions.Prefillers | StateType.Conditions.Sections | any[];
 export declare class ConditionsRunner {
     dispatch: Dispatch;
     constructor(dispatch: Dispatch);

package/dist/libs/Formatter/FormatAddress.d.ts

@@ -1 +1 @@
-export declare const cleanString: (str?: string) => string;
+export declare const cleanString: (str?: string | undefined) => string;

package/dist/libs/InputsInitiator.d.ts

@@ -1,5 +1,5 @@
 import type { StateType } from "../types/State.type";
-export type OptionsVariablesType = {
+export declare type OptionsVariablesType = {
     options: {
         [key: string]: boolean[];
     };

package/dist/libs/NumAuto.test.d.ts

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

package/dist/libs/NumAuto.test.js

@@ -0,0 +1,43 @@
+import { NumAuto } from './NumAuto';
+describe('NumAuto Test Suit', () => {
+    it('Resets properly', () => {
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(2);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+        NumAuto.resetNums();
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+        NumAuto.resetNums();
+    });
+    it('It increments indexes correctly', () => {
+        NumAuto.resetNums();
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(2);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(2);
+    });
+    it('It tags properly', () => {
+        NumAuto.resetNums();
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', 'myTestTag')).toEqual(2);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+        expect(NumAuto.getNumPre('myTestTag', 0, 0)).toEqual(2);
+        expect(NumAuto.getNum('myTestTag', null)).toEqual(2);
+    });
+    it('It returns previous indexes correctly', () => {
+        NumAuto.resetNums();
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(2);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(2);
+        expect(NumAuto.getNumPre('myTestIndex', 0, 1)).toEqual(3);
+        expect(NumAuto.getNumPre('myOtherTestIndex', 0, 0)).toEqual(2);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(4);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(3);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(4);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(5);
+        expect(NumAuto.getNumPre('myTestIndex', 0, 0)).toEqual(4);
+        expect(NumAuto.getNumPre('myOtherTestIndex', 0, 1)).toEqual(5);
+    });
+});

package/dist/libs/PathReader.d.ts

@@ -21,102 +21,7 @@ export declare class PathReader {
         appStates: string[];
     };
     getAppStatesPages(): {
-        length: number;
-        toString(): string;
-        toLocaleString(): string;
-        toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
-        pop(): string | undefined;
-        push(...items: string[]): number;
-        concat(...items: ConcatArray<string>[]): string[];
-        concat(...items: (string | ConcatArray<string>)[]): string[];
-        join(separator?: string): string;
-        reverse(): string[];
-        shift(): string | undefined;
-        slice(start?: number, end?: number): string[];
-        sort(compareFn?: ((a: string, b: string) => number) | undefined): string[];
-        splice(start: number, deleteCount?: number): string[];
-        splice(start: number, deleteCount: number, ...items: string[]): string[];
-        unshift(...items: string[]): number;
-        indexOf(searchElement: string, fromIndex?: number): number;
-        lastIndexOf(searchElement: string, fromIndex?: number): number;
-        every<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): this is S[];
-        every(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
-        some(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
-        forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void;
-        map<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[];
-        filter<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[];
-        filter(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string[];
-        reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
-        reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
-        reduce<U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
-        reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
-        reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
-        reduceRight<U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
-        find<S extends string>(predicate: (value: string, index: number, obj: string[]) => value is S, thisArg?: any): S | undefined;
-        find(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): string | undefined;
-        findIndex(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): number;
-        fill(value: string, start?: number, end?: number): string[];
-        copyWithin(target: number, start: number, end?: number): string[];
-        entries(): ArrayIterator<[number, string]>;
-        keys(): ArrayIterator<number>;
-        values(): ArrayIterator<string>;
-        includes(searchElement: string, fromIndex?: number): boolean;
-        flatMap<U, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U | readonly U[], thisArg?: This | undefined): U[];
-        flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
-        at(index: number): string | undefined;
-        findLast<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S | undefined;
-        findLast(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string | undefined;
-        findLastIndex(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): number;
-        toReversed(): string[];
-        toSorted(compareFn?: ((a: string, b: string) => number) | undefined): string[];
-        toSpliced(start: number, deleteCount: number, ...items: string[]): string[];
-        toSpliced(start: number, deleteCount?: number): string[];
-        with(index: number, value: string): string[];
-        [Symbol.iterator](): ArrayIterator<string>;
-        [Symbol.unscopables]: {
-            [x: number]: boolean | undefined;
-            length?: boolean | undefined;
-            toString?: boolean | undefined;
-            toLocaleString?: boolean | undefined;
-            pop?: boolean | undefined;
-            push?: boolean | undefined;
-            concat?: boolean | undefined;
-            join?: boolean | undefined;
-            reverse?: boolean | undefined;
-            shift?: boolean | undefined;
-            slice?: boolean | undefined;
-            sort?: boolean | undefined;
-            splice?: boolean | undefined;
-            unshift?: boolean | undefined;
-            indexOf?: boolean | undefined;
-            lastIndexOf?: boolean | undefined;
-            every?: boolean | undefined;
-            some?: boolean | undefined;
-            forEach?: boolean | undefined;
-            map?: boolean | undefined;
-            filter?: boolean | undefined;
-            reduce?: boolean | undefined;
-            reduceRight?: boolean | undefined;
-            find?: boolean | undefined;
-            findIndex?: boolean | undefined;
-            fill?: boolean | undefined;
-            copyWithin?: boolean | undefined;
-            entries?: boolean | undefined;
-            keys?: boolean | undefined;
-            values?: boolean | undefined;
-            includes?: boolean | undefined;
-            flatMap?: boolean | undefined;
-            flat?: boolean | undefined;
-            at?: boolean | undefined;
-            findLast?: boolean | undefined;
-            findLastIndex?: boolean | undefined;
-            toReversed?: boolean | undefined;
-            toSorted?: boolean | undefined;
-            toSpliced?: boolean | undefined;
-            with?: boolean | undefined;
-            [Symbol.iterator]?: boolean | undefined;
-            readonly [Symbol.unscopables]?: boolean | undefined;
-        };
+        [x: string]: string;
     };
     parsePath(page?: number, uniqid?: string | undefined, modelVersion?: string | undefined): string;
     static isWizardInstancePath(): boolean;

package/dist/libs/PathReader.js

@@ -2,6 +2,7 @@ import { createMatchSelector } from "connected-react-router";
 import queryString from "query-string";
 import { matchPath, generatePath } from "react-router";
 import { getConfig } from "../config";
+import { getPluginsPageAppStates } from "../PluginLoader";
 import { selectAvailableSections, selectAvailableAppStates, selectInstanceUniqid, selectMetaFetchStatus, } from "../redux/selectors/app";
 import { selectSectionReference } from "../redux/selectors/references";
 import Globals from "../Globals";
@@ -124,7 +125,7 @@ export class PathReader {
     }
     getAppStatesPages() {
         const globalAppStates = getConfig().router.appStatesPages || {};
-        const pluginsAppStates = [];
+        const pluginsAppStates = getPluginsPageAppStates();
         return Object.assign(Object.assign({}, globalAppStates), pluginsAppStates);
     }
     parsePath(page = this.currentPage, uniqid = this.currentUniqid, modelVersion = this.modelVersion) {

package/dist/libs/SectionValidity.test.d.ts

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

package/dist/libs/SectionValidity.test.js

@@ -0,0 +1,116 @@
+import { SectionValidity } from './SectionValidity';
+const mockInputs = {
+    options: {
+        1: [true],
+        2: [true],
+        3: [true],
+        1032: [true],
+    },
+    variables: {},
+};
+const mockReferences = {
+    sections: {
+        main: {
+            1: {
+                id: 1,
+                label: 'Section 1 - Valid Section',
+                options: [1],
+            },
+            2: {
+                id: 2,
+                label: 'Section 2 - Unvalid Section',
+                options: [2],
+            },
+            3: {
+                id: 3,
+                label: 'Section 3 - Has inexistant child',
+                options: [1032],
+            },
+        },
+    },
+    options: {
+        1: {
+            meta: {
+                type: 'checkbox',
+                id: 1,
+                label: 'Option 1',
+                step: '*',
+            },
+            options: [],
+            variables: [1],
+        },
+        2: {
+            meta: {
+                type: 'checkbox',
+                id: 2,
+                label: 'Option 2',
+                step: '*',
+            },
+            options: [3],
+            variables: [2],
+        },
+        3: {
+            meta: {
+                type: 'checkbox',
+                id: 3,
+                label: 'Option 3',
+                step: '*',
+            },
+            options: [],
+            variables: [],
+        },
+    },
+};
+const mockConditions = {
+    options: {
+        1: [true],
+        2: [true],
+        3: [true],
+    },
+    variables: {
+        1: [true],
+        2: [true],
+    },
+    validators: {
+        options: {
+            1: [true],
+            2: [true],
+            3: [false],
+        },
+        variables: {
+            1: [true],
+            2: [false],
+        },
+    },
+};
+jest.mock('../redux/selectors/inputs', () => ({
+    __esModule: true,
+    selectOptionInput: (id) => mockInputs.options[id],
+    selectOptionInputByIndex: (id, index) => mockInputs.options[id][index],
+}));
+jest.mock('../redux/selectors/references', () => ({
+    __esModule: true,
+    selectSectionReference: (id) => mockReferences.sections.main[id],
+    selectOptionReference: (id) => mockReferences.options[id],
+}));
+jest.mock('../redux/selectors/conditions', () => ({
+    __esModule: true,
+    selectOptionConditionValue: (id, index) => mockConditions.options[id][index],
+    selectOptionValidatorConditionValue: (id, index) => mockConditions.validators.options[id][index],
+    selectVariableConditionValue: (id, index) => mockConditions.variables[id][index],
+    selectVariableValidatorConditionValue: (id, index) => mockConditions.validators.variables[id][index],
+}));
+describe('SectionValidity library test suit', () => {
+    it('Checks valid section', () => {
+        expect(new SectionValidity(1).validity).toBeTruthy();
+    });
+    it('Checks unvalid section', () => {
+        expect(new SectionValidity(2).validity).toBeFalsy();
+    });
+    it('Should throw an error if option reference does not exist', () => {
+        expect(() => new SectionValidity(3).validity).toThrowError('Option 1032 does not exist');
+    });
+    it('Should throw an error if section does not exist', () => {
+        expect(() => new SectionValidity(4).validity).toThrowError('Section 4 does not exist');
+    });
+});

package/dist/libs/SmartScriptStore.d.ts

@@ -1,7 +1,7 @@
 import type { Action } from "redux";
 import type { ActionsType } from "../types/Actions.type";
 import type { StateType } from "../types/State.type";
-export type CallbackType = () => void;
+export declare type CallbackType = () => void;
 export declare class SmartScriptStore {
     static hooks: {
         variables: Record<string, CallbackType[]>;
@@ -29,11 +29,11 @@ export declare class SmartScriptStore {
     static onVariableChange(id: number | number[], callback: CallbackType): void;
     static updateVariableInput: (id: number, value: string | number, index?: number) => void;
     static updateOptionInput: (id: number, value: boolean, index?: number) => void;
-    static updateVariableMeta: (id: number, _meta: ActionsType.References.updateVariableMeta["meta"], index?: number) => void;
+    static updateVariableMeta: (id: number, _meta: ActionsType.References.updateVariableMeta["meta"], index?: number | undefined) => void;
     static updateOptionMeta: (id: number, _meta: ActionsType.References.updateOptionMeta["meta"]) => void;
     static retrieveExternalData: () => Readonly<false | any[]>;
-    static hideOption: (id: number, index?: number) => void;
-    static displayOption: (id: number, index?: number) => void;
-    static hideVariable: (id: number, index?: number) => void;
-    static displayVariable: (id: number, index?: number) => void;
+    static hideOption: (id: number, index?: number | undefined) => void;
+    static displayOption: (id: number, index?: number | undefined) => void;
+    static hideVariable: (id: number, index?: number | undefined) => void;
+    static displayVariable: (id: number, index?: number | undefined) => void;
 }

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

@@ -13,7 +13,7 @@ export declare const setFetchStatus: (fetchStatus: "waiting" | "succeeded" | "fa
 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 type initPaginationActionPropsType = Omit<ActionsType.App.initPagination, "type">;
+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;

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.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/inputs.d.ts

@@ -1,6 +1,6 @@
 import type { StateType } from "../../types/State.type";
 import type { ActionsType } from "../../types/Actions.type";
-export declare const initInputsAction: (inputs: StateType.Inputs, references?: StateType.References) => ActionsType.Inputs.initInputs;
+export declare const initInputsAction: (inputs: StateType.Inputs, references?: StateType.References | undefined) => ActionsType.Inputs.initInputs;
 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;

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,
+        });
+    });
+});