@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/redux/reducers/user.js

@@ -0,0 +1,23 @@
+import { setUserValidTokenReducer } from './user/setUserValidToken';
+import { SET_USER_VALID_TOKEN, INIT_USER, SET_USER_STATUS, } from '../constants/user';
+import { initUserReducer } from './user/initUser';
+import { setUserStatusReducer } from './user/setUserStatus';
+const initialState = {
+    status: 'unauthenticated',
+    email: '',
+    displayName: '',
+    level: 'GUEST',
+    validToken: false,
+};
+const reducersEnum = {
+    [INIT_USER]: initUserReducer,
+    [SET_USER_STATUS]: setUserStatusReducer,
+    [SET_USER_VALID_TOKEN]: setUserValidTokenReducer,
+};
+export const userReducer = (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.test.d.ts

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

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

@@ -0,0 +1,42 @@
+import { initUserReducer } from './user/initUser';
+import { userReducer } from './user';
+describe('User Reducer test suits', () => {
+    it('initUserReducer Reducer', () => {
+        const reducer = initUserReducer({
+            status: 'unauthenticated',
+            level: 'GUEST',
+            displayName: '',
+            email: '',
+            validToken: false,
+        }, {
+            type: 'INIT_USER',
+            level: 'ADMIN',
+            displayName: 'John Doe',
+            email: 'doe@legalplace.fr',
+            validToken: false,
+        });
+        return expect(reducer).toStrictEqual({
+            status: 'unauthenticated',
+            level: 'ADMIN',
+            displayName: 'John Doe',
+            email: 'doe@legalplace.fr',
+            validToken: false,
+        });
+    });
+    it('user Reducer INIT_USER Action', () => {
+        const reducer = userReducer(undefined, {
+            type: 'INIT_USER',
+            level: 'ADMIN',
+            displayName: 'John Doe',
+            email: 'doe@legalplace.fr',
+            validToken: false,
+        });
+        return expect(reducer).toStrictEqual({
+            status: 'unauthenticated',
+            level: 'ADMIN',
+            displayName: 'John Doe',
+            email: 'doe@legalplace.fr',
+            validToken: false,
+        });
+    });
+});

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

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

package/dist/redux/routerHistore.test.js

@@ -0,0 +1,15 @@
+import { createHistory, getHistory } from './routerHistory';
+describe('Router History', () => {
+    it('Thows an error when history is not initiated', () => {
+        expect(getHistory).toThrowError('History not yet created');
+    });
+    it('Creates and returns history', () => {
+        const history = createHistory('memory');
+        expect(history).toHaveProperty('location');
+    });
+    it('Returns history', () => {
+        createHistory('memory');
+        const history = getHistory();
+        expect(history).toHaveProperty('location');
+    });
+});

package/dist/redux/routerHistory.d.ts

@@ -0,0 +1,3 @@
+import { MemoryHistory, History } from 'history';
+export declare const createHistory: (historyType: 'memory' | 'browser') => History<unknown>;
+export declare const getHistory: () => History<unknown> | MemoryHistory<unknown>;

package/dist/redux/routerHistory.js

@@ -0,0 +1,12 @@
+import { createMemoryHistory, createBrowserHistory, } from 'history';
+let history;
+export const createHistory = (historyType) => {
+    history =
+        historyType === 'memory' ? createMemoryHistory() : createBrowserHistory();
+    return history;
+};
+export const getHistory = () => {
+    if (typeof history === 'undefined')
+        throw new Error('History not yet created');
+    return history;
+};

package/dist/redux/sagas/fetchModel.d.ts

@@ -0,0 +1,26 @@
+import type { CustomizationMetaDefault } from '@legalplace/models-v3-types';
+import type { HealthCheckReport } from '@legalplace/model-healthcheck/dist/libs/HealthCheck.type';
+import { OvcType } from '../../libs/OvcConverter';
+import { StateType } from '../../types/State.type';
+export interface FetchModelInformationResponse {
+    references: StateType.References;
+    meta: {
+        id: number;
+        title: string;
+        modelVersion: number;
+        productType: string;
+    };
+    customization: {
+        disableAutoDefault?: boolean | undefined;
+        meta?: CustomizationMetaDefault | undefined;
+    };
+    ovc?: OvcType;
+    smartScript: boolean;
+    status?: string;
+    report: {
+        object: HealthCheckReport;
+        raw: string;
+    };
+}
+declare function fetchModelSaga(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+export default fetchModelSaga;

package/dist/redux/sagas/fetchModel.js

@@ -0,0 +1,372 @@
+import { call, put, takeLatest, select, fork, join } from 'redux-saga/effects';
+import Cookies from 'universal-cookie';
+import { initMetaAction, initPaginationAction, initInstanceAction, fetchModelSucceededAction, fetchModelFailedAction, initCustomizationMetaAction, fetchModelUnhealthyAction, initCustomizationAutoDefaultAction, fetchModelUserLockedAction, updateAvailableAppStatesAction, goPageAction, fetchModelNonBlockingAction, setModelUuidAction, } from '../actions/app';
+import { ConditionsInitiator } from '../../libs/ConditionsInitiator';
+import { initReferencesAction } from '../actions/references';
+import { initOptionAction, initVariableAction } from '../actions/inputs';
+import { initConditionsAction } from '../actions/conditions';
+import { selectSectionConditionValue } from '../selectors/conditions';
+import { selectAllSectionsReferences, selectOptionRelations, } from '../selectors/references';
+import { selectInstanceUniqid, isStepAvailable } from '../selectors/app';
+import { getConfig, updateConfig } from '../../config';
+import { isLevelAccessibleForUser } from '../selectors/user';
+import { PathReader } from '../../libs/PathReader';
+import { IntputsInitiator } from '../../libs/InputsInitiator';
+import { initUserAction, setUserStatusAction } from '../actions/user';
+import { OvcConverter } from '../../libs/OvcConverter';
+import Globals from '../../Globals';
+import { getFetchModelArguments, getCreateInstanceArguments, getClientConfigArguments, getWizardConfigArguments, getModelInformationArguments, } from '../../service/api.manager';
+import { loadTheme, setWizardTheme } from '../../ThemeLoader';
+import { loadPlugins } from '../../PluginLoader';
+import { selectMandatoryOptionItem, selectMandatoryOption, } from '../selectors/mandatories';
+import { initMandatoryOptionAction, initMandatoryVariableAction, } from '../actions/mandatories';
+import { enableSmartscriptAction } from '../actions/smartscript';
+import { FETCH_MODEL, FETCH_MODEL_PREREQUISITES, } from '../constants/sagas/model';
+import { fetchModelAction } from '../actions/sagas/model';
+const cookies = new Cookies();
+const getValues = (arr1, arr2) => {
+    return arr1.map((v, index) => {
+        return arr2[index] || v;
+    });
+};
+function* setFetchModelToNonBlocking(firstCurrentAppState) {
+    yield put(initPaginationAction({
+        currentPage: 1,
+        greatestPage: 1,
+        currentSectionId: 0,
+        availableSections: [],
+        currentAppState: firstCurrentAppState || 'wizard',
+        availableAppStates: ['wizard'],
+    }));
+    const state = yield select((s) => s);
+    const pathReader = new PathReader(state);
+    yield put(goPageAction(pathReader.currentPage, false));
+    yield put(fetchModelNonBlockingAction());
+}
+function* getClientConfig(permalink, uniqid) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    let clientConfigResponse = yield call(fetch, ...getClientConfigArguments(permalink, uniqid));
+    if (clientConfigResponse === undefined) {
+        throw new Error(`Unable to fetch client config, we did not receive any response`);
+    }
+    clientConfigResponse = yield call([clientConfigResponse, 'json']);
+    if ((_a = clientConfigResponse.clientConfig.metadata) === null || _a === void 0 ? void 0 : _a.apiEndpoint) {
+        updateConfig(Object.assign(Object.assign({}, getConfig()), { apiEndpoint: (_b = clientConfigResponse.clientConfig.metadata) === null || _b === void 0 ? void 0 : _b.apiEndpoint }));
+    }
+    if ((_c = clientConfigResponse.clientConfig.metadata) === null || _c === void 0 ? void 0 : _c.plugins) {
+        yield call(loadPlugins, (_d = clientConfigResponse.clientConfig.metadata) === null || _d === void 0 ? void 0 : _d.plugins);
+    }
+    else
+        yield call(loadPlugins);
+    updateConfig(Object.assign(Object.assign({}, getConfig()), { authCookieDomain: ((_e = clientConfigResponse.clientConfig.metadata) === null || _e === void 0 ? void 0 : _e.authCookieDomain) ||
+            process.env.REACT_APP_COOKIES_ALL_SUBDOMAIN }));
+    if (/compactTheme/.test(window.location.href)) {
+        yield call(setWizardTheme, { name: 'compact' });
+    }
+    else if ((_g = (_f = clientConfigResponse.clientConfig.metadata) === null || _f === void 0 ? void 0 : _f.theme) === null || _g === void 0 ? void 0 : _g.name) {
+        yield call(setWizardTheme, clientConfigResponse.clientConfig.metadata.theme);
+    }
+    else {
+        yield call(loadTheme);
+    }
+    if ((_j = (_h = clientConfigResponse.clientConfig.metadata) === null || _h === void 0 ? void 0 : _h.appStates) === null || _j === void 0 ? void 0 : _j.length) {
+        yield put(updateAvailableAppStatesAction(clientConfigResponse.clientConfig.metadata.appStates));
+    }
+    const availableAppStates = ((_k = clientConfigResponse.clientConfig.metadata) === null || _k === void 0 ? void 0 : _k.appStates) ||
+        getConfig().appStates;
+    return {
+        appStates: availableAppStates,
+        enableShadowInstance: ((_l = clientConfigResponse.clientConfig.metadata) === null || _l === void 0 ? void 0 : _l.enableShadowInstance) || false,
+    };
+}
+function* getWizardConfig(permalink, uniqidParam, prefix, queryParams) {
+    let response = yield call(fetch, ...getWizardConfigArguments(permalink, uniqidParam, prefix, queryParams));
+    if (response === undefined) {
+        throw new Error(`Unable to fetch wizard config, we did not receive any response`);
+    }
+    response = yield call([response, 'json']);
+    if (response.redirect) {
+        window.onbeforeunload = null;
+        window.location.href = `${response.redirect}${response.redirectParams
+            ? `?redirectUrl=${encodeURIComponent(window.location.href)}`
+            : ''}`;
+    }
+    yield put(setModelUuidAction(response.modelUuid));
+    return { modelUuid: response.modelUuid };
+}
+function* fetchModelInformation(modelUuid, permalink, prefix, queryParams) {
+    var _a;
+    let response = yield call(fetch, ...getModelInformationArguments(modelUuid, queryParams));
+    if (response === undefined) {
+        throw new Error(`Unable to fetch wizard config, we did not receive any response`);
+    }
+    response = yield call([response, 'json']);
+    if (response.status === 'unhealthy') {
+        if (Globals.env === 'production') {
+            yield put(fetchModelFailedAction());
+        }
+        else
+            yield put(fetchModelUnhealthyAction(response.report));
+        return undefined;
+    }
+    const meta = Object.assign(Object.assign({}, response.meta), { permalink,
+        prefix });
+    yield put(initMetaAction(meta));
+    document.title = `${meta.title} - ${((_a = getConfig().brand) === null || _a === void 0 ? void 0 : _a.name) || 'LegalPlace'}`;
+    const { references, customization, smartScript } = response;
+    yield put(initReferencesAction(references));
+    if (customization.disableAutoDefault !== undefined)
+        yield put(initCustomizationAutoDefaultAction(customization.disableAutoDefault));
+    if (typeof customization === 'object' &&
+        typeof customization.meta === 'object')
+        yield put(initCustomizationMetaAction(customization.meta));
+    return { ovc: response.ovc, references, meta: response.meta, smartScript };
+}
+function* fetchInstanceInformation(appStates, permalink, uniqid, uniqidParam, prefix, queryParams, pathReader) {
+    var _a, _b;
+    let response = yield call(fetch, ...getFetchModelArguments(permalink, uniqidParam, prefix, queryParams));
+    if (response === undefined) {
+        throw new Error(`Unable to fetch ${permalink}${uniqid && uniqid.trim().length > 0 ? `/${uniqid}` : ''}, we did not recieve any response`);
+    }
+    response = yield call([response, 'json']);
+    if (response.redirect) {
+        window.onbeforeunload = null;
+        window.location.href = `${response.redirect}${response.redirectParams
+            ? `?redirectUrl=${encodeURIComponent(window.location.href)}`
+            : ''}`;
+    }
+    if (response.errors || response.status === 'error') {
+        throw new Error(`Unable to fetch ${permalink}${uniqid && uniqid.trim().length > 0 ? `/${uniqid}` : ''}`);
+    }
+    if (response.instance && response.instance.appType === 'react') {
+        const abCookie = cookies.get('X-Source');
+        if (abCookie && abCookie.split('/').length > 1) {
+            cookies.set('X-Source', `${abCookie.split('/')[0]}/wizard`, {
+                path: '/',
+                encode: (value) => value,
+            });
+            window.onbeforeunload = () => { };
+            document.location.reload();
+        }
+    }
+    const instance = {
+        dataStatus: 'saved',
+        uniqid: uniqid || '',
+        draft: response.instance && response.instance.draft,
+        companyId: (_a = response.instance) === null || _a === void 0 ? void 0 : _a.companyId,
+        employeeId: (_b = response.instance) === null || _b === void 0 ? void 0 : _b.employeeId,
+        isOrderHandled: response.instance && response.instance.isOrderHandled,
+        isPaid: response.instance &&
+            (response.instance.isPaid.toString() === '1' ||
+                response.instance.isPaid === true),
+        steps: response.instance &&
+            (typeof response.instance.steps === 'string' ||
+                Array.isArray(response.instance.steps))
+            ? response.instance.steps
+            : [1],
+    };
+    if (pathReader.modelVersion)
+        instance.steps = '*';
+    yield put(initInstanceAction(instance));
+    const availableAppStates = appStates || getConfig().appStates;
+    if (typeof response.user === 'object' &&
+        typeof response.user.email === 'string' &&
+        typeof response.user.displayName === 'string' &&
+        typeof response.user.level === 'string') {
+        yield put(initUserAction({
+            email: response.user.email,
+            displayName: response.user.displayName,
+            level: response.user.level,
+        }));
+        yield put(setUserStatusAction('authenticated'));
+        if (availableAppStates.includes('email'))
+            availableAppStates.splice(availableAppStates.indexOf('email'), 1);
+    }
+    if (instance.draft === false && !isLevelAccessibleForUser('USER')) {
+        yield put(fetchModelUserLockedAction());
+    }
+    return { instance, availableAppStates, ovc: response.ovc };
+}
+function* createInstance(enableShadowInstance, modelInformation, uniqid, permalink, pathReader, urlParams) {
+    const { meta } = modelInformation;
+    const isShadowInstanceEnabled = typeof enableShadowInstance !== 'undefined'
+        ? enableShadowInstance
+        : getConfig().enableShadowInstance;
+    const instance = {
+        dataStatus: 'saved',
+        uniqid: uniqid || '',
+        draft: false,
+        companyId: undefined,
+        employeeId: undefined,
+        isOrderHandled: undefined,
+        isPaid: false,
+        steps: [1],
+    };
+    if (pathReader.modelVersion)
+        instance.steps = '*';
+    if (isShadowInstanceEnabled === true &&
+        (instance.uniqid === undefined ||
+            (typeof instance.uniqid === 'string' && instance.uniqid.trim() === ''))) {
+        const searchParams = `${urlParams && urlParams.get('contractName') && urlParams.get('userId')
+            ? `?contractName=${urlParams.get('contractName')}&userId=${urlParams.get('userId')}`
+            : ''}`;
+        const res = yield call(fetch, ...getCreateInstanceArguments(permalink, searchParams, meta.modelVersion));
+        const instanceResponse = yield call([res, 'json']);
+        if (instanceResponse.status !== 'SUCCESS') {
+            throw new Error('Unable to create instance');
+        }
+        instance.uniqid = instanceResponse.uniqid;
+        instance.isPaid = instanceResponse.isPaid === true;
+        instance.isOrderHandled = instanceResponse.isOrderHandled;
+        instance.steps =
+            typeof instanceResponse.steps === 'string' ||
+                Array.isArray(instanceResponse.steps)
+                ? instanceResponse.steps
+                : [1];
+    }
+    yield put(initInstanceAction(instance));
+}
+function* fetchModelPrerequisites(action) {
+    const { permalink, prefix } = action;
+    if (!permalink && window.location.href.includes('smartscript'))
+        return;
+    const uniqid = selectInstanceUniqid();
+    const uniqidParam = uniqid && uniqid.trim().length > 0 ? `/${uniqid}` : '';
+    const urlParams = new URLSearchParams(window.location.search);
+    const state = yield select((s) => s);
+    const pathReader = new PathReader(state);
+    const queryParams = new URLSearchParams(window.location.search);
+    if (pathReader.modelVersion)
+        queryParams.set('version', pathReader.modelVersion);
+    const clientConfigTask = yield fork(getClientConfig, permalink, uniqid);
+    const wizardConfigTask = yield fork(getWizardConfig, permalink, uniqidParam, prefix, queryParams);
+    const [clientConfigReturnValue, wizardConfig] = yield join([
+        clientConfigTask,
+        wizardConfigTask,
+    ]);
+    yield put(fetchModelAction(permalink, prefix, uniqid, uniqidParam, queryParams, pathReader, urlParams, clientConfigReturnValue, wizardConfig));
+}
+function* fetchModelDecorator(action) {
+    try {
+        const { permalink, prefix, uniqid, uniqidParam, queryParams, pathReader, urlParams, clientConfigReturnValue, wizardConfig, callback, firstCurrentAppState, } = action;
+        if (callback) {
+            yield call(setFetchModelToNonBlocking, firstCurrentAppState);
+        }
+        const fetchModelInformationTask = yield fork(fetchModelInformation, wizardConfig.modelUuid, permalink, prefix, queryParams);
+        let modelInformation;
+        let ovcFromApi;
+        let availableAppStates;
+        if (uniqid) {
+            const fetchInstanceInformationTask = yield fork(fetchInstanceInformation, clientConfigReturnValue.appStates, permalink, uniqid, uniqidParam, prefix, queryParams, pathReader);
+            const [modelInformationFromTask, instanceInformation] = yield join([
+                fetchModelInformationTask,
+                fetchInstanceInformationTask,
+            ]);
+            modelInformation = modelInformationFromTask;
+            ovcFromApi = instanceInformation.ovc;
+            availableAppStates = instanceInformation.availableAppStates;
+        }
+        else {
+            modelInformation = yield join(fetchModelInformationTask);
+            ovcFromApi = modelInformation.ovc;
+            availableAppStates = clientConfigReturnValue.appStates;
+            yield call(createInstance, clientConfigReturnValue.enableShadowInstance, modelInformation, uniqid, permalink, pathReader, urlParams);
+        }
+        const { references, smartScript } = modelInformation;
+        let ovc = ovcFromApi || null;
+        if (typeof ovc === 'object' &&
+            ovc !== null &&
+            Object.keys(ovc).length === 0)
+            ovc = null;
+        if (OvcConverter.isOvc(ovc))
+            ovc = OvcConverter.convertToOptionsVariables(ovc, references);
+        const inputs = new IntputsInitiator(references, ovc).getInputs();
+        const conditions = new ConditionsInitiator(references, inputs).getConditions();
+        yield put(initConditionsAction(conditions));
+        const optionsIds = Object.keys(inputs.options);
+        for (let i = 0; i < optionsIds.length; i += 1) {
+            let optionId = parseInt(optionsIds[i], 10);
+            let values = inputs.options[optionId];
+            yield put(initOptionAction(optionId, values));
+            const { meta: meta2 } = references.options[optionId];
+            const { type } = meta2;
+            let { mandatory } = meta2;
+            let sendOptionAction = true;
+            if (['checkbox', 'radio'].includes(type)) {
+                if (type === 'radio') {
+                    const { parents } = selectOptionRelations(optionId);
+                    const parentId = parents[0];
+                    const isMandatoryOption = selectMandatoryOptionItem(parentId);
+                    if (typeof isMandatoryOption !== 'undefined') {
+                        const mandatoryOption = selectMandatoryOption(parentId);
+                        sendOptionAction = !mandatoryOption.every((v) => v === true);
+                        if (sendOptionAction === true && mandatoryOption) {
+                            if (values.length >= mandatoryOption.length) {
+                                values = getValues(values, [...mandatoryOption]);
+                            }
+                            else {
+                                values = getValues([...mandatoryOption], values);
+                            }
+                        }
+                    }
+                    mandatory = references.options[parentId].meta.mandatory;
+                    optionId = parentId;
+                }
+                if (mandatory === true && sendOptionAction === true) {
+                    yield put(initMandatoryOptionAction(optionId, values));
+                }
+            }
+        }
+        const variablesIds = Object.keys(inputs.variables);
+        for (let i = 0; i < variablesIds.length; i += 1) {
+            const variableId = variablesIds[i];
+            const values = inputs.variables[variableId];
+            yield put(initVariableAction(parseInt(variableId, 10), values));
+            if (references.variables[variableId].mandatory === true)
+                yield put(initMandatoryVariableAction(parseInt(variableId, 10), values.map((value) => `${value}`.trim().length > 0)));
+        }
+        yield put(initConditionsAction(conditions));
+        const sectionsReferences = selectAllSectionsReferences();
+        if (sectionsReferences === undefined)
+            throw new Error('Sections references not found');
+        const availableSections = Object.keys(sectionsReferences)
+            .filter((sectionId) => {
+            const condition = selectSectionConditionValue(parseInt(sectionId, 10)) !== false;
+            const sectionReference = sectionsReferences[sectionId];
+            const sectionGrantLevel = sectionReference.grantLevel
+                ? sectionReference.grantLevel
+                : 'GUEST';
+            const grant = isLevelAccessibleForUser(sectionGrantLevel);
+            const availableStep = isStepAvailable(sectionReference.step);
+            return condition && grant && availableStep;
+        })
+            .map((c) => parseInt(c, 10));
+        yield put(initPaginationAction({
+            currentPage: 1,
+            greatestPage: 1,
+            currentSectionId: availableSections[0],
+            availableSections,
+            currentAppState: firstCurrentAppState || 'wizard',
+            availableAppStates,
+        }));
+        if (smartScript === true) {
+            yield put(enableSmartscriptAction());
+        }
+        const state2 = yield select((s) => s);
+        const pathReader2 = new PathReader(state2);
+        yield put(goPageAction(pathReader2.currentPage, false));
+        yield put(fetchModelSucceededAction());
+        if (callback) {
+            yield call(callback);
+        }
+    }
+    catch (e) {
+        console.error(e);
+        yield put(fetchModelFailedAction());
+    }
+}
+function* fetchModelSaga() {
+    yield takeLatest(FETCH_MODEL_PREREQUISITES, fetchModelPrerequisites);
+    yield takeLatest(FETCH_MODEL, fetchModelDecorator);
+}
+export default fetchModelSaga;

package/dist/redux/sagas/fetchModel.test.d.ts

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

package/dist/redux/sagas/fetchModel.test.js

@@ -0,0 +1,56 @@
+import * as fs from 'fs';
+import { createAppStore, getStore } from '../store';
+import { initMetaAction, initInstanceAction } from '../actions/app';
+import { fetchModelPrerequisitesAction } from '../actions/sagas/model';
+const permalink = 'test-model';
+const uniqid = 'myMockUniqid';
+const mockApiEndpoint = 'https://api.mock/api/v1/';
+const model = JSON.parse(fs.readFileSync('./src/misc/test_models/testmodel.json', 'utf8'));
+const meta = {
+    id: 123,
+    title: 'Test model',
+    permalink,
+};
+require('jest-fetch-mock').enableMocks();
+jest.mock('../../config', () => ({
+    getConfig: () => ({
+        apiEndpoint: mockApiEndpoint,
+        router: {
+            wizardPath: '/:permalink/questionnaire/:page([0-9]+|sommaire)',
+            wizardInstancePath: '/:permalink/questionnaire/:uniqid([0-9a-zA-Z]+)/:page([0-9]+|sommaire)',
+        },
+        appStates: ['wizard'],
+    }),
+}));
+describe('Fetch model saga', () => {
+    let store;
+    beforeEach(() => {
+        createAppStore('memory');
+        store = getStore();
+        store.dispatch({
+            type: 'SET_DEFAULTS',
+        });
+        store.dispatch(initMetaAction({
+            id: 123,
+            title: 'Test model',
+            prefix: '',
+            permalink,
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        store.dispatch(initInstanceAction({
+            uniqid,
+            isPaid: false,
+            isOrderHandled: undefined,
+            dataStatus: 'saved',
+            steps: '*',
+        }));
+        fetchMock.resetMocks();
+    });
+    it('Sends fetch client config request to API', () => {
+        fetchMock.mockResponseOnce(JSON.stringify({ model, meta }));
+        store.dispatch(fetchModelPrerequisitesAction(permalink));
+        expect(fetchMock.mock.calls.length).toEqual(2);
+        expect(fetchMock.mock.calls[0][0]).toEqual(`${mockApiEndpoint}client-config?permalink=${permalink}&disableOnBoarding=true`);
+    });
+});

package/dist/redux/sagas/homogeneousRadioInputsSaga.d.ts

@@ -0,0 +1,2 @@
+declare function homogeneousRadioInputsSaga(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+export default homogeneousRadioInputsSaga;

package/dist/redux/sagas/homogeneousRadioInputsSaga.js

@@ -0,0 +1,22 @@
+import { put, takeLatest } from 'redux-saga/effects';
+import { UPDATE_OPTION_INPUT } from '../constants/inputs';
+import { selectRadioSiblings } from '../selectors/references';
+import { updateOptionAction } from '../actions/inputs';
+import { selectOptionInputByIndex } from '../selectors/inputs';
+function* homogeneousRadioInputsDecorator(action) {
+    const { id, index, value } = action;
+    if (value === true) {
+        const radioSiblings = selectRadioSiblings(id);
+        if (radioSiblings && value === true) {
+            for (let i = 0; i < radioSiblings.length; i += 1) {
+                const siblingId = radioSiblings[i];
+                if (selectOptionInputByIndex(siblingId, index) === true)
+                    yield put(updateOptionAction(siblingId, false, index));
+            }
+        }
+    }
+}
+function* homogeneousRadioInputsSaga() {
+    yield takeLatest(UPDATE_OPTION_INPUT, homogeneousRadioInputsDecorator);
+}
+export default homogeneousRadioInputsSaga;

package/dist/redux/sagas/runner.d.ts

@@ -0,0 +1,2 @@
+import { SagaMiddleware } from '@redux-saga/core';
+export declare const sagasRunner: (sagaMiddleware: SagaMiddleware<Record<string, unknown>>) => void;

package/dist/redux/sagas/runner.js

@@ -0,0 +1,15 @@
+import fetchModelSaga from './fetchModel';
+import setDefaultsSaga from './setDefaults';
+import saveDataSaga from './saveData';
+import homogeneousRadioInputsSaga from './homogeneousRadioInputsSaga';
+import setUserEmailSaga from './setUserEmail';
+const sagas = [
+    fetchModelSaga,
+    setDefaultsSaga,
+    saveDataSaga,
+    setUserEmailSaga,
+    homogeneousRadioInputsSaga,
+];
+export const sagasRunner = (sagaMiddleware) => {
+    sagas.forEach((saga) => sagaMiddleware.run(saga));
+};

package/dist/redux/sagas/runner.test.d.ts

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

package/dist/redux/sagas/runner.test.js

@@ -0,0 +1,10 @@
+import { sagasRunner } from './runner';
+describe('Runner', () => {
+    it('Runs sagas', () => {
+        const SagaMiddleware = {
+            run: jest.fn(),
+        };
+        sagasRunner(SagaMiddleware);
+        expect(SagaMiddleware.run).toHaveBeenCalled();
+    });
+});

package/dist/redux/sagas/saveData.d.ts

@@ -0,0 +1,2 @@
+declare function saveDataSaga(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+export default saveDataSaga;