@module-federation/runtime 0.1.11 → 0.1.13

package/dist/index.cjs.js

@@ -89,8 +89,8 @@ function registerPlugins$1(plugins, hookInstances) {
     return plugins;
 }
 
-function _extends$5() {
-    _extends$5 = 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){
@@ -101,7 +101,7 @@ function _extends$5() {
         }
         return target;
     };
-    return _extends$5.apply(this, arguments);
+    return _extends$7.apply(this, arguments);
 }
 async function loadEsmEntry({ entry, remoteEntryExports }) {
     return new Promise((resolve, reject)=>{
@@ -189,7 +189,7 @@ async function getRemoteEntry({ remoteEntryExports, remoteInfo, createScriptHook
     return share.globalLoading[uniqueKey];
 }
 function getRemoteInfo(remote) {
-    return _extends$5({}, remote, {
+    return _extends$7({}, remote, {
         entry: 'entry' in remote ? remote.entry : '',
         type: remote.type || share.DEFAULT_REMOTE_TYPE,
         entryGlobalName: remote.entryGlobalName || remote.name,
@@ -197,8 +197,8 @@ function getRemoteInfo(remote) {
     });
 }
 
-function _extends$4() {
-    _extends$4 = 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){
@@ -209,7 +209,7 @@ function _extends$4() {
         }
         return target;
     };
-    return _extends$4.apply(this, arguments);
+    return _extends$6.apply(this, arguments);
 }
 let Module = class Module {
     async getEntry() {
@@ -271,7 +271,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$4({}, initContainerOptions, {
+            await this.host.hooks.lifecycle.initContainer.emit(_extends$6({}, initContainerOptions, {
                 remoteEntryExports
             }));
         }
@@ -481,8 +481,8 @@ class PluginSystem {
     }
 }
 
-function _extends$3() {
-    _extends$3 = 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){
@@ -493,10 +493,10 @@ function _extends$3() {
         }
         return target;
     };
-    return _extends$3.apply(this, arguments);
+    return _extends$5.apply(this, arguments);
 }
 function defaultPreloadArgs(preloadConfig) {
-    return _extends$3({
+    return _extends$5({
         resourceCategory: 'sync',
         share: true,
         depsRemote: true,
@@ -603,8 +603,8 @@ function preloadAssets(remoteInfo, host, assets) {
     }
 }
 
-function _extends$2() {
-    _extends$2 = 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){
@@ -615,7 +615,7 @@ function _extends$2() {
         }
         return target;
     };
-    return _extends$2.apply(this, arguments);
+    return _extends$4.apply(this, arguments);
 }
 function assignRemoteInfo(remoteInfo, remoteSnapshot) {
     if (!('remoteEntry' in remoteSnapshot) || !remoteSnapshot.remoteEntry) {
@@ -650,7 +650,7 @@ function snapshotPlugin() {
                         depsRemote: false
                     }
                 };
-                const assets = await origin.hooks.lifecycle.generatePreloadAssets.emit({
+                const assets = await origin.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit({
                     origin,
                     preloadOptions,
                     remoteInfo,
@@ -661,7 +661,7 @@ function snapshotPlugin() {
                 if (assets) {
                     preloadAssets(remoteInfo, origin, assets);
                 }
-                return _extends$2({}, args, {
+                return _extends$4({}, args, {
                     remoteSnapshot
                 });
             }
@@ -787,7 +787,7 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
             for(let index = 0; index < assetsLength; index++){
                 const assetsInfo = moduleAssetsInfo[index];
                 const exposeFullPath = `${remoteInfo.name}/${assetsInfo.moduleName}`;
-                origin.hooks.lifecycle.handlePreloadModule.emit({
+                origin.remoteHandler.hooks.lifecycle.handlePreloadModule.emit({
                     id: assetsInfo.moduleName === '.' ? remoteInfo.name : exposeFullPath,
                     name: remoteInfo.name,
                     remoteSnapshot: moduleInfoSnapshot,
@@ -815,7 +815,7 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
     }, true, memo, remoteSnapshot);
     if (remoteSnapshot.shared) {
         const collectSharedAssets = (shareInfo, snapshotShared)=>{
-            const registeredShared = share.getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.hooks.lifecycle.resolveShare);
+            const registeredShared = share.getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare);
             // If the global share does not exist, or the lib function does not exist, it means that the shared has not been loaded yet and can be preloaded.
             if (registeredShared && typeof registeredShared.lib === 'function') {
                 snapshotShared.assets.js.sync.forEach((asset)=>{
@@ -882,8 +882,8 @@ const generatePreloadAssetsPlugin = function() {
     };
 };
 
-function _extends$1() {
-    _extends$1 = 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){
@@ -894,7 +894,7 @@ function _extends$1() {
         }
         return target;
     };
-    return _extends$1.apply(this, arguments);
+    return _extends$3.apply(this, arguments);
 }
 class SnapshotHandler {
     async loadSnapshot(moduleInfo) {
@@ -937,7 +937,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 && !share.getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name).value) {
             if ('version' in moduleInfo || 'entry' in moduleInfo) {
-                hostSnapshot.remotesInfo = _extends$1({}, 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
                     }
@@ -957,7 +957,7 @@ class SnapshotHandler {
             if (sdk.isManifestProvider(globalRemoteSnapshot)) {
                 const moduleSnapshot = await this.getManifestJson(globalRemoteSnapshot.remoteEntry, moduleInfo, {});
                 // eslint-disable-next-line @typescript-eslint/no-shadow
-                const globalSnapshotRes = share.setGlobalSnapshotInfoByModuleInfo(_extends$1({}, moduleInfo, {
+                const globalSnapshotRes = share.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
@@ -1085,8 +1085,8 @@ class SnapshotHandler {
     }
 }
 
-function _extends() {
-    _extends = 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){
@@ -1097,7 +1097,7 @@ function _extends() {
         }
         return target;
     };
-    return _extends.apply(this, arguments);
+    return _extends$2.apply(this, arguments);
 }
 function _object_without_properties_loose(source, excluded) {
     if (source == null) return {};
@@ -1111,21 +1111,34 @@ function _object_without_properties_loose(source, excluded) {
     }
     return target;
 }
-class FederationHost {
-    _setGlobalShareScopeMap() {
-        const globalShareScopeMap = share.getGlobalShareScope();
-        const identifier = this.options.id || this.options.name;
-        if (identifier && !globalShareScopeMap[identifier]) {
-            globalShareScopeMap[identifier] = this.shareScopeMap;
-        }
-    }
-    initOptions(userOptions) {
-        this.registerPlugins(userOptions.plugins);
-        const options = this.formatOptions(this.options, userOptions);
-        this.options = options;
-        return options;
+class SharedHandler {
+    // register shared in shareScopeMap
+    registerShared(globalOptions, userOptions) {
+        const { shareInfos, shared } = share.formatShareConfigs(globalOptions, userOptions);
+        const sharedKeys = Object.keys(shareInfos);
+        sharedKeys.forEach((sharedKey)=>{
+            const sharedVals = shareInfos[sharedKey];
+            sharedVals.forEach((sharedVal)=>{
+                const registeredShared = share.getRegisteredShare(this.shareScopeMap, sharedKey, sharedVal, this.hooks.lifecycle.resolveShare);
+                if (!registeredShared && sharedVal && sharedVal.lib) {
+                    this.setShared({
+                        pkgName: sharedKey,
+                        lib: sharedVal.lib,
+                        get: sharedVal.get,
+                        loaded: true,
+                        shared: sharedVal,
+                        from: userOptions.name
+                    });
+                }
+            });
+        });
+        return {
+            shareInfos,
+            shared
+        };
     }
     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
@@ -1133,7 +1146,7 @@ class FederationHost {
         const shareInfo = share.getTargetSharedOptions({
             pkgName,
             extraOptions,
-            shareInfos: this.options.shared
+            shareInfos: host.options.shared
         });
         if (shareInfo == null ? void 0 : shareInfo.scope) {
             await Promise.all(shareInfo.scope.map(async (shareScope)=>{
@@ -1144,19 +1157,19 @@ class FederationHost {
         const loadShareRes = await this.hooks.lifecycle.beforeLoadShare.emit({
             pkgName,
             shareInfo,
-            shared: this.options.shared,
-            origin: this
+            shared: host.options.shared,
+            origin: host
         });
         const { shareInfo: shareInfoRes } = loadShareRes;
         // Assert that shareInfoRes exists, if not, throw an error
-        share.assert(shareInfoRes, `Cannot find ${pkgName} Share in the ${this.options.name}. Please ensure that the ${pkgName} Share parameters have been injected`);
+        share.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 = share.getRegisteredShare(this.shareScopeMap, pkgName, shareInfoRes, this.hooks.lifecycle.resolveShare);
         const addUseIn = (shared)=>{
             if (!shared.useIn) {
                 shared.useIn = [];
             }
-            share.addUniqueItem(shared.useIn, this.options.name);
+            share.addUniqueItem(shared.useIn, host.options.name);
         };
         if (registeredShared && registeredShared.lib) {
             addUseIn(registeredShared);
@@ -1187,7 +1200,7 @@ class FederationHost {
                 pkgName,
                 loaded: false,
                 shared: registeredShared,
-                from: this.options.name,
+                from: host.options.name,
                 lib: null,
                 loading
             });
@@ -1213,22 +1226,80 @@ class FederationHost {
                 pkgName,
                 loaded: false,
                 shared: shareInfoRes,
-                from: this.options.name,
+                from: host.options.name,
                 lib: null,
                 loading
             });
             return loading;
         }
     }
+    /**
+   * This function initializes the sharing sequence (executed only once per share scope).
+   * 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(shareScopeName = share.DEFAULT_SCOPE, strategy) {
+        const { host } = this;
+        const shareScope = this.shareScopeMap;
+        const hostName = host.options.name;
+        // Creates a new share scope if necessary
+        if (!shareScope[shareScopeName]) {
+            shareScope[shareScopeName] = {};
+        }
+        // Executes all initialization snippets from all accessible modules
+        const scope = shareScope[shareScopeName];
+        const register = (name, shared)=>{
+            var _activeVersion_shareConfig;
+            const { version, eager } = shared;
+            scope[name] = scope[name] || {};
+            const versions = scope[name];
+            const activeVersion = versions[version];
+            const activeVersionEager = Boolean(activeVersion && (activeVersion.eager || ((_activeVersion_shareConfig = activeVersion.shareConfig) == null ? void 0 : _activeVersion_shareConfig.eager)));
+            if (!activeVersion || activeVersion.strategy !== 'loaded-first' && !activeVersion.loaded && (Boolean(!eager) !== !activeVersionEager ? eager : hostName > activeVersion.from)) {
+                versions[version] = shared;
+            }
+        };
+        const promises = [];
+        const initFn = (mod)=>mod && mod.init && mod.init(shareScope[shareScopeName]);
+        const initRemoteModule = async (key)=>{
+            const { module } = await host.remoteHandler.getRemoteModuleAndOptions({
+                id: key
+            });
+            if (module.getEntry) {
+                const entry = await module.getEntry();
+                if (!module.inited) {
+                    initFn(entry);
+                    module.inited = true;
+                }
+            }
+        };
+        Object.keys(host.options.shared).forEach((shareName)=>{
+            const sharedArr = host.options.shared[shareName];
+            sharedArr.forEach((shared)=>{
+                if (shared.scope.includes(shareScopeName)) {
+                    register(shareName, shared);
+                }
+            });
+        });
+        if (strategy === 'version-first') {
+            host.options.remotes.forEach((remote)=>{
+                if (remote.shareScope === shareScopeName) {
+                    promises.push(initRemoteModule(remote.name));
+                }
+            });
+        }
+        return promises;
+    }
     // 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) {
+        const { host } = this;
         const shareInfo = share.getTargetSharedOptions({
             pkgName,
             extraOptions,
-            shareInfos: this.options.shared
+            shareInfos: host.options.shared
         });
         if (shareInfo == null ? void 0 : shareInfo.scope) {
             shareInfo.scope.forEach((shareScope)=>{
@@ -1240,14 +1311,14 @@ class FederationHost {
             if (!shared.useIn) {
                 shared.useIn = [];
             }
-            share.addUniqueItem(shared.useIn, this.options.name);
+            share.addUniqueItem(shared.useIn, host.options.name);
         };
         if (registeredShared) {
             if (typeof registeredShared.lib === 'function') {
                 addUseIn(registeredShared);
                 if (!registeredShared.loaded) {
                     registeredShared.loaded = true;
-                    if (registeredShared.from === this.options.name) {
+                    if (registeredShared.from === host.options.name) {
                         shareInfo.loaded = true;
                     }
                 }
@@ -1260,7 +1331,7 @@ class FederationHost {
                     this.setShared({
                         pkgName,
                         loaded: true,
-                        from: this.options.name,
+                        from: host.options.name,
                         lib: module,
                         shared: registeredShared
                     });
@@ -1278,7 +1349,7 @@ class FederationHost {
             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 ${this.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
@@ -1288,77 +1359,112 @@ class FederationHost {
             this.setShared({
                 pkgName,
                 loaded: true,
-                from: this.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 ${this.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
       `);
     }
-    initRawContainer(name, url, container) {
-        const remoteInfo = getRemoteInfo({
-            name,
-            entry: url
+    initShareScopeMap(scopeName, shareScope) {
+        const { host } = this;
+        this.shareScopeMap[scopeName] = shareScope;
+        this.hooks.lifecycle.initContainerShareScopeMap.emit({
+            shareScope,
+            options: host.options,
+            origin: host
         });
-        const module = new Module({
-            host: this,
-            remoteInfo
+    }
+    setShared({ pkgName, shared, from, lib, loading, loaded, get }) {
+        const { version, scope = 'default' } = shared, shareInfo = _object_without_properties_loose(shared, [
+            "version",
+            "scope"
+        ]);
+        const scopes = Array.isArray(scope) ? scope : [
+            scope
+        ];
+        scopes.forEach((sc)=>{
+            if (!this.shareScopeMap[sc]) {
+                this.shareScopeMap[sc] = {};
+            }
+            if (!this.shareScopeMap[sc][pkgName]) {
+                this.shareScopeMap[sc][pkgName] = {};
+            }
+            if (this.shareScopeMap[sc][pkgName][version]) {
+                return;
+            }
+            this.shareScopeMap[sc][pkgName][version] = _extends$2({
+                version,
+                scope: [
+                    'default'
+                ]
+            }, shareInfo, {
+                lib,
+                loaded,
+                loading
+            });
+            if (get) {
+                this.shareScopeMap[sc][pkgName][version].get = get;
+            }
         });
-        module.remoteEntryExports = container;
-        this.moduleCache.set(name, module);
-        return module;
     }
-    async _getRemoteModuleAndOptions(id) {
-        const loadRemoteArgs = await this.hooks.lifecycle.beforeRequest.emit({
-            id,
-            options: this.options,
-            origin: this
+    _setGlobalShareScopeMap(hostOptions) {
+        const globalShareScopeMap = share.getGlobalShareScope();
+        const identifier = hostOptions.id || hostOptions.name;
+        if (identifier && !globalShareScopeMap[identifier]) {
+            globalShareScopeMap[identifier] = this.shareScopeMap;
+        }
+    }
+    constructor(host){
+        this.hooks = new PluginSystem({
+            afterResolve: new AsyncWaterfallHook('afterResolve'),
+            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
+            // not used yet
+            loadShare: new AsyncHook(),
+            resolveShare: new SyncWaterfallHook('resolveShare'),
+            // maybe will change, temporarily for internal use only
+            initContainerShareScopeMap: new AsyncWaterfallHook('initContainer')
         });
-        const { id: idRes } = loadRemoteArgs;
-        const remoteSplitInfo = matchRemoteWithNameAndExpose(this.options.remotes, idRes);
-        share.assert(remoteSplitInfo, `
-        Unable to locate ${idRes} in ${this.options.name}. Potential reasons for failure include:\n
-        1. ${idRes} was not included in the 'remotes' parameter of ${this.options.name || 'the host'}.\n
-        2. ${idRes} could not be found in the 'remotes' of ${this.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 this.hooks.lifecycle.afterResolve.emit(_extends({
-            id: idRes
-        }, remoteSplitInfo, {
-            options: this.options,
-            origin: this,
-            remoteInfo
-        }));
-        const { remote, expose } = matchInfo;
-        share.assert(remote && expose, `The 'beforeRequest' hook was executed, but it failed to return the correct 'remote' and 'expose' values while loading ${idRes}.`);
-        let module = this.moduleCache.get(remote.name);
-        const moduleOptions = {
-            host: this,
-            remoteInfo
-        };
-        if (!module) {
-            module = new Module(moduleOptions);
-            this.moduleCache.set(remote.name, module);
+        this.host = host;
+        this.shareScopeMap = {};
+        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 {
-            module,
-            moduleOptions,
-            remoteMatchInfo: matchInfo
-        };
+        return target;
+    };
+    return _extends$1.apply(this, arguments);
+}
+class RemoteHandler {
+    formatAndRegisterRemote(globalOptions, userOptions) {
+        const userRemotes = userOptions.remotes || [];
+        return userRemotes.reduce((res, remote)=>{
+            this.registerRemote(remote, res, {
+                force: false
+            });
+            return res;
+        }, globalOptions.remotes);
     }
     // eslint-disable-next-line max-lines-per-function
     // eslint-disable-next-line @typescript-eslint/member-ordering
     async loadRemote(id, options) {
+        const { host } = this;
         try {
             const { loadFactory = true } = options || {
                 loadFactory: true
@@ -1370,7 +1476,9 @@ class FederationHost {
             // 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 this._getRemoteModuleAndOptions(id);
+            const { module, moduleOptions, remoteMatchInfo } = await this.getRemoteModuleAndOptions({
+                id
+            });
             const { pkgNameOrAlias, remote, expose, id: idRes } = remoteMatchInfo;
             const moduleOrFactory = await module.get(expose, options);
             const moduleWrapper = await this.hooks.lifecycle.onLoad.emit({
@@ -1382,7 +1490,7 @@ class FederationHost {
                 remote,
                 options: moduleOptions,
                 moduleInstance: module,
-                origin: this
+                origin: host
             });
             if (typeof moduleWrapper === 'function') {
                 return moduleWrapper;
@@ -1396,7 +1504,8 @@ class FederationHost {
                 id,
                 error,
                 from,
-                origin: this
+                lifecycle: 'onLoad',
+                origin: host
             });
             if (!failOver) {
                 throw error;
@@ -1406,18 +1515,19 @@ class FederationHost {
     }
     // eslint-disable-next-line @typescript-eslint/member-ordering
     async preloadRemote(preloadOptions) {
+        const { host } = this;
         await this.hooks.lifecycle.beforePreloadRemote.emit({
             preloadOptions,
-            options: this.options,
-            origin: this
+            options: host.options,
+            origin: host
         });
-        const preloadOps = formatPreloadArgs(this.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 this.snapshotHandler.loadRemoteSnapshotInfo(remote);
+            const { globalSnapshot, remoteSnapshot } = await host.snapshotHandler.loadRemoteSnapshotInfo(remote);
             const assets = await this.hooks.lifecycle.generatePreloadAssets.emit({
-                origin: this,
+                origin: host,
                 preloadOptions: ops,
                 remote,
                 remoteInfo,
@@ -1427,117 +1537,279 @@ class FederationHost {
             if (!assets) {
                 return;
             }
-            preloadAssets(remoteInfo, this, assets);
+            preloadAssets(remoteInfo, host, assets);
         }));
     }
-    /**
-   * This function initializes the sharing sequence (executed only once per share scope).
-   * 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(shareScopeName = share.DEFAULT_SCOPE, strategy) {
-        const shareScope = this.shareScopeMap;
-        const hostName = this.options.name;
-        // Creates a new share scope if necessary
-        if (!shareScope[shareScopeName]) {
-            shareScope[shareScopeName] = {};
-        }
-        // Executes all initialization snippets from all accessible modules
-        const scope = shareScope[shareScopeName];
-        const register = (name, shared)=>{
-            var _activeVersion_shareConfig;
-            const { version, eager } = shared;
-            scope[name] = scope[name] || {};
-            const versions = scope[name];
-            const activeVersion = versions[version];
-            const activeVersionEager = Boolean(activeVersion && (activeVersion.eager || ((_activeVersion_shareConfig = activeVersion.shareConfig) == null ? void 0 : _activeVersion_shareConfig.eager)));
-            if (!activeVersion || activeVersion.strategy !== 'loaded-first' && !activeVersion.loaded && (Boolean(!eager) !== !activeVersionEager ? eager : hostName > activeVersion.from)) {
-                versions[version] = shared;
+    registerRemotes(remotes, options) {
+        const { host } = this;
+        remotes.forEach((remote)=>{
+            this.registerRemote(remote, host.options.remotes, {
+                force: options == null ? void 0 : options.force
+            });
+        });
+    }
+    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;
             }
-        };
-        const promises = [];
-        const initFn = (mod)=>mod && mod.init && mod.init(shareScope[shareScopeName]);
-        const initRemoteModule = async (key)=>{
-            const { module } = await this._getRemoteModuleAndOptions(key);
-            if (module.getEntry) {
-                const entry = await module.getEntry();
-                if (!module.inited) {
-                    initFn(entry);
-                    module.inited = true;
+        }
+        const { id: idRes } = loadRemoteArgs;
+        const remoteSplitInfo = matchRemoteWithNameAndExpose(host.options.remotes, idRes);
+        share.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;
+        share.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(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
+                // As multi-level path references cannot guarantee unique names, alias being a prefix of remote.name is not supported
+                const findEqual = targetRemotes.find((item)=>{
+                    var _item_alias;
+                    return remote.alias && (item.name.startsWith(remote.alias) || ((_item_alias = item.alias) == null ? void 0 : _item_alias.startsWith(remote.alias)));
+                });
+                share.assert(!findEqual, `The alias ${remote.alias} of remote ${remote.name} is not allowed to be the prefix of ${findEqual && findEqual.name} name or alias`);
+            }
+            // Set the remote entry to a complete path
+            if ('entry' in remote) {
+                if (sdk.isBrowserEnv() && !remote.entry.startsWith('http')) {
+                    remote.entry = new URL(remote.entry, window.location.origin).href;
                 }
             }
+            if (!remote.shareScope) {
+                remote.shareScope = share.DEFAULT_SCOPE;
+            }
+            if (!remote.type) {
+                remote.type = share.DEFAULT_REMOTE_TYPE;
+            }
         };
-        Object.keys(this.options.shared).forEach((shareName)=>{
-            const sharedArr = this.options.shared[shareName];
-            sharedArr.forEach((shared)=>{
-                if (shared.scope.includes(shareScopeName)) {
-                    register(shareName, shared);
+        const registeredRemote = targetRemotes.find((item)=>item.name === remote.name);
+        if (!registeredRemote) {
+            normalizeRemote();
+            targetRemotes.push(remote);
+        } else {
+            const messages = [
+                `The remote "${remote.name}" is already registered.`,
+                (options == null ? void 0 : options.force) ? 'Hope you have known that OVERRIDE it may have some unexpected errors' : 'If you want to merge the remote, you can set "force: true".'
+            ];
+            if (options == null ? void 0 : options.force) {
+                // remove registered remote
+                this.removeRemote(registeredRemote);
+                normalizeRemote();
+                targetRemotes.push(remote);
+            }
+            sdk.warn(messages.join(' '));
+        }
+    }
+    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 remoteInfo = loadedModule.remoteInfo;
+            const key = remoteInfo.entryGlobalName;
+            if (globalThis[key]) {
+                delete globalThis[key];
+            }
+            const remoteEntryUniqueKey = getRemoteEntryUniqueKey(loadedModule.remoteInfo);
+            if (share.globalLoading[remoteEntryUniqueKey]) {
+                delete share.globalLoading[remoteEntryUniqueKey];
+            }
+            // delete un loaded shared and instance
+            let remoteInsId = remoteInfo.buildVersion ? sdk.composeKeyWithSeparator(remoteInfo.name, remoteInfo.buildVersion) : remoteInfo.name;
+            const remoteInsIndex = globalThis.__FEDERATION__.__INSTANCES__.findIndex((ins)=>{
+                if (remoteInfo.buildVersion) {
+                    return ins.options.id === remoteInsId;
+                } else {
+                    return ins.name === remoteInsId;
                 }
             });
-        });
-        if (strategy === 'version-first') {
-            this.options.remotes.forEach((remote)=>{
-                if (remote.shareScope === shareScopeName) {
-                    promises.push(initRemoteModule(remote.name));
+            if (remoteInsIndex !== -1) {
+                const remoteIns = globalThis.__FEDERATION__.__INSTANCES__[remoteInsIndex];
+                remoteInsId = remoteIns.options.id || remoteInsId;
+                const globalShareScopeMap = share.getGlobalShareScope();
+                let isAllSharedNotUsed = true;
+                const needDeleteKeys = [];
+                Object.keys(globalShareScopeMap).forEach((instId)=>{
+                    Object.keys(globalShareScopeMap[instId]).forEach((shareScope)=>{
+                        Object.keys(globalShareScopeMap[instId][shareScope]).forEach((shareName)=>{
+                            Object.keys(globalShareScopeMap[instId][shareScope][shareName]).forEach((shareVersion)=>{
+                                const shared = globalShareScopeMap[instId][shareScope][shareName][shareVersion];
+                                if (shared.from === remoteInfo.name) {
+                                    if (shared.loaded || shared.loading) {
+                                        shared.useIn = shared.useIn.filter((usedHostName)=>usedHostName !== remoteInfo.name);
+                                        if (shared.useIn.length) {
+                                            isAllSharedNotUsed = false;
+                                        } else {
+                                            needDeleteKeys.push([
+                                                instId,
+                                                shareScope,
+                                                shareName,
+                                                shareVersion
+                                            ]);
+                                        }
+                                    } else {
+                                        needDeleteKeys.push([
+                                            instId,
+                                            shareScope,
+                                            shareName,
+                                            shareVersion
+                                        ]);
+                                    }
+                                }
+                            });
+                        });
+                    });
+                });
+                if (isAllSharedNotUsed) {
+                    remoteIns.shareScopeMap = {};
+                    delete globalShareScopeMap[remoteInsId];
                 }
-            });
+                needDeleteKeys.forEach(([insId, shareScope, shareName, shareVersion])=>{
+                    var _globalShareScopeMap_insId_shareScope_shareName, _globalShareScopeMap_insId_shareScope, _globalShareScopeMap_insId;
+                    (_globalShareScopeMap_insId = globalShareScopeMap[insId]) == null ? true : (_globalShareScopeMap_insId_shareScope = _globalShareScopeMap_insId[shareScope]) == null ? true : (_globalShareScopeMap_insId_shareScope_shareName = _globalShareScopeMap_insId_shareScope[shareName]) == null ? true : delete _globalShareScopeMap_insId_shareScope_shareName[shareVersion];
+                });
+                globalThis.__FEDERATION__.__INSTANCES__.splice(remoteInsIndex, 1);
+            }
+            host.moduleCache.delete(remote.name);
         }
-        return promises;
     }
-    initShareScopeMap(scopeName, shareScope) {
-        this.shareScopeMap[scopeName] = shareScope;
-        this.hooks.lifecycle.initContainerShareScopeMap.emit({
-            shareScope,
-            options: this.options,
-            origin: this
+    constructor(host){
+        this.hooks = new PluginSystem({
+            beforeRequest: new AsyncWaterfallHook('beforeRequest'),
+            onLoad: new AsyncHook('onLoad'),
+            handlePreloadModule: new SyncHook('handlePreloadModule'),
+            errorLoadRemote: new AsyncHook('errorLoadRemote'),
+            beforePreloadRemote: new AsyncHook(),
+            generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
+            // not used yet
+            afterPreloadRemote: new AsyncHook()
         });
+        this.host = host;
     }
-    formatOptions(globalOptions, userOptions) {
-        const formatShareOptions = share.formatShareConfigs(userOptions.shared || {}, userOptions.name);
-        const shared = _extends({}, globalOptions.shared);
-        Object.keys(formatShareOptions).forEach((shareKey)=>{
-            if (!shared[shareKey]) {
-                shared[shareKey] = formatShareOptions[shareKey];
-            } else {
-                formatShareOptions[shareKey].forEach((newUserSharedOptions)=>{
-                    const isSameVersion = shared[shareKey].find((sharedVal)=>sharedVal.version === newUserSharedOptions.version);
-                    if (!isSameVersion) {
-                        shared[shareKey].push(newUserSharedOptions);
-                    }
-                });
+}
+
+function _extends() {
+    _extends = 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.apply(this, arguments);
+}
+class FederationHost {
+    initOptions(userOptions) {
+        this.registerPlugins(userOptions.plugins);
+        const options = this.formatOptions(this.options, userOptions);
+        this.options = options;
+        return options;
+    }
+    async loadShare(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(pkgName, extraOptions);
+    }
+    initializeSharing(shareScopeName = share.DEFAULT_SCOPE, strategy) {
+        return this.sharedHandler.initializeSharing(shareScopeName, strategy);
+    }
+    initRawContainer(name, url, container) {
+        const remoteInfo = getRemoteInfo({
+            name,
+            entry: url
+        });
+        const module = new Module({
+            host: this,
+            remoteInfo
         });
+        module.remoteEntryExports = container;
+        this.moduleCache.set(name, module);
+        return module;
+    }
+    // eslint-disable-next-line max-lines-per-function
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    async loadRemote(id, options) {
+        return this.remoteHandler.loadRemote(id, options);
+    }
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    async preloadRemote(preloadOptions) {
+        return this.remoteHandler.preloadRemote(preloadOptions);
+    }
+    initShareScopeMap(scopeName, shareScope) {
+        this.sharedHandler.initShareScopeMap(scopeName, shareScope);
+    }
+    formatOptions(globalOptions, userOptions) {
+        const { shared } = share.formatShareConfigs(globalOptions, userOptions);
         const { userOptions: userOptionsRes, options: globalOptionsRes } = this.hooks.lifecycle.beforeInit.emit({
             origin: this,
             userOptions,
             options: globalOptions,
             shareInfo: shared
         });
-        const userRemotes = userOptionsRes.remotes || [];
-        const remotes = userRemotes.reduce((res, remote)=>{
-            this.registerRemote(remote, res, {
-                force: false
-            });
-            return res;
-        }, globalOptionsRes.remotes);
-        // register shared in shareScopeMap
-        const sharedKeys = Object.keys(formatShareOptions);
-        sharedKeys.forEach((sharedKey)=>{
-            const sharedVals = formatShareOptions[sharedKey];
-            sharedVals.forEach((sharedVal)=>{
-                const registeredShared = share.getRegisteredShare(this.shareScopeMap, sharedKey, sharedVal, this.hooks.lifecycle.resolveShare);
-                if (!registeredShared && sharedVal && sharedVal.lib) {
-                    this.setShared({
-                        pkgName: sharedKey,
-                        lib: sharedVal.lib,
-                        get: sharedVal.get,
-                        loaded: true,
-                        shared: sharedVal,
-                        from: userOptions.name
-                    });
-                }
-            });
-        });
+        const remotes = this.remoteHandler.formatAndRegisterRemote(globalOptionsRes, userOptionsRes);
+        const { shared: handledShared } = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes);
         const plugins = [
             ...globalOptionsRes.plugins
         ];
@@ -1551,7 +1823,7 @@ class FederationHost {
         const optionsRes = _extends({}, globalOptions, userOptions, {
             plugins,
             remotes,
-            shared
+            shared: handledShared
         });
         this.hooks.lifecycle.init.emit({
             origin: this,
@@ -1562,6 +1834,8 @@ class FederationHost {
     registerPlugins(plugins) {
         const pluginRes = registerPlugins$1(plugins, [
             this.hooks,
+            this.remoteHandler.hooks,
+            this.sharedHandler.hooks,
             this.snapshotHandler.hooks,
             this.loaderHook
         ]);
@@ -1574,132 +1848,19 @@ class FederationHost {
             return res;
         }, pluginRes || []);
     }
-    setShared({ pkgName, shared, from, lib, loading, loaded, get }) {
-        const { version, scope = 'default' } = shared, shareInfo = _object_without_properties_loose(shared, [
-            "version",
-            "scope"
-        ]);
-        const scopes = Array.isArray(scope) ? scope : [
-            scope
-        ];
-        scopes.forEach((sc)=>{
-            if (!this.shareScopeMap[sc]) {
-                this.shareScopeMap[sc] = {};
-            }
-            if (!this.shareScopeMap[sc][pkgName]) {
-                this.shareScopeMap[sc][pkgName] = {};
-            }
-            if (this.shareScopeMap[sc][pkgName][version]) {
-                return;
-            }
-            this.shareScopeMap[sc][pkgName][version] = _extends({
-                version,
-                scope: [
-                    'default'
-                ]
-            }, shareInfo, {
-                lib,
-                loaded,
-                loading
-            });
-            if (get) {
-                this.shareScopeMap[sc][pkgName][version].get = get;
-            }
-        });
-    }
-    removeRemote(remote) {
-        const { name } = remote;
-        const remoteIndex = this.options.remotes.findIndex((item)=>item.name === name);
-        if (remoteIndex !== -1) {
-            this.options.remotes.splice(remoteIndex, 1);
-        }
-        const loadedModule = this.moduleCache.get(remote.name);
-        if (loadedModule) {
-            const key = loadedModule.remoteInfo.entryGlobalName;
-            if (globalThis[key]) {
-                delete globalThis[key];
-            }
-            const remoteEntryUniqueKey = getRemoteEntryUniqueKey(loadedModule.remoteInfo);
-            if (share.globalLoading[remoteEntryUniqueKey]) {
-                delete share.globalLoading[remoteEntryUniqueKey];
-            }
-            this.moduleCache.delete(remote.name);
-        }
-    }
-    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
-                // As multi-level path references cannot guarantee unique names, alias being a prefix of remote.name is not supported
-                const findEqual = targetRemotes.find((item)=>{
-                    var _item_alias;
-                    return remote.alias && (item.name.startsWith(remote.alias) || ((_item_alias = item.alias) == null ? void 0 : _item_alias.startsWith(remote.alias)));
-                });
-                share.assert(!findEqual, `The alias ${remote.alias} of remote ${remote.name} is not allowed to be the prefix of ${findEqual && findEqual.name} name or alias`);
-            }
-            // Set the remote entry to a complete path
-            if ('entry' in remote) {
-                if (share.isBrowserEnv() && !remote.entry.startsWith('http')) {
-                    remote.entry = new URL(remote.entry, window.location.origin).href;
-                }
-            }
-            if (!remote.shareScope) {
-                remote.shareScope = share.DEFAULT_SCOPE;
-            }
-            if (!remote.type) {
-                remote.type = share.DEFAULT_REMOTE_TYPE;
-            }
-        };
-        const registeredRemote = targetRemotes.find((item)=>item.name === remote.name);
-        if (!registeredRemote) {
-            normalizeRemote();
-            targetRemotes.push(remote);
-        } else {
-            const messages = [
-                `The remote "${remote.name}" is already registered.`,
-                (options == null ? void 0 : options.force) ? 'Hope you have known that OVERRIDE it may have some unexpected errors' : 'If you want to merge the remote, you can set "force: true".'
-            ];
-            if (options == null ? void 0 : options.force) {
-                // remove registered remote
-                this.removeRemote(registeredRemote);
-                normalizeRemote();
-                targetRemotes.push(remote);
-            }
-            share.warn(messages.join(' '));
-        }
-    }
     registerRemotes(remotes, options) {
-        remotes.forEach((remote)=>{
-            this.registerRemote(remote, this.options.remotes, {
-                force: options == null ? void 0 : options.force
-            });
-        });
+        return this.remoteHandler.registerRemotes(remotes, options);
     }
     constructor(userOptions){
         this.hooks = new PluginSystem({
             beforeInit: new SyncWaterfallHook('beforeInit'),
             init: new SyncHook(),
-            beforeRequest: new AsyncWaterfallHook('beforeRequest'),
-            afterResolve: new AsyncWaterfallHook('afterResolve'),
             // maybe will change, temporarily for internal use only
             beforeInitContainer: new AsyncWaterfallHook('beforeInitContainer'),
             // maybe will change, temporarily for internal use only
-            initContainerShareScopeMap: new AsyncWaterfallHook('initContainer'),
-            // maybe will change, temporarily for internal use only
-            initContainer: new AsyncWaterfallHook('initContainer'),
-            onLoad: new AsyncHook('onLoad'),
-            handlePreloadModule: new SyncHook('handlePreloadModule'),
-            errorLoadRemote: new AsyncHook('errorLoadRemote'),
-            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
-            // not used yet
-            loadShare: new AsyncHook(),
-            resolveShare: new SyncWaterfallHook('resolveShare'),
-            beforePreloadRemote: new AsyncHook(),
-            generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
-            // not used yet
-            afterPreloadRemote: new AsyncHook()
+            initContainer: new AsyncWaterfallHook('initContainer')
         });
-        this.version = "0.1.11";
+        this.version = "0.1.13";
         this.moduleCache = new Map();
         this.loaderHook = new PluginSystem({
             // FIXME: may not be suitable , not open to the public yet
@@ -1724,9 +1885,10 @@ class FederationHost {
         };
         this.name = userOptions.name;
         this.options = defaultOptions;
-        this.shareScopeMap = {};
-        this._setGlobalShareScopeMap();
         this.snapshotHandler = new SnapshotHandler(this);
+        this.sharedHandler = new SharedHandler(this);
+        this.remoteHandler = new RemoteHandler(this);
+        this.shareScopeMap = this.sharedHandler.shareScopeMap;
         this.registerPlugins([
             ...defaultOptions.plugins,
             ...userOptions.plugins || []