@module-federation/runtime 0.0.0-next-20240508024041 → 0.0.0-next-20240511023318

package/dist/index.esm.js

@@ -87,8 +87,8 @@ function registerPlugins$1(plugins, hookInstances) {
     return plugins;
 }
 
-function _extends$6() {
-    _extends$6 = Object.assign || function(target) {
+function _extends$7() {
+    _extends$7 = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
             var source = arguments[i];
             for(var key in source){
@@ -99,7 +99,7 @@ function _extends$6() {
         }
         return target;
     };
-    return _extends$6.apply(this, arguments);
+    return _extends$7.apply(this, arguments);
 }
 async function loadEsmEntry({ entry, remoteEntryExports }) {
     return new Promise((resolve, reject)=>{
@@ -187,7 +187,7 @@ async function getRemoteEntry({ remoteEntryExports, remoteInfo, createScriptHook
     return globalLoading[uniqueKey];
 }
 function getRemoteInfo(remote) {
-    return _extends$6({}, remote, {
+    return _extends$7({}, remote, {
         entry: 'entry' in remote ? remote.entry : '',
         type: remote.type || DEFAULT_REMOTE_TYPE,
         entryGlobalName: remote.entryGlobalName || remote.name,
@@ -195,8 +195,8 @@ function getRemoteInfo(remote) {
     });
 }
 
-function _extends$5() {
-    _extends$5 = Object.assign || function(target) {
+function _extends$6() {
+    _extends$6 = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
             var source = arguments[i];
             for(var key in source){
@@ -207,7 +207,7 @@ function _extends$5() {
         }
         return target;
     };
-    return _extends$5.apply(this, arguments);
+    return _extends$6.apply(this, arguments);
 }
 let Module = class Module {
     async getEntry() {
@@ -269,7 +269,7 @@ let Module = class Module {
                 origin: this.host
             });
             await remoteEntryExports.init(initContainerOptions.shareScope, initContainerOptions.initScope, initContainerOptions.remoteEntryInitOptions);
-            await this.host.hooks.lifecycle.initContainer.emit(_extends$5({}, initContainerOptions, {
+            await this.host.hooks.lifecycle.initContainer.emit(_extends$6({}, initContainerOptions, {
                 remoteEntryExports
             }));
         }
@@ -479,8 +479,8 @@ class PluginSystem {
     }
 }
 
-function _extends$4() {
-    _extends$4 = Object.assign || function(target) {
+function _extends$5() {
+    _extends$5 = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
             var source = arguments[i];
             for(var key in source){
@@ -491,10 +491,10 @@ function _extends$4() {
         }
         return target;
     };
-    return _extends$4.apply(this, arguments);
+    return _extends$5.apply(this, arguments);
 }
 function defaultPreloadArgs(preloadConfig) {
-    return _extends$4({
+    return _extends$5({
         resourceCategory: 'sync',
         share: true,
         depsRemote: true,
@@ -601,8 +601,8 @@ function preloadAssets(remoteInfo, host, assets) {
     }
 }
 
-function _extends$3() {
-    _extends$3 = Object.assign || function(target) {
+function _extends$4() {
+    _extends$4 = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
             var source = arguments[i];
             for(var key in source){
@@ -613,7 +613,7 @@ function _extends$3() {
         }
         return target;
     };
-    return _extends$3.apply(this, arguments);
+    return _extends$4.apply(this, arguments);
 }
 function assignRemoteInfo(remoteInfo, remoteSnapshot) {
     if (!('remoteEntry' in remoteSnapshot) || !remoteSnapshot.remoteEntry) {
@@ -659,7 +659,7 @@ function snapshotPlugin() {
                 if (assets) {
                     preloadAssets(remoteInfo, origin, assets);
                 }
-                return _extends$3({}, args, {
+                return _extends$4({}, args, {
                     remoteSnapshot
                 });
             }
@@ -880,8 +880,8 @@ const generatePreloadAssetsPlugin = function() {
     };
 };
 
-function _extends$2() {
-    _extends$2 = Object.assign || function(target) {
+function _extends$3() {
+    _extends$3 = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
             var source = arguments[i];
             for(var key in source){
@@ -892,7 +892,7 @@ function _extends$2() {
         }
         return target;
     };
-    return _extends$2.apply(this, arguments);
+    return _extends$3.apply(this, arguments);
 }
 class SnapshotHandler {
     async loadSnapshot(moduleInfo) {
@@ -935,7 +935,7 @@ class SnapshotHandler {
         // This ensures the snapshot's integrity and helps the chrome plugin correctly identify all producer modules, ensuring that proxyable producer modules will not be missing.
         if (hostSnapshot && 'remotesInfo' in hostSnapshot && !getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name).value) {
             if ('version' in moduleInfo || 'entry' in moduleInfo) {
-                hostSnapshot.remotesInfo = _extends$2({}, hostSnapshot == null ? void 0 : hostSnapshot.remotesInfo, {
+                hostSnapshot.remotesInfo = _extends$3({}, hostSnapshot == null ? void 0 : hostSnapshot.remotesInfo, {
                     [moduleInfo.name]: {
                         matchedVersion: 'version' in moduleInfo ? moduleInfo.version : moduleInfo.entry
                     }
@@ -955,7 +955,7 @@ class SnapshotHandler {
             if (isManifestProvider(globalRemoteSnapshot)) {
                 const moduleSnapshot = await this.getManifestJson(globalRemoteSnapshot.remoteEntry, moduleInfo, {});
                 // eslint-disable-next-line @typescript-eslint/no-shadow
-                const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo(_extends$2({}, moduleInfo, {
+                const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo(_extends$3({}, moduleInfo, {
                     // The global remote may be overridden
                     // Therefore, set the snapshot key to the global address of the actual request
                     entry: globalRemoteSnapshot.remoteEntry
@@ -1083,8 +1083,8 @@ class SnapshotHandler {
     }
 }
 
-function _extends$1() {
-    _extends$1 = Object.assign || function(target) {
+function _extends$2() {
+    _extends$2 = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
             var source = arguments[i];
             for(var key in source){
@@ -1095,7 +1095,7 @@ function _extends$1() {
         }
         return target;
     };
-    return _extends$1.apply(this, arguments);
+    return _extends$2.apply(this, arguments);
 }
 function _object_without_properties_loose(source, excluded) {
     if (source == null) return {};
@@ -1112,7 +1112,7 @@ function _object_without_properties_loose(source, excluded) {
 class SharedHandler {
     formatShareConfigs(globalOptions, userOptions) {
         const shareInfos = formatShareConfigs(userOptions.shared || {}, userOptions.name);
-        const shared = _extends$1({}, globalOptions.shared);
+        const shared = _extends$2({}, globalOptions.shared);
         Object.keys(shareInfos).forEach((shareKey)=>{
             if (!shared[shareKey]) {
                 shared[shareKey] = shareInfos[shareKey];
@@ -1150,7 +1150,8 @@ class SharedHandler {
             });
         });
     }
-    async loadShare(origin, pkgName, extraOptions) {
+    async loadShare(pkgName, extraOptions) {
+        const { host } = this;
         // This function performs the following steps:
         // 1. Checks if the currently loaded share already exists, if not, it throws an error
         // 2. Searches globally for a matching share, if found, it uses it directly
@@ -1158,30 +1159,30 @@ class SharedHandler {
         const shareInfo = getTargetSharedOptions({
             pkgName,
             extraOptions,
-            shareInfos: origin.options.shared
+            shareInfos: host.options.shared
         });
         if (shareInfo == null ? void 0 : shareInfo.scope) {
             await Promise.all(shareInfo.scope.map(async (shareScope)=>{
-                await Promise.all(this.initializeSharing(origin, shareScope, shareInfo.strategy));
+                await Promise.all(this.initializeSharing(shareScope, shareInfo.strategy));
                 return;
             }));
         }
         const loadShareRes = await this.hooks.lifecycle.beforeLoadShare.emit({
             pkgName,
             shareInfo,
-            shared: origin.options.shared,
-            origin: origin
+            shared: host.options.shared,
+            origin: host
         });
         const { shareInfo: shareInfoRes } = loadShareRes;
         // Assert that shareInfoRes exists, if not, throw an error
-        assert(shareInfoRes, `Cannot find ${pkgName} Share in the ${origin.options.name}. Please ensure that the ${pkgName} Share parameters have been injected`);
+        assert(shareInfoRes, `Cannot find ${pkgName} Share in the ${host.options.name}. Please ensure that the ${pkgName} Share parameters have been injected`);
         // Retrieve from cache
         const registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareInfoRes, this.hooks.lifecycle.resolveShare);
         const addUseIn = (shared)=>{
             if (!shared.useIn) {
                 shared.useIn = [];
             }
-            addUniqueItem(shared.useIn, origin.options.name);
+            addUniqueItem(shared.useIn, host.options.name);
         };
         if (registeredShared && registeredShared.lib) {
             addUseIn(registeredShared);
@@ -1212,7 +1213,7 @@ class SharedHandler {
                 pkgName,
                 loaded: false,
                 shared: registeredShared,
-                from: origin.options.name,
+                from: host.options.name,
                 lib: null,
                 loading
             });
@@ -1238,7 +1239,7 @@ class SharedHandler {
                 pkgName,
                 loaded: false,
                 shared: shareInfoRes,
-                from: origin.options.name,
+                from: host.options.name,
                 lib: null,
                 loading
             });
@@ -1250,9 +1251,10 @@ class SharedHandler {
    * It accepts one argument, the name of the share scope.
    * If the share scope does not exist, it creates one.
    */ // eslint-disable-next-line @typescript-eslint/member-ordering
-    initializeSharing(origin, shareScopeName = DEFAULT_SCOPE, strategy) {
+    initializeSharing(shareScopeName = DEFAULT_SCOPE, strategy) {
+        const { host } = this;
         const shareScope = this.shareScopeMap;
-        const hostName = origin.options.name;
+        const hostName = host.options.name;
         // Creates a new share scope if necessary
         if (!shareScope[shareScopeName]) {
             shareScope[shareScopeName] = {};
@@ -1273,9 +1275,8 @@ class SharedHandler {
         const promises = [];
         const initFn = (mod)=>mod && mod.init && mod.init(shareScope[shareScopeName]);
         const initRemoteModule = async (key)=>{
-            const { module } = await getRemoteModuleAndOptions({
-                id: key,
-                origin
+            const { module } = await host.remoteHandler.getRemoteModuleAndOptions({
+                id: key
             });
             if (module.getEntry) {
                 const entry = await module.getEntry();
@@ -1285,8 +1286,8 @@ class SharedHandler {
                 }
             }
         };
-        Object.keys(origin.options.shared).forEach((shareName)=>{
-            const sharedArr = origin.options.shared[shareName];
+        Object.keys(host.options.shared).forEach((shareName)=>{
+            const sharedArr = host.options.shared[shareName];
             sharedArr.forEach((shared)=>{
                 if (shared.scope.includes(shareScopeName)) {
                     register(shareName, shared);
@@ -1294,7 +1295,7 @@ class SharedHandler {
             });
         });
         if (strategy === 'version-first') {
-            origin.options.remotes.forEach((remote)=>{
+            host.options.remotes.forEach((remote)=>{
                 if (remote.shareScope === shareScopeName) {
                     promises.push(initRemoteModule(remote.name));
                 }
@@ -1306,15 +1307,16 @@ class SharedHandler {
     // 1. If the loaded shared already exists globally, then it will be reused
     // 2. If lib exists in local shared, it will be used directly
     // 3. If the local get returns something other than Promise, then it will be used directly
-    loadShareSync(origin, pkgName, extraOptions) {
+    loadShareSync(pkgName, extraOptions) {
+        const { host } = this;
         const shareInfo = getTargetSharedOptions({
             pkgName,
             extraOptions,
-            shareInfos: origin.options.shared
+            shareInfos: host.options.shared
         });
         if (shareInfo == null ? void 0 : shareInfo.scope) {
             shareInfo.scope.forEach((shareScope)=>{
-                this.initializeSharing(origin, shareScope, shareInfo.strategy);
+                this.initializeSharing(shareScope, shareInfo.strategy);
             });
         }
         const registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareInfo, this.hooks.lifecycle.resolveShare);
@@ -1322,14 +1324,14 @@ class SharedHandler {
             if (!shared.useIn) {
                 shared.useIn = [];
             }
-            addUniqueItem(shared.useIn, origin.options.name);
+            addUniqueItem(shared.useIn, host.options.name);
         };
         if (registeredShared) {
             if (typeof registeredShared.lib === 'function') {
                 addUseIn(registeredShared);
                 if (!registeredShared.loaded) {
                     registeredShared.loaded = true;
-                    if (registeredShared.from === origin.options.name) {
+                    if (registeredShared.from === host.options.name) {
                         shareInfo.loaded = true;
                     }
                 }
@@ -1342,7 +1344,7 @@ class SharedHandler {
                     this.setShared({
                         pkgName,
                         loaded: true,
-                        from: origin.options.name,
+                        from: host.options.name,
                         lib: module,
                         shared: registeredShared
                     });
@@ -1360,7 +1362,7 @@ class SharedHandler {
             const module = shareInfo.get();
             if (module instanceof Promise) {
                 throw new Error(`
-        The loadShareSync function was unable to load ${pkgName}. The ${pkgName} could not be found in ${origin.options.name}.
+        The loadShareSync function was unable to load ${pkgName}. The ${pkgName} could not be found in ${host.options.name}.
         Possible reasons for failure: \n
         1. The ${pkgName} share was registered with the 'get' attribute, but loadShare was not used beforehand.\n
         2. The ${pkgName} share was not registered with the 'lib' attribute.\n
@@ -1370,25 +1372,26 @@ class SharedHandler {
             this.setShared({
                 pkgName,
                 loaded: true,
-                from: origin.options.name,
+                from: host.options.name,
                 lib: shareInfo.lib,
                 shared: shareInfo
             });
             return shareInfo.lib;
         }
         throw new Error(`
-        The loadShareSync function was unable to load ${pkgName}. The ${pkgName} could not be found in ${origin.options.name}.
+        The loadShareSync function was unable to load ${pkgName}. The ${pkgName} could not be found in ${host.options.name}.
         Possible reasons for failure: \n
         1. The ${pkgName} share was registered with the 'get' attribute, but loadShare was not used beforehand.\n
         2. The ${pkgName} share was not registered with the 'lib' attribute.\n
       `);
     }
-    initShareScopeMap(origin, scopeName, shareScope) {
+    initShareScopeMap(scopeName, shareScope) {
+        const { host } = this;
         this.shareScopeMap[scopeName] = shareScope;
         this.hooks.lifecycle.initContainerShareScopeMap.emit({
             shareScope,
-            options: origin.options,
-            origin: origin
+            options: host.options,
+            origin: host
         });
     }
     setShared({ pkgName, shared, from, lib, loading, loaded, get }) {
@@ -1409,7 +1412,7 @@ class SharedHandler {
             if (this.shareScopeMap[sc][pkgName][version]) {
                 return;
             }
-            this.shareScopeMap[sc][pkgName][version] = _extends$1({
+            this.shareScopeMap[sc][pkgName][version] = _extends$2({
                 version,
                 scope: [
                     'default'
@@ -1431,7 +1434,7 @@ class SharedHandler {
             globalShareScopeMap[identifier] = this.shareScopeMap;
         }
     }
-    constructor(hostOptions){
+    constructor(host){
         this.hooks = new PluginSystem({
             afterResolve: new AsyncWaterfallHook('afterResolve'),
             beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
@@ -1441,16 +1444,31 @@ class SharedHandler {
             // maybe will change, temporarily for internal use only
             initContainerShareScopeMap: new AsyncWaterfallHook('initContainer')
         });
+        this.host = host;
         this.shareScopeMap = {};
-        this._setGlobalShareScopeMap(hostOptions);
+        this._setGlobalShareScopeMap(host.options);
     }
 }
 
+function _extends$1() {
+    _extends$1 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$1.apply(this, arguments);
+}
 class RemoteHandler {
-    formatRemote(origin, globalOptions, userOptions) {
+    formatAndRegisterRemote(globalOptions, userOptions) {
         const userRemotes = userOptions.remotes || [];
         return userRemotes.reduce((res, remote)=>{
-            this.registerRemote(origin, remote, res, {
+            this.registerRemote(remote, res, {
                 force: false
             });
             return res;
@@ -1458,7 +1476,8 @@ class RemoteHandler {
     }
     // eslint-disable-next-line max-lines-per-function
     // eslint-disable-next-line @typescript-eslint/member-ordering
-    async loadRemote(origin, id, options) {
+    async loadRemote(id, options) {
+        const { host } = this;
         try {
             const { loadFactory = true } = options || {
                 loadFactory: true
@@ -1470,9 +1489,8 @@ class RemoteHandler {
             // id: pkgName(@federation/app1) + expose(button) = @federation/app1/button
             // id: alias(app1) + expose(button) = app1/button
             // id: alias(app1/utils) + expose(loadash/sort) = app1/utils/loadash/sort
-            const { module, moduleOptions, remoteMatchInfo } = await getRemoteModuleAndOptions({
-                id,
-                origin: origin
+            const { module, moduleOptions, remoteMatchInfo } = await this.getRemoteModuleAndOptions({
+                id
             });
             const { pkgNameOrAlias, remote, expose, id: idRes } = remoteMatchInfo;
             const moduleOrFactory = await module.get(expose, options);
@@ -1485,7 +1503,7 @@ class RemoteHandler {
                 remote,
                 options: moduleOptions,
                 moduleInstance: module,
-                origin: origin
+                origin: host
             });
             if (typeof moduleWrapper === 'function') {
                 return moduleWrapper;
@@ -1500,7 +1518,7 @@ class RemoteHandler {
                 error,
                 from,
                 lifecycle: 'onLoad',
-                origin: origin
+                origin: host
             });
             if (!failOver) {
                 throw error;
@@ -1509,19 +1527,20 @@ class RemoteHandler {
         }
     }
     // eslint-disable-next-line @typescript-eslint/member-ordering
-    async preloadRemote(origin, preloadOptions) {
+    async preloadRemote(preloadOptions) {
+        const { host } = this;
         await this.hooks.lifecycle.beforePreloadRemote.emit({
             preloadOptions,
-            options: origin.options,
-            origin: origin
+            options: host.options,
+            origin: host
         });
-        const preloadOps = formatPreloadArgs(origin.options.remotes, preloadOptions);
+        const preloadOps = formatPreloadArgs(host.options.remotes, preloadOptions);
         await Promise.all(preloadOps.map(async (ops)=>{
             const { remote } = ops;
             const remoteInfo = getRemoteInfo(remote);
-            const { globalSnapshot, remoteSnapshot } = await origin.snapshotHandler.loadRemoteSnapshotInfo(remote);
+            const { globalSnapshot, remoteSnapshot } = await host.snapshotHandler.loadRemoteSnapshotInfo(remote);
             const assets = await this.hooks.lifecycle.generatePreloadAssets.emit({
-                origin: origin,
+                origin: host,
                 preloadOptions: ops,
                 remote,
                 remoteInfo,
@@ -1531,36 +1550,77 @@ class RemoteHandler {
             if (!assets) {
                 return;
             }
-            preloadAssets(remoteInfo, origin, assets);
+            preloadAssets(remoteInfo, host, assets);
         }));
     }
-    registerRemotes(origin, remotes, options) {
+    registerRemotes(remotes, options) {
+        const { host } = this;
         remotes.forEach((remote)=>{
-            this.registerRemote(origin, remote, origin.options.remotes, {
+            this.registerRemote(remote, host.options.remotes, {
                 force: options == null ? void 0 : options.force
             });
         });
     }
-    removeRemote(origin, remote) {
-        const { name } = remote;
-        const remoteIndex = origin.options.remotes.findIndex((item)=>item.name === name);
-        if (remoteIndex !== -1) {
-            origin.options.remotes.splice(remoteIndex, 1);
-        }
-        const loadedModule = origin.moduleCache.get(remote.name);
-        if (loadedModule) {
-            const key = loadedModule.remoteInfo.entryGlobalName;
-            if (globalThis[key]) {
-                delete globalThis[key];
-            }
-            const remoteEntryUniqueKey = getRemoteEntryUniqueKey(loadedModule.remoteInfo);
-            if (globalLoading[remoteEntryUniqueKey]) {
-                delete globalLoading[remoteEntryUniqueKey];
+    async getRemoteModuleAndOptions(options) {
+        const { host } = this;
+        const { id } = options;
+        let loadRemoteArgs;
+        try {
+            loadRemoteArgs = await this.hooks.lifecycle.beforeRequest.emit({
+                id,
+                options: host.options,
+                origin: host
+            });
+        } catch (error) {
+            loadRemoteArgs = await this.hooks.lifecycle.errorLoadRemote.emit({
+                id,
+                options: host.options,
+                origin: host,
+                from: 'runtime',
+                error,
+                lifecycle: 'beforeRequest'
+            });
+            if (!loadRemoteArgs) {
+                throw error;
             }
-            origin.moduleCache.delete(remote.name);
         }
+        const { id: idRes } = loadRemoteArgs;
+        const remoteSplitInfo = matchRemoteWithNameAndExpose(host.options.remotes, idRes);
+        assert(remoteSplitInfo, `
+        Unable to locate ${idRes} in ${host.options.name}. Potential reasons for failure include:\n
+        1. ${idRes} was not included in the 'remotes' parameter of ${host.options.name || 'the host'}.\n
+        2. ${idRes} could not be found in the 'remotes' of ${host.options.name} with either 'name' or 'alias' attributes.
+        3. ${idRes} is not online, injected, or loaded.
+        4. ${idRes}  cannot be accessed on the expected.
+        5. The 'beforeRequest' hook was provided but did not return the correct 'remoteInfo' when attempting to load ${idRes}.
+      `);
+        const { remote: rawRemote } = remoteSplitInfo;
+        const remoteInfo = getRemoteInfo(rawRemote);
+        const matchInfo = await host.sharedHandler.hooks.lifecycle.afterResolve.emit(_extends$1({
+            id: idRes
+        }, remoteSplitInfo, {
+            options: host.options,
+            origin: host,
+            remoteInfo
+        }));
+        const { remote, expose } = matchInfo;
+        assert(remote && expose, `The 'beforeRequest' hook was executed, but it failed to return the correct 'remote' and 'expose' values while loading ${idRes}.`);
+        let module = host.moduleCache.get(remote.name);
+        const moduleOptions = {
+            host: host,
+            remoteInfo
+        };
+        if (!module) {
+            module = new Module(moduleOptions);
+            host.moduleCache.set(remote.name, module);
+        }
+        return {
+            module,
+            moduleOptions,
+            remoteMatchInfo: matchInfo
+        };
     }
-    registerRemote(origin, remote, targetRemotes, options) {
+    registerRemote(remote, targetRemotes, options) {
         const normalizeRemote = ()=>{
             if (remote.alias) {
                 // Validate if alias equals the prefix of remote.name and remote.alias, if so, throw an error
@@ -1595,14 +1655,34 @@ class RemoteHandler {
             ];
             if (options == null ? void 0 : options.force) {
                 // remove registered remote
-                this.removeRemote(origin, registeredRemote);
+                this.removeRemote(registeredRemote);
                 normalizeRemote();
                 targetRemotes.push(remote);
             }
             warn$1(messages.join(' '));
         }
     }
-    constructor(){
+    removeRemote(remote) {
+        const { host } = this;
+        const { name } = remote;
+        const remoteIndex = host.options.remotes.findIndex((item)=>item.name === name);
+        if (remoteIndex !== -1) {
+            host.options.remotes.splice(remoteIndex, 1);
+        }
+        const loadedModule = host.moduleCache.get(remote.name);
+        if (loadedModule) {
+            const key = loadedModule.remoteInfo.entryGlobalName;
+            if (globalThis[key]) {
+                delete globalThis[key];
+            }
+            const remoteEntryUniqueKey = getRemoteEntryUniqueKey(loadedModule.remoteInfo);
+            if (globalLoading[remoteEntryUniqueKey]) {
+                delete globalLoading[remoteEntryUniqueKey];
+            }
+            host.moduleCache.delete(remote.name);
+        }
+    }
+    constructor(host){
         this.hooks = new PluginSystem({
             beforeRequest: new AsyncWaterfallHook('beforeRequest'),
             onLoad: new AsyncHook('onLoad'),
@@ -1613,6 +1693,7 @@ class RemoteHandler {
             // not used yet
             afterPreloadRemote: new AsyncHook()
         });
+        this.host = host;
     }
 }
 
@@ -1630,64 +1711,6 @@ function _extends() {
     };
     return _extends.apply(this, arguments);
 }
-async function getRemoteModuleAndOptions(options) {
-    const { id, origin } = options;
-    let loadRemoteArgs;
-    try {
-        loadRemoteArgs = await origin.remoteHandler.hooks.lifecycle.beforeRequest.emit({
-            id,
-            options: origin.options,
-            origin: origin
-        });
-    } catch (error) {
-        loadRemoteArgs = await origin.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
-            id,
-            options: origin.options,
-            origin: origin,
-            from: 'runtime',
-            error,
-            lifecycle: 'beforeRequest'
-        });
-        if (!loadRemoteArgs) {
-            throw error;
-        }
-    }
-    const { id: idRes } = loadRemoteArgs;
-    const remoteSplitInfo = matchRemoteWithNameAndExpose(origin.options.remotes, idRes);
-    assert(remoteSplitInfo, `
-      Unable to locate ${idRes} in ${origin.options.name}. Potential reasons for failure include:\n
-      1. ${idRes} was not included in the 'remotes' parameter of ${origin.options.name || 'the host'}.\n
-      2. ${idRes} could not be found in the 'remotes' of ${origin.options.name} with either 'name' or 'alias' attributes.
-      3. ${idRes} is not online, injected, or loaded.
-      4. ${idRes}  cannot be accessed on the expected.
-      5. The 'beforeRequest' hook was provided but did not return the correct 'remoteInfo' when attempting to load ${idRes}.
-    `);
-    const { remote: rawRemote } = remoteSplitInfo;
-    const remoteInfo = getRemoteInfo(rawRemote);
-    const matchInfo = await origin.sharedHandler.hooks.lifecycle.afterResolve.emit(_extends({
-        id: idRes
-    }, remoteSplitInfo, {
-        options: origin.options,
-        origin: origin,
-        remoteInfo
-    }));
-    const { remote, expose } = matchInfo;
-    assert(remote && expose, `The 'beforeRequest' hook was executed, but it failed to return the correct 'remote' and 'expose' values while loading ${idRes}.`);
-    let module = origin.moduleCache.get(remote.name);
-    const moduleOptions = {
-        host: origin,
-        remoteInfo
-    };
-    if (!module) {
-        module = new Module(moduleOptions);
-        origin.moduleCache.set(remote.name, module);
-    }
-    return {
-        module,
-        moduleOptions,
-        remoteMatchInfo: matchInfo
-    };
-}
 class FederationHost {
     initOptions(userOptions) {
         this.registerPlugins(userOptions.plugins);
@@ -1696,17 +1719,17 @@ class FederationHost {
         return options;
     }
     async loadShare(pkgName, extraOptions) {
-        return this.sharedHandler.loadShare(this, pkgName, extraOptions);
+        return this.sharedHandler.loadShare(pkgName, extraOptions);
     }
     // The lib function will only be available if the shared set by eager or runtime init is set or the shared is successfully loaded.
     // 1. If the loaded shared already exists globally, then it will be reused
     // 2. If lib exists in local shared, it will be used directly
     // 3. If the local get returns something other than Promise, then it will be used directly
     loadShareSync(pkgName, extraOptions) {
-        return this.sharedHandler.loadShareSync(this, pkgName, extraOptions);
+        return this.sharedHandler.loadShareSync(pkgName, extraOptions);
     }
     initializeSharing(shareScopeName = DEFAULT_SCOPE, strategy) {
-        return this.sharedHandler.initializeSharing(this, shareScopeName, strategy);
+        return this.sharedHandler.initializeSharing(shareScopeName, strategy);
     }
     initRawContainer(name, url, container) {
         const remoteInfo = getRemoteInfo({
@@ -1724,25 +1747,26 @@ class FederationHost {
     // eslint-disable-next-line max-lines-per-function
     // eslint-disable-next-line @typescript-eslint/member-ordering
     async loadRemote(id, options) {
-        return this.remoteHandler.loadRemote(this, id, options);
+        return this.remoteHandler.loadRemote(id, options);
     }
     // eslint-disable-next-line @typescript-eslint/member-ordering
     async preloadRemote(preloadOptions) {
-        return this.remoteHandler.preloadRemote(this, preloadOptions);
+        return this.remoteHandler.preloadRemote(preloadOptions);
     }
     initShareScopeMap(scopeName, shareScope) {
-        this.sharedHandler.initShareScopeMap(this, scopeName, shareScope);
+        this.sharedHandler.initShareScopeMap(scopeName, shareScope);
     }
     formatOptions(globalOptions, userOptions) {
-        const { shared, shareInfos } = this.sharedHandler.formatShareConfigs(globalOptions, userOptions);
+        const { shared } = this.sharedHandler.formatShareConfigs(globalOptions, userOptions);
         const { userOptions: userOptionsRes, options: globalOptionsRes } = this.hooks.lifecycle.beforeInit.emit({
             origin: this,
             userOptions,
             options: globalOptions,
             shareInfo: shared
         });
-        const remotes = this.remoteHandler.formatRemote(this, globalOptionsRes, userOptionsRes);
-        this.sharedHandler.registerShared(shareInfos, userOptions);
+        const { shared: handledShared, shareInfos: handledShareInfos } = this.sharedHandler.formatShareConfigs(globalOptions, userOptions);
+        const remotes = this.remoteHandler.formatAndRegisterRemote(globalOptionsRes, userOptionsRes);
+        this.sharedHandler.registerShared(handledShareInfos, userOptions);
         const plugins = [
             ...globalOptionsRes.plugins
         ];
@@ -1756,7 +1780,7 @@ class FederationHost {
         const optionsRes = _extends({}, globalOptions, userOptions, {
             plugins,
             remotes,
-            shared
+            shared: handledShared
         });
         this.hooks.lifecycle.init.emit({
             origin: this,
@@ -1782,7 +1806,7 @@ class FederationHost {
         }, pluginRes || []);
     }
     registerRemotes(remotes, options) {
-        return this.remoteHandler.registerRemotes(this, remotes, options);
+        return this.remoteHandler.registerRemotes(remotes, options);
     }
     constructor(userOptions){
         this.hooks = new PluginSystem({
@@ -1793,7 +1817,7 @@ class FederationHost {
             // maybe will change, temporarily for internal use only
             initContainer: new AsyncWaterfallHook('initContainer')
         });
-        this.version = "0.1.11";
+        this.version = "0.1.12";
         this.moduleCache = new Map();
         this.loaderHook = new PluginSystem({
             // FIXME: may not be suitable , not open to the public yet
@@ -1819,8 +1843,8 @@ class FederationHost {
         this.name = userOptions.name;
         this.options = defaultOptions;
         this.snapshotHandler = new SnapshotHandler(this);
-        this.sharedHandler = new SharedHandler(this.options);
-        this.remoteHandler = new RemoteHandler();
+        this.sharedHandler = new SharedHandler(this);
+        this.remoteHandler = new RemoteHandler(this);
         this.shareScopeMap = this.sharedHandler.shareScopeMap;
         this.registerPlugins([
             ...defaultOptions.plugins,