@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/redux/sagas/saveData.js

@@ -0,0 +1,71 @@
+import { call, put, takeLatest } from 'redux-saga/effects';
+import { v4 as uuid } from 'uuid';
+import { setDataStatus } from '../actions/app';
+import { selectPermalink, selectInstanceUniqid, selectDocumentTitle, selectInstanceIsPaid, } from '../selectors/app';
+import { SAVE_DATA } from '../constants/sagas/data';
+import { selectInputs } from '../selectors/inputs';
+import { OvcConverter } from '../../libs/OvcConverter';
+import { updateInstanceArguments } from '../../service/api.manager';
+import { getSendinblueIdentifyAttributes } from '../../helpers/sendinblueHelper';
+import { getConfig } from '../../config';
+import { selectUserEmail } from '../selectors/user';
+const getSendinblueData = (uniqid, paid) => {
+    const email = selectUserEmail();
+    const apiEndpoint = getConfig().apiEndpoint + (/\/$/.test(getConfig().apiEndpoint) ? '' : '/');
+    const ovc = OvcConverter.convertToOvc(selectInputs());
+    const nbFilledVars = Object.keys(ovc.v).reduce((p, c) => {
+        const currentValue = ovc.v[c];
+        const o = Array.isArray(currentValue)
+            ? currentValue.reduce((_p, _c) => _p + (_c !== '' ? 1 : 0), 0)
+            : currentValue !== ''
+                ? 1
+                : 0;
+        return p + o;
+    }, 0);
+    const attributes = getSendinblueIdentifyAttributes(uniqid, selectDocumentTitle(), nbFilledVars, paid, window.location.host);
+    return [apiEndpoint, email, attributes];
+};
+function* saveDataDecorator(action) {
+    try {
+        yield put(setDataStatus('saving'));
+        const permalink = selectPermalink();
+        const uniqid = selectInstanceUniqid();
+        const response = yield call(fetch, ...updateInstanceArguments(permalink, uniqid, OvcConverter.convertToOvc(selectInputs()), action.confirmAnswer ? 0 : 1, action.additionalProperties));
+        const responseData = yield call([response, 'json']);
+        if (action.redirect === true) {
+            if (responseData.redirect_to) {
+                try {
+                    const [apiEndpoint, email, attributes] = getSendinblueData(uniqid, selectInstanceIsPaid());
+                    yield call(fetch, `${apiEndpoint}event/create/${uniqid}/${uuid()}`, {
+                        method: 'POST',
+                        credentials: 'include',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({
+                            email,
+                            attributes,
+                        }),
+                    });
+                }
+                catch (error) {
+                }
+                window.onbeforeunload = () => { };
+                window.location.href = responseData.redirect_to;
+            }
+            else if (action.redirectFallback) {
+                window.onbeforeunload = () => { };
+                window.location.href = action.redirectFallback;
+            }
+        }
+        yield put(setDataStatus('saved'));
+    }
+    catch (e) {
+        console.error(e);
+        yield put(setDataStatus('failed'));
+    }
+}
+function* saveDataSaga() {
+    yield takeLatest(SAVE_DATA, saveDataDecorator);
+}
+export default saveDataSaga;

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

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

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

@@ -0,0 +1,74 @@
+import * as fs from 'fs';
+import { ReferencesParser } from '@legalplace/referencesparser';
+import { createAppStore, getStore } from '../store';
+import { initMetaAction, initPaginationAction, initInstanceAction, } from '../actions/app';
+import { initReferencesAction } from '../actions/references';
+import { IntputsInitiator } from '../../libs/InputsInitiator';
+import { initOptionAction, initVariableAction, updateOptionAction, } from '../actions/inputs';
+import { initConditionsAction } from '../actions/conditions';
+import { ConditionsInitiator } from '../../libs/ConditionsInitiator';
+import { saveDataAction } from '../actions/sagas/data';
+require('jest-fetch-mock').enableMocks();
+const permalink = 'test-model';
+const uniqid = 'myMockUniqid';
+const mockApiEndpoint = 'https://api.mock/api/v1/';
+jest.mock('../../config', () => ({
+    getConfig: () => ({
+        apiEndpoint: mockApiEndpoint,
+    }),
+}));
+describe('Save data saga', () => {
+    let store;
+    beforeEach(() => {
+        createAppStore('memory');
+        store = getStore();
+        store.dispatch({
+            type: 'SET_DEFAULTS',
+        });
+        const model = JSON.parse(fs.readFileSync('./src/misc/test_models/setDefaults.testmodel.json', 'utf8'));
+        const references = new ReferencesParser(model).getReferences();
+        store.dispatch(initReferencesAction(references));
+        const inputs = new IntputsInitiator(references, null).getInputs();
+        Object.keys(inputs.options).forEach((optionId) => {
+            const values = inputs.options[optionId];
+            store.dispatch(initOptionAction(parseInt(optionId, 10), values));
+        });
+        Object.keys(inputs.variables).forEach((variableId) => {
+            const values = inputs.variables[variableId];
+            store.dispatch(initVariableAction(parseInt(variableId, 10), values));
+        });
+        store.dispatch(initMetaAction({
+            id: 123,
+            title: 'Test model',
+            permalink,
+            modelVersion: 1,
+            prefix: '',
+            productType: 'demarche',
+        }));
+        store.dispatch(initInstanceAction({
+            uniqid,
+            isPaid: false,
+            dataStatus: 'unsaved',
+            steps: '*',
+        }));
+        store.dispatch(initPaginationAction({
+            availableAppStates: ['wizard', 'termsheet'],
+            currentAppState: 'wizard',
+            currentPage: 4,
+            greatestPage: 4,
+            currentSectionId: 1,
+            availableSections: [1, 3],
+        }));
+        const conditions = new ConditionsInitiator(references, inputs).getConditions();
+        store.dispatch(initConditionsAction(conditions));
+        store.dispatch({ type: 'SET_DEFAULTS' });
+        store.dispatch(updateOptionAction(15, true, 0));
+        fetchMock.resetMocks();
+    });
+    it('Sends save request to API', () => {
+        fetchMock.mockResponseOnce(JSON.stringify({ status: 'success' }));
+        store.dispatch(saveDataAction());
+        expect(fetchMock.mock.calls.length).toEqual(1);
+        expect(fetchMock.mock.calls[0][0]).toEqual(`${mockApiEndpoint}wizard/instance/${permalink}/${uniqid}`);
+    });
+});

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

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

package/dist/redux/sagas/setDefaults.js

@@ -0,0 +1,102 @@
+import { call, put, takeLatest } from 'redux-saga/effects';
+import { selectCurrentPage, selectAvailableSections, selectCurrentSectionId, } from '../selectors/app';
+import { selectSectionDefaults, selectRadioSiblings, } from '../selectors/references';
+import { selectOptionInput, selectOptionInputByIndex, } from '../selectors/inputs';
+import { updateOptionAction } from '../actions/inputs';
+import { goPageAction } from '../actions/app';
+import { selectOptionConditionValue } from '../selectors/conditions';
+function setOptionsDefaults(id, defaults, parentIndexes) {
+    let ActionsToDispatch = [];
+    const currentConditions = selectOptionConditionValue(id);
+    const currentValues = selectOptionInput(id);
+    const Indexes = parentIndexes === undefined ? [] : parentIndexes;
+    if (parentIndexes === undefined) {
+        if (currentConditions !== undefined) {
+            currentConditions.forEach((value, index) => {
+                if (value === true)
+                    Indexes.push(index);
+            });
+        }
+        else {
+            currentValues.forEach((value, index) => {
+                if (value === true)
+                    Indexes.push(index);
+            });
+        }
+    }
+    const defaultValue = defaults.isDefault ? defaults.isDefault : false;
+    if (currentValues.reduce((p, c) => p && c, true) !== true &&
+        defaultValue !== true)
+        return [];
+    const siblings = selectRadioSiblings(id);
+    Indexes.forEach((occurencyIndex) => {
+        const currentValueOccurency = currentValues[occurencyIndex];
+        if (currentValueOccurency === true || defaultValue === false)
+            return;
+        let siblingsValue = false;
+        if (Array.isArray(siblings) && siblings.length > 0) {
+            siblings.forEach((siblingId) => {
+                const indexValue = selectOptionInputByIndex(siblingId, occurencyIndex);
+                siblingsValue =
+                    siblingsValue || (indexValue === undefined ? false : indexValue);
+            });
+        }
+        if (!siblingsValue) {
+            ActionsToDispatch.push([id, defaultValue, occurencyIndex]);
+        }
+    });
+    Object.keys(defaults.children).forEach((childId) => {
+        ActionsToDispatch = [
+            ...ActionsToDispatch,
+            ...setOptionsDefaults(parseInt(childId, 10), defaults.children[childId], Indexes),
+        ];
+    });
+    return ActionsToDispatch;
+}
+function* setDefaultOptionsSection(id) {
+    let ActionsToDispatch = [];
+    const sectionDefaults = selectSectionDefaults(id);
+    if (sectionDefaults === undefined)
+        return [];
+    Object.keys(sectionDefaults).forEach((optionId) => {
+        ActionsToDispatch = [
+            ...ActionsToDispatch,
+            ...setOptionsDefaults(parseInt(optionId, 10), sectionDefaults[optionId]),
+        ];
+    });
+    for (let i = 0; i < ActionsToDispatch.length; i += 1) {
+        yield put(updateOptionAction(...ActionsToDispatch[i]));
+    }
+    return ActionsToDispatch;
+}
+function* setDefaultOptions() {
+    let ActionsToDispatch = [];
+    const currentPage = selectCurrentPage();
+    const availableSections = selectAvailableSections();
+    let sections = [...availableSections].splice(0, currentPage - 1);
+    const previousAvailableSections = selectAvailableSections();
+    const previousSectionIndex = previousAvailableSections.indexOf(selectCurrentSectionId());
+    for (let i = 0; i < sections.length; i += 1) {
+        const sectionId = sections[i];
+        const actions = yield call(setDefaultOptionsSection, [sectionId]);
+        sections = [...selectAvailableSections()].splice(0, currentPage - 1);
+        ActionsToDispatch = [...ActionsToDispatch, ...actions];
+    }
+    const currentAvailableSections = selectAvailableSections();
+    const currentSectionIndex = currentAvailableSections.indexOf(selectCurrentSectionId());
+    if (selectAvailableSections().length <= currentSectionIndex &&
+        currentSectionIndex !== previousSectionIndex) {
+        let newPage = currentPage;
+        if (currentSectionIndex > previousSectionIndex) {
+            newPage += currentSectionIndex - previousSectionIndex;
+        }
+        else {
+            newPage -= previousSectionIndex - currentSectionIndex;
+        }
+        yield put(goPageAction(newPage));
+    }
+}
+function* setDefaultsSaga() {
+    yield takeLatest('SET_DEFAULTS', setDefaultOptions);
+}
+export default setDefaultsSaga;

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

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

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

@@ -0,0 +1,73 @@
+import * as fs from 'fs';
+import { ReferencesParser } from '@legalplace/referencesparser';
+import { createAppStore, getStore } from '../store';
+import { initMetaAction, initPaginationAction } from '../actions/app';
+import { initReferencesAction } from '../actions/references';
+import { IntputsInitiator } from '../../libs/InputsInitiator';
+import { initOptionAction, initVariableAction } from '../actions/inputs';
+import { initConditionsAction } from '../actions/conditions';
+import { ConditionsInitiator } from '../../libs/ConditionsInitiator';
+describe('Set defaults saga', () => {
+    let store;
+    beforeEach(() => {
+        createAppStore('memory');
+        store = getStore();
+        store.dispatch({
+            type: 'SET_DEFAULTS',
+        });
+        const model = JSON.parse(fs.readFileSync('./src/misc/test_models/setDefaults.testmodel.json', 'utf8'));
+        const references = new ReferencesParser(model).getReferences();
+        store.dispatch(initReferencesAction(references));
+        const inputs = new IntputsInitiator(references, null).getInputs();
+        Object.keys(inputs.options).forEach((optionId) => {
+            const values = inputs.options[optionId];
+            store.dispatch(initOptionAction(parseInt(optionId, 10), values));
+        });
+        Object.keys(inputs.variables).forEach((variableId) => {
+            const values = inputs.variables[variableId];
+            store.dispatch(initVariableAction(parseInt(variableId, 10), values));
+        });
+        store.dispatch(initMetaAction({
+            id: 123,
+            title: 'Test model',
+            permalink: 'test-model',
+            prefix: '',
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        store.dispatch(initPaginationAction({
+            availableAppStates: ['wizard', 'termsheet'],
+            currentAppState: 'wizard',
+            currentPage: 4,
+            greatestPage: 4,
+            currentSectionId: 1,
+            availableSections: [1, 3],
+        }));
+        const conditions = new ConditionsInitiator(references, inputs).getConditions();
+        store.dispatch(initConditionsAction(conditions));
+    });
+    it('Sets defaults properly', () => {
+        store.dispatch({ type: 'SET_DEFAULTS' });
+        expect(store.getState().app.wizard.availableSections).toStrictEqual([
+            1, 2, 3,
+        ]);
+        expect(store.getState().inputs.options).toStrictEqual({
+            1: [true],
+            2: [true],
+            3: [false],
+            4: [true],
+            5: [true],
+            6: [true],
+            7: [true],
+            8: [true],
+            9: [true],
+            10: [true],
+            11: [false],
+            12: [true],
+            13: [false],
+            14: [true],
+            15: [false],
+            16: [false],
+        });
+    });
+});

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

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

package/dist/redux/sagas/setUserEmail.js

@@ -0,0 +1,136 @@
+import { call, fork, put, takeLatest } from 'redux-saga/effects';
+import { getContractFunnelGAEvent } from '@legalplace/lp-events';
+import { v4 as uuid } from 'uuid';
+import { getConfig } from '../../config';
+import { selectPermalink, selectInstanceUniqid, selectDocumentTitle, selectAvailableAppStates, selectDocumentModelVersion, } from '../selectors/app';
+import { selectInputs } from '../selectors/inputs';
+import { SET_USER_EMAIL } from '../constants/sagas/user';
+import { setUserStatusAction, initUserAction } from '../actions/user';
+import { updateAvailableAppStatesAction, initInstanceAction, goNextPageAction, } from '../actions/app';
+import { OvcConverter } from '../../libs/OvcConverter';
+import { getSendinblueIdentifyAttributes } from '../../helpers/sendinblueHelper';
+import { setUserEmailSucceeded } from '../actions/sagas/user';
+import { EMAIL_REGEX } from '../../constants/emailValidation';
+const canalHeaders = {
+    'lp-referrer': window.document.referrer,
+    'lp-origin': window.location.href,
+};
+function* setUserEmailDecorator(action) {
+    try {
+        const { email, tags, inBackground } = action;
+        if (!EMAIL_REGEX.test(email)) {
+            if (!inBackground)
+                yield put(setUserStatusAction('failed'));
+            return;
+        }
+        yield put(setUserStatusAction('inprogress'));
+        const permalink = selectPermalink();
+        const instanceUniqid = selectInstanceUniqid();
+        const ovc = OvcConverter.convertToOvc(selectInputs());
+        const nbFilledVars = Object.keys(ovc.v).reduce((p, c) => {
+            const currentValue = ovc.v[c];
+            const o = Array.isArray(currentValue)
+                ? currentValue.reduce((_p, _c) => _p + (_c !== '' ? 1 : 0), 0)
+                : currentValue !== ''
+                    ? 1
+                    : 0;
+            return p + o;
+        }, 0);
+        let body = {
+            ovc,
+            nb_filled_vars: nbFilledVars,
+            nb_chosen_options: 0,
+            email,
+            tags,
+        };
+        if (instanceUniqid === undefined || instanceUniqid.length === 0) {
+            body = Object.assign(Object.assign({}, body), { app_type: 'wizardx', draft: 1, contract_version: selectDocumentModelVersion() });
+        }
+        const apiEndpoint = getConfig().apiEndpoint +
+            (/\/$/.test(getConfig().apiEndpoint) ? '' : '/');
+        const instanceResponse = yield call(fetch, `${apiEndpoint}wizard/instance/${permalink}/${instanceUniqid || ''}`, {
+            method: instanceUniqid === undefined || instanceUniqid.length === 0
+                ? 'POST'
+                : 'PUT',
+            credentials: 'include',
+            headers: Object.assign({ 'Content-Type': 'application/json' }, canalHeaders),
+            body: JSON.stringify(body),
+        });
+        const response = yield call([
+            instanceResponse,
+            'json',
+        ]);
+        const { redirect_to: redirectTo, user, uniqid, isPaid } = response;
+        if (typeof redirectTo !== 'string' || action.disableRedirect) {
+            if (instanceUniqid === undefined || instanceUniqid.length === 0) {
+                yield put(initInstanceAction({
+                    dataStatus: 'saved',
+                    uniqid,
+                    isPaid: isPaid || false,
+                    steps: [1],
+                }));
+            }
+            yield put(setUserStatusAction('authenticated'));
+            if (user) {
+                yield put(initUserAction(Object.assign(Object.assign({}, user), { level: user.role || user.level })));
+            }
+        }
+        if (typeof window.sendinblue !== 'undefined' && response.user) {
+            const attributes = getSendinblueIdentifyAttributes(uniqid, selectDocumentTitle(), nbFilledVars, false, window.location.host);
+            window.sendinblue.identify(email, attributes);
+            const fetchParams = {
+                method: 'POST',
+                credentials: 'include',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    email,
+                    attributes,
+                }),
+            };
+            try {
+                if (typeof redirectTo === 'string' && !action.disableRedirect) {
+                    yield call(fetch, `${apiEndpoint}event/create/${uniqid}/${uuid()}`, fetchParams);
+                }
+                else {
+                    yield fork(fetch, `${apiEndpoint}event/create/${uniqid}/${uuid()}`, fetchParams);
+                }
+            }
+            catch (error) {
+            }
+        }
+        try {
+            if (redirectTo && redirectTo.includes('generation'))
+                window.dataLayer.push(getContractFunnelGAEvent({
+                    currentStep: 1,
+                    contractName: selectDocumentTitle(),
+                    sectionTitle: 'Choississez votre pack',
+                    pageAction: 'Confirmation avant paiement 1 | 2',
+                }));
+        }
+        catch (error) {
+            console.error(error);
+        }
+        if (typeof redirectTo === 'string' && !action.disableRedirect) {
+            window.onbeforeunload = () => { };
+            setTimeout(() => {
+                window.location.href = redirectTo;
+            }, 1000);
+        }
+        const availableAppStates = [...selectAvailableAppStates()];
+        availableAppStates.splice(availableAppStates.indexOf('email'), 1);
+        yield put(updateAvailableAppStatesAction(availableAppStates));
+        if (!inBackground)
+            yield put(goNextPageAction());
+        yield put(setUserEmailSucceeded());
+    }
+    catch (e) {
+        console.error(e);
+        yield put(setUserStatusAction('inprogress'));
+    }
+}
+function* setUserEmailSaga() {
+    yield takeLatest(SET_USER_EMAIL, setUserEmailDecorator);
+}
+export default setUserEmailSaga;

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

@@ -0,0 +1,30 @@
+export declare const selectCurrentPage: () => number;
+export declare const selectAvailableAppStates: () => readonly string[];
+export declare const selectCurrentAppState: () => string;
+export declare const selectIsFirstPage: () => Readonly<boolean>;
+export declare const selectIsLastPage: () => Readonly<boolean>;
+export declare const selectIsLastWizardPage: () => Readonly<boolean>;
+export declare const selectGreatestPage: () => number;
+export declare const selectCurrentSectionId: () => number;
+export declare const selectAvailableSections: () => readonly number[];
+export declare const selectAvailableOptions: (document?: any) => readonly number[];
+export declare const selectMultipleOccurencies: () => Readonly<Record<string, number>>;
+export declare const selectOutputsIds: (document: string) => readonly [number, string][];
+export declare const selectPermalink: () => string;
+export declare const selectDocumentTitle: () => string;
+export declare const selectDocumentId: () => number;
+export declare const selectDocumentModelVersion: () => number;
+export declare const selectDocumentProductType: () => string;
+export declare const selectMeta: () => Readonly<import("../../types/State.type").AppMetaType>;
+export declare const selectMetaFetchStatus: () => Readonly<"failed" | "waiting" | "succeeded" | "unhealthy" | "userLocked" | "nonBlocking">;
+export declare const selectPrefix: () => Readonly<string | undefined>;
+export declare const selectInstanceUniqid: () => Readonly<string | undefined>;
+export declare const selectInstanceCompanyId: () => Readonly<number | undefined>;
+export declare const selectInstanceEmployeeId: () => Readonly<number | undefined>;
+export declare const selectDataStatus: () => Readonly<"saved" | "unsaved" | "saving" | "failed">;
+export declare const selectInstanceIsPaid: () => Readonly<boolean>;
+export declare const selectInstanceSteps: () => Readonly<boolean>;
+export declare const isStepAvailable: (steps: number[] | "*" | undefined) => Readonly<boolean>;
+export declare const selectCustomizationMeta: () => Readonly<import("../../types/State.type").AppCustomizationMetaType | undefined>;
+export declare const selectCustomizationAutoDefaultType: () => Readonly<boolean | undefined>;
+export declare const selectModelUuid: () => Readonly<string | undefined>;

package/dist/redux/selectors/app.js

@@ -0,0 +1,100 @@
+import { createSelector } from './selectors';
+import { selectOptionInput } from './inputs';
+export const selectCurrentPage = createSelector((state) => state.app.pagination.currentPage, (state) => state.app.pagination.currentPage.toString());
+export const selectAvailableAppStates = createSelector((state) => state.app.pagination.availableAppStates, (state) => state.app.pagination.availableAppStates.join('-'));
+export const selectCurrentAppState = createSelector((state) => state.app.pagination.currentAppState, (state) => state.app.pagination.currentAppState);
+export const selectIsFirstPage = createSelector((state) => state.app.pagination.isFirstPage, (state) => state.app.pagination.isFirstPage.toString());
+export const selectIsLastPage = createSelector((state) => state.app.pagination.isLastPage, (state) => state.app.pagination.isLastPage.toString());
+export const selectIsLastWizardPage = createSelector((state) => {
+    return (state.app.pagination.currentPage ===
+        state.app.wizard.availableSections.length);
+}, (state) => state.app.pagination.currentPage.toString());
+export const selectGreatestPage = createSelector((state) => state.app.pagination.greatestPage, (state) => state.app.pagination.greatestPage);
+export const selectCurrentSectionId = createSelector((state) => state.app.wizard.currentSectionId, (state) => state.app.wizard.currentSectionId);
+export const selectAvailableSections = createSelector((state) => [...state.app.wizard.availableSections], (state) => state.app.wizard.availableSections.reduce((p, c) => p + c, 0));
+export const selectAvailableOptions = createSelector((state, document = 'main') => {
+    let availableOptions = [];
+    const { availableSections } = state.app.wizard;
+    const documentSections = Object.keys(state.references.sections[document]).map((id) => parseInt(id, 10));
+    const sections = document === 'main' ? availableSections : documentSections;
+    sections.forEach((sectionId) => {
+        const { options } = state.references.sections[document][sectionId];
+        availableOptions = [...availableOptions, ...options];
+    });
+    return availableOptions;
+}, (state, document = 'main') => {
+    if (document === 'main')
+        return state.app.wizard.availableSections.reduce((a, b) => `${a}${b}`, '');
+    return document;
+});
+export const selectMultipleOccurencies = createSelector((state) => {
+    const multipleOptionsOccurencies = {};
+    const availableOptions = selectAvailableOptions('main');
+    if (availableOptions === undefined)
+        return {};
+    availableOptions.forEach((optionId) => {
+        var _a;
+        const ref = state.references.options[optionId];
+        if (((_a = ref.meta.multiple) === null || _a === void 0 ? void 0 : _a.enabled) === true) {
+            multipleOptionsOccurencies[optionId] =
+                selectOptionInput(optionId).length;
+        }
+    });
+    return multipleOptionsOccurencies;
+}, () => Math.random());
+export const selectOutputsIds = createSelector((state, document) => {
+    const availableOptions = selectAvailableOptions(document);
+    if (availableOptions === undefined)
+        return [];
+    const outputs = availableOptions.map((optionId) => {
+        const ref = state.references.options[optionId];
+        return [optionId, ref.meta.type];
+    });
+    return outputs;
+}, (state, document) => {
+    if (document !== 'main')
+        return document;
+    return state.app.wizard.availableSections.reduce((a, b) => `${a}${b}`, '');
+});
+export const selectPermalink = createSelector((state) => state.app.meta.permalink, (state) => state.app.meta.permalink);
+export const selectDocumentTitle = createSelector((state) => state.app.meta.title, (state) => state.app.meta.title);
+export const selectDocumentId = createSelector((state) => state.app.meta.id, (state) => state.app.meta.id);
+export const selectDocumentModelVersion = createSelector((state) => state.app.meta.modelVersion, (state) => state.app.meta.modelVersion);
+export const selectDocumentProductType = createSelector((state) => state.app.meta.productType, (state) => state.app.meta.productType);
+export const selectMeta = createSelector((state) => state.app.meta, (state) => state.app.meta.title);
+export const selectMetaFetchStatus = createSelector((state) => state.app.meta.fetchStatus, (state) => state.app.meta.fetchStatus);
+export const selectPrefix = createSelector((state) => (!state.app.meta ? undefined : state.app.meta.prefix), (state) => (!state.app.meta ? '0' : state.app.meta.permalink));
+export const selectInstanceUniqid = createSelector((state) => !state.app.instance ? undefined : state.app.instance.uniqid, (state) => (!state.app.instance ? '0' : state.app.instance.uniqid));
+export const selectInstanceCompanyId = createSelector((state) => !state.app.instance ? undefined : state.app.instance.companyId, (state) => !state.app.instance || !state.app.instance.companyId
+    ? '0'
+    : state.app.instance.companyId);
+export const selectInstanceEmployeeId = createSelector((state) => !state.app.instance ? undefined : state.app.instance.employeeId, (state) => !state.app.instance || !state.app.instance.employeeId
+    ? '0'
+    : state.app.instance.employeeId);
+export const selectDataStatus = createSelector((state) => !state.app.instance ? 'unsaved' : state.app.instance.dataStatus, (state) => !state.app.instance ? '0' : state.app.instance.dataStatus);
+export const selectInstanceIsPaid = createSelector((state) => !!(state.app.instance && state.app.instance.isPaid), (state) => state.app.instance && state.app.instance.isPaid
+    ? state.app.instance.isPaid.toString()
+    : '0');
+export const selectInstanceSteps = createSelector((state) => !!(state.app.instance && state.app.instance.steps), (state) => state.app.instance && state.app.instance.steps
+    ? state.app.instance.steps.toString()
+    : '0');
+export const isStepAvailable = createSelector((state, steps) => {
+    if (steps === undefined)
+        return true;
+    if (state.app.instance === undefined)
+        return steps === '*' ? true : steps.includes(1);
+    if (steps === '*')
+        return true;
+    if (state.app.instance.steps === '*')
+        return true;
+    return state.app.instance.steps
+        .map((c) => steps.includes(c))
+        .reduce((a, b) => a || b, false);
+}, (state, steps) => state.app.instance && state.app.instance.steps && steps
+    ? `${state.app.instance.steps.toString()}-${steps.toString()}`
+    : '0');
+export const selectCustomizationMeta = createSelector((state) => state.app.customization.meta, (state) => state.app.customization.meta !== undefined ? '1' : Math.random());
+export const selectCustomizationAutoDefaultType = createSelector((state) => state.app.customization.disableAutoDefault, (state) => state.app.customization.disableAutoDefault !== undefined
+    ? '1'
+    : Math.random());
+export const selectModelUuid = createSelector((state) => state.app.meta.modelUuid, (state) => state.app.meta.modelUuid !== undefined ? '1' : Math.random());

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

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