@module-federation/runtime 0.0.0-next-20240830100524 → 0.0.0-next-20240902023803

package/dist/index.cjs.js

@@ -2,8 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var share = require('./share.cjs.js');
+var _extends = require('@swc/helpers/_/_extends');
 var sdk = require('@module-federation/sdk');
+var share = require('./share.cjs.js');
+var _object_without_properties_loose = require('@swc/helpers/_/_object_without_properties_loose');
 
 // Function to match a remote with its name and expose
 // id: pkgName(@federation/app1) + expose(button) = @federation/app1/button
@@ -69,20 +71,26 @@ function matchRemote(remotes, nameOrAlias) {
     return;
 }
 
-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){
-                if (Object.prototype.hasOwnProperty.call(source, key)) {
-                    target[key] = source[key];
-                }
+function registerPlugins$1(plugins, hookInstances) {
+    const globalPlugins = share.getGlobalHostPlugins();
+    // Incorporate global plugins
+    if (globalPlugins.length > 0) {
+        globalPlugins.forEach((plugin)=>{
+            if (plugins == null ? void 0 : plugins.find((item)=>item.name !== plugin.name)) {
+                plugins.push(plugin);
             }
-        }
-        return target;
-    };
-    return _extends$7.apply(this, arguments);
+        });
+    }
+    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 {
@@ -245,7 +253,7 @@ async function getRemoteEntry({ origin, remoteEntryExports, remoteInfo }) {
     return share.globalLoading[uniqueKey];
 }
 function getRemoteInfo(remote) {
-    return _extends$7({}, remote, {
+    return _extends._({}, remote, {
         entry: 'entry' in remote ? remote.entry : '',
         type: remote.type || share.DEFAULT_REMOTE_TYPE,
         entryGlobalName: remote.entryGlobalName || remote.name,
@@ -253,20 +261,6 @@ function getRemoteInfo(remote) {
     });
 }
 
-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){
-                if (Object.prototype.hasOwnProperty.call(source, key)) {
-                    target[key] = source[key];
-                }
-            }
-        }
-        return target;
-    };
-    return _extends$6.apply(this, arguments);
-}
 let Module = class Module {
     async getEntry() {
         if (this.remoteEntryExports) {
@@ -278,7 +272,7 @@ let Module = class Module {
             remoteInfo: this.remoteInfo,
             remoteEntryExports: this.remoteEntryExports
         });
-        share.assert(remoteEntryExports, `remoteEntryExports is undefined \n ${share.safeToString(this.remoteInfo)}`);
+        share.assert(remoteEntryExports, `remoteEntryExports is undefined \n ${sdk.safeToString(this.remoteInfo)}`);
         this.remoteEntryExports = remoteEntryExports;
         return this.remoteEntryExports;
     }
@@ -318,7 +312,7 @@ let Module = class Module {
                 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.');
             }
             await remoteEntryExports.init(initContainerOptions.shareScope, initContainerOptions.initScope, initContainerOptions.remoteEntryInitOptions);
-            await this.host.hooks.lifecycle.initContainer.emit(_extends$6({}, initContainerOptions, {
+            await this.host.hooks.lifecycle.initContainer.emit(_extends._({}, initContainerOptions, {
                 remoteEntryExports
             }));
         }
@@ -367,22 +361,195 @@ let Module = class Module {
     }
 };
 
-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){
-                if (Object.prototype.hasOwnProperty.call(source, key)) {
-                    target[key] = source[key];
+class SyncHook {
+    on(fn) {
+        if (typeof fn === 'function') {
+            this.listeners.add(fn);
+        }
+    }
+    once(fn) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        this.on(function wrapper(...args) {
+            self.remove(wrapper);
+            // eslint-disable-next-line prefer-spread
+            return fn.apply(null, args);
+        });
+    }
+    emit(...data) {
+        let result;
+        if (this.listeners.size > 0) {
+            // eslint-disable-next-line prefer-spread
+            this.listeners.forEach((fn)=>{
+                result = fn(...data);
+            });
+        }
+        return result;
+    }
+    remove(fn) {
+        this.listeners.delete(fn);
+    }
+    removeAll() {
+        this.listeners.clear();
+    }
+    constructor(type){
+        this.type = '';
+        this.listeners = new Set();
+        if (type) {
+            this.type = type;
+        }
+    }
+}
+
+class AsyncHook extends SyncHook {
+    emit(...data) {
+        let result;
+        const ls = Array.from(this.listeners);
+        if (ls.length > 0) {
+            let i = 0;
+            const call = (prev)=>{
+                if (prev === false) {
+                    return false; // Abort process
+                } else if (i < ls.length) {
+                    return Promise.resolve(ls[i++].apply(null, data)).then(call);
+                } else {
+                    return prev;
                 }
+            };
+            result = call();
+        }
+        return Promise.resolve(result);
+    }
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function checkReturnData(originalData, returnedData) {
+    if (!share.isObject(returnedData)) {
+        return false;
+    }
+    if (originalData !== returnedData) {
+        // eslint-disable-next-line no-restricted-syntax
+        for(const key in originalData){
+            if (!(key in returnedData)) {
+                return false;
             }
         }
-        return target;
-    };
-    return _extends$5.apply(this, arguments);
+    }
+    return true;
+}
+class SyncWaterfallHook extends SyncHook {
+    emit(data) {
+        if (!share.isObject(data)) {
+            share.error(`The data for the "${this.type}" hook should be an object.`);
+        }
+        for (const fn of this.listeners){
+            try {
+                const tempData = fn(data);
+                if (checkReturnData(data, tempData)) {
+                    data = tempData;
+                } else {
+                    this.onerror(`A plugin returned an unacceptable value for the "${this.type}" type.`);
+                    break;
+                }
+            } catch (e) {
+                share.warn(e);
+                this.onerror(e);
+            }
+        }
+        return data;
+    }
+    constructor(type){
+        super();
+        this.onerror = share.error;
+        this.type = type;
+    }
+}
+
+class AsyncWaterfallHook extends SyncHook {
+    emit(data) {
+        if (!share.isObject(data)) {
+            share.error(`The response data for the "${this.type}" hook must be an object.`);
+        }
+        const ls = Array.from(this.listeners);
+        if (ls.length > 0) {
+            let i = 0;
+            const processError = (e)=>{
+                share.warn(e);
+                this.onerror(e);
+                return data;
+            };
+            const call = (prevData)=>{
+                if (checkReturnData(data, prevData)) {
+                    data = prevData;
+                    if (i < ls.length) {
+                        try {
+                            return Promise.resolve(ls[i++](data)).then(call, processError);
+                        } catch (e) {
+                            return processError(e);
+                        }
+                    }
+                } else {
+                    this.onerror(`A plugin returned an incorrect value for the "${this.type}" type.`);
+                }
+                return data;
+            };
+            return Promise.resolve(call(data));
+        }
+        return Promise.resolve(data);
+    }
+    constructor(type){
+        super();
+        this.onerror = share.error;
+        this.type = type;
+    }
+}
+
+class PluginSystem {
+    applyPlugin(plugin) {
+        share.assert(share.isPlainObject(plugin), 'Plugin configuration is invalid.');
+        // The plugin's name is mandatory and must be unique
+        const pluginName = plugin.name;
+        share.assert(pluginName, 'A name must be provided by the plugin.');
+        if (!this.registerPlugins[pluginName]) {
+            this.registerPlugins[pluginName] = plugin;
+            Object.keys(this.lifecycle).forEach((key)=>{
+                const pluginLife = plugin[key];
+                if (pluginLife) {
+                    this.lifecycle[key].on(pluginLife);
+                }
+            });
+        }
+    }
+    removePlugin(pluginName) {
+        share.assert(pluginName, 'A name is required.');
+        const plugin = this.registerPlugins[pluginName];
+        share.assert(plugin, `The plugin "${pluginName}" is not registered.`);
+        Object.keys(plugin).forEach((key)=>{
+            if (key !== 'name') {
+                this.lifecycle[key].remove(plugin[key]);
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    inherit({ lifecycle, registerPlugins }) {
+        Object.keys(lifecycle).forEach((hookName)=>{
+            share.assert(!this.lifecycle[hookName], `The hook "${hookName}" has a conflict and cannot be inherited.`);
+            this.lifecycle[hookName] = lifecycle[hookName];
+        });
+        Object.keys(registerPlugins).forEach((pluginName)=>{
+            share.assert(!this.registerPlugins[pluginName], `The plugin "${pluginName}" has a conflict and cannot be inherited.`);
+            this.applyPlugin(registerPlugins[pluginName]);
+        });
+    }
+    constructor(lifecycle){
+        this.registerPlugins = {};
+        this.lifecycle = lifecycle;
+        this.lifecycleKeys = Object.keys(lifecycle);
+    }
 }
+
 function defaultPreloadArgs(preloadConfig) {
-    return _extends$5({
+    return _extends._({
         resourceCategory: 'sync',
         share: true,
         depsRemote: true,
@@ -392,7 +559,7 @@ function defaultPreloadArgs(preloadConfig) {
 function formatPreloadArgs(remotes, preloadArgs) {
     return preloadArgs.map((args)=>{
         const remoteInfo = matchRemote(remotes, args.nameOrAlias);
-        share.assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo && share.safeToString({
+        share.assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo && sdk.safeToString({
             remoteInfo,
             remotes
         })}`);
@@ -538,27 +705,13 @@ useLinkPreload = true) {
     }
 }
 
-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){
-                if (Object.prototype.hasOwnProperty.call(source, key)) {
-                    target[key] = source[key];
-                }
-            }
-        }
-        return target;
-    };
-    return _extends$4.apply(this, arguments);
-}
 function assignRemoteInfo(remoteInfo, remoteSnapshot) {
     const remoteEntryInfo = share.getRemoteEntryInfoFromSnapshot(remoteSnapshot);
     if (!remoteEntryInfo.url) {
         share.error(`The attribute remoteEntry of ${remoteInfo.name} must not be undefined.`);
     }
     let entryUrl = sdk.getResourceUrl(remoteSnapshot, remoteEntryInfo.url);
-    if (!share.isBrowserEnv() && !entryUrl.startsWith('http')) {
+    if (!sdk.isBrowserEnv() && !entryUrl.startsWith('http')) {
         entryUrl = `https:${entryUrl}`;
     }
     remoteInfo.type = remoteEntryInfo.type;
@@ -599,7 +752,7 @@ function snapshotPlugin() {
                 if (assets) {
                     preloadAssets(remoteInfo, origin, assets, false);
                 }
-                return _extends$4({}, args, {
+                return _extends._({}, args, {
                     remoteSnapshot
                 });
             }
@@ -820,20 +973,6 @@ const generatePreloadAssetsPlugin = function() {
     };
 };
 
-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){
-                if (Object.prototype.hasOwnProperty.call(source, key)) {
-                    target[key] = source[key];
-                }
-            }
-        }
-        return target;
-    };
-    return _extends$3.apply(this, arguments);
-}
 function getGlobalRemoteInfo(moduleInfo, origin) {
     const hostGlobalSnapshot = share.getGlobalSnapshotInfoByModuleInfo({
         name: origin.options.name,
@@ -901,7 +1040,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$3({}, hostSnapshot == null ? void 0 : hostSnapshot.remotesInfo, {
+                hostSnapshot.remotesInfo = _extends._({}, hostSnapshot == null ? void 0 : hostSnapshot.remotesInfo, {
                     [moduleInfo.name]: {
                         matchedVersion: 'version' in moduleInfo ? moduleInfo.version : moduleInfo.entry
                     }
@@ -916,21 +1055,21 @@ class SnapshotHandler {
             remoteSnapshot,
             globalSnapshot
         });
-        let mSnapshot;
-        let gSnapshot;
         // global snapshot includes manifest or module info includes manifest
         if (globalRemoteSnapshot) {
             if (sdk.isManifestProvider(globalRemoteSnapshot)) {
-                const remoteEntry = share.isBrowserEnv() ? globalRemoteSnapshot.remoteEntry : globalRemoteSnapshot.ssrRemoteEntry || globalRemoteSnapshot.remoteEntry || '';
+                const remoteEntry = sdk.isBrowserEnv() ? globalRemoteSnapshot.remoteEntry : globalRemoteSnapshot.ssrRemoteEntry || globalRemoteSnapshot.remoteEntry || '';
                 const moduleSnapshot = await this.getManifestJson(remoteEntry, moduleInfo, {});
                 // eslint-disable-next-line @typescript-eslint/no-shadow
-                const globalSnapshotRes = share.setGlobalSnapshotInfoByModuleInfo(_extends$3({}, moduleInfo, {
+                const globalSnapshotRes = share.setGlobalSnapshotInfoByModuleInfo(_extends._({}, moduleInfo, {
                     // The global remote may be overridden
                     // 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,
@@ -938,8 +1077,10 @@ class SnapshotHandler {
                     remoteSnapshot: globalRemoteSnapshot,
                     from: 'global'
                 });
-                mSnapshot = remoteSnapshotRes;
-                gSnapshot = globalSnapshotRes;
+                return {
+                    remoteSnapshot: remoteSnapshotRes,
+                    globalSnapshot: globalSnapshotRes
+                };
             }
         } else {
             if (share.isRemoteInfoWithEntry(moduleInfo)) {
@@ -953,8 +1094,10 @@ class SnapshotHandler {
                     remoteSnapshot: moduleSnapshot,
                     from: 'global'
                 });
-                mSnapshot = remoteSnapshotRes;
-                gSnapshot = globalSnapshotRes;
+                return {
+                    remoteSnapshot: remoteSnapshotRes,
+                    globalSnapshot: globalSnapshotRes
+                };
             } else {
                 share.error(`
           Cannot get remoteSnapshot with the name: '${moduleInfo.name}', version: '${moduleInfo.version}' from __FEDERATION__.moduleInfo. The following reasons may be causing the problem:\n
@@ -964,15 +1107,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);
@@ -1022,11 +1156,10 @@ class SnapshotHandler {
     constructor(HostInstance){
         this.loadingHostSnapshot = null;
         this.manifestCache = new Map();
-        this.hooks = new share.PluginSystem({
-            beforeLoadRemoteSnapshot: new share.AsyncHook('beforeLoadRemoteSnapshot'),
-            loadSnapshot: new share.AsyncWaterfallHook('loadGlobalSnapshot'),
-            loadRemoteSnapshot: new share.AsyncWaterfallHook('loadRemoteSnapshot'),
-            afterLoadSnapshot: new share.AsyncWaterfallHook('afterLoadSnapshot')
+        this.hooks = new PluginSystem({
+            beforeLoadRemoteSnapshot: new AsyncHook('beforeLoadRemoteSnapshot'),
+            loadSnapshot: new AsyncWaterfallHook('loadGlobalSnapshot'),
+            loadRemoteSnapshot: new AsyncWaterfallHook('loadRemoteSnapshot')
         });
         this.manifestLoading = share.Global.__FEDERATION__.__MANIFEST_LOADING__;
         this.HostInstance = HostInstance;
@@ -1034,32 +1167,6 @@ class SnapshotHandler {
     }
 }
 
-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){
-                if (Object.prototype.hasOwnProperty.call(source, key)) {
-                    target[key] = source[key];
-                }
-            }
-        }
-        return target;
-    };
-    return _extends$2.apply(this, arguments);
-}
-function _object_without_properties_loose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for(i = 0; i < sourceKeys.length; i++){
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        target[key] = source[key];
-    }
-    return target;
-}
 class SharedHandler {
     // register shared in shareScopeMap
     registerShared(globalOptions, userOptions) {
@@ -1099,7 +1206,9 @@ class SharedHandler {
         });
         if (shareInfo == null ? void 0 : shareInfo.scope) {
             await Promise.all(shareInfo.scope.map(async (shareScope)=>{
-                await Promise.all(this.initializeSharing(shareScope, shareInfo.strategy));
+                await Promise.all(this.initializeSharing(shareScope, {
+                    strategy: shareInfo.strategy
+                }));
                 return;
             }));
         }
@@ -1187,8 +1296,22 @@ 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(shareScopeName = share.DEFAULT_SCOPE, strategy) {
+    initializeSharing(shareScopeName = share.DEFAULT_SCOPE, extraOptions) {
         const { host } = this;
+        const from = extraOptions == null ? void 0 : extraOptions.from;
+        const strategy = extraOptions == null ? void 0 : extraOptions.strategy;
+        let initScope = extraOptions == null ? void 0 : extraOptions.initScope;
+        const promises = [];
+        if (from !== 'build') {
+            const { initTokens } = this;
+            if (!initScope) initScope = [];
+            let initToken = initTokens[shareScopeName];
+            if (!initToken) initToken = initTokens[shareScopeName] = {
+                from: this.host.name
+            };
+            if (initScope.indexOf(initToken) >= 0) return promises;
+            initScope.push(initToken);
+        }
         const shareScope = this.shareScopeMap;
         const hostName = host.options.name;
         // Creates a new share scope if necessary
@@ -1208,8 +1331,7 @@ class SharedHandler {
                 versions[version] = shared;
             }
         };
-        const promises = [];
-        const initFn = (mod)=>mod && mod.init && mod.init(shareScope[shareScopeName]);
+        const initFn = (mod)=>mod && mod.init && mod.init(shareScope[shareScopeName], initScope);
         const initRemoteModule = async (key)=>{
             const { module } = await host.remoteHandler.getRemoteModuleAndOptions({
                 id: key
@@ -1217,7 +1339,7 @@ class SharedHandler {
             if (module.getEntry) {
                 const entry = await module.getEntry();
                 if (!module.inited) {
-                    initFn(entry);
+                    await initFn(entry);
                     module.inited = true;
                 }
             }
@@ -1253,7 +1375,9 @@ class SharedHandler {
         });
         if (shareInfo == null ? void 0 : shareInfo.scope) {
             shareInfo.scope.forEach((shareScope)=>{
-                this.initializeSharing(shareScope, shareInfo.strategy);
+                this.initializeSharing(shareScope, {
+                    strategy: shareInfo.strategy
+                });
             });
         }
         const registeredShared = share.getRegisteredShare(this.shareScopeMap, pkgName, shareInfo, this.hooks.lifecycle.resolveShare);
@@ -1334,7 +1458,7 @@ class SharedHandler {
         });
     }
     setShared({ pkgName, shared, from, lib, loading, loaded, get }) {
-        const { version, scope = 'default' } = shared, shareInfo = _object_without_properties_loose(shared, [
+        const { version, scope = 'default' } = shared, shareInfo = _object_without_properties_loose._(shared, [
             "version",
             "scope"
         ]);
@@ -1351,7 +1475,7 @@ class SharedHandler {
             if (this.shareScopeMap[sc][pkgName][version]) {
                 return;
             }
-            this.shareScopeMap[sc][pkgName][version] = _extends$2({
+            this.shareScopeMap[sc][pkgName][version] = _extends._({
                 version,
                 scope: [
                     'default'
@@ -1374,35 +1498,22 @@ class SharedHandler {
         }
     }
     constructor(host){
-        this.hooks = new share.PluginSystem({
-            afterResolve: new share.AsyncWaterfallHook('afterResolve'),
-            beforeLoadShare: new share.AsyncWaterfallHook('beforeLoadShare'),
+        this.hooks = new PluginSystem({
+            afterResolve: new AsyncWaterfallHook('afterResolve'),
+            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
             // not used yet
-            loadShare: new share.AsyncHook(),
-            resolveShare: new share.SyncWaterfallHook('resolveShare'),
+            loadShare: new AsyncHook(),
+            resolveShare: new SyncWaterfallHook('resolveShare'),
             // maybe will change, temporarily for internal use only
-            initContainerShareScopeMap: new share.SyncWaterfallHook('initContainerShareScopeMap')
+            initContainerShareScopeMap: new SyncWaterfallHook('initContainerShareScopeMap')
         });
         this.host = host;
         this.shareScopeMap = {};
+        this.initTokens = {};
         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 {
     formatAndRegisterRemote(globalOptions, userOptions) {
         const userRemotes = userOptions.remotes || [];
@@ -1559,7 +1670,7 @@ class RemoteHandler {
       `);
         const { remote: rawRemote } = remoteSplitInfo;
         const remoteInfo = getRemoteInfo(rawRemote);
-        const matchInfo = await host.sharedHandler.hooks.lifecycle.afterResolve.emit(_extends$1({
+        const matchInfo = await host.sharedHandler.hooks.lifecycle.afterResolve.emit(_extends._({
             id: idRes
         }, remoteSplitInfo, {
             options: host.options,
@@ -1728,7 +1839,8 @@ class RemoteHandler {
                     const remoteKey = hostGlobalSnapshot && 'remotesInfo' in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && share.getInfoWithoutType(hostGlobalSnapshot.remotesInfo, remote.name).key;
                     if (remoteKey) {
                         delete hostGlobalSnapshot.remotesInfo[remoteKey];
-                        if (Boolean(share.Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey])) {
+                        if (//eslint-disable-next-line no-extra-boolean-cast
+                        Boolean(share.Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey])) {
                             delete share.Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey];
                         }
                     }
@@ -1740,38 +1852,24 @@ class RemoteHandler {
         }
     }
     constructor(host){
-        this.hooks = new share.PluginSystem({
-            beforeRegisterRemote: new share.SyncWaterfallHook('beforeRegisterRemote'),
-            registerRemote: new share.SyncWaterfallHook('registerRemote'),
-            beforeRequest: new share.AsyncWaterfallHook('beforeRequest'),
-            onLoad: new share.AsyncHook('onLoad'),
-            handlePreloadModule: new share.SyncHook('handlePreloadModule'),
-            errorLoadRemote: new share.AsyncHook('errorLoadRemote'),
-            beforePreloadRemote: new share.AsyncHook('beforePreloadRemote'),
-            generatePreloadAssets: new share.AsyncHook('generatePreloadAssets'),
+        this.hooks = new PluginSystem({
+            beforeRegisterRemote: new SyncWaterfallHook('beforeRegisterRemote'),
+            registerRemote: new SyncWaterfallHook('registerRemote'),
+            beforeRequest: new AsyncWaterfallHook('beforeRequest'),
+            onLoad: new AsyncHook('onLoad'),
+            handlePreloadModule: new SyncHook('handlePreloadModule'),
+            errorLoadRemote: new AsyncHook('errorLoadRemote'),
+            beforePreloadRemote: new AsyncHook('beforePreloadRemote'),
+            generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
             // not used yet
-            afterPreloadRemote: new share.AsyncHook(),
-            loadEntry: new share.AsyncHook()
+            afterPreloadRemote: new AsyncHook(),
+            loadEntry: new AsyncHook()
         });
         this.host = host;
         this.idToRemoteMap = {};
     }
 }
 
-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);
@@ -1789,8 +1887,8 @@ class FederationHost {
     loadShareSync(pkgName, extraOptions) {
         return this.sharedHandler.loadShareSync(pkgName, extraOptions);
     }
-    initializeSharing(shareScopeName = share.DEFAULT_SCOPE, strategy) {
-        return this.sharedHandler.initializeSharing(shareScopeName, strategy);
+    initializeSharing(shareScopeName = share.DEFAULT_SCOPE, extraOptions) {
+        return this.sharedHandler.initializeSharing(shareScopeName, extraOptions);
     }
     initRawContainer(name, url, container) {
         const remoteInfo = getRemoteInfo({
@@ -1837,7 +1935,7 @@ class FederationHost {
                 }
             });
         }
-        const optionsRes = _extends({}, globalOptions, userOptions, {
+        const optionsRes = _extends._({}, globalOptions, userOptions, {
             plugins,
             remotes,
             shared: handledShared
@@ -1849,7 +1947,7 @@ class FederationHost {
         return optionsRes;
     }
     registerPlugins(plugins) {
-        const pluginRes = share.registerPlugins(plugins, [
+        const pluginRes = registerPlugins$1(plugins, [
             this.hooks,
             this.remoteHandler.hooks,
             this.sharedHandler.hooks,
@@ -1869,23 +1967,23 @@ class FederationHost {
         return this.remoteHandler.registerRemotes(remotes, options);
     }
     constructor(userOptions){
-        this.hooks = new share.PluginSystem({
-            beforeInit: new share.SyncWaterfallHook('beforeInit'),
-            init: new share.SyncHook(),
+        this.hooks = new PluginSystem({
+            beforeInit: new SyncWaterfallHook('beforeInit'),
+            init: new SyncHook(),
             // maybe will change, temporarily for internal use only
-            beforeInitContainer: new share.AsyncWaterfallHook('beforeInitContainer'),
+            beforeInitContainer: new AsyncWaterfallHook('beforeInitContainer'),
             // maybe will change, temporarily for internal use only
-            initContainer: new share.AsyncWaterfallHook('initContainer')
+            initContainer: new AsyncWaterfallHook('initContainer')
         });
-        this.version = "0.5.1";
+        this.version = "0.6.0";
         this.moduleCache = new Map();
-        this.loaderHook = new share.PluginSystem({
+        this.loaderHook = new PluginSystem({
             // FIXME: may not be suitable , not open to the public yet
-            getModuleInfo: new share.SyncHook(),
-            createScript: new share.SyncHook(),
-            createLink: new share.SyncHook(),
+            getModuleInfo: new SyncHook(),
+            createScript: new SyncHook(),
+            createLink: new SyncHook(),
             // only work for manifest , so not open to the public yet
-            fetch: new share.AsyncHook()
+            fetch: new AsyncHook()
         });
         // TODO: Validate the details of the options
         // Initialize options with default values
@@ -1898,7 +1996,7 @@ class FederationHost {
             ],
             remotes: [],
             shared: {},
-            inBrowser: share.isBrowserEnv()
+            inBrowser: sdk.isBrowserEnv()
         };
         this.name = userOptions.name;
         this.options = defaultOptions;
@@ -1972,7 +2070,6 @@ function getInstance() {
 // Inject for debug
 share.setGlobalFederationConstructor(FederationHost);
 
-exports.registerGlobalPlugins = share.registerGlobalPlugins;
 Object.defineProperty(exports, 'loadScript', {
   enumerable: true,
   get: function () { return sdk.loadScript; }
@@ -1981,6 +2078,7 @@ Object.defineProperty(exports, 'loadScriptNode', {
   enumerable: true,
   get: function () { return sdk.loadScriptNode; }
 });
+exports.registerGlobalPlugins = share.registerGlobalPlugins;
 exports.FederationHost = FederationHost;
 exports.getInstance = getInstance;
 exports.getRemoteEntry = getRemoteEntry;