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

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

@@ -1,471 +0,0 @@
-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: {},
-    optionTags: {},
-    variableTags: {}
-};
-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.test.d.ts

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

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

@@ -1,16 +0,0 @@
-import configureMockStore from "redux-mock-store";
-import { createSelector, selectorsMiddleware } from "./selectors";
-describe("Selectors Test", () => {
-    it("Middleware", () => {
-        const mockStore = configureMockStore([selectorsMiddleware]);
-        const store = mockStore({});
-        const myFakeFunction = jest.fn();
-        const selector = createSelector(myFakeFunction, () => "myFakeCacheKey");
-        store.dispatch({ type: "FAKE_ACTION" });
-        selector();
-        selector();
-        selector();
-        selector();
-        expect(myFakeFunction).toHaveBeenCalledTimes(1);
-    });
-});

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

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

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

@@ -1,29 +0,0 @@
-import { createAppStore, getStore } from '../store';
-import { selectCurrentUserLevel, isLevelAccessibleForUser } from './user';
-import { initUserAction } from '../actions/user';
-createAppStore('memory');
-const store = getStore();
-describe('User selectors test suit', () => {
-    it('selectCurrentUserLevel', () => {
-        store.dispatch(initUserAction({
-            displayName: 'John Doe',
-            level: 'MANAGER',
-            email: 'john@doe.com',
-        }));
-        const selector = selectCurrentUserLevel();
-        expect(selector).toEqual('MANAGER');
-    });
-    it('selectCurrentUserLevel', () => {
-        store.dispatch(initUserAction({
-            displayName: 'John Doe',
-            level: 'MANAGER',
-            email: 'john@doe.com',
-        }));
-        expect(isLevelAccessibleForUser('GUEST')).toBeTruthy();
-        expect(isLevelAccessibleForUser('USER')).toBeTruthy();
-        expect(isLevelAccessibleForUser('MANAGER')).toBeTruthy();
-        expect(isLevelAccessibleForUser('OPS')).toBeFalsy();
-        expect(isLevelAccessibleForUser('ADMIN')).toBeFalsy();
-        expect(isLevelAccessibleForUser('SUPER')).toBeFalsy();
-    });
-});

package/dist/redux/store.test.d.ts

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

package/dist/redux/store.test.js

@@ -1,16 +0,0 @@
-import { createAppStore, getStore } from './store';
-describe('Store Creation', () => {
-    it('Throws error when trying to get store before creation', () => {
-        expect(() => getStore()).toThrowError('Store not yet created');
-    });
-    it('It creates store', () => {
-        createAppStore();
-        const store = getStore();
-        return expect(store).toHaveProperty('getState');
-    });
-    it('It properly connects redux', () => {
-        createAppStore();
-        const state = getStore().getState();
-        return expect(state).toHaveProperty('router');
-    });
-});