@module-federation/runtime 0.0.0-next-20241106033302 → 0.0.0-next-20241106104434

package/dist/share.esm.mjs

@@ -1,5 +1,6 @@
-import { _ as _object_without_properties_loose, a as _extends } from './polyfills.esm.mjs';
 import { createLogger, isBrowserEnv, isDebugMode } from '@module-federation/sdk';
+import '@module-federation/error-codes';
+import { a as _object_without_properties_loose, _ as _extends } from './polyfills.esm.mjs';
 
 function getBuilderId() {
     //@ts-ignore
@@ -87,6 +88,20 @@ function getRemoteEntryInfoFromSnapshot(snapshot) {
     }
     return defaultRemoteEntryInfo;
 }
+const processModuleAlias = (name, subPath)=>{
+    // @host/ ./button -> @host/button
+    let moduleName;
+    if (name.endsWith('/')) {
+        moduleName = name.slice(0, -1);
+    } else {
+        moduleName = name;
+    }
+    if (subPath.startsWith('.')) {
+        subPath = subPath.slice(1);
+    }
+    moduleName = moduleName + subPath;
+    return moduleName;
+};
 
 const CurrentGlobal = typeof globalThis === 'object' ? globalThis : window;
 const nativeGlobal = (()=>{
@@ -278,9 +293,214 @@ const getGlobalHostPlugins = ()=>nativeGlobal.__FEDERATION__.__GLOBAL_PLUGIN__;
 const getPreloaded = (id)=>CurrentGlobal.__FEDERATION__.__PRELOADED_MAP__.get(id);
 const setPreloaded = (id)=>CurrentGlobal.__FEDERATION__.__PRELOADED_MAP__.set(id, true);
 
+function registerPlugins(plugins, hookInstances) {
+    const globalPlugins = getGlobalHostPlugins();
+    // Incorporate global plugins
+    if (globalPlugins.length > 0) {
+        globalPlugins.forEach((plugin)=>{
+            if (plugins == null ? void 0 : plugins.find((item)=>item.name !== plugin.name)) {
+                plugins.push(plugin);
+            }
+        });
+    }
+    if (plugins && plugins.length > 0) {
+        plugins.forEach((plugin)=>{
+            hookInstances.forEach((hookInstance)=>{
+                hookInstance.applyPlugin(plugin);
+            });
+        });
+    }
+    return plugins;
+}
+
 const DEFAULT_SCOPE = 'default';
 const DEFAULT_REMOTE_TYPE = 'global';
 
+class SyncHook {
+    on(fn) {
+        if (typeof fn === 'function') {
+            this.listeners.add(fn);
+        }
+    }
+    once(fn) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        this.on(function wrapper(...args) {
+            self.remove(wrapper);
+            // eslint-disable-next-line prefer-spread
+            return fn.apply(null, args);
+        });
+    }
+    emit(...data) {
+        let result;
+        if (this.listeners.size > 0) {
+            // eslint-disable-next-line prefer-spread
+            this.listeners.forEach((fn)=>{
+                result = fn(...data);
+            });
+        }
+        return result;
+    }
+    remove(fn) {
+        this.listeners.delete(fn);
+    }
+    removeAll() {
+        this.listeners.clear();
+    }
+    constructor(type){
+        this.type = '';
+        this.listeners = new Set();
+        if (type) {
+            this.type = type;
+        }
+    }
+}
+
+class AsyncHook extends SyncHook {
+    emit(...data) {
+        let result;
+        const ls = Array.from(this.listeners);
+        if (ls.length > 0) {
+            let i = 0;
+            const call = (prev)=>{
+                if (prev === false) {
+                    return false; // Abort process
+                } else if (i < ls.length) {
+                    return Promise.resolve(ls[i++].apply(null, data)).then(call);
+                } else {
+                    return prev;
+                }
+            };
+            result = call();
+        }
+        return Promise.resolve(result);
+    }
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function checkReturnData(originalData, returnedData) {
+    if (!isObject(returnedData)) {
+        return false;
+    }
+    if (originalData !== returnedData) {
+        // eslint-disable-next-line no-restricted-syntax
+        for(const key in originalData){
+            if (!(key in returnedData)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+class SyncWaterfallHook extends SyncHook {
+    emit(data) {
+        if (!isObject(data)) {
+            error(`The data for the "${this.type}" hook should be an object.`);
+        }
+        for (const fn of this.listeners){
+            try {
+                const tempData = fn(data);
+                if (checkReturnData(data, tempData)) {
+                    data = tempData;
+                } else {
+                    this.onerror(`A plugin returned an unacceptable value for the "${this.type}" type.`);
+                    break;
+                }
+            } catch (e) {
+                warn(e);
+                this.onerror(e);
+            }
+        }
+        return data;
+    }
+    constructor(type){
+        super(), this.onerror = error;
+        this.type = type;
+    }
+}
+
+class AsyncWaterfallHook extends SyncHook {
+    emit(data) {
+        if (!isObject(data)) {
+            error(`The response data for the "${this.type}" hook must be an object.`);
+        }
+        const ls = Array.from(this.listeners);
+        if (ls.length > 0) {
+            let i = 0;
+            const processError = (e)=>{
+                warn(e);
+                this.onerror(e);
+                return data;
+            };
+            const call = (prevData)=>{
+                if (checkReturnData(data, prevData)) {
+                    data = prevData;
+                    if (i < ls.length) {
+                        try {
+                            return Promise.resolve(ls[i++](data)).then(call, processError);
+                        } catch (e) {
+                            return processError(e);
+                        }
+                    }
+                } else {
+                    this.onerror(`A plugin returned an incorrect value for the "${this.type}" type.`);
+                }
+                return data;
+            };
+            return Promise.resolve(call(data));
+        }
+        return Promise.resolve(data);
+    }
+    constructor(type){
+        super(), this.onerror = error;
+        this.type = type;
+    }
+}
+
+class PluginSystem {
+    applyPlugin(plugin) {
+        assert(isPlainObject(plugin), 'Plugin configuration is invalid.');
+        // The plugin's name is mandatory and must be unique
+        const pluginName = plugin.name;
+        assert(pluginName, 'A name must be provided by the plugin.');
+        if (!this.registerPlugins[pluginName]) {
+            this.registerPlugins[pluginName] = plugin;
+            Object.keys(this.lifecycle).forEach((key)=>{
+                const pluginLife = plugin[key];
+                if (pluginLife) {
+                    this.lifecycle[key].on(pluginLife);
+                }
+            });
+        }
+    }
+    removePlugin(pluginName) {
+        assert(pluginName, 'A name is required.');
+        const plugin = this.registerPlugins[pluginName];
+        assert(plugin, `The plugin "${pluginName}" is not registered.`);
+        Object.keys(plugin).forEach((key)=>{
+            if (key !== 'name') {
+                this.lifecycle[key].remove(plugin[key]);
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    inherit({ lifecycle, registerPlugins }) {
+        Object.keys(lifecycle).forEach((hookName)=>{
+            assert(!this.lifecycle[hookName], `The hook "${hookName}" has a conflict and cannot be inherited.`);
+            this.lifecycle[hookName] = lifecycle[hookName];
+        });
+        Object.keys(registerPlugins).forEach((pluginName)=>{
+            assert(!this.registerPlugins[pluginName], `The plugin "${pluginName}" has a conflict and cannot be inherited.`);
+            this.applyPlugin(registerPlugins[pluginName]);
+        });
+    }
+    constructor(lifecycle){
+        this.registerPlugins = {};
+        this.lifecycle = lifecycle;
+        this.lifecycleKeys = Object.keys(lifecycle);
+    }
+}
+
 // fork from https://github.com/originjs/vite-plugin-federation/blob/v1.1.12/packages/lib/src/utils/semver/index.ts
 // those constants are based on https://www.rubydoc.info/gems/semantic_range/3.0.0/SemanticRange#BUILDIDENTIFIER-constant
 // Copyright (c)
@@ -876,4 +1096,4 @@ function getTargetSharedOptions(options) {
     return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions == null ? void 0 : extraOptions.customShareInfo);
 }
 
-export { isPlainObject as A, isRemoteInfoWithEntry as B, isPureRemoteEntry as C, DEFAULT_REMOTE_TYPE as D, getRemoteEntryInfoFromSnapshot as E, arrayOptions as F, Global as G, formatShareConfigs as H, getTargetSharedOptions as I, addUniqueItem as J, CurrentGlobal as K, logger as L, getBuilderId as M, getGlobalShareScope as a, getGlobalFederationInstance as b, getGlobalFederationConstructor as c, setGlobalFederationConstructor as d, getInfoWithoutType as e, getGlobalSnapshot as f, getRegisteredShare as g, getTargetSnapshotInfoByModuleInfo as h, getGlobalSnapshotInfoByModuleInfo as i, setGlobalSnapshotInfoByModuleInfo as j, addGlobalSnapshot as k, getRemoteEntryExports as l, registerGlobalPlugins as m, nativeGlobal as n, getGlobalHostPlugins as o, getPreloaded as p, setPreloaded as q, resetFederationGlobalInfo as r, setGlobalFederationInstance as s, globalLoading as t, DEFAULT_SCOPE as u, assert as v, error as w, getFMId as x, isObject as y, warn as z };
+export { AsyncHook as A, getFMId as B, processModuleAlias as C, DEFAULT_REMOTE_TYPE as D, isRemoteInfoWithEntry as E, isPureRemoteEntry as F, Global as G, getRemoteEntryInfoFromSnapshot as H, arrayOptions as I, formatShareConfigs as J, getTargetSharedOptions as K, addUniqueItem as L, CurrentGlobal as M, logger as N, getBuilderId as O, PluginSystem as P, SyncHook as S, AsyncWaterfallHook as a, SyncWaterfallHook as b, getGlobalShareScope as c, getGlobalFederationInstance as d, getGlobalFederationConstructor as e, setGlobalFederationConstructor as f, getRegisteredShare as g, getInfoWithoutType as h, getGlobalSnapshot as i, getTargetSnapshotInfoByModuleInfo as j, getGlobalSnapshotInfoByModuleInfo as k, setGlobalSnapshotInfoByModuleInfo as l, addGlobalSnapshot as m, nativeGlobal as n, getRemoteEntryExports as o, registerGlobalPlugins as p, getGlobalHostPlugins as q, resetFederationGlobalInfo as r, setGlobalFederationInstance as s, getPreloaded as t, setPreloaded as u, registerPlugins as v, globalLoading as w, DEFAULT_SCOPE as x, assert as y, error as z };

package/dist/src/core.d.ts

@@ -66,6 +66,12 @@ export declare class FederationHost {
             moduleInfo: RemoteInfo;
         }], Promise<(() => Promise<Module>) | undefined>>;
     }>;
+    bridgeHook: PluginSystem<{
+        beforeBridgeRender: SyncHook<[Record<string, any>], any>;
+        afterBridgeRender: SyncHook<[Record<string, any>], any>;
+        beforeBridgeDestroy: SyncHook<[Record<string, any>], any>;
+        afterBridgeDestroy: SyncHook<[Record<string, any>], any>;
+    }>;
     constructor(userOptions: UserOptions);
     initOptions(userOptions: UserOptions): Options;
     loadShare<T>(pkgName: string, extraOptions?: {

package/dist/src/embedded.d.ts

@@ -78,6 +78,12 @@ export declare class FederationHost implements IndexModule.FederationHost {
             moduleInfo: import("./type").RemoteInfo;
         }], Promise<(() => Promise<IndexModule.Module>) | undefined>>;
     }>;
+    get bridgeHook(): import("./utils/hooks").PluginSystem<{
+        beforeBridgeRender: import("./utils/hooks").SyncHook<[Record<string, any>], any>;
+        afterBridgeRender: import("./utils/hooks").SyncHook<[Record<string, any>], any>;
+        beforeBridgeDestroy: import("./utils/hooks").SyncHook<[Record<string, any>], any>;
+        afterBridgeDestroy: import("./utils/hooks").SyncHook<[Record<string, any>], any>;
+    }>;
     initOptions(...args: Parameters<IndexModule.FederationHost['initOptions']>): import("./type").Options;
     loadShare<T>(...args: Parameters<IndexModule.FederationHost['loadShare']>): Promise<false | (() => T | undefined)>;
     loadShareSync<T>(...args: Parameters<IndexModule.FederationHost['loadShareSync']>): () => T | never;

package/dist/src/helpers.d.ts

@@ -1,5 +1,7 @@
 import { resetFederationGlobalInfo, getGlobalFederationInstance, setGlobalFederationInstance, getGlobalFederationConstructor, setGlobalFederationConstructor, getInfoWithoutType, getGlobalSnapshot, getTargetSnapshotInfoByModuleInfo, getGlobalSnapshotInfoByModuleInfo, setGlobalSnapshotInfoByModuleInfo, addGlobalSnapshot, getRemoteEntryExports, registerGlobalPlugins, getGlobalHostPlugins, getPreloaded, setPreloaded, Global } from './global';
 import { getRegisteredShare, getGlobalShareScope } from './utils/share';
+import * as pluginHelper from './utils/hooks';
+import { registerPlugins } from './utils';
 interface IShareUtils {
     getRegisteredShare: typeof getRegisteredShare;
     getGlobalShareScope: typeof getGlobalShareScope;
@@ -23,6 +25,8 @@ interface IGlobalUtils {
     getGlobalHostPlugins: typeof getGlobalHostPlugins;
     getPreloaded: typeof getPreloaded;
     setPreloaded: typeof setPreloaded;
+    registerPlugins: typeof registerPlugins;
+    pluginHelper: typeof pluginHelper;
 }
 declare const _default: {
     global: IGlobalUtils;

package/dist/src/plugins/snapshot/SnapshotHandler.d.ts

@@ -32,6 +32,11 @@ export declare class SnapshotHandler {
             remoteSnapshot: ModuleInfo;
             from: "global" | "manifest";
         }>;
+        afterLoadSnapshot: AsyncWaterfallHook<{
+            options: Options;
+            moduleInfo: Remote;
+            remoteSnapshot: ModuleInfo;
+        }>;
     }>;
     loaderHook: FederationHost['loaderHook'];
     manifestLoading: Record<string, Promise<ModuleInfo>>;

package/dist/src/type/config.d.ts

@@ -4,7 +4,7 @@ export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
 export type PartialOptional<T, K extends keyof T> = Omit<T, K> & {
     [P in K]-?: T[P];
 };
-interface RemoteInfoCommon {
+export interface RemoteInfoCommon {
     alias?: string;
     shareScope?: string;
     type?: RemoteEntryType;

package/dist/src/type/plugin.d.ts

@@ -23,8 +23,9 @@ type RemoteLifeCycle = RemoteHandler['hooks']['lifecycle'];
 type RemoteLifeCycleCyclePartial = Partial<{
     [k in keyof RemoteLifeCycle]: Parameters<RemoteLifeCycle[k]['on']>[0];
 }>;
-export type FederationRuntimePlugin = CoreLifeCyclePartial & SnapshotLifeCycleCyclePartial & SharedLifeCycleCyclePartial & RemoteLifeCycleCyclePartial & ModuleLifeCycleCyclePartial & {
+type LifeCycle = CoreLifeCyclePartial & SnapshotLifeCycleCyclePartial & SharedLifeCycleCyclePartial & RemoteLifeCycleCyclePartial & ModuleLifeCycleCyclePartial & {
     name: string;
     version?: string;
 };
+export type FederationRuntimePlugin<T = LifeCycle> = LifeCycle & T;
 export {};

package/dist/src/utils/plugin.d.ts

@@ -1,4 +1,5 @@
 import { FederationHost } from '../core';
 import { UserOptions } from '../type';
 import { Module } from '../module';
-export declare function registerPlugins(plugins: UserOptions['plugins'], hookInstances: Array<FederationHost['hooks'] | FederationHost['snapshotHandler']['hooks'] | FederationHost['sharedHandler']['hooks'] | FederationHost['remoteHandler']['hooks'] | Module['host']['loaderHook']>): import("../type").FederationRuntimePlugin[] | undefined;
+import { PluginSystem } from './hooks';
+export declare function registerPlugins<Y extends Record<string, any>, T extends PluginSystem<Y>>(plugins: UserOptions['plugins'], hookInstances: Array<T | FederationHost['hooks'] | FederationHost['snapshotHandler']['hooks'] | FederationHost['sharedHandler']['hooks'] | FederationHost['remoteHandler']['hooks'] | Module['host']['loaderHook'] | Module['host']['bridgeHook']>): import("../type").FederationRuntimePlugin[] | undefined;

package/dist/src/utils/tool.d.ts

@@ -15,3 +15,4 @@ export declare function getRemoteEntryInfoFromSnapshot(snapshot: ModuleInfo): {
     type: RemoteEntryType;
     globalName: string;
 };
+export declare const processModuleAlias: (name: string, subPath: string) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/runtime",
-  "version": "0.0.0-next-20241106033302",
+  "version": "0.0.0-next-20241106104434",
   "author": "zhouxiao <codingzx@gmail.com>",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.esm.mjs",
@@ -50,7 +50,7 @@
     }
   },
   "dependencies": {
-    "@module-federation/sdk": "0.0.0-next-20241106033302",
-    "@module-federation/error-codes": "0.0.0-next-20241106033302"
+    "@module-federation/sdk": "0.0.0-next-20241106104434",
+    "@module-federation/error-codes": "0.0.0-next-20241106104434"
   }
 }