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

package/dist/PluginLoader.js

@@ -1,116 +1,253 @@
+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, Fragment as _Fragment } from "react/jsx-runtime";
 import React from "react";
+import PropTypes from "prop-types";
+import { getConfig } from "./config";
 import { getStore } from "./redux/store";
+import { getHistory } from "./redux/routerHistory";
+import Globals from "./Globals";
+import { INIT_PLUGINS } from "./redux/constants/app";
+let globalAnchors = {};
+let reduxAnchors = {};
+let actionOverrideAnchor = {};
+let replacers = {};
 let pluginsStoreReducers = {};
-let pluginsSagas = [];
-const replacers = {};
+const pluginsStoreSagas = {};
+export const getPluginsStoreReducers = () => pluginsStoreReducers;
+export const getPluginsStoreSagas = () => pluginsStoreSagas;
+let PluginsAppStatesRegistrers = [];
+let PluginsPageAppStates = {};
+let PluginsAppStatesComponents = {};
+let PluginAdditionRoutes = {};
+const pluginAppStates = (declaration) => {
+    PluginsAppStatesRegistrers.push(declaration.register);
+    if (typeof declaration.pageAppState === "object")
+        Object.keys(declaration.pageAppState).forEach((appState) => {
+            if (typeof declaration.pageAppState[appState] === "string") {
+                const page = declaration.pageAppState[appState];
+                if (Object.prototype.hasOwnProperty.call(PluginsPageAppStates, appState)) {
+                    throw new Error(`Plugins AppState "${appState}" already declared.`);
+                }
+                const samePageAppStates = Object.keys(PluginsPageAppStates).filter((currentAppState) => PluginsPageAppStates[currentAppState] === page);
+                if (samePageAppStates.length > 0)
+                    throw new Error(`Plugins AppState page "${page}" already declared.`);
+                PluginsPageAppStates[appState] = page;
+            }
+        });
+    Object.keys(declaration.components).forEach((appState) => {
+        if (Object.prototype.hasOwnProperty.call(declaration, appState) === true)
+            throw new Error(`Plugin's appState ${appState} already declared previously`);
+        PluginsAppStatesComponents[appState] = declaration.components[appState];
+    });
+};
+export const registerPluginsAppStates = (currentAppStates) => {
+    let appStates = [...currentAppStates];
+    PluginsAppStatesRegistrers.forEach((register) => {
+        appStates = register(appStates);
+    });
+    return appStates;
+};
+export const loadPluginComponent = (name) => {
+    if (Object.prototype.hasOwnProperty.call(PluginsAppStatesComponents, name) ===
+        false) {
+        return undefined;
+    }
+    return PluginsAppStatesComponents[name];
+};
+export const pluginPageAppState = (page) => {
+    const appStates = Object.keys(PluginsPageAppStates).filter((appState) => PluginsPageAppStates[appState] === page);
+    if (appStates.length === 1)
+        return appStates[0];
+    if (appStates.length > 1)
+        throw new Error("Found multipled appStates when checking for plugins page name");
+    return false;
+};
+export const getPluginsPageAppStates = () => PluginsPageAppStates;
+const loadPluginFiles = (pluginsList) => __awaiter(void 0, void 0, void 0, function* () {
+    const plugins = Object.keys(pluginsList);
+    const pluginModules = yield Promise.all(plugins.map((plugin) => Globals.loadPlugin(plugin)));
+    plugins.forEach((plugin, index) => {
+        const pluginModule = pluginModules[index];
+        const anchors = pluginModule.default;
+        const { loader } = pluginModule;
+        if (loader !== undefined) {
+            loader(getStore().dispatch, getHistory(), getConfig());
+        }
+        Object.keys(anchors).forEach((anchor) => {
+            if (anchor === "replace") {
+                Object.keys(anchors[anchor]).forEach((replacer) => {
+                    if (!Object.prototype.hasOwnProperty.call(replacers, replacer)) {
+                        replacers[replacer] = [];
+                    }
+                    replacers[replacer].push(anchors[anchor][replacer]);
+                });
+                return;
+            }
+            if (anchor === "appstates") {
+                pluginAppStates(anchors.appstates);
+            }
+            if (anchor === "redux") {
+                Object.keys(anchors[anchor]).forEach((action) => {
+                    if (reduxAnchors[action] === undefined)
+                        reduxAnchors[action] = [];
+                    reduxAnchors[action].push(anchors[anchor][action]);
+                });
+                return;
+            }
+            if (anchor === "actionOverride") {
+                Object.keys(anchors[anchor]).forEach((action) => {
+                    if (actionOverrideAnchor[action] === undefined)
+                        actionOverrideAnchor[action] = [];
+                    actionOverrideAnchor[action].push(anchors[anchor][action]);
+                });
+                return;
+            }
+            if (anchor === "additionalRoutes") {
+                Object.keys(anchors[anchor]).forEach((route) => {
+                    PluginAdditionRoutes[anchors[anchor][route].path] =
+                        anchors[anchor][route].component;
+                });
+                return;
+            }
+            if (anchor === "reduxStore" && anchors[anchor].reducer) {
+                pluginsStoreReducers[plugin] = anchors[anchor].reducer;
+            }
+            if (anchor === "reduxStore" && anchors[anchor].sagas) {
+                pluginsStoreSagas[plugin] = anchors[anchor].sagas;
+            }
+            if (!Object.prototype.hasOwnProperty.call(globalAnchors, anchor))
+                globalAnchors[anchor] = [];
+            globalAnchors[anchor].push(anchors[anchor]);
+        });
+        if (typeof anchors.onLoad === "function")
+            anchors.onLoad();
+    });
+    if (Object.keys(pluginsStoreReducers).length > 0 ||
+        Object.keys(pluginsStoreSagas).length > 0) {
+        getStore().dispatch({ type: INIT_PLUGINS });
+    }
+});
+let pluginsLoadingDone = false;
+export const loadPlugins = (plugins) => __awaiter(void 0, void 0, void 0, function* () {
+    let pluginsList;
+    if (!plugins)
+        pluginsList = getConfig().plugins;
+    else
+        pluginsList = plugins;
+    if (pluginsList === undefined) {
+        pluginsList = getConfig().plugins;
+    }
+    yield loadPluginFiles(pluginsList);
+    pluginsLoadingDone = true;
+});
+export const pluginsLoaded = () => pluginsLoadingDone;
 export const PluginLoader = (props) => {
     const { anchor } = props;
-    const plugins = getStore().getState().pluginsStore;
+    const anchorsList = !Array.isArray(anchor) ? [anchor] : anchor;
     let Plugins = [];
-    const matchedPlugins = plugins.config.filter((p) => {
-        if (p.anchor.length !== anchor.length)
-            return false;
-        for (let i = 0; i < anchor.length; i += 1) {
-            if (p.anchor[i] !== anchor[i] && p.anchor[i] !== "*")
-                return false;
+    for (let i = 0; i < anchorsList.length; i += 1) {
+        const currentAnchor = anchorsList[i];
+        if (Object.prototype.hasOwnProperty.call(globalAnchors, currentAnchor) &&
+            globalAnchors[currentAnchor].length > 0) {
+            const currentPlugins = globalAnchors[currentAnchor];
+            Plugins = [
+                ...Plugins,
+                ...currentPlugins.map((Plugin) => (_jsx(React.Suspense, Object.assign({ fallback: null }, { children: _jsx(Plugin, Object.assign({}, props.props), void 0) }), `lpwp-${currentAnchor}-${Math.random()}`))),
+            ];
         }
-        return true;
-    });
-    if (matchedPlugins.length > 0) {
-        Plugins = matchedPlugins.map((p, i) => (_jsx(p.component, Object.assign({}, (props.props || {})), i)));
     }
-    return _jsx(_Fragment, { children: Plugins });
+    if (Plugins.length > 0) {
+        return _jsx(_Fragment, { children: Plugins }, void 0);
+    }
+    return null;
+};
+PluginLoader.propTypes = {
+    anchor: PropTypes.arrayOf(PropTypes.string.isRequired).isRequired,
+    props: PropTypes.object,
 };
+PluginLoader.defaultProps = {
+    props: {},
+};
+let cache = {};
 export function replaceComponent(replacerName, OriginalComponent, componentName) {
+    const displayName = componentName ||
+        OriginalComponent.displayName ||
+        OriginalComponent.name ||
+        "Component";
+    const anchorsList = !Array.isArray(replacerName)
+        ? [replacerName]
+        : replacerName;
     let Replacer = null;
-    const name = componentName || OriginalComponent.displayName;
-    if (Array.isArray(replacerName)) {
-        replacerName.forEach((r) => {
-            if (replacers[r])
-                Replacer = r;
-        });
+    const cacheKey = anchorsList.reduce((a, b) => a + b) + OriginalComponent.toString();
+    if (Object.prototype.hasOwnProperty.call(cache, cacheKey)) {
+        return cache[cacheKey];
     }
-    else if (replacers[replacerName]) {
-        Replacer = replacerName;
+    for (let i = 0; i < anchorsList.length; i += 1) {
+        const currentAnchor = anchorsList[i];
+        if (Object.prototype.hasOwnProperty.call(replacers, currentAnchor)) {
+            Replacer = currentAnchor;
+            break;
+        }
     }
+    let FinalComponent;
     if (Replacer !== null) {
-        const BaseComponent = (props) => (_jsx(OriginalComponent, Object.assign({}, props, { children: props.children })));
+        const BaseComponent = (props) => (_jsx(OriginalComponent, Object.assign({}, props, { children: props.children }), void 0));
         const FinalReplacedComponent = replacers[Replacer].reduce((PreviousReplacer, CurrentReplacer) => {
-            const ReplacedComponent = (props) => (_jsx(React.Suspense, { fallback: null, children: _jsx(CurrentReplacer, Object.assign({}, props, { OriginalComponent: PreviousReplacer, children: props.children })) }));
+            const ReplacedComponent = (props) => (_jsx(React.Suspense, Object.assign({ fallback: null }, { children: _jsx(CurrentReplacer, Object.assign({}, props, { OriginalComponent: PreviousReplacer }, { children: props.children }), void 0) }), void 0));
             return ReplacedComponent;
         }, BaseComponent);
-        if (name) {
-            FinalReplacedComponent.displayName = `Replaced(${name})`;
-        }
-        return FinalReplacedComponent;
+        FinalComponent = FinalReplacedComponent;
+        FinalComponent.displayName = `replacedComponent(${displayName})`;
     }
-    return OriginalComponent;
+    else {
+        FinalComponent = OriginalComponent;
+        FinalComponent.displayName = `originalComponent(${displayName})`;
+    }
+    cache[cacheKey] = React.memo(FinalComponent);
+    return cache[cacheKey];
 }
 export const ReplaceFragment = ({ replacerName, fragmentName, children, }) => {
-    let Replacer = null;
-    if (Array.isArray(replacerName)) {
-        replacerName.forEach((r) => {
-            if (replacers[r])
-                Replacer = r;
+    const Fragment = () => _jsx(_Fragment, { children: children }, void 0);
+    const FinalFragment = replaceComponent(replacerName, Fragment, `Fragment::${fragmentName}`);
+    return _jsx(FinalFragment, {}, void 0);
+};
+export function RunActionAnchor(anchor, ...args) {
+    if (Object.prototype.hasOwnProperty.call(reduxAnchors, anchor) &&
+        reduxAnchors[anchor].length > 0) {
+        reduxAnchors[anchor].forEach((currentFn) => {
+            currentFn.call(null, ...args);
         });
     }
-    else if (replacers[replacerName]) {
-        Replacer = replacerName;
-    }
-    if (Replacer !== null) {
-        const Fragment = (props) => _jsx(_Fragment, { children: props.children });
-        const FinalReplacedComponent = replacers[Replacer].reduce((PreviousReplacer, CurrentReplacer) => {
-            const ReplacedComponent = (props) => (_jsx(React.Suspense, { fallback: null, children: _jsx(CurrentReplacer, Object.assign({}, props, { OriginalComponent: PreviousReplacer, children: props.children })) }));
-            return ReplacedComponent;
-        }, Fragment);
-        if (fragmentName) {
-            FinalReplacedComponent.displayName = `Replaced(${fragmentName})`;
-        }
-        return _jsx(FinalReplacedComponent, { children: children });
-    }
-    return _jsx(_Fragment, { children: children });
-};
-export function registerReplacer(replacerName, Replacer) {
-    if (!replacers[replacerName])
-        replacers[replacerName] = [];
-    replacers[replacerName].push(Replacer);
-}
-export function loadPlugins(plugins) {
-    const promises = [];
-    const store = getStore();
-    Object.keys(plugins).forEach((key) => {
-        promises.push(plugins[key]().then((plugin) => {
-            if (plugin.redux) {
-                pluginsStoreReducers = Object.assign(Object.assign({}, pluginsStoreReducers), { [key]: plugin.redux.reducer });
-                pluginsSagas = [...pluginsSagas, ...plugin.redux.sagas];
-            }
-        }));
-    });
-    return Promise.all(promises);
-}
-export function getPluginsReducers() {
-    return pluginsStoreReducers;
-}
-export function getPluginsAdditionalRoutes() {
-    const routes = [];
-    const plugins = getStore().getState().pluginsStore;
-    plugins.config.forEach((p) => {
-        if (p.anchor[0] === "routes") {
-            routes.push(p);
-        }
-    });
-    return routes;
 }
-export function getPluginsSagas() {
-    return pluginsSagas;
+export function RunOverrideActionAnchor(action) {
+    let overridedAction = action;
+    if (Object.prototype.hasOwnProperty.call(actionOverrideAnchor, action.type) &&
+        actionOverrideAnchor[action.type].length > 0) {
+        actionOverrideAnchor[action.type].forEach((currentFn) => {
+            overridedAction = currentFn.call(null, overridedAction);
+        });
+    }
+    return overridedAction;
 }
-export function clearPlugins() {
+export const getPluginsAdditionalRoutes = () => PluginAdditionRoutes;
+export const clearPlugins = () => {
+    globalAnchors = {};
+    reduxAnchors = {};
+    actionOverrideAnchor = {};
+    replacers = {};
+    PluginsAppStatesRegistrers = [];
+    PluginsPageAppStates = {};
+    PluginsAppStatesComponents = {};
+    PluginAdditionRoutes = {};
+    cache = {};
+    pluginsLoadingDone = false;
     pluginsStoreReducers = {};
-    pluginsSagas = [];
-}
-export const RunActionAnchor = () => { };
-export const RunOverrideActionAnchor = () => { };
-export const registerPluginsAppStates = () => { };
-export const getPluginsStoreReducers = getPluginsReducers;
-export const getPluginsStoreSagas = getPluginsSagas;
+};

package/dist/PluginLoader.test.d.ts

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

package/dist/PluginLoader.test.js

@@ -0,0 +1,52 @@
+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 '@testing-library/jest-dom/extend-expect';
+import { render, waitFor } from '@testing-library/react';
+import { replaceComponent } from './PluginLoader';
+jest.mock('react', () => {
+    const rct = jest.requireActual('react');
+    const Loadable = jest.requireActual('@loadable/component');
+    rct.lazy = Loadable.lazy;
+    return rct;
+});
+jest.mock('./config', () => ({
+    getConfig: () => ({
+        plugins: {
+            jestTestPlugin: '1.0.0',
+        },
+    }),
+}));
+jest.mock('./Globals', () => ({
+    loadPlugin: (plugin) => import(`./tests-misc/plugins/${plugin}`),
+}));
+const { loadPlugins, PluginLoader } = require('./PluginLoader');
+loadPlugins();
+describe('<PluginLoader />', () => {
+    it('Loads "after" hook', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { container } = render(_jsx(PluginLoader, { anchor: ['after'] }, void 0));
+        yield waitFor(() => expect(container).toContainHTML('<div><div class="title">Hello world - AFTER</div></div>'));
+    }));
+    it('Loads "before" hook', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { container } = render(_jsx(PluginLoader, { anchor: ['before'] }, void 0));
+        yield waitFor(() => expect(container).toContainHTML('<div><h1>Hello<b>world</b>!!!</h1></div>'));
+    }));
+    it('Tries to load non existing plugin', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { container } = render(_jsx(PluginLoader, { anchor: ['myNonExistingPlugin'] }, void 0));
+        yield waitFor(() => expect(container).toContainHTML('<div></div>'));
+    }));
+    it('Loads replacement module', () => __awaiter(void 0, void 0, void 0, function* () {
+        const Component = replaceComponent('TitleComponent', () => {
+            return _jsx("span", { children: "Original" }, void 0);
+        });
+        const { container } = render(_jsx(Component, { children: "Replaced" }, void 0));
+        yield waitFor(() => expect(container).toContainHTML('<div><h1 style="color: red;">Replaced</h1></div>'));
+    }));
+});

package/dist/Shimmer.d.ts

@@ -1,12 +1,15 @@
 import React from "react";
-import type { StateType } from "./types/State.type";
 declare const _default: import("react-redux").ConnectedComponent<React.FC<{
-    fetchStatus: StateType.App.Meta["fetchStatus"];
-    children?: React.ReactNode;
-    report: StateType.App.Meta["report"];
+    fetchStatus: "failed" | "waiting" | "succeeded" | "unhealthy" | "userLocked" | "nonBlocking";
+    report: {
+        object: import("@legalplace/model-healthcheck/dist/libs/HealthCheck.type").HealthCheckReport;
+        raw: string;
+    } | undefined;
 }>, import("react-redux").Omit<{
-    fetchStatus: StateType.App.Meta["fetchStatus"];
-    children?: React.ReactNode;
-    report: StateType.App.Meta["report"];
-}, "children" | "fetchStatus" | "report">>;
+    fetchStatus: "failed" | "waiting" | "succeeded" | "unhealthy" | "userLocked" | "nonBlocking";
+    report: {
+        object: import("@legalplace/model-healthcheck/dist/libs/HealthCheck.type").HealthCheckReport;
+        raw: string;
+    } | undefined;
+}, "fetchStatus" | "report">>;
 export default _default;

package/dist/Shimmer.js

@@ -9,7 +9,7 @@ const Shimmer = (props) => {
     const [themeLoaded, setThemeloaded] = useState(false);
     if (props.fetchStatus === "succeeded" ||
         props.fetchStatus === "nonBlocking") {
-        return _jsx(_Fragment, { children: props.children });
+        return _jsx(_Fragment, { children: props.children }, void 0);
     }
     addOnThemeLoadCallback(() => {
         if (!themeLoaded)
@@ -48,10 +48,10 @@ const Shimmer = (props) => {
         borderRadius: "4px",
     };
     if (ThemeShimmer !== null && props.fetchStatus === "waiting") {
-        return _jsx(ThemeShimmer, {});
+        return _jsx(ThemeShimmer, {}, void 0);
     }
-    return (_jsxs(_Fragment, { children: [["waiting", "failed"].includes(props.fetchStatus) && (_jsxs("div", { style: style, children: [props.fetchStatus === "waiting" && (_jsxs("div", { className: "lds-ripple", children: [_jsx("div", {}), _jsx("div", {})] })), props.fetchStatus === "failed" &&
-                        "Une erreur a eu lieu pendant le chargement du questionnaire"] })), props.fetchStatus === "userLocked" && (_jsxs(_Fragment, { children: [_jsx(PluginLoader, { anchor: ["userLockedScreen"], props: props }), _jsx(UserLockedComponent, { unhealthyStyle: unhealthyStyle })] })), props.fetchStatus === "unhealthy" && (_jsxs("div", { style: unhealthyStyle, children: ["Le mod\u00E8le semble contenir des erreurs", _jsx("pre", { style: unhealthyStylePre, children: (_a = props.report) === null || _a === void 0 ? void 0 : _a.raw })] }))] }));
+    return (_jsxs(_Fragment, { children: [["waiting", "failed"].includes(props.fetchStatus) && (_jsxs("div", Object.assign({ style: style }, { children: [props.fetchStatus === "waiting" && (_jsxs("div", Object.assign({ className: "lds-ripple" }, { children: [_jsx("div", {}, void 0), _jsx("div", {}, void 0)] }), void 0)), props.fetchStatus === "failed" &&
+                        "Une erreur a eu lieu pendant le chargement du questionnaire"] }), void 0)), props.fetchStatus === "userLocked" && (_jsxs(_Fragment, { children: [_jsx(PluginLoader, { anchor: ["userLockedScreen"], props: props }, void 0), _jsx(UserLockedComponent, { unhealthyStyle: unhealthyStyle }, void 0)] }, void 0)), props.fetchStatus === "unhealthy" && (_jsxs("div", Object.assign({ style: unhealthyStyle }, { children: ["Le mod\u00E8le semble contenir des erreurs", _jsx("pre", Object.assign({ style: unhealthyStylePre }, { children: (_a = props.report) === null || _a === void 0 ? void 0 : _a.raw }), void 0)] }), void 0))] }, void 0));
 };
 const mapStateToProps = (state) => ({
     fetchStatus: state.app.meta.fetchStatus === "succeeded"

package/dist/ThemeLoader.d.ts

@@ -1,28 +1,28 @@
 import type React from "react";
 import type { IWizardParamsTheme } from "./types/config.type";
-export declare const loadTheme: (theme?: string, force?: boolean) => Promise<void>;
+export declare const loadTheme: (theme?: string | undefined, force?: boolean | undefined) => Promise<void>;
 export declare const getThemeShimmer: () => React.LazyExoticComponent<React.FC<{}>> | null;
 export declare const setWizardTheme: (theme: IWizardParamsTheme) => Promise<void>;
 export declare const getThemeParams: () => {
     [key: string]: any;
     ui?: {
+        [key: string]: any;
         topbar: {
-            previewBtn: boolean;
             [key: string]: any;
+            previewBtn: boolean;
         };
-        [key: string]: any;
-    };
+    } | undefined;
     sidebar?: {
+        [key: string]: any;
         default: import("./types/config.type").SideBarType;
         states: {
+            [key: string]: import("./types/config.type").SideBarType;
             wizard?: import("./types/config.type").SideBarType;
             email?: import("./types/config.type").SideBarType;
-            [key: string]: import("./types/config.type").SideBarType;
         };
-        [key: string]: any;
-    };
+    } | undefined;
     fonts?: any;
-    style?: Record<string, any>;
+    style?: Record<string, any> | undefined;
 };
 export declare const loadThemeComponent: (name: string) => React.LazyExoticComponent<React.FC<{}>>;
 export declare const addOnThemeLoadCallback: (cb: () => void) => void;

package/dist/ThemeLoader.test.d.ts

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

package/dist/ThemeLoader.test.js

@@ -0,0 +1,65 @@
+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';
+afterEach(cleanup);
+jest.mock('./config', () => ({
+    __esModule: true,
+    getConfig: () => ({
+        theme: { name: 'jestTestTheme' },
+        plugins: {},
+    }),
+    loadConfig: () => __awaiter(void 0, void 0, void 0, function* () {
+        return ({
+            theme: { name: 'jestTestTheme' },
+            plugins: {},
+        });
+    }),
+    isConfigReady: () => true,
+}));
+jest.mock('./Globals', () => ({
+    loadTheme: (theme) => import(`./tests-misc/themes/${theme}`),
+}));
+let loadThemeComponent;
+let loadTheme;
+describe('<ThemeLoader />', () => {
+    beforeEach(() => {
+        loadThemeComponent = require('./ThemeLoader').loadThemeComponent;
+        loadTheme = require('./ThemeLoader').loadTheme;
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    it('Loads WizardComponent properly', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield loadTheme();
+        const WizardComponent = loadThemeComponent('WizardComponent');
+        const { container } = render(_jsx(WizardComponent, {}, 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* () {
+        const TermsheetComponent = loadThemeComponent('TermsheetComponent');
+        const { container } = render(_jsx(TermsheetComponent, {}, void 0));
+        yield waitFor(() => expect(container).toContainHTML('<div><h1>Wizard test theme, TermsheetComponent</h1></div>'));
+    }));
+});
+describe('loadTheme', () => {
+    it("loadTheme reloads theme properly if it's not yet loaded", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(loadTheme(undefined, true)).resolves.toEqual(undefined);
+    }));
+    it('loadTheme throws an error if theme param is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(loadTheme('madeUpTheme')).rejects.toEqual(new Error("We are unable to load the theme, please make sure the theme param is valid"));
+    }));
+    it('loadTheme throws an error if theme param is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(loadTheme('jestTestTheme/faltyIndexLoader')).rejects.toEqual(new Error("Unable to retrieve theme index"));
+    }));
+    it('loadTheme throws an error if loader result is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(loadTheme('jestTestTheme/faltyIndex')).rejects.toEqual(new Error("Unable to retrieve theme index"));
+    }));
+});

package/dist/components/PluginRoute.d.ts

@@ -2,6 +2,6 @@ import type { RouteComponentProps } from "react-router-dom";
 export interface IRouteProps {
     path: string;
 }
-export type IProps = RouteComponentProps<IRouteProps>;
-declare const PluginRoute: ({ match: { params: { path }, }, }: IProps) => import("react/jsx-runtime").JSX.Element;
+export declare type IProps = RouteComponentProps<IRouteProps>;
+declare const PluginRoute: ({ match: { params: { path }, }, }: IProps) => JSX.Element;
 export default PluginRoute;

package/dist/components/PluginRoute.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { Suspense, useCallback, useEffect, useState } from "react";
-import { getPluginsAdditionalRoutes } from "../PluginLoader";
+import { getPluginsAdditionalRoutes, loadPlugins } from "../PluginLoader";
 import Shimmer from "../Shimmer";
 const PluginRoute = ({ match: { params: { path }, }, }) => {
     const [RenderComponent, setRenderComponent] = useState(null);
@@ -17,9 +17,10 @@ const PluginRoute = ({ match: { params: { path }, }, }) => {
         try {
             let routes = getPluginsAdditionalRoutes();
             if (!routes.length) {
+                yield loadPlugins({ authentication: "1.0.0" });
                 routes = getPluginsAdditionalRoutes();
             }
-            if (false && routes[routePath])
+            if (routes[routePath])
                 setRenderComponent(routes[routePath]);
         }
         catch (error) {
@@ -29,6 +30,6 @@ const PluginRoute = ({ match: { params: { path }, }, }) => {
     useEffect(() => {
         loadRouteComponent(path);
     }, [path, loadRouteComponent]);
-    return (_jsx(Suspense, { fallback: _jsx(Shimmer, {}), children: _jsx(_Fragment, { children: RenderComponent && _jsx(RenderComponent, {}) }) }));
+    return (_jsx(Suspense, Object.assign({ fallback: () => Shimmer }, { children: _jsx(_Fragment, { children: RenderComponent && _jsx(RenderComponent, {}, void 0) }, void 0) }), void 0));
 };
 export default PluginRoute;

package/dist/components/SmartScript.d.ts

@@ -2,7 +2,7 @@ import type { Action } from "redux";
 import moment from "moment-business-days";
 import { SmartScriptStore } from "../libs/SmartScriptStore";
 import type { StateType } from "../types/State.type";
-export type TInitTriggersCallback = (triggers: StateType.SmartScript["triggers"], actions: Action[]) => void;
+export declare type TInitTriggersCallback = (triggers: StateType.SmartScript["triggers"], actions: Action[]) => void;
 declare global {
     interface Window {
         onInit: typeof SmartScriptStore.onInit;
@@ -27,5 +27,9 @@ declare global {
         initTriggers: (callback: TInitTriggersCallback, inputs: StateType.Inputs, newInstance: boolean) => void;
     }
 }
-declare const _default: import("react-redux").ConnectedComponent<any, import("react-redux").Omit<unknown, never>>;
+declare const _default: import("react-redux").ConnectedComponent<({ inpiActivities }: {
+    inpiActivities?: never[] | undefined;
+}) => JSX.Element, import("react-redux").Omit<{
+    inpiActivities?: never[] | undefined;
+}, never>>;
 export default _default;

package/dist/components/SmartScript.js

@@ -111,7 +111,7 @@ const SmartScriptComponent = ({ inpiActivities = [] }) => {
         }
         return SmartScriptStore.grabActions();
     });
-    return _jsx(_Fragment, { children: smartScriptLoaded ? "SmartScript" : "Loading..." });
+    return _jsx(_Fragment, { children: smartScriptLoaded ? "SmartScript" : "Loading..." }, void 0);
 };
 const mapStateToProps = () => {
     const inpiActivities = selectDataSmartscript();

package/dist/components/UserLocked/UserLockedComponent.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { replaceComponent } from "../../PluginLoader";
-const UserLockedComponent = ({ unhealthyStyle }) => (_jsx("div", { style: unhealthyStyle, children: "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 UserLockedComponent = ({ unhealthyStyle }) => (_jsx("div", Object.assign({ style: unhealthyStyle }, { children: "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" }), void 0));
 const UserLockHooc = (Component) => (props) => {
     const replaceAnchors = ["UserLockedComponent"];
     const FinalComponent = replaceComponent(replaceAnchors, Component);
-    return (_jsx(_Fragment, { children: _jsx(FinalComponent, Object.assign({}, props)) }));
+    return (_jsx(_Fragment, { children: _jsx(FinalComponent, Object.assign({}, props), void 0) }, void 0));
 };
 export default UserLockHooc(UserLockedComponent);