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

package/dist/PluginLoader.js

@@ -1,253 +1,116 @@
-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 = {};
-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;
+let pluginsSagas = [];
+const replacers = {};
 export const PluginLoader = (props) => {
     const { anchor } = props;
-    const anchorsList = !Array.isArray(anchor) ? [anchor] : anchor;
+    const plugins = getStore().getState().pluginsStore;
     let Plugins = [];
-    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()}`))),
-            ];
+    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;
         }
+        return true;
+    });
+    if (matchedPlugins.length > 0) {
+        Plugins = matchedPlugins.map((p, i) => (_jsx(p.component, Object.assign({}, (props.props || {})), i)));
     }
-    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,
+    return _jsx(_Fragment, { children: Plugins });
 };
-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 cacheKey = anchorsList.reduce((a, b) => a + b) + OriginalComponent.toString();
-    if (Object.prototype.hasOwnProperty.call(cache, cacheKey)) {
-        return cache[cacheKey];
+    const name = componentName || OriginalComponent.displayName;
+    if (Array.isArray(replacerName)) {
+        replacerName.forEach((r) => {
+            if (replacers[r])
+                Replacer = r;
+        });
     }
-    for (let i = 0; i < anchorsList.length; i += 1) {
-        const currentAnchor = anchorsList[i];
-        if (Object.prototype.hasOwnProperty.call(replacers, currentAnchor)) {
-            Replacer = currentAnchor;
-            break;
-        }
+    else if (replacers[replacerName]) {
+        Replacer = replacerName;
     }
-    let FinalComponent;
     if (Replacer !== null) {
-        const BaseComponent = (props) => (_jsx(OriginalComponent, Object.assign({}, props, { children: props.children }), void 0));
+        const BaseComponent = (props) => (_jsx(OriginalComponent, Object.assign({}, props, { children: props.children })));
         const FinalReplacedComponent = replacers[Replacer].reduce((PreviousReplacer, CurrentReplacer) => {
-            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));
+            const ReplacedComponent = (props) => (_jsx(React.Suspense, { fallback: null, children: _jsx(CurrentReplacer, Object.assign({}, props, { OriginalComponent: PreviousReplacer, children: props.children })) }));
             return ReplacedComponent;
         }, BaseComponent);
-        FinalComponent = FinalReplacedComponent;
-        FinalComponent.displayName = `replacedComponent(${displayName})`;
-    }
-    else {
-        FinalComponent = OriginalComponent;
-        FinalComponent.displayName = `originalComponent(${displayName})`;
+        if (name) {
+            FinalReplacedComponent.displayName = `Replaced(${name})`;
+        }
+        return FinalReplacedComponent;
     }
-    cache[cacheKey] = React.memo(FinalComponent);
-    return cache[cacheKey];
+    return OriginalComponent;
 }
 export const ReplaceFragment = ({ replacerName, fragmentName, children, }) => {
-    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);
+    let Replacer = null;
+    if (Array.isArray(replacerName)) {
+        replacerName.forEach((r) => {
+            if (replacers[r])
+                Replacer = r;
         });
     }
-}
-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);
-        });
+    else if (replacers[replacerName]) {
+        Replacer = replacerName;
     }
-    return overridedAction;
+    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 const getPluginsAdditionalRoutes = () => PluginAdditionRoutes;
-export const clearPlugins = () => {
-    globalAnchors = {};
-    reduxAnchors = {};
-    actionOverrideAnchor = {};
-    replacers = {};
-    PluginsAppStatesRegistrers = [];
-    PluginsPageAppStates = {};
-    PluginsAppStatesComponents = {};
-    PluginAdditionRoutes = {};
-    cache = {};
-    pluginsLoadingDone = false;
+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 clearPlugins() {
     pluginsStoreReducers = {};
-};
+    pluginsSagas = [];
+}
+export const RunActionAnchor = () => { };
+export const RunOverrideActionAnchor = () => { };
+export const registerPluginsAppStates = () => { };
+export const getPluginsStoreReducers = getPluginsReducers;
+export const getPluginsStoreSagas = getPluginsSagas;

package/dist/Shimmer.d.ts

@@ -1,15 +1,12 @@
 import React from "react";
+import type { StateType } from "./types/State.type";
 declare const _default: import("react-redux").ConnectedComponent<React.FC<{
-    fetchStatus: "failed" | "waiting" | "succeeded" | "unhealthy" | "userLocked" | "nonBlocking";
-    report: {
-        object: import("@legalplace/model-healthcheck/dist/libs/HealthCheck.type").HealthCheckReport;
-        raw: string;
-    } | undefined;
+    fetchStatus: StateType.App.Meta["fetchStatus"];
+    children?: React.ReactNode;
+    report: StateType.App.Meta["report"];
 }>, import("react-redux").Omit<{
-    fetchStatus: "failed" | "waiting" | "succeeded" | "unhealthy" | "userLocked" | "nonBlocking";
-    report: {
-        object: import("@legalplace/model-healthcheck/dist/libs/HealthCheck.type").HealthCheckReport;
-        raw: string;
-    } | undefined;
-}, "fetchStatus" | "report">>;
+    fetchStatus: StateType.App.Meta["fetchStatus"];
+    children?: React.ReactNode;
+    report: StateType.App.Meta["report"];
+}, "children" | "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 }, void 0);
+        return _jsx(_Fragment, { children: props.children });
     }
     addOnThemeLoadCallback(() => {
         if (!themeLoaded)
@@ -48,10 +48,10 @@ const Shimmer = (props) => {
         borderRadius: "4px",
     };
     if (ThemeShimmer !== null && props.fetchStatus === "waiting") {
-        return _jsx(ThemeShimmer, {}, void 0);
+        return _jsx(ThemeShimmer, {});
     }
-    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));
+    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 })] }))] }));
 };
 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 | undefined, force?: boolean | undefined) => Promise<void>;
+export declare const loadTheme: (theme?: string, force?: boolean) => 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: {
-            [key: string]: any;
             previewBtn: boolean;
+            [key: string]: any;
         };
-    } | undefined;
-    sidebar?: {
         [key: string]: any;
+    };
+    sidebar?: {
         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;
         };
-    } | undefined;
+        [key: string]: any;
+    };
     fonts?: any;
-    style?: Record<string, any> | undefined;
+    style?: Record<string, any>;
 };
 export declare const loadThemeComponent: (name: string) => React.LazyExoticComponent<React.FC<{}>>;
 export declare const addOnThemeLoadCallback: (cb: () => void) => void;

package/dist/WizardCore.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+import type { ModelV3 } from "@legalplace/models-v3-types";
+import type { StateType } from "./types/State.type";
+import type { IWizardParams } from "./types/config.type";
+import type { IRouterAdapter, IWizardCoreRouterProps } from "./routing/types";
+export interface WizardCoreProps {
+    historyType?: "browser" | "memory";
+    model?: ModelV3;
+    meta?: StateType.App.Meta;
+    instance?: StateType.App.Instance;
+    user?: StateType.User;
+    wizardParams?: IWizardParams;
+    preloadTheme?: boolean;
+    loadPlugin: (plugin: string) => Promise<any>;
+    loadTheme: (theme: string) => Promise<any>;
+    routerAdapter?: IRouterAdapter;
+    routing?: IWizardCoreRouterProps;
+}
+declare class WizardCore extends React.Component<WizardCoreProps, {
+    initialized: boolean;
+}> {
+    private storeInitialized;
+    constructor(props: WizardCoreProps);
+    private initializeStore;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): import("react/jsx-runtime").JSX.Element | null;
+}
+export default WizardCore;

package/dist/WizardCore.js

@@ -0,0 +1,153 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { Provider } from "react-redux";
+import { getStore, createAppStore } from "./redux/store";
+import Globals, { setGlobals } from "./Globals";
+import { getConfig, updateConfig } from "./config";
+import { fetchModelPrerequisitesAction } from "./redux/actions/sagas/model";
+import { preloadTheme } from "./helpers/preloadTheme";
+import ViewComponent from "./components/View";
+import PluginRoute from "./components/PluginRoute";
+import SmartScriptComponent from "./components/SmartScript";
+import { clearPlugins } from "./PluginLoader";
+import { PathReader } from "./libs/PathReader";
+import { resetStateAction } from "./redux/actions/app";
+import { callInitDataSmartscriptAction } from "./redux";
+import { externalPartnerRedirectUrl } from "./helpers/redirectionConfig";
+import { autoSave } from "./helpers/autosave.helper";
+import { NOT_FOUND_PAGE_LINK } from "./constants/links.constant";
+import { RouterProvider } from "./routing/context";
+const getRouteComponent = (pathname, params) => {
+    const config = getConfig();
+    if (pathname.startsWith("/p/")) {
+        const pluginPath = params.path || pathname.replace("/p/", "");
+        return {
+            component: PluginRoute,
+            props: { match: { params: { path: pluginPath } } },
+        };
+    }
+    if (pathname.includes("/smartscript/")) {
+        return { component: SmartScriptComponent };
+    }
+    const wizardInstanceRegex = /\/contrats\/.*\/continuer\//;
+    const wizardRegex = /\/contrats\/.*\/creer\//;
+    if (wizardInstanceRegex.test(pathname) || wizardRegex.test(pathname)) {
+        return { component: ViewComponent };
+    }
+    return null;
+};
+const RedirectHandler = ({ navigate, }) => {
+    React.useEffect(() => {
+        const matchedPartner = Object.keys(externalPartnerRedirectUrl).find((partner) => window.location.origin.toLowerCase().includes(partner));
+        if (matchedPartner) {
+            window.location.href = externalPartnerRedirectUrl[matchedPartner];
+        }
+        else {
+            window.location.href = NOT_FOUND_PAGE_LINK;
+        }
+    }, []);
+    return null;
+};
+class WizardCore extends React.Component {
+    constructor(props) {
+        super(props);
+        this.storeInitialized = false;
+        this.state = {
+            initialized: false,
+        };
+        this.initializeStore(props);
+    }
+    initializeStore(props) {
+        var _a;
+        if (this.storeInitialized)
+            return;
+        clearPlugins();
+        const historyType = typeof props.historyType === "string" ? props.historyType : "browser";
+        const params = Object.assign(Object.assign({}, Globals), { loadTheme: props.loadTheme, loadPlugin: props.loadPlugin });
+        if (props.model) {
+            params.model = props.model;
+        }
+        if (props.meta) {
+            params.meta = props.meta;
+        }
+        if (props.instance) {
+            params.instance = props.instance;
+        }
+        if (props.user) {
+            params.user = props.user;
+        }
+        setGlobals(params);
+        if (props.wizardParams)
+            updateConfig(props.wizardParams);
+        if (props.preloadTheme && ((_a = props.wizardParams) === null || _a === void 0 ? void 0 : _a.theme.name))
+            preloadTheme(props.wizardParams.theme.name);
+        try {
+            createAppStore(historyType);
+            this.storeInitialized = true;
+        }
+        catch (error) {
+            console.error("Failed to initialize store:", error);
+        }
+    }
+    componentDidMount() {
+        if (!this.storeInitialized) {
+            this.initializeStore(this.props);
+        }
+        setTimeout(() => {
+            try {
+                const { dispatch, getState } = getStore();
+                const state = getState();
+                let parent = null;
+                window.addEventListener("message", ({ data, source }) => {
+                    if (parent === null || data.from === "BO") {
+                        parent = source;
+                    }
+                    if (data.from && data.from === "BO") {
+                        const { variables } = data;
+                        autoSave(variables, getStore());
+                    }
+                });
+                dispatch(callInitDataSmartscriptAction());
+                if (!PathReader.isSmartScriptPath()) {
+                    dispatch(fetchModelPrerequisitesAction(getConfig().permalink || state.app.meta.permalink, getConfig().prefix || state.app.meta.prefix || ""));
+                }
+                this.setState({ initialized: true });
+            }
+            catch (error) {
+                console.error("Error during component mount:", error);
+            }
+        }, 0);
+    }
+    componentWillUnmount() {
+        getStore().dispatch(resetStateAction());
+    }
+    render() {
+        if (!this.storeInitialized) {
+            return null;
+        }
+        const { routerAdapter, routing } = this.props;
+        try {
+            const store = getStore();
+            if (routing) {
+                const { pathname, params, navigate } = routing;
+                const routeMatch = getRouteComponent(pathname, params);
+                if (routeMatch) {
+                    const RouteComponent = routeMatch.component;
+                    return (_jsx(Provider, { store: store, children: _jsx(RouteComponent, Object.assign({}, (routeMatch.props || {}))) }));
+                }
+                return (_jsx(Provider, { store: store, children: _jsx(RedirectHandler, { navigate: navigate }) }));
+            }
+            if (routerAdapter) {
+                return (_jsx(Provider, { store: store, children: _jsx(RouterProvider, { adapter: routerAdapter, children: _jsx(WizardCoreContent, {}) }) }));
+            }
+            console.warn("WizardCore: No routing mechanism provided. Pass either 'routerAdapter' or 'routing' props.");
+            return (_jsx(Provider, { store: store, children: _jsx("div", { children: "No routing configured" }) }));
+        }
+        catch (error) {
+            console.error("Error rendering WizardCore:", error);
+            return _jsx("div", { children: "Error initializing wizard. Check console for details." });
+        }
+    }
+}
+const WizardCoreContent = () => (_jsx(ViewComponent, {}));
+export default WizardCore;

package/dist/app.entry.d.ts

@@ -0,0 +1,2 @@
+export { default as App } from "./App";
+export type { AppProps } from "./App";

package/dist/app.entry.js

@@ -0,0 +1 @@
+export { default as App } from "./App";

package/dist/components/PluginRoute.d.ts

@@ -2,6 +2,6 @@ import type { RouteComponentProps } from "react-router-dom";
 export interface IRouteProps {
     path: string;
 }
-export declare type IProps = RouteComponentProps<IRouteProps>;
-declare const PluginRoute: ({ match: { params: { path }, }, }: IProps) => JSX.Element;
+export type IProps = RouteComponentProps<IRouteProps>;
+declare const PluginRoute: ({ match: { params: { path }, }, }: IProps) => import("react/jsx-runtime").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, loadPlugins } from "../PluginLoader";
+import { getPluginsAdditionalRoutes } from "../PluginLoader";
 import Shimmer from "../Shimmer";
 const PluginRoute = ({ match: { params: { path }, }, }) => {
     const [RenderComponent, setRenderComponent] = useState(null);
@@ -17,10 +17,9 @@ const PluginRoute = ({ match: { params: { path }, }, }) => {
         try {
             let routes = getPluginsAdditionalRoutes();
             if (!routes.length) {
-                yield loadPlugins({ authentication: "1.0.0" });
                 routes = getPluginsAdditionalRoutes();
             }
-            if (routes[routePath])
+            if (false && routes[routePath])
                 setRenderComponent(routes[routePath]);
         }
         catch (error) {
@@ -30,6 +29,6 @@ const PluginRoute = ({ match: { params: { path }, }, }) => {
     useEffect(() => {
         loadRouteComponent(path);
     }, [path, loadRouteComponent]);
-    return (_jsx(Suspense, Object.assign({ fallback: () => Shimmer }, { children: _jsx(_Fragment, { children: RenderComponent && _jsx(RenderComponent, {}, void 0) }, void 0) }), void 0));
+    return (_jsx(Suspense, { fallback: _jsx(Shimmer, {}), children: _jsx(_Fragment, { children: RenderComponent && _jsx(RenderComponent, {}) }) }));
 };
 export default PluginRoute;