@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/componentsConnectors/connectTermsheet.js

@@ -0,0 +1,202 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import React from 'react';
+import { PluginLoader, ReplaceComponent } from '../PluginLoader';
+import { selectAvailableSections } from '../redux/selectors/app';
+import { selectSectionReference, selectOptionReference, selectVariableReference, } from '../redux/selectors/references';
+import { selectOptionInput, selectVariableInputByIndex, selectOptionInputByIndex, } from '../redux/selectors/inputs';
+import { selectOptionConditionValue, selectSectionConditionValue, selectVariableConditionValue, selectOptionValidatorConditionValue, selectVariableValidatorConditionValue, } from '../redux/selectors/conditions';
+import { PathReader } from '../libs/PathReader';
+import { isLevelAccessibleForUser } from '../redux/selectors/user';
+import { parseOptionLabel } from '../helpers/outputsParsing';
+const pushMultipleLabelForOption = (optionId, index, termsheet, pageNumber) => {
+    var _a, _b, _c, _d, _e, _f;
+    const optionReference = selectOptionReference(optionId);
+    if (optionReference === undefined)
+        throw new Error(`Option ${optionId} does not exist`);
+    if (((_a = optionReference.meta.termsheet) === null || _a === void 0 ? void 0 : _a.hide) === true)
+        return;
+    let occurencyId = index + 1;
+    const label = ((_c = (_b = optionReference.meta) === null || _b === void 0 ? void 0 : _b.multiple) === null || _c === void 0 ? void 0 : _c.label) ||
+        ((_e = (_d = optionReference.meta) === null || _d === void 0 ? void 0 : _d.multiple) === null || _e === void 0 ? void 0 : _e.cta) ||
+        '';
+    if ((_f = optionReference.meta.multiple) === null || _f === void 0 ? void 0 : _f.incrementationStart) {
+        const { incrementationStart } = optionReference.meta.multiple;
+        occurencyId += incrementationStart - 1;
+    }
+    termsheet.push({
+        label: `${label} ${occurencyId}`,
+        type: 'multiplelabel',
+        pageNumber,
+        hash: '',
+        value: '',
+        allowUpdate: false,
+    });
+};
+const rolldownTermsheetForVariable = (variableId, index, termsheet, pageNumber) => {
+    var _a, _b, _c, _d;
+    const variableReference = selectVariableReference(variableId);
+    if (variableReference === undefined)
+        throw new Error(`Variable ${variableId} does not exist`);
+    if (((_a = variableReference.termsheet) === null || _a === void 0 ? void 0 : _a.hide) === true)
+        return;
+    let value = selectVariableInputByIndex(variableId, index);
+    value = value || '';
+    const variableCondition = selectVariableConditionValue(variableId, index);
+    const variableValidator = selectVariableValidatorConditionValue(variableId, index);
+    const { grantLevel } = variableReference;
+    if (!isLevelAccessibleForUser(grantLevel || 'GUEST'))
+        return;
+    let { label } = variableReference;
+    if (typeof ((_b = variableReference.termsheet) === null || _b === void 0 ? void 0 : _b.label) === 'string' &&
+        ((_c = variableReference.termsheet) === null || _c === void 0 ? void 0 : _c.label.trim().length) > 0) {
+        label = (_d = variableReference.termsheet) === null || _d === void 0 ? void 0 : _d.label;
+    }
+    const variableTermsheet = {
+        type: 'variable',
+        label,
+        valid: variableValidator !== false,
+        value: typeof value === 'number' ? value.toString() : value,
+        pageNumber,
+        hash: `variable-${variableId}-${index}`,
+        allowUpdate: variableReference.type !== 'eval',
+    };
+    if (variableCondition !== false && variableReference.hidden !== false)
+        termsheet.push(variableTermsheet);
+};
+const rolldownTermsheetForOption = (optionId, index, termsheet, pageNumber) => {
+    var _a, _b, _c, _d;
+    const optionReference = selectOptionReference(optionId);
+    if (optionReference === undefined)
+        throw new Error(`Option ${optionId} does not exist`);
+    const optionInput = selectOptionInputByIndex(optionId, index);
+    const optionCondition = selectOptionConditionValue(optionId, index);
+    const optionValidator = selectOptionValidatorConditionValue(optionId, index);
+    if ((optionReference.meta.type !== 'checkbox' && optionInput === false) ||
+        optionCondition === false ||
+        ['hidden', 'repeated', 'box', 'separator', 'brut-text'].includes(optionReference.meta.type)) {
+        return;
+    }
+    const radioChilds = optionReference.options.filter((childId) => {
+        const childReference = selectOptionReference(childId);
+        if (childReference === undefined)
+            throw new Error(`Option ${childId} does not exist`);
+        return childReference.meta.type === 'radio';
+    });
+    const selectedChild = radioChilds.filter((childId) => selectOptionInputByIndex(childId, index));
+    let value = selectedChild
+        .map((childId) => {
+        const childReference = selectOptionReference(childId);
+        if (childReference === undefined)
+            throw new Error(`Option ${childId} does not exist`);
+        const label = parseOptionLabel(childId, index);
+        return label;
+    })
+        .join('');
+    if (optionReference.meta.type === 'checkbox') {
+        value = optionInput === true ? 'Oui' : 'Non';
+    }
+    else if (optionReference.meta.type === 'static' &&
+        radioChilds.length === 0) {
+        value = 'null-value';
+    }
+    let { label } = optionReference.meta;
+    if (typeof ((_a = optionReference.meta.termsheet) === null || _a === void 0 ? void 0 : _a.label) === 'string' &&
+        ((_b = optionReference.meta.termsheet) === null || _b === void 0 ? void 0 : _b.label.trim().length) > 0) {
+        label = (_c = optionReference.meta.termsheet) === null || _c === void 0 ? void 0 : _c.label;
+    }
+    if (/\[var:([0-9]+)\]/gi.test(label))
+        label = parseOptionLabel(optionId, index);
+    if (((_d = optionReference.meta.termsheet) === null || _d === void 0 ? void 0 : _d.hide) !== true) {
+        termsheet.push({
+            pageNumber,
+            hash: `option-${optionId}-${index}`,
+            valid: optionValidator !== false,
+            label,
+            value,
+            type: 'option',
+            allowUpdate: true,
+        });
+    }
+    if (optionInput === true) {
+        optionReference.options.forEach((childrenId) => {
+            rolldownTermsheetForOption(childrenId, index, termsheet, pageNumber);
+        });
+    }
+    if (optionInput === true) {
+        optionReference.variables.forEach((variableId) => {
+            rolldownTermsheetForVariable(variableId, index, termsheet, pageNumber);
+        });
+    }
+};
+const rolldownTermsheetForSection = (section, sectionIndex = 0, termsheet) => {
+    const pageNumber = sectionIndex + 1;
+    const sectionTermsheetRow = {
+        label: section.label,
+        preLabel: pageNumber < 10 ? `0${pageNumber}` : pageNumber.toString(),
+        type: 'section',
+        pageNumber,
+        hash: '',
+        value: '',
+        allowUpdate: false,
+    };
+    termsheet.push(sectionTermsheetRow);
+    section.options.forEach((optionId) => {
+        var _a;
+        const inputs = selectOptionInput(optionId);
+        const optionReference = selectOptionReference(optionId);
+        if (optionReference === undefined)
+            throw new Error(`Option ${optionId} does not exist`);
+        const { grantLevel } = optionReference.meta;
+        if (!isLevelAccessibleForUser(grantLevel || 'GUEST'))
+            return;
+        inputs.forEach((value, index) => {
+            if (inputs.length > 1) {
+                pushMultipleLabelForOption(optionId, index, termsheet, pageNumber);
+            }
+            rolldownTermsheetForOption(optionId, index, termsheet, pageNumber);
+        });
+        if (inputs.length > 1 && ((_a = optionReference.meta.termsheet) === null || _a === void 0 ? void 0 : _a.hide) !== true) {
+            termsheet.push({
+                label: '',
+                type: 'multiplelabel',
+                pageNumber,
+                hash: '',
+                value: '',
+                allowUpdate: false,
+            });
+        }
+    });
+    if (termsheet[termsheet.length - 1] === sectionTermsheetRow) {
+        termsheet.splice(termsheet.indexOf(sectionTermsheetRow), 1);
+    }
+};
+const TermsheetHooc = (Component) => (props) => {
+    const beforeAnchors = ['beforeTermsheet'];
+    const afterAnchors = ['afterTermsheet'];
+    const replaceAnchors = ['Termsheet'];
+    const FinalComponent = ReplaceComponent(replaceAnchors, Component);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(PluginLoader, { anchor: beforeAnchors, props: props }),
+        React.createElement(FinalComponent, Object.assign({}, props)),
+        React.createElement(PluginLoader, { anchor: afterAnchors, props: props })));
+};
+const mapStateToProps = (state) => {
+    const pathReader = new PathReader(state);
+    const sectionsIds = selectAvailableSections();
+    const termsheet = [];
+    sectionsIds.forEach((sectionId, sectionIndex) => {
+        const sectionReference = selectSectionReference(sectionId);
+        if (sectionReference === undefined)
+            throw new Error(`Section ${sectionId} does not exist`);
+        const sectionCondition = selectSectionConditionValue(sectionId);
+        if (sectionCondition === false)
+            return;
+        rolldownTermsheetForSection(sectionReference, sectionIndex, termsheet);
+    });
+    return {
+        termsheet,
+        parseLink: (page) => pathReader.parsePath(page),
+    };
+};
+export const connectTermsheet = compose(connect(mapStateToProps), TermsheetHooc);

package/dist/componentsConnectors/connectVariable.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import type { VariableV3 } from '@legalplace/models-v3-types';
+export declare type ConnectVariableOwnProps = {
+    id: number;
+    index: number;
+};
+export declare type ConnectVariableMapProps = {
+    id: number;
+    index: number;
+    label: string;
+    type: string;
+    value: string | number;
+    condition?: boolean;
+    validator?: boolean;
+    validatorMessage: string;
+    mandatoryValidated: boolean;
+    mandatoryIgnore: boolean;
+    display: boolean;
+    meta: VariableV3;
+};
+export declare type ConnectVariableDispatchProps = {
+    updateVariable: (value: string | number) => void;
+};
+export declare const connectVariable: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectVariableOwnProps & ConnectVariableMapProps & ConnectVariableDispatchProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & ConnectVariableOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectVariable.js

@@ -0,0 +1,69 @@
+import { componentConnector, } from './connector/componentConnector';
+import { isStepAvailable } from '../redux/selectors/app';
+import { parseRawWithVariables, parseVariableLabel, } from '../helpers/outputsParsing';
+const canVariableDisplay = (id, index, selectors) => {
+    const { selectVariableReference, isLevelAccessibleForUser } = selectors;
+    const variable = selectVariableReference(id);
+    let display = isStepAvailable(variable.step);
+    display = display && !(variable.hidden === true);
+    display =
+        display && !selectors.selectIsSmartscriptVariableIndexHidden(id, index);
+    display = display && isLevelAccessibleForUser(variable.grantLevel || 'GUEST');
+    return display;
+};
+const stateToProps = (selectors) => (state, ownProps) => {
+    var _a;
+    const { selectVariableReference, selectVariableInputByIndex, selectVariableConditionValue, selectVariableValidatorConditionValue, selectMandatoryVariableByIndex, } = selectors;
+    const { id, index } = ownProps;
+    const variable = selectVariableReference(id);
+    const label = parseVariableLabel(id, index);
+    const display = canVariableDisplay(id, index, selectors);
+    const value = selectVariableInputByIndex(id, index) || '';
+    const condition = selectVariableConditionValue(id, index);
+    const validator = selectVariableValidatorConditionValue(id, index);
+    const { type } = variable;
+    const mandatoryValidated = selectMandatoryVariableByIndex(id, index);
+    const mandatoryIgnore = selectors.selectMandatoryIgnore();
+    const validatorMessage = typeof ((_a = variable.validator) === null || _a === void 0 ? void 0 : _a.message) === 'string'
+        ? parseRawWithVariables(variable.validator.message)
+        : '';
+    const helper = variable.helper
+        ? parseRawWithVariables(variable.helper, undefined, '________________')
+        : undefined;
+    const warning = variable.warning
+        ? parseRawWithVariables(variable.warning, undefined, '________________')
+        : undefined;
+    return {
+        id,
+        index,
+        label,
+        type,
+        meta: Object.assign(Object.assign({}, variable), { helper,
+            warning }),
+        value,
+        condition,
+        validator,
+        validatorMessage,
+        mandatoryValidated,
+        mandatoryIgnore,
+        display,
+    };
+};
+const dispatchToProps = (actions) => (dispatch, ownProps) => ({
+    updateVariable: (value) => dispatch(actions.updateVariableAction(ownProps.id, value, ownProps.index)),
+});
+export const connectVariable = componentConnector({
+    componentName: 'Variable',
+    stateToProps,
+    dispatchToProps,
+    additionnalHooks: (props, hookType) => {
+        const { tags, type } = props.meta;
+        const hooks = [`${hookType}VariableOfType(${type})`];
+        if (Array.isArray(tags)) {
+            tags.forEach((currentTag) => {
+                hooks.push(`${hookType}Tag{${currentTag}}`);
+            });
+        }
+        return hooks;
+    },
+});

package/dist/componentsConnectors/connectWizardWrapper.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export declare type ConnectWizardWrapperDispatchProps = {
+    openPreview: () => void;
+    closePreview: () => void;
+};
+export declare type ConnectWizardWrapperOwnProps = {};
+export declare const connectWizardWrapper: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectWizardWrapperDispatchProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectWizardWrapper.js

@@ -0,0 +1,9 @@
+import { componentConnector, } from './connector/componentConnector';
+const dispatchToProps = () => (dispatch) => ({
+    openPreview: () => dispatch({ type: 'OPEN_PREVIEW' }),
+    closePreview: () => dispatch({ type: 'CLOSE_PREVIEW' }),
+});
+export const connectWizardWrapper = componentConnector({
+    componentName: 'WizardWrapper',
+    dispatchToProps,
+});

package/dist/componentsConnectors/connector/componentConnector.d.ts

@@ -0,0 +1,24 @@
+import { Dispatch, Store } from 'redux';
+import React, { ComponentType } from 'react';
+import { StateType } from '../../types/State.type';
+import * as connectorActions from '../../redux/actions';
+import * as connectorSelectors from '../../redux/selectors';
+export declare type AdditionnalHooksFunction<P> = (props: P, hookType: string) => string[];
+export declare type ConnectorDispatchProps<OwnProps, DispatchProps, OwnPropsWithStore = OwnProps & {
+    store?: Store;
+}> = (actions: Readonly<typeof connectorActions>, selectors: Readonly<typeof connectorSelectors>) => (dispatch: Dispatch, ownProps: OwnPropsWithStore) => DispatchProps;
+export declare type ConnectorStateToProps<OwnProps, MapProps, OwnPropsWithStore = OwnProps & {
+    store?: Store;
+}> = ((selectors: Readonly<typeof connectorSelectors>) => (state: StateType, ownProps: OwnPropsWithStore) => MapProps) | undefined;
+export declare type ConnectorAdditionnalHooks<InjectedProps> = (props: InjectedProps, hookType: string) => string[];
+export declare type ConnectorMapSelectors = typeof connectorSelectors;
+export declare function componentConnector<OwnProps = {}, MapProps = {}, DispatchProps = {}, OwnPropsWithStore = OwnProps & {
+    store?: Store;
+}, InjectedProps = OwnPropsWithStore & MapProps & DispatchProps>(options: {
+    componentName: string;
+    stateToProps?: ConnectorStateToProps<OwnPropsWithStore, MapProps> | undefined;
+    dispatchToProps?: ConnectorDispatchProps<OwnPropsWithStore, DispatchProps> | undefined;
+    additionnalHooks?: AdditionnalHooksFunction<InjectedProps>;
+}): <AdditionnalProps = {}>(Component: React.ComponentType<InjectedProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & OwnPropsWithStore & AdditionnalProps & {
+    store?: Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connector/componentConnector.js

@@ -0,0 +1,62 @@
+import { connect } from 'react-redux';
+import React from 'react';
+import { PluginLoader, ReplaceComponent } from '../../PluginLoader';
+import * as connectorActions from '../../redux/actions';
+import * as connectorSelectors from '../../redux/selectors';
+const AnchorsHooks = (props, componentName, additionnalHooks) => {
+    let beforeAnchors = [`before(${componentName})`];
+    let afterAnchors = [`after(${componentName})`];
+    let replaceAnchors = [`${componentName}`];
+    if (typeof additionnalHooks === 'function') {
+        beforeAnchors = [...beforeAnchors, ...additionnalHooks(props, 'before')];
+        afterAnchors = [...afterAnchors, ...additionnalHooks(props, 'after')];
+        replaceAnchors = [...replaceAnchors, ...additionnalHooks(props, 'replace')];
+    }
+    return {
+        beforeAnchors,
+        afterAnchors,
+        replaceAnchors,
+    };
+};
+const PluginWrapper = (props, anchors) => {
+    const WrappedPlugin = () => React.createElement(PluginLoader, { anchor: anchors, props: props });
+    WrappedPlugin.displayName = `Plugin(${anchors
+        .join(', ')
+        .replace(/\(/g, '[')
+        .replace(/\)/g, ']')})`.trim();
+    return WrappedPlugin;
+};
+const ConnectorHooc = (Component, componentName, additionnalHooks) => {
+    const ConnectedComponent = (props) => {
+        const { beforeAnchors, afterAnchors, replaceAnchors } = AnchorsHooks(props, componentName, additionnalHooks);
+        const FinalComponent = ReplaceComponent(replaceAnchors, Component, componentName);
+        const BeforePlugings = PluginWrapper(props, beforeAnchors);
+        const AfterPlugings = PluginWrapper(props, afterAnchors);
+        return (React.createElement(React.Fragment, null,
+            React.createElement(BeforePlugings, null),
+            React.createElement(FinalComponent, Object.assign({}, props)),
+            React.createElement(AfterPlugings, null)));
+    };
+    ConnectedComponent.displayName = `connectedComponent(${componentName})`;
+    return ConnectedComponent;
+};
+function ConnectorConnect(options) {
+    const { stateToProps, dispatchToProps } = options;
+    const mapStateToProps = stateToProps
+        ? stateToProps(connectorSelectors)
+        : undefined;
+    const mapDispatchToProps = dispatchToProps
+        ? dispatchToProps(connectorActions, connectorSelectors)
+        : undefined;
+    return connect(mapStateToProps, mapDispatchToProps);
+}
+export function componentConnector(options) {
+    return function Connector(Component) {
+        const { componentName, stateToProps, dispatchToProps, additionnalHooks } = options;
+        const hooc = ConnectorHooc(Component, componentName, additionnalHooks);
+        return ConnectorConnect({
+            stateToProps,
+            dispatchToProps,
+        })(hooc);
+    };
+}

package/dist/componentsConnectors/connector/connectorSelectors.d.ts

@@ -0,0 +1,97 @@
+import * as inputsSelectors from '../../redux/selectors/inputs';
+declare const connectorSelectors: {
+    selectIsSmartscriptOptionIndexHidden: (id: number, index: number) => Readonly<boolean>;
+    selectIsSmartscriptVariableIndexHidden: (id: number, index: number) => Readonly<boolean>;
+    selectMandatoryIgnore: () => Readonly<boolean>;
+    selectMandatorySection: (id: number) => Readonly<boolean>;
+    selectFirstUnfinishedSectionId: (id: number) => number;
+    selectMandatoryOptionItem: (id: number) => readonly boolean[];
+    selectMandatoryOption: (id: number) => readonly boolean[];
+    selectMandatoryOptionByIndex: (id: number, index: number) => Readonly<boolean>;
+    selectMandatoryVariable: (id: number) => readonly boolean[];
+    selectMandatoryVariableByIndex: (id: number, index: number) => Readonly<boolean>;
+    selectCurrentUserLevel: () => Readonly<"ADMIN" | "MANAGER" | "USER" | "GUEST" | "SUPER" | undefined>;
+    selectUserStatus: () => Readonly<"failed" | "authenticated" | "unauthenticated" | "inprogress">;
+    selectUserValidToken: () => Readonly<boolean>;
+    selectUserEmail: () => string;
+    isLevelAccessibleForUser: (level: "ADMIN" | "MANAGER" | "USER" | "GUEST" | "SUPER") => Readonly<boolean>;
+    selectOutputReference: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesSingleOutputType | undefined>;
+    selectBoxReference: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesSingleBoxType>;
+    isOptionMultiple: (id: number) => Readonly<boolean | undefined>;
+    selectOptionReference: (id: number) => Readonly<import("@legalplace/models-v3-types").OptionV3>;
+    selectOptionRelations: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesRelationsOptionsType>;
+    selectSectionRelations: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesRelationsSectionsType>;
+    selectOptionParents: (id: number) => readonly number[];
+    selectRadioSiblings: (id: number) => Readonly<number[] | undefined>;
+    selectVariableReference: (id: number, noThrow?: any) => Readonly<import("@legalplace/models-v3-types").VariableV3>;
+    selectVariableRelations: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesRelationsVariablesType>;
+    selectVariableParents: (id: number) => readonly number[];
+    selectAllDocumentsReferences: () => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesDocumentsListType>;
+    selectDocumentReference: (document: string) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesDocumentType>;
+    selectAllSectionsReferences: (document?: any) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesSectionsDocumentType | undefined>;
+    selectSectionReference: (id: number, document?: any) => Readonly<import("@legalplace/models-v3-types").SectionV3>;
+    selectSectionDefaults: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesDefaultsOptionType | undefined>;
+    selectOptionConditionsObject: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS | undefined>;
+    selectVariableConditionsObject: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS | undefined>;
+    selectDocumentConditionsObject: (name: string) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS | undefined>;
+    selectSectionConditionsObject: (id: number, document?: any) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS>;
+    selectPrefillerConditionsObject: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS[] | undefined>;
+    selectOptionValidatorConditionsObject: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS | undefined>;
+    selectVariableValidatorConditionsObject: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS | undefined>;
+    areVariablesSiblings: (...args: number[]) => Readonly<boolean | undefined>;
+    selectVariablesByTag: (tag: string) => readonly number[];
+    selectOptionsByTag: (tag: string) => readonly number[];
+    selectOptionParentSection: (id: number) => number;
+    selectVariableParentSection: (id: number) => number;
+    selectUserEmailSectionVariableIds: (sectionId: number) => readonly string[];
+    selectInputs: inputsSelectors.selectInputsType;
+    selectOptionInput: (id: number) => readonly boolean[];
+    selectOptionInputByIndex: (id: number, index: number) => Readonly<boolean | undefined>;
+    selectVariableInput: (id: number) => readonly (string | number)[];
+    selectVariableInputByIndex: (id: number, index: number) => Readonly<string | number>;
+    selectOptionConditionValue(id: number): Readonly<boolean[] | undefined>;
+    selectOptionConditionValue(id: number, index: number): Readonly<boolean | undefined>;
+    selectVariableConditionValue(id: number): boolean[] | undefined;
+    selectVariableConditionValue(id: number, index: number): boolean | undefined;
+    selectPrefillerConditionValue(id: number): boolean[][] | undefined;
+    selectPrefillerConditionValue(id: number, index: number): boolean[] | undefined;
+    selectOptionValidatorConditionValue(id: number): boolean[] | undefined;
+    selectOptionValidatorConditionValue(id: number, index: number): boolean | undefined;
+    selectVariableValidatorConditionValue(id: number): boolean[] | undefined;
+    selectVariableValidatorConditionValue(id: number, index: number): boolean | undefined;
+    selectSectionConditionValue: (id: number, document?: any) => Readonly<boolean | undefined>;
+    selectDocumentConditionValue: (name: string) => Readonly<boolean | undefined>;
+    selectIsOptionDisplayed: (id: number, index: number) => Readonly<boolean>;
+    selectIsVariableDisplayed: (id: number, index: number) => Readonly<boolean>;
+    selectCurrentPage: () => number;
+    selectAvailableAppStates: () => readonly string[];
+    selectCurrentAppState: () => string;
+    selectIsFirstPage: () => Readonly<boolean>;
+    selectIsLastPage: () => Readonly<boolean>;
+    selectIsLastWizardPage: () => Readonly<boolean>;
+    selectGreatestPage: () => number;
+    selectCurrentSectionId: () => number;
+    selectAvailableSections: () => readonly number[];
+    selectAvailableOptions: (document?: any) => readonly number[];
+    selectMultipleOccurencies: () => Readonly<Record<string, number>>;
+    selectOutputsIds: (document: string) => readonly [number, string][];
+    selectPermalink: () => string;
+    selectDocumentTitle: () => string;
+    selectDocumentId: () => number;
+    selectDocumentModelVersion: () => number;
+    selectDocumentProductType: () => string;
+    selectMeta: () => Readonly<import("../..").AppMetaType>;
+    selectMetaFetchStatus: () => Readonly<"failed" | "waiting" | "succeeded" | "unhealthy" | "userLocked" | "nonBlocking">;
+    selectPrefix: () => Readonly<string | undefined>;
+    selectInstanceUniqid: () => Readonly<string | undefined>;
+    selectInstanceCompanyId: () => Readonly<number | undefined>;
+    selectInstanceEmployeeId: () => Readonly<number | undefined>;
+    selectDataStatus: () => Readonly<"saved" | "unsaved" | "saving" | "failed">;
+    selectInstanceIsPaid: () => Readonly<boolean>;
+    selectInstanceSteps: () => Readonly<boolean>;
+    isStepAvailable: (steps: number[] | "*" | undefined) => Readonly<boolean>;
+    selectCustomizationMeta: () => Readonly<import("../..").AppCustomizationMetaType | undefined>;
+    selectCustomizationAutoDefaultType: () => Readonly<boolean | undefined>;
+    selectModelUuid: () => Readonly<string | undefined>;
+};
+export default connectorSelectors;

package/dist/componentsConnectors/connector/connectorSelectors.js

@@ -0,0 +1,9 @@
+import * as appSelectors from '../../redux/selectors/app';
+import * as conditionsSelectors from '../../redux/selectors/conditions';
+import * as inputsSelectors from '../../redux/selectors/inputs';
+import * as referencesSelectors from '../../redux/selectors/references';
+import * as userSelectors from '../../redux/selectors/user';
+import * as mandatoriesSelectors from '../../redux/selectors/mandatories';
+import * as smartscriptSelectors from '../../redux/selectors/smartscript';
+const connectorSelectors = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, appSelectors), conditionsSelectors), inputsSelectors), referencesSelectors), userSelectors), mandatoriesSelectors), smartscriptSelectors);
+export default connectorSelectors;

package/dist/componentsConnectors/index.d.ts

@@ -0,0 +1,16 @@
+export * from './connectOption';
+export * from './connectBox';
+export * from './connectDocument';
+export * from './connectPagination';
+export * from './connectMetaTitle';
+export * from './connectProgress';
+export * from './connectRootOption';
+export * from './connectSection';
+export * from './connectSummary';
+export * from './connectSummaryItem';
+export * from './connectPreview';
+export * from './connectTermsheet';
+export * from './connectVariable';
+export * from './connectWizardWrapper';
+export * from './connectHeader';
+export * from './connector/componentConnector';

package/dist/componentsConnectors/index.js

@@ -0,0 +1,16 @@
+export * from './connectOption';
+export * from './connectBox';
+export * from './connectDocument';
+export * from './connectPagination';
+export * from './connectMetaTitle';
+export * from './connectProgress';
+export * from './connectRootOption';
+export * from './connectSection';
+export * from './connectSummary';
+export * from './connectSummaryItem';
+export * from './connectPreview';
+export * from './connectTermsheet';
+export * from './connectVariable';
+export * from './connectWizardWrapper';
+export * from './connectHeader';
+export * from './connector/componentConnector';

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import type { IWizardParams } from './types/config.type';
+export declare const getConfig: () => IWizardParams;
+export declare const updateConfig: (newConfig: IWizardParams) => void;
+export declare const isConfigReady: () => boolean | undefined;
+export declare const loadConfig: () => Promise<IWizardParams>;

package/dist/config.js

@@ -0,0 +1,21 @@
+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 config from './wizard-params';
+let updatedConfig = config;
+export const getConfig = () => updatedConfig;
+export const updateConfig = (newConfig) => {
+    updatedConfig = newConfig;
+};
+export const isConfigReady = () => {
+    return getConfig().fixedConfig && getConfig().fixedConfig === true;
+};
+export const loadConfig = () => __awaiter(void 0, void 0, void 0, function* () {
+    return getConfig();
+});

package/dist/config.test.d.ts

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

package/dist/config.test.js

@@ -0,0 +1,36 @@
+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 { getConfig, loadConfig } from './config';
+jest.mock('./wizard-params', () => ({
+    apiEndpoint: 'some-endpoint/',
+    plugins: {
+        jestTestPlugin: '1.0.0',
+    },
+    theme: {
+        name: 'test',
+        params: {},
+    },
+}));
+describe('Config loader', () => {
+    it('Loads config', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield loadConfig();
+        const config = getConfig();
+        expect(config).toStrictEqual({
+            apiEndpoint: 'some-endpoint/',
+            plugins: {
+                jestTestPlugin: '1.0.0',
+            },
+            theme: {
+                name: 'test',
+                params: {},
+            },
+        });
+    }));
+});

package/dist/constants/emailValidation.d.ts

@@ -0,0 +1 @@
+export declare const EMAIL_REGEX: RegExp;

package/dist/constants/emailValidation.js

@@ -0,0 +1 @@
+export const EMAIL_REGEX = /^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+@(?:(?:(?:[a-zA-Z0-9_](?:[a-zA-Z0-9_\-](?!\.)){0,61}[a-zA-Z0-9_-]?\.)+[a-zA-Z0-9_](?:[a-zA-Z0-9_\-](?!$)){0,61}[a-zA-Z0-9_]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/;

package/dist/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './emailValidation';

package/dist/constants/index.js

@@ -0,0 +1 @@
+export * from './emailValidation';

package/dist/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './outputsParsing';
+export * from './sendinblueHelper';

package/dist/helpers/index.js

@@ -0,0 +1,2 @@
+export * from './outputsParsing';
+export * from './sendinblueHelper';