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

package/dist/index.esm.js

@@ -1,8 +1,8 @@
-import { _ as _extends, a as _object_without_properties_loose } from './polyfills.esm.js';
-import { isBrowserEnv, loadScriptNode, composeKeyWithSeparator, loadScript, safeToString, createLink, createScript, getResourceUrl, isManifestProvider, generateSnapshotFromManifest, warn } from '@module-federation/sdk';
+import { a as _extends, _ as _object_without_properties_loose } from './polyfills.esm.js';
+import { isBrowserEnv, loadScriptNode, composeKeyWithSeparator, loadScript, safeToString, createLink, createScript, getResourceUrl, isManifestProvider, generateSnapshotFromManifest, warn as warn$1 } from '@module-federation/sdk';
 export { loadScript, loadScriptNode } from '@module-federation/sdk';
-import { w as globalLoading, D as DEFAULT_REMOTE_TYPE, x as DEFAULT_SCOPE, o as getRemoteEntryExports, y as assert, z as getFMId, B as processModuleAlias, C as isRemoteInfoWithEntry, E as isPureRemoteEntry, F as getRemoteEntryInfoFromSnapshot, H as error, h as getInfoWithoutType, t as getPreloaded, u as setPreloaded, g as getRegisteredShare, I as arrayOptions, k as getGlobalSnapshotInfoByModuleInfo, m as addGlobalSnapshot, l as setGlobalSnapshotInfoByModuleInfo, P as PluginSystem, A as AsyncHook, a as AsyncWaterfallHook, G as Global, i as getGlobalSnapshot, J as formatShareConfigs, K as getTargetSharedOptions, c as getGlobalShareScope, b as SyncWaterfallHook, L as addUniqueItem, S as SyncHook, v as registerPlugins$1, M as getBuilderId, f as setGlobalFederationConstructor, d as getGlobalFederationInstance, e as getGlobalFederationConstructor, s as setGlobalFederationInstance } from './share.esm.js';
-export { p as registerGlobalPlugins } from './share.esm.js';
+import { o as getGlobalHostPlugins, t as globalLoading, D as DEFAULT_REMOTE_TYPE, u as DEFAULT_SCOPE, l as getRemoteEntryExports, v as assert, w as logger, x as getFMId, y as isObject, z as error, A as warn, B as isPlainObject, C as isRemoteInfoWithEntry, E as isPureRemoteEntry, F as getRemoteEntryInfoFromSnapshot, e as getInfoWithoutType, p as getPreloaded, q as setPreloaded, g as getRegisteredShare, H as arrayOptions, i as getGlobalSnapshotInfoByModuleInfo, k as addGlobalSnapshot, j as setGlobalSnapshotInfoByModuleInfo, G as Global, f as getGlobalSnapshot, I as formatShareConfigs, J as getTargetSharedOptions, a as getGlobalShareScope, K as addUniqueItem, L as getBuilderId, d as setGlobalFederationConstructor, b as getGlobalFederationInstance, c as getGlobalFederationConstructor, s as setGlobalFederationInstance } from './share.esm.js';
+export { m as registerGlobalPlugins } from './share.esm.js';
 
 // Function to match a remote with its name and expose
 // id: pkgName(@federation/app1) + expose(button) = @federation/app1/button
@@ -68,6 +68,26 @@ function matchRemote(remotes, nameOrAlias) {
     return;
 }
 
+function registerPlugins$1(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;
+}
+
 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.');
+                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(_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);
+        }
         assert(moduleFactory, `${getFMId(this.remoteInfo)} remote don't export ${expose}.`);
-        // keep symbol for module name always one format
-        const symbolName = 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 (!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);
+    }
+}
+
 function defaultPreloadArgs(preloadConfig) {
     return _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 (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 (isRemoteInfoWithEntry(moduleInfo)) {
@@ -891,8 +1104,10 @@ class SnapshotHandler {
                     remoteSnapshot: moduleSnapshot,
                     from: 'global'
                 });
-                mSnapshot = remoteSnapshotRes;
-                gSnapshot = globalSnapshotRes;
+                return {
+                    remoteSnapshot: remoteSnapshotRes,
+                    globalSnapshot: globalSnapshotRes
+                };
             } else {
                 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);
@@ -963,8 +1169,7 @@ class SnapshotHandler {
         this.hooks = new PluginSystem({
             beforeLoadRemoteSnapshot: new AsyncHook('beforeLoadRemoteSnapshot'),
             loadSnapshot: new AsyncWaterfallHook('loadGlobalSnapshot'),
-            loadRemoteSnapshot: new AsyncWaterfallHook('loadRemoteSnapshot'),
-            afterLoadSnapshot: new AsyncWaterfallHook('afterLoadSnapshot')
+            loadRemoteSnapshot: new AsyncWaterfallHook('loadRemoteSnapshot')
         });
         this.manifestLoading = Global.__FEDERATION__.__MANIFEST_LOADING__;
         this.HostInstance = HostInstance;
@@ -1566,7 +1771,7 @@ class RemoteHandler {
                     origin: host
                 });
             }
-            warn(messages.join(' '));
+            warn$1(messages.join(' '));
         }
     }
     removeRemote(remote) {
@@ -1668,7 +1873,7 @@ class RemoteHandler {
                 host.moduleCache.delete(remote.name);
             }
         } catch (err) {
-            console.log('removeRemote fail: ', err);
+            logger.log('removeRemote fail: ', err);
         }
     }
     constructor(host){
@@ -1795,7 +2000,7 @@ class FederationHost {
             // maybe will change, temporarily for internal use only
             initContainer: new AsyncWaterfallHook('initContainer')
         });
-        this.version = "0.6.11";
+        this.version = "0.6.15";
         this.moduleCache = new Map();
         this.loaderHook = new PluginSystem({
             // FIXME: may not be suitable , not open to the public yet
@@ -1803,13 +2008,8 @@ class FederationHost {
             createScript: new SyncHook(),
             createLink: new SyncHook(),
             // only work for manifest , so not open to the public yet
-            fetch: new AsyncHook()
-        });
-        this.bridgeHook = new PluginSystem({
-            beforeBridgeRender: new SyncHook(),
-            afterBridgeRender: new SyncHook(),
-            beforeBridgeDestroy: new SyncHook(),
-            afterBridgeDestroy: new SyncHook()
+            fetch: new AsyncHook(),
+            getModuleFactory: new AsyncHook()
         });
         // TODO: Validate the details of the options
         // Initialize options with default values

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/runtime",
-  "version": "0.6.11",
+  "version": "0.6.15",
   "author": "zhouxiao <codingzx@gmail.com>",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",

package/dist/polyfills.esm.js

@@ -22,4 +22,4 @@ function _object_without_properties_loose(source, excluded) {
     return target;
 }
 
-export { _extends as _, _object_without_properties_loose as a };
+export { _object_without_properties_loose as _, _extends as a };