@module-federation/runtime 0.0.0-next-20241101093646 → 0.0.0-next-20241104024700

package/dist/embedded.cjs.js

@@ -88,9 +88,6 @@ 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.js

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

package/dist/helpers.esm.js

@@ -1,15 +1,6 @@
-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.js';
-import '@module-federation/sdk';
+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.js';
 import './polyfills.esm.js';
-
-var pluginHelper = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  AsyncHook: AsyncHook,
-  AsyncWaterfallHook: AsyncWaterfallHook,
-  PluginSystem: PluginSystem,
-  SyncHook: SyncHook,
-  SyncWaterfallHook: SyncWaterfallHook
-});
+import '@module-federation/sdk';
 
 const ShareUtils = {
     getRegisteredShare,
@@ -33,9 +24,7 @@ const GlobalUtils = {
     registerGlobalPlugins,
     getGlobalHostPlugins,
     getPreloaded,
-    setPreloaded,
-    registerPlugins,
-    pluginHelper
+    setPreloaded
 };
 var helpers = {
     global: GlobalUtils,

package/dist/index.cjs.js

@@ -68,6 +68,26 @@ 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 {
@@ -285,7 +305,7 @@ let Module = class Module {
                 origin: this.host
             });
             if (typeof (remoteEntryExports == null ? void 0 : remoteEntryExports.init) === 'undefined') {
-                console.error('The remote entry interface does not contain "init"', '\n', 'Ensure the name of this remote is not reserved or in use. Check if anything already exists on window[nameOfRemote]', '\n', 'Ensure that window[nameOfRemote] is returning a {get,init} object.');
+                share.logger.error('The remote entry interface does not contain "init"', '\n', 'Ensure the name of this remote is not reserved or in use. Check if anything already exists on window[nameOfRemote]', '\n', 'Ensure that window[nameOfRemote] is returning a {get,init} object.');
             }
             await remoteEntryExports.init(initContainerOptions.shareScope, initContainerOptions.initScope, initContainerOptions.remoteEntryInitOptions);
             await this.host.hooks.lifecycle.initContainer.emit(polyfills._extends({}, initContainerOptions, {
@@ -296,12 +316,18 @@ let Module = class Module {
         }
         this.lib = remoteEntryExports;
         this.inited = true;
+        let moduleFactory;
+        moduleFactory = await this.host.loaderHook.lifecycle.getModuleFactory.emit({
+            remoteEntryExports,
+            expose,
+            moduleInfo: this.remoteInfo
+        });
         // get exposeGetter
-        const moduleFactory = await remoteEntryExports.get(expose);
+        if (!moduleFactory) {
+            moduleFactory = await remoteEntryExports.get(expose);
+        }
         share.assert(moduleFactory, `${share.getFMId(this.remoteInfo)} remote don't export ${expose}.`);
-        // keep symbol for module name always one format
-        const symbolName = share.processModuleAlias(this.remoteInfo.name, expose);
-        const wrapModuleFactory = this.wraperFactory(moduleFactory, symbolName);
+        const wrapModuleFactory = this.wraperFactory(moduleFactory, id);
         if (!loadFactory) {
             return wrapModuleFactory;
         }
@@ -341,6 +367,191 @@ 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',
@@ -854,8 +1065,6 @@ class SnapshotHandler {
             remoteSnapshot,
             globalSnapshot
         });
-        let mSnapshot;
-        let gSnapshot;
         // global snapshot includes manifest or module info includes manifest
         if (globalRemoteSnapshot) {
             if (sdk.isManifestProvider(globalRemoteSnapshot)) {
@@ -867,8 +1076,10 @@ class SnapshotHandler {
                     // Therefore, set the snapshot key to the global address of the actual request
                     entry: remoteEntry
                 }), moduleSnapshot);
-                mSnapshot = moduleSnapshot;
-                gSnapshot = globalSnapshotRes;
+                return {
+                    remoteSnapshot: moduleSnapshot,
+                    globalSnapshot: globalSnapshotRes
+                };
             } else {
                 const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
                     options: this.HostInstance.options,
@@ -876,8 +1087,10 @@ class SnapshotHandler {
                     remoteSnapshot: globalRemoteSnapshot,
                     from: 'global'
                 });
-                mSnapshot = remoteSnapshotRes;
-                gSnapshot = globalSnapshotRes;
+                return {
+                    remoteSnapshot: remoteSnapshotRes,
+                    globalSnapshot: globalSnapshotRes
+                };
             }
         } else {
             if (share.isRemoteInfoWithEntry(moduleInfo)) {
@@ -891,8 +1104,10 @@ class SnapshotHandler {
                     remoteSnapshot: moduleSnapshot,
                     from: 'global'
                 });
-                mSnapshot = remoteSnapshotRes;
-                gSnapshot = globalSnapshotRes;
+                return {
+                    remoteSnapshot: remoteSnapshotRes,
+                    globalSnapshot: globalSnapshotRes
+                };
             } else {
                 share.error(`
           Cannot get remoteSnapshot with the name: '${moduleInfo.name}', version: '${moduleInfo.version}' from __FEDERATION__.moduleInfo. The following reasons may be causing the problem:\n
@@ -902,15 +1117,6 @@ class SnapshotHandler {
         `);
             }
         }
-        await this.hooks.lifecycle.afterLoadSnapshot.emit({
-            options,
-            moduleInfo,
-            remoteSnapshot: mSnapshot
-        });
-        return {
-            remoteSnapshot: mSnapshot,
-            globalSnapshot: gSnapshot
-        };
     }
     getGlobalRemoteInfo(moduleInfo) {
         return getGlobalRemoteInfo(moduleInfo, this.HostInstance);
@@ -960,11 +1166,10 @@ class SnapshotHandler {
     constructor(HostInstance){
         this.loadingHostSnapshot = null;
         this.manifestCache = new Map();
-        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.hooks = new PluginSystem({
+            beforeLoadRemoteSnapshot: new AsyncHook('beforeLoadRemoteSnapshot'),
+            loadSnapshot: new AsyncWaterfallHook('loadGlobalSnapshot'),
+            loadRemoteSnapshot: new AsyncWaterfallHook('loadRemoteSnapshot')
         });
         this.manifestLoading = share.Global.__FEDERATION__.__MANIFEST_LOADING__;
         this.HostInstance = HostInstance;
@@ -1318,14 +1523,14 @@ class SharedHandler {
         }
     }
     constructor(host){
-        this.hooks = new share.PluginSystem({
-            afterResolve: new share.AsyncWaterfallHook('afterResolve'),
-            beforeLoadShare: new share.AsyncWaterfallHook('beforeLoadShare'),
+        this.hooks = new PluginSystem({
+            afterResolve: new AsyncWaterfallHook('afterResolve'),
+            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
             // not used yet
-            loadShare: new share.AsyncHook(),
-            resolveShare: new share.SyncWaterfallHook('resolveShare'),
+            loadShare: new AsyncHook(),
+            resolveShare: new SyncWaterfallHook('resolveShare'),
             // maybe will change, temporarily for internal use only
-            initContainerShareScopeMap: new share.SyncWaterfallHook('initContainerShareScopeMap')
+            initContainerShareScopeMap: new SyncWaterfallHook('initContainerShareScopeMap')
         });
         this.host = host;
         this.shareScopeMap = {};
@@ -1668,22 +1873,22 @@ class RemoteHandler {
                 host.moduleCache.delete(remote.name);
             }
         } catch (err) {
-            console.log('removeRemote fail: ', err);
+            share.logger.log('removeRemote fail: ', err);
         }
     }
     constructor(host){
-        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'),
+        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'),
             // not used yet
-            afterPreloadRemote: new share.AsyncHook(),
-            loadEntry: new share.AsyncHook()
+            afterPreloadRemote: new AsyncHook(),
+            loadEntry: new AsyncHook()
         });
         this.host = host;
         this.idToRemoteMap = {};
@@ -1767,7 +1972,7 @@ class FederationHost {
         return optionsRes;
     }
     registerPlugins(plugins) {
-        const pluginRes = share.registerPlugins(plugins, [
+        const pluginRes = registerPlugins$1(plugins, [
             this.hooks,
             this.remoteHandler.hooks,
             this.sharedHandler.hooks,
@@ -1787,29 +1992,24 @@ class FederationHost {
         return this.remoteHandler.registerRemotes(remotes, options);
     }
     constructor(userOptions){
-        this.hooks = new share.PluginSystem({
-            beforeInit: new share.SyncWaterfallHook('beforeInit'),
-            init: new share.SyncHook(),
+        this.hooks = new PluginSystem({
+            beforeInit: new SyncWaterfallHook('beforeInit'),
+            init: new SyncHook(),
             // maybe will change, temporarily for internal use only
-            beforeInitContainer: new share.AsyncWaterfallHook('beforeInitContainer'),
+            beforeInitContainer: new AsyncWaterfallHook('beforeInitContainer'),
             // maybe will change, temporarily for internal use only
-            initContainer: new share.AsyncWaterfallHook('initContainer')
+            initContainer: new AsyncWaterfallHook('initContainer')
         });
-        this.version = "0.6.11";
+        this.version = "0.6.15";
         this.moduleCache = new Map();
-        this.loaderHook = new share.PluginSystem({
+        this.loaderHook = new PluginSystem({
             // FIXME: may not be suitable , not open to the public yet
-            getModuleInfo: new share.SyncHook(),
-            createScript: new share.SyncHook(),
-            createLink: new share.SyncHook(),
+            getModuleInfo: new SyncHook(),
+            createScript: new SyncHook(),
+            createLink: new SyncHook(),
             // only work for manifest , so not open to the public yet
-            fetch: new share.AsyncHook()
-        });
-        this.bridgeHook = new share.PluginSystem({
-            beforeBridgeRender: new share.SyncHook(),
-            afterBridgeRender: new share.SyncHook(),
-            beforeBridgeDestroy: new share.SyncHook(),
-            afterBridgeDestroy: new share.SyncHook()
+            fetch: new AsyncHook(),
+            getModuleFactory: new AsyncHook()
         });
         // TODO: Validate the details of the options
         // Initialize options with default values