@legalplace/wizardx-core 4.42.10-nightly.20251125160107 → 4.42.10-nightly.20251125160911

package/dist/App.js

@@ -77,7 +77,7 @@ class WizardXCore extends React.Component {
         getStore().dispatch(resetStateAction());
     }
     render() {
-        return (_jsxs(Provider, { store: getStore(), children: [_jsx("h1", { children: "IAM APP" }), _jsx(ConnectedRouter, { history: getHistory(), children: _jsxs(Switch, { children: [_jsx(Route, { path: "/p/:path", component: PluginRoute }), _jsx(Route, { path: getConfig().router.smartscriptPath, exact: true, strict: true, component: SmartScriptComponent }), _jsx(Route, { path: getConfig().router.wizardInstancePath, component: ViewComponent }), _jsx(Route, { path: getConfig().router.wizardPath, component: ViewComponent }), !window.location.href.includes("smartscript") && (_jsx(Route, { component: RedirectHandler }))] }) })] }));
+        return (_jsx(Provider, { store: getStore(), children: _jsx(ConnectedRouter, { history: getHistory(), children: _jsxs(Switch, { children: [_jsx(Route, { path: "/p/:path", component: PluginRoute }), _jsx(Route, { path: getConfig().router.smartscriptPath, exact: true, strict: true, component: SmartScriptComponent }), _jsx(Route, { path: getConfig().router.wizardInstancePath, component: ViewComponent }), _jsx(Route, { path: getConfig().router.wizardPath, component: ViewComponent }), !window.location.href.includes("smartscript") && (_jsx(Route, { component: RedirectHandler }))] }) }) }));
     }
 }
 export default WizardXCore;

package/dist/PluginLoader.d.ts

@@ -18,14 +18,14 @@ export type ReplaceFragmentPropsType = {
 };
 export declare const ReplaceFragment: ({ replacerName, fragmentName, children, }: ReplaceFragmentPropsType) => import("react/jsx-runtime").JSX.Element;
 export declare function registerReplacer(replacerName: string, Replacer: ReactComponent<any>): void;
-export declare function loadPlugins(plugins?: Record<string, () => Promise<IPlugin>>): Promise<any>;
+export declare function loadPlugins(plugins?: Record<string, (() => Promise<IPlugin>) | Promise<IPlugin> | IPlugin>): Promise<any>;
 export declare function getPluginsReducers(): Record<string, Reducer<Record<string, any>, any>>;
 export declare function getPluginsAdditionalRoutes(): IPluginConfig[];
 export declare function getPluginsSagas(): Saga[];
 export declare function clearPlugins(): void;
 export declare const RunActionAnchor: () => void;
 export declare const RunOverrideActionAnchor: () => void;
-export declare const registerPluginsAppStates: () => void;
+export declare const registerPluginsAppStates: (appStates: any) => any;
 export declare const getPluginsStoreReducers: typeof getPluginsReducers;
 export declare const getPluginsStoreSagas: typeof getPluginsSagas;
 export {};

package/dist/PluginLoader.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import React from "react";
 import { getStore } from "./redux/store";
 let pluginsStoreReducers = {};
@@ -8,6 +8,9 @@ export const PluginLoader = (props) => {
     const { anchor } = props;
     const plugins = getStore().getState().pluginsStore;
     let Plugins = [];
+    if (!plugins || !plugins.config || !Array.isArray(plugins.config)) {
+        return _jsx(_Fragment, {});
+    }
     const matchedPlugins = plugins.config.filter((p) => {
         if (p.anchor.length !== anchor.length)
             return false;
@@ -83,16 +86,44 @@ export function loadPlugins(plugins) {
     }
     const store = getStore();
     Object.keys(plugins).forEach((key) => {
-        const pluginLoader = plugins[key];
-        if (typeof pluginLoader !== "function") {
-            console.warn(`Plugin "${key}" loader is not a function, skipping...`);
+        const pluginValue = plugins[key];
+        let pluginPromise;
+        if (typeof pluginValue === "function") {
+            try {
+                pluginPromise = Promise.resolve(pluginValue());
+            }
+            catch (error) {
+                console.error(`Failed to execute plugin "${key}" loader:`, error);
+                return;
+            }
+        }
+        else if (pluginValue && typeof pluginValue === "object" && "then" in pluginValue) {
+            pluginPromise = pluginValue;
+        }
+        else if (pluginValue && typeof pluginValue === "object") {
+            pluginPromise = Promise.resolve(pluginValue);
+        }
+        else {
+            console.warn(`Plugin "${key}" has invalid format, skipping...`);
             return;
         }
-        promises.push(pluginLoader().then((plugin) => {
+        promises.push(pluginPromise.then((plugin) => {
+            if (!plugin)
+                return;
             if (plugin.redux) {
                 pluginsStoreReducers = Object.assign(Object.assign({}, pluginsStoreReducers), { [key]: plugin.redux.reducer });
                 pluginsSagas = [...pluginsSagas, ...plugin.redux.sagas];
             }
+            if (plugin.config && Array.isArray(plugin.config)) {
+                const currentState = store.getState().pluginsStore;
+                const existingConfig = currentState.config || [];
+                store.dispatch({
+                    type: "@@PLUGIN/ADD_CONFIG",
+                    payload: {
+                        config: [...existingConfig, ...plugin.config],
+                    },
+                });
+            }
         }).catch((error) => {
             console.error(`Failed to load plugin "${key}":`, error);
         }));
@@ -105,11 +136,13 @@ export function getPluginsReducers() {
 export function getPluginsAdditionalRoutes() {
     const routes = [];
     const plugins = getStore().getState().pluginsStore;
-    plugins.config.forEach((p) => {
-        if (p.anchor[0] === "routes") {
-            routes.push(p);
-        }
-    });
+    if ((plugins === null || plugins === void 0 ? void 0 : plugins.config) && Array.isArray(plugins.config)) {
+        plugins.config.forEach((p) => {
+            if (p.anchor[0] === "routes") {
+                routes.push(p);
+            }
+        });
+    }
     return routes;
 }
 export function getPluginsSagas() {
@@ -118,9 +151,18 @@ export function getPluginsSagas() {
 export function clearPlugins() {
     pluginsStoreReducers = {};
     pluginsSagas = [];
+    const store = getStore(false);
+    if (store) {
+        store.dispatch({
+            type: "@@PLUGIN/ADD_CONFIG",
+            payload: {
+                config: [],
+            },
+        });
+    }
 }
 export const RunActionAnchor = () => { };
 export const RunOverrideActionAnchor = () => { };
-export const registerPluginsAppStates = () => { };
+export const registerPluginsAppStates = (appStates) => appStates || [];
 export const getPluginsStoreReducers = getPluginsReducers;
 export const getPluginsStoreSagas = getPluginsSagas;

package/dist/WizardCore.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from "react";
 import { Provider } from "react-redux";
 import { getStore, createAppStore } from "./redux/store";
@@ -17,6 +17,7 @@ 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";
+import { RouterSync } from "./routing/RouterSync";
 const getRouteComponent = (pathname, params) => {
     if (pathname.startsWith("/p/")) {
         const pluginPath = params.path || pathname.replace("/p/", "");
@@ -134,7 +135,7 @@ class WizardCore extends React.Component {
                 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, {}) }) }));
+                return (_jsx(Provider, { store: store, children: _jsxs(RouterProvider, { adapter: routerAdapter, children: [_jsx(RouterSync, {}), _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" }) }));

package/dist/redux/reducers/pluginsStore.js

@@ -1,8 +1,14 @@
 import { getPluginsStoreReducers } from "../../PluginLoader";
 import { RESET_STATE } from "../constants/app";
-export const pluginsStoreReducer = (state = {}, action) => {
+const initialState = {
+    config: [],
+};
+export const pluginsStoreReducer = (state = initialState, action) => {
     if (action.type === RESET_STATE)
-        return {};
+        return initialState;
+    if (action.type === "@@PLUGIN/ADD_CONFIG") {
+        return Object.assign(Object.assign({}, state), { config: action.payload.config });
+    }
     const pluginsStoreReducers = getPluginsStoreReducers();
     const plugins = Object.keys(pluginsStoreReducers);
     const newState = Object.assign({}, state);

package/dist/redux/store.d.ts

@@ -1,4 +1,6 @@
-import type { Store } from "redux";
+import type { Store, EmptyObject, AnyAction } from "redux";
 import type { StateType } from "../types/State.type";
-export declare const createAppStore: (historyType?: "browser" | "memory") => Store<StateType>;
-export declare const getStore: (throwIfDoesNotExist?: boolean) => Store<StateType>;
+export declare const createAppStore: (historyType?: "browser" | "memory") => void;
+export declare const getStore: (throwIfDoesNotExist?: boolean) => Store<EmptyObject & StateType, AnyAction> & {
+    dispatch: unknown;
+};

package/dist/redux/store.js

@@ -1,5 +1,6 @@
-import { configureStore } from "@reduxjs/toolkit";
+import { combineReducers, legacy_createStore as createStore, applyMiddleware } from "redux";
 import { connectRouter, routerMiddleware } from "connected-react-router";
+import { composeWithDevTools } from "redux-devtools-extension";
 import { appReducer } from "./reducers/app";
 import { userReducer } from "./reducers/user";
 import { referencesReducer } from "./reducers/references";
@@ -27,74 +28,32 @@ let store;
 export const createAppStore = (historyType = "browser") => {
     if (store !== undefined) {
         createHistory(historyType);
-        return store;
+        return;
     }
     const history = createHistory(historyType);
-    const sagaMiddleware = getSagaMiddleware();
-    store = configureStore({
-        reducer: {
-            router: connectRouter(history),
-            app: appReducer,
-            user: userReducer,
-            references: referencesReducer,
-            inputs: inputsReducer,
-            mandatories: mandatoriesReducer,
-            conditions: conditionsReducer,
-            smartscript: smartscriptReducer,
-            pluginsStore: pluginsStoreReducer,
-        },
-        middleware: (getDefaultMiddleware) => getDefaultMiddleware({
-            serializableCheck: {
-                ignoredActions: [
-                    "@@router/LOCATION_CHANGE",
-                    "@@router/CALL_HISTORY_METHOD",
-                ],
-                ignoredPaths: ["router"],
-            },
-            immutableCheck: Globals.appEnv !== "production",
-        })
-            .concat([
-            pluginsHookMiddleware,
-            routerMiddleware(history),
-            sagaMiddleware,
-            paginationWatcherMiddleware,
-            selectorsMiddleware,
-            conditionsWatcherMiddleware,
-            prefillerWatcherMiddleware,
-            evaluationsWatcherMiddleware,
-            multiplesActionsMiddleware,
-            mandatoriesWatcherMiddleware,
-            smartscriptMiddleware,
-            thirdPartyScriptsMiddleware,
-        ]),
-        devTools: Globals.appEnv !== "production"
-            ? {
-                name: "WizardX Core",
-                trace: true,
-                traceLimit: 25,
-                features: {
-                    pause: true,
-                    lock: true,
-                    persist: true,
-                    export: true,
-                    import: "custom",
-                    jump: true,
-                    skip: true,
-                    reorder: true,
-                    dispatch: true,
-                    test: true,
-                },
-            }
-            : false,
+    const wizardxReducers = combineReducers({
+        router: connectRouter(history),
+        app: appReducer,
+        user: userReducer,
+        references: referencesReducer,
+        inputs: inputsReducer,
+        mandatories: mandatoriesReducer,
+        conditions: conditionsReducer,
+        smartscript: smartscriptReducer,
+        pluginsStore: pluginsStoreReducer,
     });
+    const sagaMiddleware = getSagaMiddleware();
+    const appliedMiddlewares = applyMiddleware(pluginsHookMiddleware, routerMiddleware(history), sagaMiddleware, paginationWatcherMiddleware, selectorsMiddleware, conditionsWatcherMiddleware, prefillerWatcherMiddleware, evaluationsWatcherMiddleware, multiplesActionsMiddleware, mandatoriesWatcherMiddleware, smartscriptMiddleware, thirdPartyScriptsMiddleware);
+    const middlewares = Globals.appEnv !== "production"
+        ? composeWithDevTools(appliedMiddlewares)
+        : appliedMiddlewares;
+    store = createStore(wizardxReducers, middlewares);
     sagasRunner(sagaMiddleware);
     subscribeListeners(store);
     store.dispatch({ type: "@@WIZARDX/INIT" });
-    return store;
 };
 export const getStore = (throwIfDoesNotExist = true) => {
-    if (store === undefined && throwIfDoesNotExist) {
-        throw new Error("Store not yet created. Call createAppStore() first before accessing the store.");
-    }
+    if (store === undefined && throwIfDoesNotExist)
+        throw new Error("Store not yet created");
     return store;
 };

package/dist/routing/RouterSync.d.ts

@@ -0,0 +1 @@
+export declare const RouterSync: () => null;

package/dist/routing/RouterSync.js

@@ -0,0 +1,12 @@
+import { useEffect } from "react";
+import { useDispatch } from "react-redux";
+import { useLocation } from "./context";
+import { push } from "connected-react-router";
+export const RouterSync = () => {
+    const location = useLocation();
+    const dispatch = useDispatch();
+    useEffect(() => {
+        dispatch(push(location.pathname + location.search));
+    }, [location.pathname, location.search, dispatch]);
+    return null;
+};

package/dist/types/State.type.d.ts

@@ -271,5 +271,6 @@ export interface SmartScriptType {
     data?: object;
 }
 export interface PluginsStoreType {
-    [key: string]: Record<string, any>;
+    config?: any[];
+    [key: string]: any;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/wizardx-core",
-  "version": "4.42.10-nightly.20251125160107",
+  "version": "4.42.10-nightly.20251125160911",
   "author": "Moncef Hammou (moncef@legalplace.fr)",
   "license": "MIT",
   "files": [
@@ -60,7 +60,6 @@
     "@legalplace/typeorm-constants": "^3.74.4",
     "@loadable/component": "^5.15.0",
     "@redux-saga/core": "^1.1.3",
-    "@reduxjs/toolkit": "^2.11.0",
     "axios": "^0.24.0",
     "connected-react-router": "^6.8.0",
     "crypto-js": "^4.1.1",
@@ -112,6 +111,7 @@
     "jest-junit": "^13.0.0",
     "lodash": "^4.17.21",
     "react-async-ssr": "^0.7.2",
+    "redux-devtools-extension": "^2.13.9",
     "redux-mock-store": "^1.5.4",
     "regenerator-runtime": "^0.13.9",
     "rimraf": "^3.0.2",