@legalplace/wizardx-core 4.42.10-nightly.20251125120616 → 4.42.11

package/dist/components/View.d.ts

@@ -1,16 +1,16 @@
 import React from "react";
-export type OwnProps = {
+export declare type OwnProps = {
     currentAppState: string;
     goPage: (p: number) => void;
 };
-export type OwnState = {
+export declare type OwnState = {
     themeLoaded: boolean;
 };
 declare class ViewComponent extends React.Component<OwnProps, OwnState> {
     constructor(props: OwnProps);
     componentDidMount(): void;
     shouldComponentUpdate(newProps: OwnProps, newState: OwnState): boolean;
-    render(): import("react/jsx-runtime").JSX.Element | null;
+    render(): JSX.Element | null;
 }
 declare const _default: import("react-redux").ConnectedComponent<typeof ViewComponent, any>;
 export default _default;

package/dist/components/View.js

@@ -6,6 +6,7 @@ import { addOnThemeLoadCallback, loadThemeComponent } from "../ThemeLoader";
 import { selectCurrentAppState } from "../redux/selectors/app";
 import Globals from "../Globals";
 import { goPageAction } from "../redux/actions/app";
+import { loadPluginComponent, pluginsLoaded } from "../PluginLoader";
 class ViewComponent extends React.Component {
     constructor(props) {
         super(props);
@@ -38,11 +39,12 @@ class ViewComponent extends React.Component {
                 AppStateComponent = loadThemeComponent("WizardComponent");
                 break;
             default:
-                if (false)
+                if (pluginsLoaded())
                     AppStateComponent =
-                        loadThemeComponent("WizardComponent");
+                        loadPluginComponent(this.props.currentAppState) ||
+                            loadThemeComponent("WizardComponent");
                 else
-                    AppStateComponent = () => _jsx(_Fragment, {});
+                    AppStateComponent = () => _jsx(_Fragment, {}, void 0);
                 break;
         }
         const envStyle = {
@@ -62,8 +64,8 @@ class ViewComponent extends React.Component {
             opacity: 0.6,
             userSelect: "none",
         };
-        return (_jsxs(Shimmer, Object.assign({}, {}, { children: [Globals.appEnv !== "production" &&
-                    process.env.JEST_WORKER_ID === undefined && (_jsxs("div", { style: envStyle, children: [Globals.appEnv, " (", Globals.version, ")"] })), _jsx(React.Suspense, { fallback: null, children: _jsx(AppStateComponent, {}) })] })));
+        return (_jsxs(Shimmer, { children: [Globals.appEnv !== "production" &&
+                    process.env.JEST_WORKER_ID === undefined && (_jsxs("div", Object.assign({ style: envStyle }, { children: [Globals.appEnv, " (", Globals.version, ")"] }), void 0)), _jsx(React.Suspense, Object.assign({ fallback: null }, { children: _jsx(AppStateComponent, {}, void 0) }), void 0)] }, void 0));
     }
 }
 const mapStateToProps = () => {

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,84 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import 'regenerator-runtime/runtime';
+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';
+import { loadTheme } from '../ThemeLoader';
+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],
+            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* () {
+        yield loadTheme();
+        const { container } = render(_jsx(Provider, Object.assign({ store: store }, { children: _jsx(View, {}, void 0) }), void 0));
+        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(2));
+        yield loadTheme();
+        const { container } = render(_jsx(Provider, Object.assign({ store: store }, { children: _jsx(View, {}, void 0) }), void 0));
+        yield waitFor(() => expect(container).toContainHTML('<div><h1>Wizard test theme, TermsheetComponent</h1></div>'));
+    }));
+});

package/dist/componentsConnectors/connectBox.d.ts

@@ -1,9 +1,9 @@
 import type { OptionV3 } from "@legalplace/models-v3-types";
-export type ConnectBoxOwnProps = {
+export declare type ConnectBoxOwnProps = {
     id: number;
     index: number;
 };
-export type ConnectBoxMapProps = {
+export declare type ConnectBoxMapProps = {
     type: string;
     content: string;
     box: OptionV3["meta"]["box"];
@@ -12,5 +12,7 @@ export type ConnectBoxMapProps = {
     tags?: string[];
 };
 export declare const connectBox: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectBoxOwnProps & ConnectBoxMapProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & ConnectBoxOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

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

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

package/dist/componentsConnectors/connectBox.test.js

@@ -0,0 +1,218 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import renderer, { act } 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',
+        },
+    },
+    optionTags: {},
+    variableTags: {}
+};
+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* () {
+        act(() => {
+            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', () => __awaiter(void 0, void 0, void 0, function* () {
+        let component;
+        act(() => {
+            const ConnectedBox = connectBox((props) => {
+                return _jsx("h1", { children: props.content }, void 0);
+            });
+            component = renderer.create(_jsx(ConnectedBox, { store: store, id: 1, index: 0 }, void 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', () => {
+        let component;
+        act(() => {
+            store.dispatch(updateOptionConditionsAction(1, 0, false));
+            const ConnectedBox = connectBox((props) => {
+                return _jsx("h1", { children: props.content }, void 0);
+            });
+            component = renderer.create(_jsx(ConnectedBox, { store: store, id: 1, index: 0 }, void 0));
+        });
+        expect(component.toTree().rendered.props.content).toEqual('');
+    });
+    it('Should retrun props properly', () => {
+        store.dispatch(updateOptionConditionsAction(1, 0, true));
+        const ConnectedBox = connectBox((props) => {
+            return _jsx("h1", { children: props.content }, void 0);
+        });
+        const component = renderer.create(_jsx(ConnectedBox, { store: store, id: 1, index: 0 }, void 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

@@ -1,10 +1,12 @@
-export type ConnectDocumentOwnProps = {
+export declare type ConnectDocumentOwnProps = {
     document: string;
 };
-export type ConnectDocumentMapProps = {
+export declare type ConnectDocumentMapProps = {
     document: string;
     outputs: Record<string, string>;
 };
 export declare const connectDocument: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectDocumentOwnProps & ConnectDocumentMapProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & ConnectDocumentOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

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

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

package/dist/componentsConnectors/connectDocument.test.js

@@ -0,0 +1,95 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import * as fs from "fs";
+import renderer, { act } from "react-test-renderer";
+import { ReferencesParser } from "@legalplace/referencesparser";
+import { runSaga } from "redux-saga";
+import { call } from "redux-saga/effects";
+import { getStore, createAppStore } from "../redux/store";
+import { initReferencesAction } from "../redux/actions/references";
+import { IntputsInitiator } from "../libs/InputsInitiator";
+import { initInputsAction } from "../redux/actions/inputs";
+import { initInputsDecorator } from "../redux/sagas/initInputs";
+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* () {
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            createAppStore("memory");
+            const model = JSON.parse(fs.readFileSync("./src/misc/test_models/connectDocument.testmodel.json", "utf8"));
+            connectDocument = (yield import("./connectDocument")).connectDocument;
+            const references = new ReferencesParser(model).getReferences();
+            const inputs = new IntputsInitiator(references, ovc).getInputs();
+            store = getStore();
+            store.dispatch(initReferencesAction(references));
+            yield runSaga({
+                dispatch: (action) => store.dispatch(action),
+                getState: () => store.getState(),
+            }, function* initInputs() {
+                yield call(initInputsDecorator, initInputsAction(inputs, references));
+            }).toPromise();
+        }));
+    }));
+    it("Should retrun props properly", () => __awaiter(void 0, void 0, void 0, function* () {
+        let component;
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            const ConnectDocument = connectDocument((props) => (_jsx("h1", { children: props.document }, void 0)));
+            component = renderer.create(_jsx(ConnectDocument, { store: store, document: "main" }, void 0));
+        }));
+        const tree = component === null || component === void 0 ? void 0 : component.toTree();
+        if (!(tree === null || tree === void 0 ? void 0 : tree.rendered)) {
+            throw Error("Component not rendered while testing");
+        }
+        const { props } = Array.isArray(tree.rendered)
+            ? tree.rendered[0]
+            : tree.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",
+                "output-7-0": "<p>Output for Option 1, Should display Variable 2 &amp; 3 when Option 1 is selected, My VAR 2 1st My VAR 3 1st</p>\n",
+                "output-8-1": "<p>Output for Option 2, Should display Variable 2 &amp; 3 when Option 2 is selected, My VAR 2 2nd My VAR 3 2nd</p>\n",
+            },
+        });
+    }));
+    it("Should use main as default", () => __awaiter(void 0, void 0, void 0, function* () {
+        let component;
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            const ConnectDocument = connectDocument((props) => (_jsx("h1", { children: props.document }, void 0)));
+            component = renderer.create(_jsx(ConnectDocument, { store: store, document: "default" }, void 0));
+        }));
+        const tree = component === null || component === void 0 ? void 0 : component.toTree();
+        if (!(tree === null || tree === void 0 ? void 0 : tree.rendered)) {
+            throw Error("Component not rendered while testing");
+        }
+        const { props } = Array.isArray(tree.rendered)
+            ? tree.rendered[0]
+            : tree.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",
+                "output-7-0": "<p>Output for Option 1, Should display Variable 2 &amp; 3 when Option 1 is selected, My VAR 2 1st My VAR 3 1st</p>\n",
+                "output-8-1": "<p>Output for Option 2, Should display Variable 2 &amp; 3 when Option 2 is selected, My VAR 2 2nd My VAR 3 2nd</p>\n",
+            },
+        });
+    }));
+});

package/dist/componentsConnectors/connectHeader.d.ts

@@ -1,9 +1,11 @@
-export type ConnectHeaderOwnProps = {
+export declare type ConnectHeaderOwnProps = {
     isPreviewDisplayed: boolean;
 };
-export type ConnectHeaderMapProps = {
+export declare type ConnectHeaderMapProps = {
     hasValidAuthToken: boolean;
 };
 export declare const connectHeader: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectHeaderOwnProps & ConnectHeaderMapProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & ConnectHeaderOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectMetaTitle.d.ts

@@ -1,7 +1,11 @@
 export declare const connectMetaTitle: <AdditionnalProps = {}>(Component: import("react").ComponentType<{
-    store?: import("redux").Store;
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
 } & {
     title: string;
 } & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+} & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

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

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

package/dist/componentsConnectors/connectMetaTitle.test.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+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 _jsx("h1", { children: props.title }, void 0);
+        });
+        const component = renderer.create(_jsx(ConnectMetaTitle, { store: store }, void 0));
+        const { props } = component.toTree().rendered;
+        const { title } = props;
+        expect({ title }).toStrictEqual({ title: 'My Test Document' });
+    });
+});

package/dist/componentsConnectors/connectOption.d.ts

@@ -1,6 +1,6 @@
 import type { OptionV3 } from "@legalplace/models-v3-types";
 import type { ConnectorMapSelectors } from "./connector/componentConnector";
-export type ConnectOptionOwnProps = {
+export declare type ConnectOptionOwnProps = {
     id: number;
     index: number;
     isLast?: boolean;
@@ -8,7 +8,7 @@ export type ConnectOptionOwnProps = {
     hasMany?: boolean;
     mandatoryError?: boolean;
 };
-export type ConnectOptionMapProps = {
+export declare type ConnectOptionMapProps = {
     label: string;
     type: OptionV3["meta"]["type"];
     value: boolean;
@@ -26,7 +26,7 @@ export type ConnectOptionMapProps = {
     isAllHiddenOptions?: boolean;
     isParentMandatory?: boolean;
 };
-export type ConnectOptionDispatchProps = {
+export declare type ConnectOptionDispatchProps = {
     updateOption: (value: boolean, id?: number, index?: number) => void;
     addMultipleOccurency: () => void;
     deleteMultipleOccurency: () => void;
@@ -34,5 +34,7 @@ export type ConnectOptionDispatchProps = {
 };
 export declare const canOptionDisplay: (id: number, index: number, selectors: ConnectorMapSelectors) => Readonly<boolean>;
 export declare const connectOption: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectOptionOwnProps & ConnectOptionMapProps & ConnectOptionDispatchProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & ConnectOptionOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectPagination.d.ts

@@ -1,5 +1,5 @@
-export type ConnectPaginationOwnProps = {};
-export type ConnectPaginationMapProps = {
+export declare type ConnectPaginationOwnProps = {};
+export declare type ConnectPaginationMapProps = {
     totalPages: number;
     isFirstPage: boolean;
     isLastPage: boolean;
@@ -12,10 +12,12 @@ export type ConnectPaginationMapProps = {
     currentPage: number;
     link?: string;
 };
-export type ConnectPaginationDispatchProps = {
+export declare type ConnectPaginationDispatchProps = {
     goNextPage: () => void;
     goPreviousPage: () => void;
 };
 export declare const connectPagination: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectPaginationMapProps & ConnectPaginationDispatchProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectPreview.d.ts

@@ -1,5 +1,9 @@
 export declare const connectPreview: <AdditionnalProps = {}>(Component: import("react").ComponentType<{
-    store?: import("redux").Store;
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
 } & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+} & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;