@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/components/SmartScript.js

@@ -0,0 +1,85 @@
+import React, { useEffect, useState } from 'react';
+import { useParams } from 'react-router-dom';
+import queryString from 'query-string';
+import moment from 'moment-business-days';
+import { getConfig } from '../config';
+import { SmartScriptStore } from '../libs/SmartScriptStore';
+const SmartScriptComponent = () => {
+    const [smartScriptLoaded, setSmartScriptLoaded] = useState(false);
+    const [isNewInstance, setIsNewInstance] = useState(true);
+    const [initTriggersCallback, setInitTriggersCallback] = useState(null);
+    window.onInit = SmartScriptStore.onInit;
+    window.onLoad = SmartScriptStore.onLoad;
+    window.onOptionChange = SmartScriptStore.onOptionChange;
+    window.onVariableChange = SmartScriptStore.onVariableChange;
+    window.updateOptionInput = SmartScriptStore.updateOptionInput;
+    window.updateVariableInput = SmartScriptStore.updateVariableInput;
+    window.updateOptionMeta = SmartScriptStore.updateOptionMeta;
+    window.updateVariableMeta = SmartScriptStore.updateVariableMeta;
+    window.option = SmartScriptStore.getOptionInput;
+    window.variable = SmartScriptStore.getVariableInput;
+    window.optionAll = SmartScriptStore.getOptionAllInput;
+    window.variableAll = SmartScriptStore.getVariableAllInput;
+    window.hideVariable = SmartScriptStore.hideVariable;
+    window.displayVariable = SmartScriptStore.displayVariable;
+    window.hideOption = SmartScriptStore.hideOption;
+    window.displayOption = SmartScriptStore.displayOption;
+    window.moment = moment;
+    const apiEndpoint = getConfig().apiEndpoint + (/\/$/.test(getConfig().apiEndpoint) ? '' : '/');
+    const { permalink, uniqid } = useParams();
+    const modelVersion = queryString.parse(window.location.search).version;
+    useEffect(() => {
+        if (!smartScriptLoaded) {
+            const src = `${apiEndpoint}wizard/contractv1/smartscript/${permalink}${uniqid ? `/${uniqid}` : ''}${modelVersion ? `?version=${modelVersion}` : ''}`;
+            const scriptElement = document.createElement('script');
+            scriptElement.setAttribute('src', src);
+            scriptElement.onload = () => {
+                if (typeof initTriggersCallback === 'function') {
+                    if (isNewInstance)
+                        SmartScriptStore.execOnInit();
+                    SmartScriptStore.execOnLoad();
+                    initTriggersCallback(SmartScriptStore.triggers, SmartScriptStore.grabActions());
+                }
+                setSmartScriptLoaded(true);
+            };
+            document.body.append(scriptElement);
+        }
+    }, [
+        smartScriptLoaded,
+        apiEndpoint,
+        initTriggersCallback,
+        modelVersion,
+        permalink,
+        uniqid,
+        isNewInstance,
+    ]);
+    window.initTriggers = (callback, inputs, newInstance = true) => {
+        SmartScriptStore.inputs = inputs;
+        if (smartScriptLoaded) {
+            if (newInstance)
+                SmartScriptStore.execOnInit();
+            SmartScriptStore.execOnLoad();
+            callback(SmartScriptStore.triggers, SmartScriptStore.grabActions());
+        }
+        else {
+            setInitTriggersCallback(callback);
+            setIsNewInstance(newInstance);
+        }
+    };
+    window.triggerListeners = (type, id, inputs) => {
+        const hooks = SmartScriptStore.hooks[type === 'option' ? 'options' : 'variables'];
+        const listeners = hooks[id];
+        if (Array.isArray(listeners)) {
+            SmartScriptStore.inputs = inputs;
+            try {
+                listeners.forEach((_cb) => _cb());
+            }
+            catch (e) {
+                console.error('SmartScript (onInit) error: ', e.message);
+            }
+        }
+        return SmartScriptStore.grabActions();
+    };
+    return React.createElement(React.Fragment, null, "SmartScript");
+};
+export default SmartScriptComponent;

package/dist/components/UserLocked/UserLockedComponent.d.ts

@@ -0,0 +1,6 @@
+import React, { CSSProperties } from 'react';
+export interface IProps {
+    unhealthyStyle: CSSProperties;
+}
+declare const _default: React.FC<IProps>;
+export default _default;

package/dist/components/UserLocked/UserLockedComponent.js

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ReplaceComponent } from '../../PluginLoader';
+const UserLockedComponent = ({ unhealthyStyle }) => (React.createElement("div", { style: unhealthyStyle }, "Merci d\u2018avoir compl\u00E9t\u00E9 votre questionnaire ! Votre Expert-Comptable a \u00E9t\u00E9 notifi\u00E9 de vos r\u00E9ponses et vous contactera pour la suite de la proc\u00E9dure"));
+const UserLockHooc = (Component) => (props) => {
+    const replaceAnchors = ['UserLockedComponent'];
+    const FinalComponent = ReplaceComponent(replaceAnchors, Component);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(FinalComponent, Object.assign({}, props))));
+};
+export default UserLockHooc(UserLockedComponent);

package/dist/components/View.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare type OwnProps = {
+    currentAppState: string;
+    goPage: (p: number) => void;
+};
+declare class ViewComponent extends React.Component<OwnProps> {
+    componentDidMount(): void;
+    shouldComponentUpdate(newProps: OwnProps): boolean;
+    render(): JSX.Element;
+}
+declare const _default: import("react-redux").ConnectedComponent<typeof ViewComponent, any>;
+export default _default;

package/dist/components/View.js

@@ -0,0 +1,91 @@
+import React from 'react';
+import { connect } from 'react-redux';
+import Moustrap from 'mousetrap';
+import Shimmer from '../Shimmer';
+import { loadThemeComponent } from '../ThemeLoader';
+import { selectCurrentAppState, selectAvailableAppStates, selectAvailableSections, } from '../redux/selectors/app';
+import Globals from '../Globals';
+import { goPageAction } from '../redux/actions/app';
+import { loadPluginComponent, pluginsLoaded } from '../PluginLoader';
+class ViewComponent extends React.Component {
+    componentDidMount() {
+        Moustrap.bind('g o d l d', () => {
+            const currentAppState = selectCurrentAppState();
+            if (currentAppState === 'email') {
+                return;
+            }
+            const totalSections = selectAvailableSections().length;
+            const availableAppStates = selectAvailableAppStates();
+            const emailIndex = availableAppStates.indexOf('email');
+            const wizardIndex = availableAppStates.indexOf('wizard');
+            const emailPage = totalSections + (emailIndex - wizardIndex);
+            this.props.goPage(emailPage);
+        });
+    }
+    shouldComponentUpdate(newProps) {
+        if (this.props.currentAppState !== newProps.currentAppState) {
+            return true;
+        }
+        return false;
+    }
+    render() {
+        let AppStateComponent;
+        switch (this.props.currentAppState) {
+            case 'termsheet':
+                AppStateComponent = loadThemeComponent('TermsheetComponent');
+                break;
+            case 'email':
+                AppStateComponent = loadThemeComponent('EmailComponent');
+                break;
+            case 'wizard':
+                AppStateComponent = loadThemeComponent('WizardComponent');
+                break;
+            default:
+                if (pluginsLoaded())
+                    AppStateComponent =
+                        loadPluginComponent(this.props.currentAppState) ||
+                            loadThemeComponent('WizardComponent');
+                else
+                    AppStateComponent = () => React.createElement(React.Fragment, null);
+                break;
+        }
+        const envStyle = {
+            top: '0',
+            left: '50%',
+            fontSize: '8pt',
+            padding: '4px 8px',
+            lineHeight: '16px',
+            background: '#E0182D',
+            color: '#FFF',
+            textTransform: 'uppercase',
+            fontWeight: 'bold',
+            borderRadius: '0 0 4px 4px',
+            zIndex: 99999999,
+            position: 'fixed',
+            transform: 'translateX(-50%)',
+            opacity: 0.6,
+            userSelect: 'none',
+        };
+        return (React.createElement(Shimmer, null,
+            Globals.env !== 'production' &&
+                process.env.JEST_WORKER_ID === undefined && (React.createElement("div", { style: envStyle },
+                Globals.env,
+                " (",
+                Globals.version,
+                ")")),
+            React.createElement(React.Suspense, { fallback: null },
+                React.createElement(AppStateComponent, null))));
+    }
+}
+const mapStateToProps = () => {
+    const currentAppState = selectCurrentAppState();
+    return {
+        currentAppState,
+    };
+};
+const mapDispatchToProps = (dispatch) => {
+    return {
+        goPage: (page) => dispatch(goPageAction(page)),
+    };
+};
+export default connect(mapStateToProps, mapDispatchToProps)(ViewComponent);

package/dist/components/View.test.d.ts

@@ -0,0 +1,2 @@
+import 'regenerator-runtime/runtime';
+import '@testing-library/jest-dom/extend-expect';

package/dist/components/View.test.js

@@ -0,0 +1,83 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import 'regenerator-runtime/runtime';
+import React from 'react';
+import '@testing-library/jest-dom/extend-expect';
+import { render, cleanup, waitFor } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import { createAppStore, getStore } from '../redux/store';
+import { initPaginationAction, initMetaAction, fetchModelSucceededAction, goPageAction, } from '../redux/actions/app';
+import View from './View';
+afterEach(cleanup);
+jest.mock('../config', () => ({
+    __esModule: true,
+    getConfig: () => ({
+        theme: { name: 'jestTestTheme' },
+        plugins: {},
+        apiEndpoint: 'https://api.legalplace.fr/api/v1/',
+        router: {
+            wizardPath: '/:permalink/:modelId([0-9]+)?/questionnaire/:page([0-9]+|sommaire)',
+            wizardInstancePath: '/:permalink/:modelId([0-9]+)?/questionnaire/:uniqid([0-9a-zA-Z]+)/:page([0-9]+|sommaire)',
+        },
+        appStates: ['wizard', 'termsheet'],
+    }),
+    isConfigReady: () => true,
+    loadConfig: () => __awaiter(void 0, void 0, void 0, function* () {
+        return ({
+            theme: { name: 'jestTestTheme' },
+            plugins: {},
+            apiEndpoint: 'https://api.legalplace.fr/api/v1/',
+            router: {
+                wizardPath: '/:permalink/:modelId([0-9]+)?/questionnaire/:page([0-9]+|sommaire)',
+                wizardInstancePath: '/:permalink/:modelId([0-9]+)?/questionnaire/:uniqid([0-9a-zA-Z]+)/:page([0-9]+|sommaire)',
+            },
+            appStates: ['wizard', 'termsheet'],
+        });
+    }),
+}));
+jest.mock('../Globals', () => ({
+    loadTheme: (plugin) => import(`../tests-misc/themes/${plugin}`),
+}));
+describe('<View />', () => {
+    let store;
+    beforeEach(() => {
+        createAppStore('memory');
+        store = getStore();
+        store.dispatch(initPaginationAction({
+            currentPage: 1,
+            greatestPage: 1,
+            currentSectionId: 1,
+            availableSections: [1, 2],
+            currentAppState: 'wizard',
+            availableAppStates: ['wizard', 'termsheet'],
+        }));
+        store.dispatch(initMetaAction({
+            title: 'My Test Document',
+            id: 132,
+            prefix: '',
+            permalink: 'my-test-document',
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        store.dispatch(fetchModelSucceededAction());
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    it('Loads WizardComponent properly', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { container } = render(React.createElement(Provider, { store: store },
+            React.createElement(View, null)));
+        yield waitFor(() => expect(container).toContainHTML('<div><h1>Wizard test theme, WizardComponent</h1></div>'));
+    }));
+    it('Loads TermsheetComponent properly', () => __awaiter(void 0, void 0, void 0, function* () {
+        store.dispatch(goPageAction(3));
+        const { container } = render(React.createElement(Provider, { store: store },
+            React.createElement(View, null)));
+        yield waitFor(() => expect(container).toContainHTML('<div><h1>Wizard test theme, TermsheetComponent</h1></div>'));
+    }));
+});

package/dist/componentsConnectors/connectBox.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import type { OptionV3 } from '@legalplace/models-v3-types';
+export declare type ConnectBoxOwnProps = {
+    id: number;
+    index: number;
+};
+export declare type ConnectBoxMapProps = {
+    type: string;
+    content: string;
+    box: OptionV3['meta']['box'];
+    condition?: boolean;
+    options: number[];
+    tags?: string[];
+};
+export declare const connectBox: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectBoxOwnProps & ConnectBoxMapProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & ConnectBoxOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectBox.js

@@ -0,0 +1,28 @@
+import { componentConnector, } from './connector/componentConnector';
+import { getRelatedVariablesValues, parseContentWithVariables, } from '../helpers/outputsParsing';
+const stateToProps = (selectors) => (state, ownProps) => {
+    const { id, index } = ownProps;
+    const option = selectors.selectOptionReference(id);
+    const boxReference = selectors.selectBoxReference(id);
+    const variables = getRelatedVariablesValues(id, index, boxReference.variables);
+    const condition = selectors.selectOptionConditionValue(id, index);
+    const content = condition === false
+        ? ''
+        : parseContentWithVariables(boxReference.raw, id, index, variables);
+    const { options, meta } = option;
+    const { tags, type, box } = meta;
+    return {
+        id,
+        index,
+        type,
+        content,
+        condition,
+        box,
+        tags,
+        options,
+    };
+};
+export const connectBox = componentConnector({
+    componentName: 'Box',
+    stateToProps,
+});

package/dist/componentsConnectors/connectBox.test.d.ts

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

package/dist/componentsConnectors/connectBox.test.js

@@ -0,0 +1,208 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import React from 'react';
+import renderer from 'react-test-renderer';
+import { initOptionAction, initVariableAction } from '../redux/actions/inputs';
+import { getStore, createAppStore } from '../redux/store';
+import { initReferencesAction } from '../redux/actions/references';
+import { initConditionsAction, updateOptionConditionsAction, } from '../redux/actions/conditions';
+const references = {
+    options: {
+        1: {
+            meta: {
+                id: 1,
+                label: 'textbox',
+                type: 'box',
+                step: '*',
+                box: {
+                    content: 'This content should be parsed with [var:1] value',
+                    collapsable: true,
+                    aggregatable: false,
+                    type: 'error',
+                    title: 'My Test Box',
+                },
+                tags: ['ivann'],
+            },
+            options: [],
+            variables: [],
+        },
+        2: {
+            meta: {
+                id: 2,
+                label: 'My test question',
+                step: '*',
+                type: 'static',
+            },
+            options: [],
+            variables: [1],
+        },
+    },
+    variables: {
+        1: {
+            id: 1,
+            label: 'My Test Variable',
+            step: '*',
+            type: 'text',
+        },
+    },
+    relations: {
+        options: {
+            1: {
+                options: [],
+                variables: [],
+                validators: {
+                    options: [],
+                    variables: [],
+                },
+                sections: {},
+                prefillers: [],
+                documents: [],
+                parents: [],
+                children: {
+                    options: [],
+                    variables: [],
+                },
+                dependants: [],
+            },
+            2: {
+                options: [],
+                variables: [],
+                validators: {
+                    options: [],
+                    variables: [],
+                },
+                sections: {},
+                prefillers: [],
+                documents: [],
+                parents: [],
+                children: {
+                    options: [],
+                    variables: [2],
+                },
+                dependants: [],
+            },
+        },
+        variables: {
+            1: {
+                options: [],
+                variables: [],
+                validators: {
+                    options: [],
+                    variables: [],
+                },
+                sections: {},
+                prefillers: [],
+                prefillingsContents: [],
+                documents: [],
+                parents: [2],
+            },
+        },
+        sections: {},
+    },
+    conditions: {
+        options: {},
+        variables: {},
+        prefillers: {},
+        validators: {
+            options: {},
+            variables: {},
+        },
+        sections: {},
+        documents: {},
+    },
+    sections: {},
+    documents: {},
+    defaults: {},
+    outputs: {},
+    evaluations: {},
+    boxes: {
+        1: {
+            variables: [1],
+            raw: 'This content should be parsed with [var:1] value',
+        },
+    },
+};
+const conditions = {
+    options: {
+        1: [true],
+    },
+    variables: {},
+    prefillers: {},
+    sections: {
+        main: {},
+    },
+    documents: {},
+    validators: {
+        options: {},
+        variables: {},
+    },
+};
+describe('connectBox test suit', () => {
+    let store;
+    let connectBox;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        createAppStore('memory');
+        store = getStore();
+        store.dispatch(initReferencesAction(references));
+        store.dispatch(initVariableAction(1, ['My Test Variable']));
+        store.dispatch(initConditionsAction(conditions));
+        store.dispatch(initOptionAction(1, [true]));
+        connectBox = require('./connectBox').connectBox;
+    }));
+    it('Should parse variables', () => {
+        const ConnectedBox = connectBox((props) => {
+            return React.createElement("h1", null, props.content);
+        });
+        const component = renderer.create(React.createElement(ConnectedBox, { store: store, id: 1, index: 0 }));
+        expect(component.toTree().rendered.props.content).toEqual('This content should be parsed with My Test Variable value');
+    });
+    it('Should not parse on false condition', () => {
+        store.dispatch(updateOptionConditionsAction(1, 0, false));
+        const ConnectedBox = connectBox((props) => {
+            return React.createElement("h1", null, props.content);
+        });
+        const component = renderer.create(React.createElement(ConnectedBox, { store: store, id: 1, index: 0 }));
+        expect(component.toTree().rendered.props.content).toEqual('');
+    });
+    it('Should retrun props properly', () => {
+        store.dispatch(updateOptionConditionsAction(1, 0, true));
+        const ConnectedBox = connectBox((props) => {
+            return React.createElement("h1", null, props.content);
+        });
+        const component = renderer.create(React.createElement(ConnectedBox, { store: store, id: 1, index: 0 }));
+        const { props } = component.toTree().rendered;
+        const { id, index, type, content, condition, box, tags, options } = props;
+        expect({
+            id,
+            index,
+            type,
+            content,
+            condition,
+            box,
+            tags,
+            options,
+        }).toEqual({
+            id: 1,
+            index: 0,
+            type: 'box',
+            content: 'This content should be parsed with My Test Variable value',
+            condition: true,
+            box: {
+                type: 'error',
+                title: 'My Test Box',
+                content: 'This content should be parsed with [var:1] value',
+                aggregatable: false,
+                collapsable: true,
+            },
+            tags: ['ivann'],
+            options: [],
+        });
+    });
+});

package/dist/componentsConnectors/connectDocument.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+export declare type ConnectDocumentOwnProps = {
+    document: string;
+};
+export declare type ConnectDocumentMapProps = {
+    document: string;
+    outputs: Record<string, string>;
+};
+export declare const connectDocument: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectDocumentOwnProps & ConnectDocumentMapProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & ConnectDocumentOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectDocument.js

@@ -0,0 +1,29 @@
+import { componentConnector, } from './connector/componentConnector';
+import { NumAuto } from '../libs/NumAuto';
+import { DocumentsOutputs } from '../libs/DocumentsOutputs';
+import { selectAllSectionsReferences } from '../redux/selectors/references';
+const stateToProps = (selectors) => (state, ownProps) => {
+    const { selectOptionConditionValue, selectSectionConditionValue, selectOptionInput, selectVariableInput, selectOptionReference, selectOutputReference, selectVariableReference, selectSectionReference, } = selectors;
+    const document = ownProps.document === 'default' ? 'main' : ownProps.document;
+    const documentOutputs = new DocumentsOutputs({
+        optionConditions: (id, index) => selectOptionConditionValue(id, index),
+        sectionConditions: (id, doc) => selectSectionConditionValue(id, doc),
+        optionInputs: (id) => selectOptionInput(id),
+        variablesInputs: (id) => selectVariableInput(id),
+        optionReference: (id) => selectOptionReference(id),
+        outputReference: (id) => selectOutputReference(id),
+        variableReference: (id) => selectVariableReference(id),
+        sectionReference: (id) => selectSectionReference(id),
+        documentSections: (doc) => selectAllSectionsReferences(doc),
+    }, document);
+    const outputs = documentOutputs.getOutputs();
+    NumAuto.resetNums();
+    return {
+        document,
+        outputs,
+    };
+};
+export const connectDocument = componentConnector({
+    componentName: 'Document',
+    stateToProps,
+});

package/dist/componentsConnectors/connectDocument.test.d.ts

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