@module-federation/runtime 0.0.0-next-20240920040817 → 0.0.0-next-20240920074009

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,
-  SyncHook: share.SyncHook,
-  AsyncHook: share.AsyncHook,
-  SyncWaterfallHook: share.SyncWaterfallHook,
-  AsyncWaterfallHook: share.AsyncWaterfallHook,
-  PluginSystem: share.PluginSystem
-});
+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 { y as SyncHook, A as AsyncHook, S as SyncWaterfallHook, r as AsyncWaterfallHook, P as PluginSystem, l as getRegisteredShare, w as getGlobalShareScope, G as Global, J as nativeGlobal, K as resetFederationGlobalInfo, E as getGlobalFederationInstance, H as setGlobalFederationInstance, F as getGlobalFederationConstructor, C as setGlobalFederationConstructor, j as getInfoWithoutType, t as getGlobalSnapshot, L as getTargetSnapshotInfoByModuleInfo, n as getGlobalSnapshotInfoByModuleInfo, q as setGlobalSnapshotInfoByModuleInfo, o as addGlobalSnapshot, b as getRemoteEntryExports, I as registerGlobalPlugins, M as getGlobalHostPlugins, k as getPreloaded, s as setPreloaded, z as registerPlugins } from './share.esm.js';
-import '@module-federation/sdk';
+import { o as getRegisteredShare, y as getGlobalShareScope, G as Global, I as nativeGlobal, J as resetFederationGlobalInfo, C as getGlobalFederationInstance, F as setGlobalFederationInstance, E as getGlobalFederationConstructor, B as setGlobalFederationConstructor, m as getInfoWithoutType, u as getGlobalSnapshot, K as getTargetSnapshotInfoByModuleInfo, q as getGlobalSnapshotInfoByModuleInfo, t as setGlobalSnapshotInfoByModuleInfo, r as addGlobalSnapshot, c as getRemoteEntryExports, H as registerGlobalPlugins, g as getGlobalHostPlugins, n as getPreloaded, s as setPreloaded } from './share.esm.js';
 import './polyfills.esm.js';
-
-var pluginHelper = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  SyncHook: SyncHook,
-  AsyncHook: AsyncHook,
-  SyncWaterfallHook: SyncWaterfallHook,
-  AsyncWaterfallHook: AsyncWaterfallHook,
-  PluginSystem: PluginSystem
-});
+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

@@ -70,6 +70,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 {
@@ -302,9 +322,7 @@ let Module = class Module {
         // get exposeGetter
         const 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;
         }
@@ -344,6 +362,193 @@ 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',
@@ -851,8 +1056,6 @@ class SnapshotHandler {
             remoteSnapshot,
             globalSnapshot
         });
-        let mSnapshot;
-        let gSnapshot;
         // global snapshot includes manifest or module info includes manifest
         if (globalRemoteSnapshot) {
             if (sdk.isManifestProvider(globalRemoteSnapshot)) {
@@ -864,8 +1067,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,
@@ -873,8 +1078,10 @@ class SnapshotHandler {
                     remoteSnapshot: globalRemoteSnapshot,
                     from: 'global'
                 });
-                mSnapshot = remoteSnapshotRes;
-                gSnapshot = globalSnapshotRes;
+                return {
+                    remoteSnapshot: remoteSnapshotRes,
+                    globalSnapshot: globalSnapshotRes
+                };
             }
         } else {
             if (share.isRemoteInfoWithEntry(moduleInfo)) {
@@ -888,8 +1095,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
@@ -899,15 +1108,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);
@@ -957,11 +1157,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;
@@ -1304,14 +1503,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 = {};
@@ -1658,18 +1857,18 @@ class RemoteHandler {
         }
     }
     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 = {};
@@ -1753,7 +1952,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,
@@ -1773,23 +1972,23 @@ 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.6";
+        this.version = "0.6.5";
         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()
+            fetch: new AsyncHook()
         });
         // TODO: Validate the details of the options
         // Initialize options with default values