@module-federation/runtime 0.0.0-next-20241015065721 → 0.0.0-next-20241016071233

package/dist/embedded.cjs.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 function getRuntime() {
     // @ts-ignore
     const runtime = __webpack_require__.federation.runtime;

package/dist/embedded.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/embedded";

package/dist/helpers.cjs.js

@@ -1,17 +1,8 @@
 'use strict';
 
 var share = require('./share.cjs.js');
-require('@module-federation/sdk');
 require('./polyfills.cjs.js');
-
-var pluginHelper = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  SyncHook: share.SyncHook,
-  AsyncHook: share.AsyncHook,
-  SyncWaterfallHook: share.SyncWaterfallHook,
-  AsyncWaterfallHook: share.AsyncWaterfallHook,
-  PluginSystem: share.PluginSystem
-});
+require('@module-federation/sdk');
 
 const ShareUtils = {
     getRegisteredShare: share.getRegisteredShare,
@@ -35,9 +26,7 @@ const GlobalUtils = {
     registerGlobalPlugins: share.registerGlobalPlugins,
     getGlobalHostPlugins: share.getGlobalHostPlugins,
     getPreloaded: share.getPreloaded,
-    setPreloaded: share.setPreloaded,
-    registerPlugins: share.registerPlugins,
-    pluginHelper
+    setPreloaded: share.setPreloaded
 };
 var helpers = {
     global: GlobalUtils,

package/dist/helpers.esm.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/helpers";
+export { default } from "./src/helpers";

package/dist/helpers.esm.js

@@ -1,15 +1,6 @@
-import { y as SyncHook, A as AsyncHook, S as SyncWaterfallHook, r as AsyncWaterfallHook, P as PluginSystem, l as getRegisteredShare, w as getGlobalShareScope, G as Global, J as nativeGlobal, K as resetFederationGlobalInfo, E as getGlobalFederationInstance, H as setGlobalFederationInstance, F as getGlobalFederationConstructor, C as setGlobalFederationConstructor, j as getInfoWithoutType, t as getGlobalSnapshot, L as getTargetSnapshotInfoByModuleInfo, n as getGlobalSnapshotInfoByModuleInfo, q as setGlobalSnapshotInfoByModuleInfo, o as addGlobalSnapshot, b as getRemoteEntryExports, I as registerGlobalPlugins, M as getGlobalHostPlugins, k as getPreloaded, s as setPreloaded, z as registerPlugins } from './share.esm.js';
-import '@module-federation/sdk';
+import { g as getRegisteredShare, a as getGlobalShareScope, G as Global, n as nativeGlobal, r as resetFederationGlobalInfo, b as getGlobalFederationInstance, s as setGlobalFederationInstance, c as getGlobalFederationConstructor, d as setGlobalFederationConstructor, e as getInfoWithoutType, f as getGlobalSnapshot, h as getTargetSnapshotInfoByModuleInfo, i as getGlobalSnapshotInfoByModuleInfo, j as setGlobalSnapshotInfoByModuleInfo, k as addGlobalSnapshot, l as getRemoteEntryExports, m as registerGlobalPlugins, o as getGlobalHostPlugins, p as getPreloaded, q as setPreloaded } from './share.esm.js';
 import './polyfills.esm.js';
-
-var pluginHelper = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  SyncHook: SyncHook,
-  AsyncHook: AsyncHook,
-  SyncWaterfallHook: SyncWaterfallHook,
-  AsyncWaterfallHook: AsyncWaterfallHook,
-  PluginSystem: PluginSystem
-});
+import '@module-federation/sdk';
 
 const ShareUtils = {
     getRegisteredShare,
@@ -33,9 +24,7 @@ const GlobalUtils = {
     registerGlobalPlugins,
     getGlobalHostPlugins,
     getPreloaded,
-    setPreloaded,
-    registerPlugins,
-    pluginHelper
+    setPreloaded
 };
 var helpers = {
     global: GlobalUtils,

package/dist/index.cjs.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var polyfills = require('./polyfills.cjs.js');
 var sdk = require('@module-federation/sdk');
 var share = require('./share.cjs.js');
@@ -70,15 +68,31 @@ function matchRemote(remotes, nameOrAlias) {
     return;
 }
 
+function registerPlugins$1(plugins, hookInstances) {
+    const globalPlugins = share.getGlobalHostPlugins();
+    // Incorporate global plugins
+    if (globalPlugins.length > 0) {
+        globalPlugins.forEach((plugin)=>{
+            if (plugins == null ? void 0 : plugins.find((item)=>item.name !== plugin.name)) {
+                plugins.push(plugin);
+            }
+        });
+    }
+    if (plugins && plugins.length > 0) {
+        plugins.forEach((plugin)=>{
+            hookInstances.forEach((hookInstance)=>{
+                hookInstance.applyPlugin(plugin);
+            });
+        });
+    }
+    return plugins;
+}
+
 async function loadEsmEntry({ entry, remoteEntryExports }) {
     return new Promise((resolve, reject)=>{
         try {
             if (!remoteEntryExports) {
-                // eslint-disable-next-line no-eval
-                new Function('callbacks', `import("${entry}").then(callbacks[0]).catch(callbacks[1])`)([
-                    resolve,
-                    reject
-                ]);
+                import(/* webpackIgnore: true */ entry).then(resolve).catch(reject);
             } else {
                 resolve(remoteEntryExports);
             }
@@ -91,11 +105,16 @@ async function loadSystemJsEntry({ entry, remoteEntryExports }) {
     return new Promise((resolve, reject)=>{
         try {
             if (!remoteEntryExports) {
-                // eslint-disable-next-line no-eval
-                new Function('callbacks', `System.import("${entry}").then(callbacks[0]).catch(callbacks[1])`)([
-                    resolve,
-                    reject
-                ]);
+                //@ts-ignore
+                if (typeof __system_context__ === 'undefined') {
+                    //@ts-ignore
+                    System.import(entry).then(resolve).catch(reject);
+                } else {
+                    new Function('callbacks', `System.import("${entry}").then(callbacks[0]).catch(callbacks[1])`)([
+                        resolve,
+                        reject
+                    ]);
+                }
             } else {
                 resolve(remoteEntryExports);
             }
@@ -162,7 +181,7 @@ async function loadEntryDom({ remoteInfo, remoteEntryExports, createScriptHook }
     }
 }
 async function loadEntryNode({ remoteInfo, createScriptHook }) {
-    const { entry, entryGlobalName: globalName, name } = remoteInfo;
+    const { entry, entryGlobalName: globalName, name, type } = remoteInfo;
     const { entryExports: remoteEntryExports } = share.getRemoteEntryExports(name, globalName);
     if (remoteEntryExports) {
         return remoteEntryExports;
@@ -170,7 +189,8 @@ async function loadEntryNode({ remoteInfo, createScriptHook }) {
     return sdk.loadScriptNode(entry, {
         attrs: {
             name,
-            globalName
+            globalName,
+            type
         },
         createScriptHook: (url, attrs)=>{
             const res = createScriptHook.emit({
@@ -207,27 +227,24 @@ async function getRemoteEntry({ origin, remoteEntryExports, remoteInfo }) {
     }
     if (!share.globalLoading[uniqueKey]) {
         const loadEntryHook = origin.remoteHandler.hooks.lifecycle.loadEntry;
-        if (loadEntryHook.listeners.size) {
-            share.globalLoading[uniqueKey] = loadEntryHook.emit({
-                createScriptHook: origin.loaderHook.lifecycle.createScript,
-                remoteInfo,
-                remoteEntryExports
-            }).then((res)=>res || undefined);
-        } else {
-            const createScriptHook = origin.loaderHook.lifecycle.createScript;
-            if (!sdk.isBrowserEnv()) {
-                share.globalLoading[uniqueKey] = loadEntryNode({
-                    remoteInfo,
-                    createScriptHook
-                });
-            } else {
-                share.globalLoading[uniqueKey] = loadEntryDom({
-                    remoteInfo,
-                    remoteEntryExports,
-                    createScriptHook
-                });
+        const createScriptHook = origin.loaderHook.lifecycle.createScript;
+        share.globalLoading[uniqueKey] = loadEntryHook.emit({
+            createScriptHook,
+            remoteInfo,
+            remoteEntryExports
+        }).then((res)=>{
+            if (res) {
+                return res;
             }
-        }
+            return sdk.isBrowserEnv() ? loadEntryDom({
+                remoteInfo,
+                remoteEntryExports,
+                createScriptHook
+            }) : loadEntryNode({
+                remoteInfo,
+                createScriptHook
+            });
+        });
     }
     return share.globalLoading[uniqueKey];
 }
@@ -302,9 +319,7 @@ let Module = class Module {
         // get exposeGetter
         const moduleFactory = await remoteEntryExports.get(expose);
         share.assert(moduleFactory, `${share.getFMId(this.remoteInfo)} remote don't export ${expose}.`);
-        // keep symbol for module name always one format
-        const symbolName = share.processModuleAlias(this.remoteInfo.name, expose);
-        const wrapModuleFactory = this.wraperFactory(moduleFactory, symbolName);
+        const wrapModuleFactory = this.wraperFactory(moduleFactory, id);
         if (!loadFactory) {
             return wrapModuleFactory;
         }
@@ -344,6 +359,191 @@ let Module = class Module {
     }
 };
 
+class SyncHook {
+    on(fn) {
+        if (typeof fn === 'function') {
+            this.listeners.add(fn);
+        }
+    }
+    once(fn) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        this.on(function wrapper(...args) {
+            self.remove(wrapper);
+            // eslint-disable-next-line prefer-spread
+            return fn.apply(null, args);
+        });
+    }
+    emit(...data) {
+        let result;
+        if (this.listeners.size > 0) {
+            // eslint-disable-next-line prefer-spread
+            this.listeners.forEach((fn)=>{
+                result = fn(...data);
+            });
+        }
+        return result;
+    }
+    remove(fn) {
+        this.listeners.delete(fn);
+    }
+    removeAll() {
+        this.listeners.clear();
+    }
+    constructor(type){
+        this.type = '';
+        this.listeners = new Set();
+        if (type) {
+            this.type = type;
+        }
+    }
+}
+
+class AsyncHook extends SyncHook {
+    emit(...data) {
+        let result;
+        const ls = Array.from(this.listeners);
+        if (ls.length > 0) {
+            let i = 0;
+            const call = (prev)=>{
+                if (prev === false) {
+                    return false; // Abort process
+                } else if (i < ls.length) {
+                    return Promise.resolve(ls[i++].apply(null, data)).then(call);
+                } else {
+                    return prev;
+                }
+            };
+            result = call();
+        }
+        return Promise.resolve(result);
+    }
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function checkReturnData(originalData, returnedData) {
+    if (!share.isObject(returnedData)) {
+        return false;
+    }
+    if (originalData !== returnedData) {
+        // eslint-disable-next-line no-restricted-syntax
+        for(const key in originalData){
+            if (!(key in returnedData)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+class SyncWaterfallHook extends SyncHook {
+    emit(data) {
+        if (!share.isObject(data)) {
+            share.error(`The data for the "${this.type}" hook should be an object.`);
+        }
+        for (const fn of this.listeners){
+            try {
+                const tempData = fn(data);
+                if (checkReturnData(data, tempData)) {
+                    data = tempData;
+                } else {
+                    this.onerror(`A plugin returned an unacceptable value for the "${this.type}" type.`);
+                    break;
+                }
+            } catch (e) {
+                share.warn(e);
+                this.onerror(e);
+            }
+        }
+        return data;
+    }
+    constructor(type){
+        super(), this.onerror = share.error;
+        this.type = type;
+    }
+}
+
+class AsyncWaterfallHook extends SyncHook {
+    emit(data) {
+        if (!share.isObject(data)) {
+            share.error(`The response data for the "${this.type}" hook must be an object.`);
+        }
+        const ls = Array.from(this.listeners);
+        if (ls.length > 0) {
+            let i = 0;
+            const processError = (e)=>{
+                share.warn(e);
+                this.onerror(e);
+                return data;
+            };
+            const call = (prevData)=>{
+                if (checkReturnData(data, prevData)) {
+                    data = prevData;
+                    if (i < ls.length) {
+                        try {
+                            return Promise.resolve(ls[i++](data)).then(call, processError);
+                        } catch (e) {
+                            return processError(e);
+                        }
+                    }
+                } else {
+                    this.onerror(`A plugin returned an incorrect value for the "${this.type}" type.`);
+                }
+                return data;
+            };
+            return Promise.resolve(call(data));
+        }
+        return Promise.resolve(data);
+    }
+    constructor(type){
+        super(), this.onerror = share.error;
+        this.type = type;
+    }
+}
+
+class PluginSystem {
+    applyPlugin(plugin) {
+        share.assert(share.isPlainObject(plugin), 'Plugin configuration is invalid.');
+        // The plugin's name is mandatory and must be unique
+        const pluginName = plugin.name;
+        share.assert(pluginName, 'A name must be provided by the plugin.');
+        if (!this.registerPlugins[pluginName]) {
+            this.registerPlugins[pluginName] = plugin;
+            Object.keys(this.lifecycle).forEach((key)=>{
+                const pluginLife = plugin[key];
+                if (pluginLife) {
+                    this.lifecycle[key].on(pluginLife);
+                }
+            });
+        }
+    }
+    removePlugin(pluginName) {
+        share.assert(pluginName, 'A name is required.');
+        const plugin = this.registerPlugins[pluginName];
+        share.assert(plugin, `The plugin "${pluginName}" is not registered.`);
+        Object.keys(plugin).forEach((key)=>{
+            if (key !== 'name') {
+                this.lifecycle[key].remove(plugin[key]);
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    inherit({ lifecycle, registerPlugins }) {
+        Object.keys(lifecycle).forEach((hookName)=>{
+            share.assert(!this.lifecycle[hookName], `The hook "${hookName}" has a conflict and cannot be inherited.`);
+            this.lifecycle[hookName] = lifecycle[hookName];
+        });
+        Object.keys(registerPlugins).forEach((pluginName)=>{
+            share.assert(!this.registerPlugins[pluginName], `The plugin "${pluginName}" has a conflict and cannot be inherited.`);
+            this.applyPlugin(registerPlugins[pluginName]);
+        });
+    }
+    constructor(lifecycle){
+        this.registerPlugins = {};
+        this.lifecycle = lifecycle;
+        this.lifecycleKeys = Object.keys(lifecycle);
+    }
+}
+
 function defaultPreloadArgs(preloadConfig) {
     return polyfills._extends({
         resourceCategory: 'sync',
@@ -403,13 +603,14 @@ useLinkPreload = true) {
         if (useLinkPreload) {
             const defaultAttrs = {
                 rel: 'preload',
-                as: 'style',
-                crossorigin: 'anonymous'
+                as: 'style'
             };
             cssAssets.forEach((cssUrl)=>{
                 const { link: cssEl, needAttach } = sdk.createLink({
                     url: cssUrl,
-                    cb: ()=>{},
+                    cb: ()=>{
+                    // noop
+                    },
                     attrs: defaultAttrs,
                     createLinkHook: (url, attrs)=>{
                         const res = host.loaderHook.lifecycle.createLink.emit({
@@ -432,7 +633,9 @@ useLinkPreload = true) {
             cssAssets.forEach((cssUrl)=>{
                 const { link: cssEl, needAttach } = sdk.createLink({
                     url: cssUrl,
-                    cb: ()=>{},
+                    cb: ()=>{
+                    // noop
+                    },
                     attrs: defaultAttrs,
                     createLinkHook: (url, attrs)=>{
                         const res = host.loaderHook.lifecycle.createLink.emit({
@@ -452,13 +655,14 @@ useLinkPreload = true) {
         if (useLinkPreload) {
             const defaultAttrs = {
                 rel: 'preload',
-                as: 'script',
-                crossorigin: 'anonymous'
+                as: 'script'
             };
             jsAssetsWithoutEntry.forEach((jsUrl)=>{
                 const { link: linkEl, needAttach } = sdk.createLink({
                     url: jsUrl,
-                    cb: ()=>{},
+                    cb: ()=>{
+                    // noop
+                    },
                     attrs: defaultAttrs,
                     createLinkHook: (url, attrs)=>{
                         const res = host.loaderHook.lifecycle.createLink.emit({
@@ -481,7 +685,9 @@ useLinkPreload = true) {
             jsAssetsWithoutEntry.forEach((jsUrl)=>{
                 const { script: scriptEl, needAttach } = sdk.createScript({
                     url: jsUrl,
-                    cb: ()=>{},
+                    cb: ()=>{
+                    // noop
+                    },
                     attrs: defaultAttrs,
                     createScriptHook: (url, attrs)=>{
                         const res = host.loaderHook.lifecycle.createScript.emit({
@@ -754,7 +960,7 @@ const generatePreloadAssetsPlugin = function() {
                             moduleInfo: {
                                 name: remoteInfo.name,
                                 entry: remote.entry,
-                                type: 'global',
+                                type: remoteInfo.type || 'global',
                                 entryGlobalName: '',
                                 shareScope: ''
                             }
@@ -851,8 +1057,6 @@ class SnapshotHandler {
             remoteSnapshot,
             globalSnapshot
         });
-        let mSnapshot;
-        let gSnapshot;
         // global snapshot includes manifest or module info includes manifest
         if (globalRemoteSnapshot) {
             if (sdk.isManifestProvider(globalRemoteSnapshot)) {
@@ -864,8 +1068,10 @@ class SnapshotHandler {
                     // Therefore, set the snapshot key to the global address of the actual request
                     entry: remoteEntry
                 }), moduleSnapshot);
-                mSnapshot = moduleSnapshot;
-                gSnapshot = globalSnapshotRes;
+                return {
+                    remoteSnapshot: moduleSnapshot,
+                    globalSnapshot: globalSnapshotRes
+                };
             } else {
                 const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
                     options: this.HostInstance.options,
@@ -873,8 +1079,10 @@ class SnapshotHandler {
                     remoteSnapshot: globalRemoteSnapshot,
                     from: 'global'
                 });
-                mSnapshot = remoteSnapshotRes;
-                gSnapshot = globalSnapshotRes;
+                return {
+                    remoteSnapshot: remoteSnapshotRes,
+                    globalSnapshot: globalSnapshotRes
+                };
             }
         } else {
             if (share.isRemoteInfoWithEntry(moduleInfo)) {
@@ -888,8 +1096,10 @@ class SnapshotHandler {
                     remoteSnapshot: moduleSnapshot,
                     from: 'global'
                 });
-                mSnapshot = remoteSnapshotRes;
-                gSnapshot = globalSnapshotRes;
+                return {
+                    remoteSnapshot: remoteSnapshotRes,
+                    globalSnapshot: globalSnapshotRes
+                };
             } else {
                 share.error(`
           Cannot get remoteSnapshot with the name: '${moduleInfo.name}', version: '${moduleInfo.version}' from __FEDERATION__.moduleInfo. The following reasons may be causing the problem:\n
@@ -899,15 +1109,6 @@ class SnapshotHandler {
         `);
             }
         }
-        await this.hooks.lifecycle.afterLoadSnapshot.emit({
-            options,
-            moduleInfo,
-            remoteSnapshot: mSnapshot
-        });
-        return {
-            remoteSnapshot: mSnapshot,
-            globalSnapshot: gSnapshot
-        };
     }
     getGlobalRemoteInfo(moduleInfo) {
         return getGlobalRemoteInfo(moduleInfo, this.HostInstance);
@@ -957,11 +1158,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;
@@ -1139,9 +1339,20 @@ class SharedHandler {
                 id: key
             });
             if (module.getEntry) {
-                const entry = await module.getEntry();
+                let remoteEntryExports;
+                try {
+                    remoteEntryExports = await module.getEntry();
+                } catch (error) {
+                    remoteEntryExports = await host.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+                        id: key,
+                        error,
+                        from: 'runtime',
+                        lifecycle: 'beforeLoadShare',
+                        origin: host
+                    });
+                }
                 if (!module.inited) {
-                    await initFn(entry);
+                    await initFn(remoteEntryExports);
                     module.inited = true;
                 }
             }
@@ -1304,14 +1515,14 @@ class SharedHandler {
         }
     }
     constructor(host){
-        this.hooks = new share.PluginSystem({
-            afterResolve: new share.AsyncWaterfallHook('afterResolve'),
-            beforeLoadShare: new share.AsyncWaterfallHook('beforeLoadShare'),
+        this.hooks = new PluginSystem({
+            afterResolve: new AsyncWaterfallHook('afterResolve'),
+            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
             // not used yet
-            loadShare: new share.AsyncHook(),
-            resolveShare: new share.SyncWaterfallHook('resolveShare'),
+            loadShare: new AsyncHook(),
+            resolveShare: new SyncWaterfallHook('resolveShare'),
             // maybe will change, temporarily for internal use only
-            initContainerShareScopeMap: new share.SyncWaterfallHook('initContainerShareScopeMap')
+            initContainerShareScopeMap: new SyncWaterfallHook('initContainerShareScopeMap')
         });
         this.host = host;
         this.shareScopeMap = {};
@@ -1658,18 +1869,18 @@ class RemoteHandler {
         }
     }
     constructor(host){
-        this.hooks = new share.PluginSystem({
-            beforeRegisterRemote: new share.SyncWaterfallHook('beforeRegisterRemote'),
-            registerRemote: new share.SyncWaterfallHook('registerRemote'),
-            beforeRequest: new share.AsyncWaterfallHook('beforeRequest'),
-            onLoad: new share.AsyncHook('onLoad'),
-            handlePreloadModule: new share.SyncHook('handlePreloadModule'),
-            errorLoadRemote: new share.AsyncHook('errorLoadRemote'),
-            beforePreloadRemote: new share.AsyncHook('beforePreloadRemote'),
-            generatePreloadAssets: new share.AsyncHook('generatePreloadAssets'),
+        this.hooks = new PluginSystem({
+            beforeRegisterRemote: new SyncWaterfallHook('beforeRegisterRemote'),
+            registerRemote: new SyncWaterfallHook('registerRemote'),
+            beforeRequest: new AsyncWaterfallHook('beforeRequest'),
+            onLoad: new AsyncHook('onLoad'),
+            handlePreloadModule: new SyncHook('handlePreloadModule'),
+            errorLoadRemote: new AsyncHook('errorLoadRemote'),
+            beforePreloadRemote: new AsyncHook('beforePreloadRemote'),
+            generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
             // not used yet
-            afterPreloadRemote: new share.AsyncHook(),
-            loadEntry: new share.AsyncHook()
+            afterPreloadRemote: new AsyncHook(),
+            loadEntry: new AsyncHook()
         });
         this.host = host;
         this.idToRemoteMap = {};
@@ -1753,7 +1964,7 @@ class FederationHost {
         return optionsRes;
     }
     registerPlugins(plugins) {
-        const pluginRes = share.registerPlugins(plugins, [
+        const pluginRes = registerPlugins$1(plugins, [
             this.hooks,
             this.remoteHandler.hooks,
             this.sharedHandler.hooks,
@@ -1773,23 +1984,23 @@ class FederationHost {
         return this.remoteHandler.registerRemotes(remotes, options);
     }
     constructor(userOptions){
-        this.hooks = new share.PluginSystem({
-            beforeInit: new share.SyncWaterfallHook('beforeInit'),
-            init: new share.SyncHook(),
+        this.hooks = new PluginSystem({
+            beforeInit: new SyncWaterfallHook('beforeInit'),
+            init: new SyncHook(),
             // maybe will change, temporarily for internal use only
-            beforeInitContainer: new share.AsyncWaterfallHook('beforeInitContainer'),
+            beforeInitContainer: new AsyncWaterfallHook('beforeInitContainer'),
             // maybe will change, temporarily for internal use only
-            initContainer: new share.AsyncWaterfallHook('initContainer')
+            initContainer: new AsyncWaterfallHook('initContainer')
         });
-        this.version = "0.6.6";
+        this.version = "0.6.10";
         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
@@ -1876,11 +2087,11 @@ function getInstance() {
 // Inject for debug
 share.setGlobalFederationConstructor(FederationHost);
 
-Object.defineProperty(exports, 'loadScript', {
+Object.defineProperty(exports, "loadScript", {
   enumerable: true,
   get: function () { return sdk.loadScript; }
 });
-Object.defineProperty(exports, 'loadScriptNode', {
+Object.defineProperty(exports, "loadScriptNode", {
   enumerable: true,
   get: function () { return sdk.loadScriptNode; }
 });

package/dist/index.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";