@legalplace/wizardx-core 4.42.10-nightly.20251126151952 → 4.42.10-nightly.20251126154644

package/dist/PluginLoader.d.ts

@@ -1,7 +1,22 @@
 import React from "react";
-import type { Reducer } from "redux";
+import type { LoadableComponent } from "@loadable/component";
+import type { Action, Reducer } from "redux";
 import type { Saga } from "redux-saga";
-import type { IPlugin, IPluginConfig } from "./types/PluginConfig.type";
+declare let pluginsStoreReducers: Record<string, Reducer<Record<string, any>, any>>;
+declare const pluginsStoreSagas: Record<string, Saga[]>;
+export type PluginAppStatesRegisterFunction = (currentAppStates: string[]) => string[];
+export type PluginsPageAppStatesType = Record<string, string>;
+export type actionOverrideFunction = (action: Action) => Action;
+export interface IPluginsAppStatesComponents {
+    [key: string]: LoadableComponent<any>;
+}
+export interface PluginsAppStatesDeclarations {
+    register: PluginAppStatesRegisterFunction;
+    pageAppState: PluginsPageAppStatesType;
+    components: IPluginsAppStatesComponents;
+    additionalRoutes?: Record<string, ReactComponent<any>>[];
+}
+declare let PluginsPageAppStates: PluginsPageAppStatesType;
 type TPluginLoader = React.FC<PluginLoaderProps>;
 export interface PluginLoaderProps {
     anchor: string[];
@@ -16,16 +31,20 @@ export type ReplaceFragmentPropsType = {
     fragmentName?: string;
     children?: React.ReactNode;
 };
-export declare const ReplaceFragment: ({ replacerName, fragmentName, children, }: ReplaceFragmentPropsType) => import("react/jsx-runtime").JSX.Element;
+export declare const ReplaceFragment: React.FC<ReplaceFragmentPropsType>;
 export declare function registerReplacer(replacerName: string, Replacer: ReactComponent<any>): void;
-export declare function loadPlugins(plugins?: Record<string, string | (() => Promise<IPlugin>) | Promise<IPlugin> | IPlugin>): Promise<any>;
+export declare const registerPluginsAppStates: PluginAppStatesRegisterFunction;
+export declare const loadPluginComponent: (name: string) => LoadableComponent<any> | undefined;
+export declare const pluginPageAppState: (page: string) => string | false;
+export declare const getPluginsPageAppStates: () => Readonly<typeof PluginsPageAppStates>;
+export declare const getPluginsStoreReducers: () => Readonly<typeof pluginsStoreReducers>;
+export declare const getPluginsStoreSagas: () => Readonly<typeof pluginsStoreSagas>;
+export declare function RunActionAnchor(anchor: string, ...args: any[]): void;
+export declare function RunOverrideActionAnchor(action: Action): Action<any>;
+export declare const loadPlugins: (plugins?: Record<string, string>) => Promise<void>;
+export declare const pluginsLoaded: () => boolean;
+export declare const getPluginsAdditionalRoutes: () => Record<string, ReactComponent<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: (appStates: any) => any;
-export declare const getPluginsStoreReducers: typeof getPluginsReducers;
-export declare const getPluginsStoreSagas: typeof getPluginsSagas;
+export declare function getPluginsSagas(): Record<string, Saga[]>;
+export declare const clearPlugins: () => void;
 export {};

package/dist/PluginLoader.js

@@ -1,184 +1,256 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+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 { getStore } from "./redux/store";
+import { getHistory } from "./redux/routerHistory";
+import { getConfig } from "./config";
 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 = {};
+let cache = {};
+let pluginsLoadingDone = false;
+let PluginsAppStatesRegistrers = [];
+let PluginsPageAppStates = {};
+let PluginsAppStatesComponents = {};
+let PluginAdditionRoutes = {};
 export const PluginLoader = (props) => {
     const { anchor } = props;
-    const plugins = getStore().getState().pluginsStore;
+    const anchorsList = !Array.isArray(anchor) ? [anchor] : anchor;
     let Plugins = [];
-    console.log("PluginLoader", plugins);
-    console.log("anchor", anchor);
-    if (!plugins || !plugins.config || !Array.isArray(plugins.config)) {
-        ``;
-        console.log("No plugins found");
-        return _jsx(_Fragment, {});
-    }
-    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, { fallback: null, children: _jsx(Plugin, Object.assign({}, props.props)) }, `lpwp-${currentAnchor}-${Math.random()}`))),
+            ];
         }
-        console.log("Matched plugin", p);
-        return true;
-    });
-    if (matchedPlugins.length > 0) {
-        Plugins = matchedPlugins.map((p, i) => (_jsx(p.component, Object.assign({}, (props.props || {})), i)));
     }
-    console.log("Plugins", Plugins);
-    return _jsx(_Fragment, { children: Plugins });
+    if (Plugins.length > 0) {
+        return _jsx(_Fragment, { children: Plugins });
+    }
+    return null;
 };
 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) => React.createElement(OriginalComponent, props, 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;
         }, 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;
-        });
-    }
-    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 });
+    const Fragment = () => _jsx(_Fragment, { children: children });
+    const FinalFragment = replaceComponent(replacerName, Fragment, `Fragment::${fragmentName}`);
+    return _jsx(FinalFragment, {});
 };
 export function registerReplacer(replacerName, Replacer) {
     if (!replacers[replacerName])
         replacers[replacerName] = [];
     replacers[replacerName].push(Replacer);
 }
-export function loadPlugins(plugins) {
-    const promises = [];
-    if (!plugins || typeof plugins !== "object") {
-        return Promise.resolve([]);
-    }
-    const store = getStore();
-    Object.keys(plugins).forEach((key) => {
-        const pluginValue = plugins[key];
-        let pluginPromise;
-        if (typeof pluginValue === "string") {
-            try {
-                pluginPromise = Promise.resolve(Globals.loadPlugin(key));
+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;
             }
-            catch (error) {
-                console.error(`Failed to load plugin "${key}" using Globals.loadPlugin:`, error);
+        });
+    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;
+export const getPluginsStoreReducers = () => pluginsStoreReducers;
+export const getPluginsStoreSagas = () => pluginsStoreSagas;
+export function RunActionAnchor(anchor, ...args) {
+    if (Object.prototype.hasOwnProperty.call(reduxAnchors, anchor) &&
+        reduxAnchors[anchor].length > 0) {
+        reduxAnchors[anchor].forEach((currentFn) => {
+            currentFn.call(null, ...args);
+        });
+    }
+}
+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;
+}
+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;
             }
-        }
-        else if (typeof pluginValue === "function") {
-            try {
-                pluginPromise = Promise.resolve(pluginValue());
+            if (anchor === "appstates") {
+                pluginAppStates(anchors.appstates);
             }
-            catch (error) {
-                console.error(`Failed to execute plugin "${key}" loader:`, error);
+            if (anchor === "redux") {
+                Object.keys(anchors[anchor]).forEach((action) => {
+                    if (reduxAnchors[action] === undefined)
+                        reduxAnchors[action] = [];
+                    reduxAnchors[action].push(anchors[anchor][action]);
+                });
                 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(pluginPromise.then((plugin) => {
-            if (!plugin)
+            if (anchor === "actionOverride") {
+                Object.keys(anchors[anchor]).forEach((action) => {
+                    if (actionOverrideAnchor[action] === undefined)
+                        actionOverrideAnchor[action] = [];
+                    actionOverrideAnchor[action].push(anchors[anchor][action]);
+                });
                 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],
-                    },
+            if (anchor === "additionalRoutes") {
+                Object.keys(anchors[anchor]).forEach((route) => {
+                    PluginAdditionRoutes[anchors[anchor][route].path] =
+                        anchors[anchor][route].component;
                 });
+                return;
             }
-        }).catch((error) => {
-            console.error(`Failed to load plugin "${key}":`, error);
-        }));
-    });
-    return Promise.all(promises);
-}
-export function getPluginsReducers() {
-    return pluginsStoreReducers;
-}
-export function getPluginsAdditionalRoutes() {
-    const routes = [];
-    const plugins = getStore().getState().pluginsStore;
-    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);
+            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 });
     }
-    return routes;
+});
+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 getPluginsAdditionalRoutes = () => PluginAdditionRoutes;
+export function getPluginsReducers() {
+    return pluginsStoreReducers;
 }
 export function getPluginsSagas() {
-    return pluginsSagas;
+    return pluginsStoreSagas;
 }
-export function clearPlugins() {
+export const clearPlugins = () => {
+    globalAnchors = {};
+    reduxAnchors = {};
+    actionOverrideAnchor = {};
+    replacers = {};
+    PluginsAppStatesRegistrers = [];
+    PluginsPageAppStates = {};
+    PluginsAppStatesComponents = {};
+    PluginAdditionRoutes = {};
+    cache = {};
+    pluginsLoadingDone = false;
     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 = (appStates) => appStates || [];
-export const getPluginsStoreReducers = getPluginsReducers;
-export const getPluginsStoreSagas = getPluginsSagas;
+};

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

@@ -1,4 +1,5 @@
 import type { LoadableComponent } from "@loadable/component";
+import type React from "react";
 import type { Reducer } from "redux";
 import type { ActionsLibraryType } from "./getActions.type";
 import type { StateType } from "./State.type";
@@ -18,6 +19,23 @@ export type IPluginConfigReduxWithState<T extends Record<string, any> = {}, K ex
     stateKey: K;
 };
 export interface IPlugin {
-    config: IPluginConfig[];
+    config?: IPluginConfig[];
     redux?: IPluginConfigRedux;
+    reduxStore?: {
+        reducer: IPluginConfigReduxReducer;
+        sagas?: IPluginConfigReduxSaga[];
+    };
+    replace?: Record<string, React.ComponentType<any> | React.LazyExoticComponent<React.ComponentType<any>>>;
+    appstates?: {
+        register?: (currentAppStates: string[]) => string[];
+        pageAppState?: Record<string, string>;
+        components?: Record<string, React.ComponentType<any> | React.LazyExoticComponent<React.ComponentType<any>>>;
+    };
+    actionOverride?: Record<string, (action: any) => any>;
+    additionalRoutes?: Array<{
+        path: string;
+        component: React.ComponentType<any> | React.LazyExoticComponent<React.ComponentType<any>>;
+    }>;
+    paginationAfterNext?: React.ComponentType<any> | React.LazyExoticComponent<React.ComponentType<any>>;
+    [key: string]: any;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/wizardx-core",
-  "version": "4.42.10-nightly.20251126151952",
+  "version": "4.42.10-nightly.20251126154644",
   "author": "Moncef Hammou (moncef@legalplace.fr)",
   "license": "MIT",
   "files": [