@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/componentsConnectors/connectDocument.test.js

@@ -0,0 +1,82 @@
+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 * as fs from 'fs';
+import React from 'react';
+import renderer from 'react-test-renderer';
+import { ReferencesParser } from '@legalplace/referencesparser';
+import { getStore, createAppStore } from '../redux/store';
+import { initReferencesAction } from '../redux/actions/references';
+import { ConditionsInitiator } from '../libs/ConditionsInitiator';
+import { initConditionsAction } from '../redux/actions/conditions';
+import { IntputsInitiator } from '../libs/InputsInitiator';
+import { initOptionAction, initVariableAction } from '../redux/actions/inputs';
+const ovc = {
+    options: { 1: [true], 2: [true, true], 3: [true, false], 4: [false, true] },
+    variables: {
+        1: ['My VAR1'],
+        2: ['My VAR 2 1st', 'My VAR 2 2nd'],
+        3: ['My VAR 3 1st', 'My VAR 3 2nd'],
+    },
+};
+describe('connectDocument test suit', () => {
+    let store;
+    let connectDocument;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        createAppStore('memory');
+        const model = JSON.parse(fs.readFileSync('./src/misc/test_models/connectDocumen.testmodel.json', 'utf8'));
+        connectDocument = yield require('./connectDocument').connectDocument;
+        const references = new ReferencesParser(model).getReferences();
+        const inputs = new IntputsInitiator(references, ovc).getInputs();
+        const conditions = new ConditionsInitiator(references, inputs).getConditions();
+        store = getStore();
+        store.dispatch(initReferencesAction(references));
+        store.dispatch(initConditionsAction(conditions));
+        const optionsIds = Object.keys(inputs.options);
+        for (let i = 0; i < optionsIds.length; i += 1) {
+            const optionId = optionsIds[i];
+            const values = inputs.options[optionId];
+            store.dispatch(initOptionAction(parseInt(optionId, 10), 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];
+            store.dispatch(initVariableAction(parseInt(variableId, 10), values));
+        }
+    }));
+    it('Should retrun props properly', () => __awaiter(void 0, void 0, void 0, function* () {
+        const ConnectDocument = connectDocument((props) => {
+            return React.createElement("h1", null, props.document);
+        });
+        const component = renderer.create(React.createElement(ConnectDocument, { store: store, document: "main" }));
+        const { props } = component.toTree().rendered;
+        const { document, outputs } = props;
+        expect({ document, outputs }).toStrictEqual({
+            document: 'main',
+            outputs: {
+                'output-5-0': '<p>Should output <strong>Variable 1</strong>&nbsp;My VAR1</p>\n',
+            },
+        });
+    }));
+    it('Should use main as default', () => {
+        const ConnectDocument = connectDocument((props) => {
+            return React.createElement("h1", null, props.document);
+        });
+        const component = renderer.create(React.createElement(ConnectDocument, { store: store, document: "default" }));
+        const { props } = component.toTree().rendered;
+        const { document, outputs } = props;
+        expect({ document, outputs }).toStrictEqual({
+            document: 'main',
+            outputs: {
+                'output-5-0': '<p>Should output <strong>Variable 1</strong>&nbsp;My VAR1</p>\n',
+            },
+        });
+    });
+});

package/dist/componentsConnectors/connectHeader.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+export declare type ConnectHeaderOwnProps = {
+    isPreviewDisplayed: boolean;
+};
+export declare type ConnectHeaderMapProps = {
+    hasValidAuthToken: boolean;
+};
+export declare const connectHeader: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectHeaderOwnProps & ConnectHeaderMapProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & ConnectHeaderOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectHeader.js

@@ -0,0 +1,8 @@
+import { componentConnector, } from './connector/componentConnector';
+const stateToProps = (selectors) => () => ({
+    hasValidAuthToken: selectors.selectUserValidToken(),
+});
+export const connectHeader = componentConnector({
+    componentName: 'AppHeader',
+    stateToProps,
+});

package/dist/componentsConnectors/connectMetaTitle.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+export declare const connectMetaTitle: <AdditionnalProps = {}>(Component: import("react").ComponentType<{
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+} & {
+    title: string;
+} & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+} & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectMetaTitle.js

@@ -0,0 +1,7 @@
+import { componentConnector } from './connector/componentConnector';
+export const connectMetaTitle = componentConnector({
+    componentName: 'MetaTitle',
+    stateToProps: (selectors) => () => ({
+        title: selectors.selectDocumentTitle(),
+    }),
+});

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

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

package/dist/componentsConnectors/connectMetaTitle.test.js

@@ -0,0 +1,32 @@
+import React from 'react';
+import renderer from 'react-test-renderer';
+import { getStore, createAppStore } from '../redux/store';
+import { initMetaAction } from '../redux/actions/app';
+const meta = {
+    title: 'My Test Document',
+    id: 132,
+    prefix: '',
+    permalink: 'my-test-document',
+    fetchStatus: 'succeeded',
+    modelVersion: 1,
+    productType: 'demarche',
+};
+describe('connectMetaTitle test suit', () => {
+    let store;
+    let connectMetaTitle;
+    beforeEach(() => {
+        createAppStore('memory');
+        store = getStore();
+        store.dispatch(initMetaAction(meta));
+        connectMetaTitle = require('./connectMetaTitle').connectMetaTitle;
+    });
+    it('Should retrun props properly', () => {
+        const ConnectMetaTitle = connectMetaTitle((props) => {
+            return React.createElement("h1", null, props.title);
+        });
+        const component = renderer.create(React.createElement(ConnectMetaTitle, { store: store }));
+        const { props } = component.toTree().rendered;
+        const { title } = props;
+        expect({ title }).toStrictEqual({ title: 'My Test Document' });
+    });
+});

package/dist/componentsConnectors/connectOption.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="react" />
+import type { OptionV3 } from '@legalplace/models-v3-types';
+export declare type ConnectOptionOwnProps = {
+    id: number;
+    index: number;
+    isLast?: boolean;
+    isMultiple?: boolean;
+    hasMany?: boolean;
+};
+export declare type ConnectOptionMapProps = {
+    label: string;
+    type: string;
+    value: boolean;
+    condition?: boolean;
+    validator?: boolean;
+    mandatoryValidated: boolean;
+    mandatoryIgnore: boolean;
+    display: boolean;
+    meta: OptionV3['meta'];
+    selectedRadioChild: number;
+    childOptions: number[];
+    childVariables: number[];
+};
+export declare type ConnectOptionDispatchProps = {
+    updateOption: (value: boolean, id?: number, index?: number) => void;
+    addMultipleOccurency: () => void;
+    deleteMultipleOccurency: () => void;
+};
+export declare const connectOption: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectOptionOwnProps & ConnectOptionMapProps & ConnectOptionDispatchProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & ConnectOptionOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectOption.js

@@ -0,0 +1,83 @@
+import { parseOptionLabel, parseRawWithVariables, } from '../helpers/outputsParsing';
+import { componentConnector, } from './connector/componentConnector';
+import { isStepAvailable } from '../redux/selectors/app';
+const canOptionDisplay = (id, index, selectors) => {
+    const option = selectors.selectOptionReference(id);
+    let display = isStepAvailable(option.meta.step);
+    display = display && !(option.meta.hidden === true);
+    display =
+        display && !selectors.selectIsSmartscriptOptionIndexHidden(id, index);
+    const grantLevel = typeof option.meta.grantLevel === 'string'
+        ? option.meta.grantLevel
+        : 'GUEST';
+    display = display && selectors.isLevelAccessibleForUser(grantLevel);
+    return display;
+};
+const selectedRadioChilds = (id, index, selectors) => {
+    const option = selectors.selectOptionReference(id);
+    return option.options.filter((childId) => {
+        const childReference = selectors.selectOptionReference(childId);
+        return (childReference.meta.type === 'radio' &&
+            selectors.selectOptionInputByIndex(childId, index));
+    })[0];
+};
+const stateToProps = (selectors) => (state, ownProps) => {
+    const { id, index } = ownProps;
+    const option = selectors.selectOptionReference(id);
+    const display = canOptionDisplay(id, index, selectors);
+    const selectedRadioChild = selectedRadioChilds(id, index, selectors);
+    const label = parseOptionLabel(id, index);
+    let value = selectors.selectOptionInputByIndex(id, index);
+    value = value || false;
+    const condition = selectors.selectOptionConditionValue(id, index);
+    const validator = selectors.selectOptionValidatorConditionValue(id, index);
+    const mandatoryValidated = selectors.selectMandatoryOptionByIndex(id, index);
+    const mandatoryIgnore = selectors.selectMandatoryIgnore();
+    const { meta, options: childOptions, variables: childVariables } = option;
+    const helper = meta.helper
+        ? parseRawWithVariables(meta.helper, undefined, '________________')
+        : undefined;
+    const warning = meta.warning
+        ? parseRawWithVariables(meta.warning, undefined, '________________')
+        : undefined;
+    const { type } = meta;
+    return {
+        label,
+        type,
+        meta: Object.assign(Object.assign({}, meta), { warning,
+            helper }),
+        value,
+        mandatoryValidated,
+        mandatoryIgnore,
+        condition,
+        validator,
+        display,
+        selectedRadioChild,
+        childOptions,
+        childVariables,
+    };
+};
+const dispatchToProps = (actions) => (dispatch, ownProps) => ({
+    updateOption: (value, id = ownProps.id, index = ownProps.index) => dispatch(actions.updateOptionAction(id, value, index)),
+    addMultipleOccurency: () => {
+        dispatch(actions.addMultipleOccurencyAction(ownProps.id));
+    },
+    deleteMultipleOccurency: () => {
+        dispatch(actions.deleteMultipleOccurencyAction(ownProps.id, ownProps.index));
+    },
+});
+export const connectOption = componentConnector({
+    componentName: 'Option',
+    stateToProps,
+    dispatchToProps,
+    additionnalHooks: (props, hookType) => {
+        const { tags, type } = props.meta;
+        const hooks = [`${hookType}OptionOfType(${type})`];
+        if (Array.isArray(tags)) {
+            tags.forEach((currentTag) => {
+                hooks.push(`${hookType}Tag{${currentTag}}`);
+            });
+        }
+        return hooks;
+    },
+});

package/dist/componentsConnectors/connectPagination.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+export declare type ConnectPaginationOwnProps = {};
+export declare type ConnectPaginationMapProps = {
+    totalPages: number;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    isLastWizardPage: boolean;
+    isUserAuthenticated: boolean;
+    isCurrentSectionMandatoryValidated: boolean;
+    mandatoryIgnore: boolean;
+    firstUnfinishedSectionId: number;
+    currentSection: number;
+    currentPage: number;
+};
+export declare type ConnectPaginationDispatchProps = {
+    goNextPage: () => void;
+    goPreviousPage: () => void;
+};
+export declare const connectPagination: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectPaginationMapProps & ConnectPaginationDispatchProps & 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/connectPagination.js

@@ -0,0 +1,37 @@
+import { componentConnector, } from './connector/componentConnector';
+const stateToProps = (selectors) => () => {
+    const { selectIsFirstPage, selectCurrentPage, selectIsLastPage, selectIsLastWizardPage, selectAvailableSections, selectUserStatus, selectMandatorySection, selectCurrentSectionId, selectFirstUnfinishedSectionId, selectMandatoryIgnore, } = selectors;
+    const isFirstPage = selectIsFirstPage();
+    const currentPage = selectCurrentPage();
+    const isLastPage = selectIsLastPage();
+    const isLastWizardPage = selectIsLastWizardPage();
+    const totalPages = selectAvailableSections().length;
+    const userStatus = selectUserStatus();
+    const currentSection = selectCurrentSectionId();
+    const mandatoryIgnore = selectMandatoryIgnore();
+    const isCurrentSectionMandatoryValidated = selectMandatorySection(currentSection);
+    const firstUnfinishedSectionId = selectFirstUnfinishedSectionId(currentSection);
+    return {
+        isFirstPage,
+        isLastPage,
+        totalPages,
+        isLastWizardPage,
+        isCurrentSectionMandatoryValidated,
+        firstUnfinishedSectionId,
+        currentSection,
+        mandatoryIgnore,
+        isUserAuthenticated: userStatus === 'authenticated',
+        currentPage,
+    };
+};
+const dispatchToProps = (actions) => (dispatch) => {
+    return {
+        goNextPage: () => dispatch(actions.goNextPageAction()),
+        goPreviousPage: () => dispatch(actions.goPreviousPageAction()),
+    };
+};
+export const connectPagination = componentConnector({
+    componentName: 'Pagination',
+    stateToProps,
+    dispatchToProps,
+});

package/dist/componentsConnectors/connectPreview.d.ts

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

package/dist/componentsConnectors/connectPreview.js

@@ -0,0 +1,4 @@
+import { componentConnector } from './connector/componentConnector';
+export const connectPreview = componentConnector({
+    componentName: 'PreviewComponent',
+});

package/dist/componentsConnectors/connectProgress.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+export declare type ConnectPreviewOwnProps = {
+    id?: number;
+};
+export declare type ConnectPreviewMapProps = {
+    currentSectionTitle: string;
+    currentSectionId: number;
+    currentSection: number;
+    currentPage: number;
+    greatestPage: number;
+    totalPages: number;
+};
+export declare const connectProgress: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectPreviewOwnProps & ConnectPreviewMapProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & ConnectPreviewOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectProgress.js

@@ -0,0 +1,21 @@
+import { componentConnector, } from './connector/componentConnector';
+const stateToProps = (selectors) => (state, ownProps) => {
+    const { selectCurrentSectionId, selectAvailableSections, selectSectionReference, selectCurrentPage, } = selectors;
+    const currentSectionId = typeof ownProps.id === 'number' ? ownProps.id : selectCurrentSectionId();
+    const sectionReference = selectSectionReference(currentSectionId);
+    const currentSectionTitle = sectionReference.label;
+    const availableSections = selectAvailableSections();
+    const totalPages = availableSections.length;
+    return {
+        currentSectionTitle,
+        currentSectionId,
+        totalPages,
+        currentSection: availableSections.indexOf(currentSectionId) + 1,
+        currentPage: selectCurrentPage(),
+        greatestPage: state.app.pagination.greatestPage,
+    };
+};
+export const connectProgress = componentConnector({
+    componentName: 'Progress',
+    stateToProps,
+});

package/dist/componentsConnectors/connectRootOption.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+import type { OptionV3 } from '@legalplace/models-v3-types';
+export declare type ConnectRootOptionOwnProps = {
+    id: number;
+};
+export declare type ConnectRootOptionMapProps = {
+    id: number;
+    multiple: boolean;
+    values: boolean[];
+    isMultiple: boolean;
+    hasMany: boolean;
+    lastIndex: number;
+    meta: OptionV3['meta'];
+};
+export declare type ConnectRootOptionDispatchProps = {
+    addMultipleOccurency: () => void;
+    deleteMultipleOccurency: (index: number) => void;
+};
+export declare const connectRootOption: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectRootOptionOwnProps & ConnectRootOptionMapProps & ConnectRootOptionDispatchProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & ConnectRootOptionOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectRootOption.js

@@ -0,0 +1,43 @@
+import { componentConnector, } from './connector/componentConnector';
+const stateToProps = (selectors) => (state, ownProps) => {
+    var _a, _b;
+    const { selectOptionReference } = selectors;
+    const option = selectOptionReference(ownProps.id);
+    const multiple = ((_a = option.meta.multiple) === null || _a === void 0 ? void 0 : _a.enabled) || false;
+    const values = state.inputs.options[ownProps.id];
+    return {
+        id: ownProps.id,
+        multiple,
+        meta: option.meta,
+        values,
+        hasMany: values.length > 1,
+        isMultiple: ((_b = option.meta.multiple) === null || _b === void 0 ? void 0 : _b.enabled) === true,
+        lastIndex: values.length - 1,
+    };
+};
+const dispatchToProps = (actions) => (dispatch, ownProps) => ({
+    addMultipleOccurency: () => {
+        dispatch(actions.addMultipleOccurencyAction(ownProps.id));
+    },
+    deleteMultipleOccurency: (index) => {
+        dispatch(actions.deleteMultipleOccurencyAction(ownProps.id, index));
+    },
+});
+export const connectRootOption = componentConnector({
+    componentName: 'RootOption',
+    stateToProps,
+    dispatchToProps,
+    additionnalHooks: (props, hookType) => {
+        const { tags, type } = props.meta;
+        const hooks = [`${hookType}RootOptionOfType(${type})`];
+        if (props.meta.multiple) {
+            hooks.push(`${hookType}RootOptionMultiple`);
+        }
+        if (Array.isArray(tags)) {
+            tags.forEach((currentTag) => {
+                hooks.push(`${hookType}Tag{${currentTag}}`);
+            });
+        }
+        return hooks;
+    },
+});

package/dist/componentsConnectors/connectSection.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+export declare type ConnectSectionOwnProps = {
+    id?: number;
+};
+export declare type ConnectSectionMapProps = {
+    id: number;
+    title: string;
+    mandatoryValidated: boolean;
+    childOptions: number[];
+    tags?: string[];
+};
+export declare const connectSection: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectSectionOwnProps & ConnectSectionMapProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & ConnectSectionOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectSection.js

@@ -0,0 +1,39 @@
+import { componentConnector, } from './connector/componentConnector';
+const childOptionsCache = {};
+const stateToProps = (selectors) => (state, ownProps) => {
+    const { selectCurrentSectionId, selectSectionReference, selectOptionReference, } = selectors;
+    const id = typeof ownProps.id !== 'undefined' ? ownProps.id : selectCurrentSectionId();
+    const section = selectSectionReference(id);
+    if (section === undefined)
+        throw new Error(`Section ${id} does not exist`);
+    if (!(id in childOptionsCache)) {
+        childOptionsCache[id] = section.options.filter((optionId) => {
+            const optionReference = selectOptionReference(optionId);
+            if (optionReference === undefined)
+                throw new Error(`Option ${optionId} does not exist`);
+            return !['hidden', 'repeated'].includes(optionReference.meta.type);
+        });
+    }
+    const mandatoryValidated = selectors.selectMandatorySection(id);
+    return {
+        id,
+        mandatoryValidated,
+        childOptions: childOptionsCache[id],
+        title: section.label,
+        tags: section.tags,
+    };
+};
+export const connectSection = componentConnector({
+    componentName: 'Section',
+    stateToProps,
+    additionnalHooks: (props, hookType) => {
+        const { tags } = props;
+        const hooks = [];
+        if (Array.isArray(tags)) {
+            tags.forEach((currentTag) => {
+                hooks.push(`${hookType}Tag{${currentTag}}`);
+            });
+        }
+        return hooks;
+    },
+});

package/dist/componentsConnectors/connectSummary.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export declare type ConnectSummaryOwnProps = {};
+export declare type ConnectSummaryMapProps = {
+    sections: Readonly<number[]>;
+};
+export declare const connectSummary: <AdditionnalProps = {}>(Component: import("react").ComponentType<{
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+} & ConnectSummaryMapProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+} & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectSummary.js

@@ -0,0 +1,8 @@
+import { componentConnector, } from './connector/componentConnector';
+const stateToProps = (selectors) => () => ({
+    sections: selectors.selectAvailableSections(),
+});
+export const connectSummary = componentConnector({
+    componentName: 'Summary',
+    stateToProps,
+});

package/dist/componentsConnectors/connectSummaryItem.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+export declare type ConnectSummaryItemOwnProps = {
+    id: number;
+};
+export declare type ConnectSummaryItemMapProps = {
+    link: string;
+    label: string;
+    validity: boolean;
+    preLabel: string;
+    active: boolean;
+    pageNumber: number;
+    disableClick?: boolean;
+};
+export declare const connectSummaryItem: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectSummaryItemOwnProps & ConnectSummaryItemMapProps & AdditionnalProps>) => import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never> & ConnectSummaryItemOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectSummaryItem.js

@@ -0,0 +1,47 @@
+import queryString from 'query-string';
+import { componentConnector, } from './connector/componentConnector';
+import { PathReader } from '../libs/PathReader';
+import { SectionValidity } from '../libs/SectionValidity';
+const stateToProps = (selectors) => (state, ownProps) => {
+    const { selectSectionReference, selectAvailableSections, selectCurrentSectionId, selectMandatorySection, selectMandatoryIgnore, } = selectors;
+    const currentSection = selectCurrentSectionId();
+    const mandatoryIgnore = selectMandatoryIgnore();
+    const isCurrentSectionMandatoryValidated = selectMandatorySection(currentSection);
+    const sectionReference = selectSectionReference(ownProps.id);
+    const { label, id } = sectionReference;
+    const pathReader = new PathReader(state);
+    const pageNumber = selectAvailableSections().indexOf(ownProps.id) + 1;
+    const link = pathReader.parsePath(pageNumber);
+    const active = id === currentSection;
+    let disableClick = false;
+    if (queryString.parse(window.location.search).ignore !== 'true' &&
+        id > currentSection &&
+        mandatoryIgnore === false) {
+        const mandatoriesSections = selectAvailableSections().map((sectionId) => selectMandatorySection(sectionId));
+        if (mandatoriesSections.every((sectionValue) => sectionValue === true)) {
+            disableClick = false;
+        }
+        else if (id === currentSection + 1 &&
+            isCurrentSectionMandatoryValidated === true) {
+            disableClick = false;
+        }
+        else {
+            disableClick = true;
+        }
+    }
+    const { validity } = new SectionValidity(ownProps.id);
+    const preLabel = pageNumber < 10 ? `0${pageNumber}` : pageNumber.toString();
+    return {
+        link,
+        validity,
+        preLabel,
+        label,
+        active,
+        pageNumber,
+        disableClick,
+    };
+};
+export const connectSummaryItem = componentConnector({
+    componentName: 'SummaryItem',
+    stateToProps,
+});

package/dist/componentsConnectors/connectTermsheet.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { TermsheetPropsType } from '../types/Components.type';
+export declare const connectTermsheet: import("redux").Func1<React.ComponentType<TermsheetPropsType>, import("react-redux").ConnectedComponent<React.FC<TermsheetPropsType>, import("react-redux").Omit<TermsheetPropsType, "termsheet" | "parseLink">>>;