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

package/dist/embedded.cjs.js

@@ -88,6 +88,9 @@ class FederationHost {
     get loaderHook() {
         return this._getInstance().loaderHook;
     }
+    get bridgeHook() {
+        return this._getInstance().bridgeHook;
+    }
     initOptions(...args) {
         return this._getInstance().initOptions(...args);
     }

package/dist/embedded.esm.mjs

@@ -86,6 +86,9 @@ class FederationHost {
     get loaderHook() {
         return this._getInstance().loaderHook;
     }
+    get bridgeHook() {
+        return this._getInstance().bridgeHook;
+    }
     initOptions(...args) {
         return this._getInstance().initOptions(...args);
     }

package/dist/helpers.cjs.js

@@ -1,6 +1,17 @@
 'use strict';
 
 var share = require('./share.cjs.js');
+require('@module-federation/sdk');
+require('@module-federation/error-codes');
+
+var pluginHelper = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  AsyncHook: share.AsyncHook,
+  AsyncWaterfallHook: share.AsyncWaterfallHook,
+  PluginSystem: share.PluginSystem,
+  SyncHook: share.SyncHook,
+  SyncWaterfallHook: share.SyncWaterfallHook
+});
 
 const ShareUtils = {
     getRegisteredShare: share.getRegisteredShare,
@@ -24,7 +35,9 @@ const GlobalUtils = {
     registerGlobalPlugins: share.registerGlobalPlugins,
     getGlobalHostPlugins: share.getGlobalHostPlugins,
     getPreloaded: share.getPreloaded,
-    setPreloaded: share.setPreloaded
+    setPreloaded: share.setPreloaded,
+    registerPlugins: share.registerPlugins,
+    pluginHelper
 };
 var helpers = {
     global: GlobalUtils,

package/dist/helpers.esm.mjs

@@ -1,4 +1,15 @@
-import { g as getRegisteredShare, a as getGlobalShareScope, G as Global, n as nativeGlobal, r as resetFederationGlobalInfo, b as getGlobalFederationInstance, s as setGlobalFederationInstance, c as getGlobalFederationConstructor, d as setGlobalFederationConstructor, e as getInfoWithoutType, f as getGlobalSnapshot, h as getTargetSnapshotInfoByModuleInfo, i as getGlobalSnapshotInfoByModuleInfo, j as setGlobalSnapshotInfoByModuleInfo, k as addGlobalSnapshot, l as getRemoteEntryExports, m as registerGlobalPlugins, o as getGlobalHostPlugins, p as getPreloaded, q as setPreloaded } from './share.esm.mjs';
+import { A as AsyncHook, a as AsyncWaterfallHook, P as PluginSystem, S as SyncHook, b as SyncWaterfallHook, g as getRegisteredShare, c as getGlobalShareScope, G as Global, n as nativeGlobal, r as resetFederationGlobalInfo, d as getGlobalFederationInstance, s as setGlobalFederationInstance, e as getGlobalFederationConstructor, f as setGlobalFederationConstructor, h as getInfoWithoutType, i as getGlobalSnapshot, j as getTargetSnapshotInfoByModuleInfo, k as getGlobalSnapshotInfoByModuleInfo, l as setGlobalSnapshotInfoByModuleInfo, m as addGlobalSnapshot, o as getRemoteEntryExports, p as registerGlobalPlugins, q as getGlobalHostPlugins, t as getPreloaded, u as setPreloaded, v as registerPlugins } from './share.esm.mjs';
+import '@module-federation/sdk';
+import '@module-federation/error-codes';
+
+var pluginHelper = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  AsyncHook: AsyncHook,
+  AsyncWaterfallHook: AsyncWaterfallHook,
+  PluginSystem: PluginSystem,
+  SyncHook: SyncHook,
+  SyncWaterfallHook: SyncWaterfallHook
+});
 
 const ShareUtils = {
     getRegisteredShare,
@@ -22,7 +33,9 @@ const GlobalUtils = {
     registerGlobalPlugins,
     getGlobalHostPlugins,
     getPreloaded,
-    setPreloaded
+    setPreloaded,
+    registerPlugins,
+    pluginHelper
 };
 var helpers = {
     global: GlobalUtils,

package/dist/index.cjs.js

@@ -69,26 +69,6 @@ function matchRemote(remotes, nameOrAlias) {
     return;
 }
 
-function registerPlugins$1(plugins, hookInstances) {
-    const globalPlugins = share.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;
-}
-
 async function loadEsmEntry({ entry, remoteEntryExports }) {
     return new Promise((resolve, reject)=>{
         try {
@@ -333,7 +313,9 @@ let Module = class Module {
             moduleFactory = await remoteEntryExports.get(expose);
         }
         share.assert(moduleFactory, `${share.getFMId(this.remoteInfo)} remote don't export ${expose}.`);
-        const wrapModuleFactory = this.wraperFactory(moduleFactory, id);
+        // keep symbol for module name always one format
+        const symbolName = share.processModuleAlias(this.remoteInfo.name, expose);
+        const wrapModuleFactory = this.wraperFactory(moduleFactory, symbolName);
         if (!loadFactory) {
             return wrapModuleFactory;
         }
@@ -373,191 +355,6 @@ let Module = class Module {
     }
 };
 
-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 (!share.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 (!share.isObject(data)) {
-            share.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) {
-                share.warn(e);
-                this.onerror(e);
-            }
-        }
-        return data;
-    }
-    constructor(type){
-        super(), this.onerror = share.error;
-        this.type = type;
-    }
-}
-
-class AsyncWaterfallHook extends SyncHook {
-    emit(data) {
-        if (!share.isObject(data)) {
-            share.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)=>{
-                share.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 = share.error;
-        this.type = type;
-    }
-}
-
-class PluginSystem {
-    applyPlugin(plugin) {
-        share.assert(share.isPlainObject(plugin), 'Plugin configuration is invalid.');
-        // The plugin's name is mandatory and must be unique
-        const pluginName = plugin.name;
-        share.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) {
-        share.assert(pluginName, 'A name is required.');
-        const plugin = this.registerPlugins[pluginName];
-        share.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)=>{
-            share.assert(!this.lifecycle[hookName], `The hook "${hookName}" has a conflict and cannot be inherited.`);
-            this.lifecycle[hookName] = lifecycle[hookName];
-        });
-        Object.keys(registerPlugins).forEach((pluginName)=>{
-            share.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);
-    }
-}
-
 function defaultPreloadArgs(preloadConfig) {
     return polyfills._extends({
         resourceCategory: 'sync',
@@ -1071,6 +868,8 @@ class SnapshotHandler {
             remoteSnapshot,
             globalSnapshot
         });
+        let mSnapshot;
+        let gSnapshot;
         // global snapshot includes manifest or module info includes manifest
         if (globalRemoteSnapshot) {
             if (sdk.isManifestProvider(globalRemoteSnapshot)) {
@@ -1082,10 +881,8 @@ class SnapshotHandler {
                     // Therefore, set the snapshot key to the global address of the actual request
                     entry: remoteEntry
                 }), moduleSnapshot);
-                return {
-                    remoteSnapshot: moduleSnapshot,
-                    globalSnapshot: globalSnapshotRes
-                };
+                mSnapshot = moduleSnapshot;
+                gSnapshot = globalSnapshotRes;
             } else {
                 const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
                     options: this.HostInstance.options,
@@ -1093,10 +890,8 @@ class SnapshotHandler {
                     remoteSnapshot: globalRemoteSnapshot,
                     from: 'global'
                 });
-                return {
-                    remoteSnapshot: remoteSnapshotRes,
-                    globalSnapshot: globalSnapshotRes
-                };
+                mSnapshot = remoteSnapshotRes;
+                gSnapshot = globalSnapshotRes;
             }
         } else {
             if (share.isRemoteInfoWithEntry(moduleInfo)) {
@@ -1110,10 +905,8 @@ class SnapshotHandler {
                     remoteSnapshot: moduleSnapshot,
                     from: 'global'
                 });
-                return {
-                    remoteSnapshot: remoteSnapshotRes,
-                    globalSnapshot: globalSnapshotRes
-                };
+                mSnapshot = remoteSnapshotRes;
+                gSnapshot = globalSnapshotRes;
             } else {
                 share.error(errorCodes.getShortErrorMsg(errorCodes.RUNTIME_007, errorCodes.runtimeDescMap, {
                     hostName: moduleInfo.name,
@@ -1122,6 +915,15 @@ class SnapshotHandler {
                 }));
             }
         }
+        await this.hooks.lifecycle.afterLoadSnapshot.emit({
+            options,
+            moduleInfo,
+            remoteSnapshot: mSnapshot
+        });
+        return {
+            remoteSnapshot: mSnapshot,
+            globalSnapshot: gSnapshot
+        };
     }
     getGlobalRemoteInfo(moduleInfo) {
         return getGlobalRemoteInfo(moduleInfo, this.HostInstance);
@@ -1172,10 +974,11 @@ class SnapshotHandler {
     constructor(HostInstance){
         this.loadingHostSnapshot = null;
         this.manifestCache = new Map();
-        this.hooks = new PluginSystem({
-            beforeLoadRemoteSnapshot: new AsyncHook('beforeLoadRemoteSnapshot'),
-            loadSnapshot: new AsyncWaterfallHook('loadGlobalSnapshot'),
-            loadRemoteSnapshot: new AsyncWaterfallHook('loadRemoteSnapshot')
+        this.hooks = new share.PluginSystem({
+            beforeLoadRemoteSnapshot: new share.AsyncHook('beforeLoadRemoteSnapshot'),
+            loadSnapshot: new share.AsyncWaterfallHook('loadGlobalSnapshot'),
+            loadRemoteSnapshot: new share.AsyncWaterfallHook('loadRemoteSnapshot'),
+            afterLoadSnapshot: new share.AsyncWaterfallHook('afterLoadSnapshot')
         });
         this.manifestLoading = share.Global.__FEDERATION__.__MANIFEST_LOADING__;
         this.HostInstance = HostInstance;
@@ -1526,14 +1329,14 @@ class SharedHandler {
         }
     }
     constructor(host){
-        this.hooks = new PluginSystem({
-            afterResolve: new AsyncWaterfallHook('afterResolve'),
-            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
+        this.hooks = new share.PluginSystem({
+            afterResolve: new share.AsyncWaterfallHook('afterResolve'),
+            beforeLoadShare: new share.AsyncWaterfallHook('beforeLoadShare'),
             // not used yet
-            loadShare: new AsyncHook(),
-            resolveShare: new SyncWaterfallHook('resolveShare'),
+            loadShare: new share.AsyncHook(),
+            resolveShare: new share.SyncWaterfallHook('resolveShare'),
             // maybe will change, temporarily for internal use only
-            initContainerShareScopeMap: new SyncWaterfallHook('initContainerShareScopeMap')
+            initContainerShareScopeMap: new share.SyncWaterfallHook('initContainerShareScopeMap')
         });
         this.host = host;
         this.shareScopeMap = {};
@@ -1876,18 +1679,18 @@ class RemoteHandler {
         }
     }
     constructor(host){
-        this.hooks = new PluginSystem({
-            beforeRegisterRemote: new SyncWaterfallHook('beforeRegisterRemote'),
-            registerRemote: new SyncWaterfallHook('registerRemote'),
-            beforeRequest: new AsyncWaterfallHook('beforeRequest'),
-            onLoad: new AsyncHook('onLoad'),
-            handlePreloadModule: new SyncHook('handlePreloadModule'),
-            errorLoadRemote: new AsyncHook('errorLoadRemote'),
-            beforePreloadRemote: new AsyncHook('beforePreloadRemote'),
-            generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
+        this.hooks = new share.PluginSystem({
+            beforeRegisterRemote: new share.SyncWaterfallHook('beforeRegisterRemote'),
+            registerRemote: new share.SyncWaterfallHook('registerRemote'),
+            beforeRequest: new share.AsyncWaterfallHook('beforeRequest'),
+            onLoad: new share.AsyncHook('onLoad'),
+            handlePreloadModule: new share.SyncHook('handlePreloadModule'),
+            errorLoadRemote: new share.AsyncHook('errorLoadRemote'),
+            beforePreloadRemote: new share.AsyncHook('beforePreloadRemote'),
+            generatePreloadAssets: new share.AsyncHook('generatePreloadAssets'),
             // not used yet
-            afterPreloadRemote: new AsyncHook(),
-            loadEntry: new AsyncHook()
+            afterPreloadRemote: new share.AsyncHook(),
+            loadEntry: new share.AsyncHook()
         });
         this.host = host;
         this.idToRemoteMap = {};
@@ -1971,12 +1774,13 @@ class FederationHost {
         return optionsRes;
     }
     registerPlugins(plugins) {
-        const pluginRes = registerPlugins$1(plugins, [
+        const pluginRes = share.registerPlugins(plugins, [
             this.hooks,
             this.remoteHandler.hooks,
             this.sharedHandler.hooks,
             this.snapshotHandler.hooks,
-            this.loaderHook
+            this.loaderHook,
+            this.bridgeHook
         ]);
         // Merge plugin
         this.options.plugins = this.options.plugins.reduce((res, plugin)=>{
@@ -1991,24 +1795,30 @@ class FederationHost {
         return this.remoteHandler.registerRemotes(remotes, options);
     }
     constructor(userOptions){
-        this.hooks = new PluginSystem({
-            beforeInit: new SyncWaterfallHook('beforeInit'),
-            init: new SyncHook(),
+        this.hooks = new share.PluginSystem({
+            beforeInit: new share.SyncWaterfallHook('beforeInit'),
+            init: new share.SyncHook(),
             // maybe will change, temporarily for internal use only
-            beforeInitContainer: new AsyncWaterfallHook('beforeInitContainer'),
+            beforeInitContainer: new share.AsyncWaterfallHook('beforeInitContainer'),
             // maybe will change, temporarily for internal use only
-            initContainer: new AsyncWaterfallHook('initContainer')
+            initContainer: new share.AsyncWaterfallHook('initContainer')
         });
         this.version = "0.7.0";
         this.moduleCache = new Map();
-        this.loaderHook = new PluginSystem({
+        this.loaderHook = new share.PluginSystem({
             // FIXME: may not be suitable , not open to the public yet
-            getModuleInfo: new SyncHook(),
-            createScript: new SyncHook(),
-            createLink: new SyncHook(),
+            getModuleInfo: new share.SyncHook(),
+            createScript: new share.SyncHook(),
+            createLink: new share.SyncHook(),
             // only work for manifest , so not open to the public yet
-            fetch: new AsyncHook(),
-            getModuleFactory: new AsyncHook()
+            fetch: new share.AsyncHook(),
+            getModuleFactory: new share.AsyncHook()
+        });
+        this.bridgeHook = new share.PluginSystem({
+            beforeBridgeRender: new share.SyncHook(),
+            afterBridgeRender: new share.SyncHook(),
+            beforeBridgeDestroy: new share.SyncHook(),
+            afterBridgeDestroy: new share.SyncHook()
         });
         // TODO: Validate the details of the options
         // Initialize options with default values