Project Init

node_modules/@module-federation/runtime-core/dist/shared/index.cjs

@@ -0,0 +1,418 @@
+const require_logger = require('../utils/logger.cjs');
+const require_constant = require('../constant.cjs');
+const require_share = require('../utils/share.cjs');
+const require_context = require('../utils/context.cjs');
+require('../utils/index.cjs');
+const require_syncHook = require('../utils/hooks/syncHook.cjs');
+const require_asyncHook = require('../utils/hooks/asyncHook.cjs');
+const require_syncWaterfallHook = require('../utils/hooks/syncWaterfallHook.cjs');
+const require_asyncWaterfallHooks = require('../utils/hooks/asyncWaterfallHooks.cjs');
+const require_pluginSystem = require('../utils/hooks/pluginSystem.cjs');
+require('../utils/hooks/index.cjs');
+let _module_federation_error_codes = require("@module-federation/error-codes");
+
+//#region src/shared/index.ts
+var SharedHandler = class {
+	constructor(host) {
+		this.hooks = new require_pluginSystem.PluginSystem({
+			beforeRegisterShare: new require_syncWaterfallHook.SyncWaterfallHook("beforeRegisterShare"),
+			afterResolve: new require_asyncWaterfallHooks.AsyncWaterfallHook("afterResolve"),
+			beforeLoadShare: new require_asyncWaterfallHooks.AsyncWaterfallHook("beforeLoadShare"),
+			loadShare: new require_asyncHook.AsyncHook(),
+			afterLoadShare: new require_syncHook.SyncHook("afterLoadShare"),
+			errorLoadShare: new require_syncHook.SyncHook("errorLoadShare"),
+			resolveShare: new require_syncWaterfallHook.SyncWaterfallHook("resolveShare"),
+			initContainerShareScopeMap: new require_syncWaterfallHook.SyncWaterfallHook("initContainerShareScopeMap")
+		});
+		this.host = host;
+		this.shareScopeMap = {};
+		this.initTokens = {};
+		this._setGlobalShareScopeMap(host.options);
+	}
+	emitAfterLoadShare({ lifecycle, pkgName, shareInfo, selectedShared }) {
+		try {
+			this.hooks.lifecycle.afterLoadShare.emit({
+				pkgName,
+				shareInfo,
+				selectedShared,
+				shared: this.host.options.shared,
+				shareScopeMap: this.shareScopeMap,
+				lifecycle,
+				origin: this.host
+			});
+		} catch (error) {
+			require_logger.warn(error);
+		}
+	}
+	emitErrorLoadShare({ lifecycle, pkgName, shareInfo, error, recovered }) {
+		try {
+			this.hooks.lifecycle.errorLoadShare.emit({
+				pkgName,
+				shareInfo,
+				shared: this.host.options.shared,
+				shareScopeMap: this.shareScopeMap,
+				lifecycle,
+				origin: this.host,
+				error,
+				recovered
+			});
+		} catch (hookError) {
+			require_logger.warn(hookError);
+		}
+	}
+	registerShared(globalOptions, userOptions) {
+		const { newShareInfos, allShareInfos } = require_share.formatShareConfigs(globalOptions, userOptions);
+		Object.keys(newShareInfos).forEach((sharedKey) => {
+			newShareInfos[sharedKey].forEach((sharedVal) => {
+				sharedVal.scope.forEach((sc) => {
+					this.hooks.lifecycle.beforeRegisterShare.emit({
+						origin: this.host,
+						pkgName: sharedKey,
+						shared: sharedVal
+					});
+					if (!this.shareScopeMap[sc]?.[sharedKey]) this.setShared({
+						pkgName: sharedKey,
+						lib: sharedVal.lib,
+						get: sharedVal.get,
+						loaded: sharedVal.loaded || Boolean(sharedVal.lib),
+						shared: sharedVal,
+						from: userOptions.name
+					});
+				});
+			});
+		});
+		return {
+			newShareInfos,
+			allShareInfos
+		};
+	}
+	async loadShare(pkgName, extraOptions) {
+		const { host } = this;
+		const shareOptions = require_share.getTargetSharedOptions({
+			pkgName,
+			extraOptions,
+			shareInfos: host.options.shared
+		});
+		let shareOptionsRes = shareOptions;
+		try {
+			if (shareOptions?.scope) await Promise.all(shareOptions.scope.map(async (shareScope) => {
+				await Promise.all(this.initializeSharing(shareScope, { strategy: shareOptions.strategy }));
+			}));
+			shareOptionsRes = (await this.hooks.lifecycle.beforeLoadShare.emit({
+				pkgName,
+				shareInfo: shareOptions,
+				shared: host.options.shared,
+				origin: host
+			})).shareInfo;
+			require_logger.assert(shareOptionsRes, `Cannot find shared "${pkgName}" in host "${host.options.name}". Ensure the shared config for "${pkgName}" is declared in the federation plugin options and the host has been initialized before loading shares.`);
+			const resolvedShareOptions = shareOptionsRes;
+			const { shared: registeredShared, useTreesShaking } = require_share.getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
+			if (registeredShared) {
+				const targetShared = require_share.directShare(registeredShared, useTreesShaking);
+				if (targetShared.lib) {
+					require_share.addUseIn(targetShared, host.options.name);
+					this.emitAfterLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						selectedShared: registeredShared
+					});
+					return targetShared.lib;
+				} else if (targetShared.loading && !targetShared.loaded) {
+					const factory = await targetShared.loading;
+					targetShared.loaded = true;
+					if (!targetShared.lib) targetShared.lib = factory;
+					require_share.addUseIn(targetShared, host.options.name);
+					this.emitAfterLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						selectedShared: registeredShared
+					});
+					return factory;
+				} else {
+					const asyncLoadProcess = async () => {
+						const factory = await targetShared.get();
+						require_share.addUseIn(targetShared, host.options.name);
+						targetShared.loaded = true;
+						targetShared.lib = factory;
+						return factory;
+					};
+					const loading = asyncLoadProcess();
+					this.setShared({
+						pkgName,
+						loaded: false,
+						shared: registeredShared,
+						from: host.options.name,
+						lib: null,
+						loading,
+						treeShaking: useTreesShaking ? targetShared : void 0
+					});
+					const factory = await loading;
+					this.emitAfterLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						selectedShared: registeredShared
+					});
+					return factory;
+				}
+			} else {
+				if (extraOptions?.customShareInfo) {
+					this.emitErrorLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						recovered: true
+					});
+					return false;
+				}
+				const _useTreeShaking = require_share.shouldUseTreeShaking(resolvedShareOptions.treeShaking);
+				const targetShared = require_share.directShare(resolvedShareOptions, _useTreeShaking);
+				const asyncLoadProcess = async () => {
+					const factory = await targetShared.get();
+					targetShared.lib = factory;
+					targetShared.loaded = true;
+					require_share.addUseIn(targetShared, host.options.name);
+					const { shared: gShared, useTreesShaking: gUseTreeShaking } = require_share.getRegisteredShare(this.shareScopeMap, pkgName, resolvedShareOptions, this.hooks.lifecycle.resolveShare) || {};
+					if (gShared) {
+						const targetGShared = require_share.directShare(gShared, gUseTreeShaking);
+						targetGShared.lib = factory;
+						targetGShared.loaded = true;
+						gShared.from = resolvedShareOptions.from;
+					}
+					return factory;
+				};
+				const loading = asyncLoadProcess();
+				this.setShared({
+					pkgName,
+					loaded: false,
+					shared: resolvedShareOptions,
+					from: host.options.name,
+					lib: null,
+					loading,
+					treeShaking: _useTreeShaking ? targetShared : void 0
+				});
+				const factory = await loading;
+				this.emitAfterLoadShare({
+					lifecycle: "loadShare",
+					pkgName,
+					shareInfo: resolvedShareOptions,
+					selectedShared: resolvedShareOptions
+				});
+				return factory;
+			}
+		} catch (shareError) {
+			this.emitErrorLoadShare({
+				lifecycle: "loadShare",
+				pkgName,
+				shareInfo: shareOptionsRes,
+				error: shareError
+			});
+			throw shareError;
+		}
+	}
+	/**
+	* 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.
+	*/
+	initializeSharing(shareScopeName = require_constant.DEFAULT_SCOPE, extraOptions) {
+		const { host } = this;
+		const from = extraOptions?.from;
+		const strategy = extraOptions?.strategy;
+		let initScope = 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;
+		if (!shareScope[shareScopeName]) shareScope[shareScopeName] = {};
+		const scope = shareScope[shareScopeName];
+		const register = (name, shared) => {
+			const { version, eager } = shared;
+			scope[name] = scope[name] || {};
+			const versions = scope[name];
+			const activeVersion = versions[version] && require_share.directShare(versions[version]);
+			const activeVersionEager = Boolean(activeVersion && ("eager" in activeVersion && activeVersion.eager || "shareConfig" in activeVersion && activeVersion.shareConfig?.eager));
+			if (!activeVersion || activeVersion.strategy !== "loaded-first" && !activeVersion.loaded && (Boolean(!eager) !== !activeVersionEager ? eager : hostName > versions[version].from)) versions[version] = shared;
+		};
+		const initRemoteModule = async (key) => {
+			const { module } = await host.remoteHandler.getRemoteModuleAndOptions({ id: key });
+			let remoteEntryExports = void 0;
+			try {
+				remoteEntryExports = await module.getEntry();
+			} catch (error) {
+				remoteEntryExports = await host.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+					id: key,
+					error,
+					from: "runtime",
+					lifecycle: "beforeLoadShare",
+					remote: module.remoteInfo,
+					origin: host
+				});
+				if (!remoteEntryExports) return;
+			} finally {
+				if (remoteEntryExports?.init && !module.initing) {
+					module.remoteEntryExports = remoteEntryExports;
+					await module.init(void 0, void 0, initScope);
+				}
+			}
+		};
+		Object.keys(host.options.shared).forEach((shareName) => {
+			host.options.shared[shareName].forEach((shared) => {
+				if (shared.scope.includes(shareScopeName)) register(shareName, shared);
+			});
+		});
+		if (host.options.shareStrategy === "version-first" || strategy === "version-first") host.options.remotes.forEach((remote) => {
+			if (remote.shareScope === shareScopeName) promises.push(initRemoteModule(remote.name));
+		});
+		return promises;
+	}
+	loadShareSync(pkgName, extraOptions) {
+		const { host } = this;
+		const shareOptions = require_share.getTargetSharedOptions({
+			pkgName,
+			extraOptions,
+			shareInfos: host.options.shared
+		});
+		try {
+			if (shareOptions?.scope) shareOptions.scope.forEach((shareScope) => {
+				this.initializeSharing(shareScope, { strategy: shareOptions.strategy });
+			});
+			const { shared: registeredShared } = require_share.getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare) || {};
+			if (registeredShared) {
+				if (typeof registeredShared.lib === "function") {
+					require_share.addUseIn(registeredShared, host.options.name);
+					if (!registeredShared.loaded) {
+						registeredShared.loaded = true;
+						if (registeredShared.from === host.options.name) shareOptions.loaded = true;
+					}
+					this.emitAfterLoadShare({
+						lifecycle: "loadShareSync",
+						pkgName,
+						shareInfo: shareOptions,
+						selectedShared: registeredShared
+					});
+					return registeredShared.lib;
+				}
+				if (typeof registeredShared.get === "function") {
+					const module = registeredShared.get();
+					if (!(module instanceof Promise)) {
+						require_share.addUseIn(registeredShared, host.options.name);
+						this.setShared({
+							pkgName,
+							loaded: true,
+							from: host.options.name,
+							lib: module,
+							shared: registeredShared
+						});
+						this.emitAfterLoadShare({
+							lifecycle: "loadShareSync",
+							pkgName,
+							shareInfo: shareOptions,
+							selectedShared: registeredShared
+						});
+						return module;
+					}
+				}
+			}
+			if (shareOptions.lib) {
+				if (!shareOptions.loaded) shareOptions.loaded = true;
+				this.emitAfterLoadShare({
+					lifecycle: "loadShareSync",
+					pkgName,
+					shareInfo: shareOptions,
+					selectedShared: shareOptions
+				});
+				return shareOptions.lib;
+			}
+			if (shareOptions.get) {
+				const module = shareOptions.get();
+				if (module instanceof Promise) require_logger.error(extraOptions?.from === "build" ? _module_federation_error_codes.RUNTIME_005 : _module_federation_error_codes.RUNTIME_006, _module_federation_error_codes.runtimeDescMap, {
+					hostName: host.options.name,
+					sharedPkgName: pkgName
+				}, void 0, require_context.optionsToMFContext(host.options));
+				shareOptions.lib = module;
+				this.setShared({
+					pkgName,
+					loaded: true,
+					from: host.options.name,
+					lib: shareOptions.lib,
+					shared: shareOptions
+				});
+				this.emitAfterLoadShare({
+					lifecycle: "loadShareSync",
+					pkgName,
+					shareInfo: shareOptions,
+					selectedShared: shareOptions
+				});
+				return shareOptions.lib;
+			}
+			require_logger.error(_module_federation_error_codes.RUNTIME_006, _module_federation_error_codes.runtimeDescMap, {
+				hostName: host.options.name,
+				sharedPkgName: pkgName
+			}, void 0, require_context.optionsToMFContext(host.options));
+		} catch (shareError) {
+			this.emitErrorLoadShare({
+				lifecycle: "loadShareSync",
+				pkgName,
+				shareInfo: shareOptions,
+				error: shareError
+			});
+			throw shareError;
+		}
+	}
+	initShareScopeMap(scopeName, shareScope, extraOptions = {}) {
+		const { host } = this;
+		this.shareScopeMap[scopeName] = shareScope;
+		this.hooks.lifecycle.initContainerShareScopeMap.emit({
+			shareScope,
+			options: host.options,
+			origin: host,
+			scopeName,
+			hostShareScopeMap: extraOptions.hostShareScopeMap
+		});
+	}
+	setShared({ pkgName, shared, from, lib, loading, loaded, get, treeShaking }) {
+		const { version, scope = "default", ...shareInfo } = shared;
+		const scopes = Array.isArray(scope) ? scope : [scope];
+		const mergeAttrs = (shared) => {
+			const merge = (s, key, val) => {
+				if (val && !s[key]) s[key] = val;
+			};
+			const targetShared = treeShaking ? shared.treeShaking : shared;
+			merge(targetShared, "loaded", loaded);
+			merge(targetShared, "loading", loading);
+			merge(targetShared, "get", get);
+		};
+		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]) this.shareScopeMap[sc][pkgName][version] = {
+				version,
+				scope: [sc],
+				...shareInfo,
+				lib
+			};
+			const registeredShared = this.shareScopeMap[sc][pkgName][version];
+			mergeAttrs(registeredShared);
+			if (from && registeredShared.from !== from) registeredShared.from = from;
+		});
+	}
+	_setGlobalShareScopeMap(hostOptions) {
+		const globalShareScopeMap = require_share.getGlobalShareScope();
+		const identifier = hostOptions.id || hostOptions.name;
+		if (identifier && !globalShareScopeMap[identifier]) globalShareScopeMap[identifier] = this.shareScopeMap;
+	}
+};
+
+//#endregion
+exports.SharedHandler = SharedHandler;
+//# sourceMappingURL=index.cjs.map

node_modules/@module-federation/runtime-core/dist/shared/index.d.ts

@@ -0,0 +1,104 @@
+import { SyncHook } from "../utils/hooks/syncHook.js";
+import { AsyncHook } from "../utils/hooks/asyncHook.js";
+import { SyncWaterfallHook } from "../utils/hooks/syncWaterfallHook.js";
+import { AsyncWaterfallHook } from "../utils/hooks/asyncWaterfallHooks.js";
+import { PluginSystem } from "../utils/hooks/pluginSystem.js";
+import { Federation } from "../global.js";
+import { LoadRemoteMatch } from "../remote/index.js";
+import { ModuleFederation } from "../core.js";
+import { CallFrom, InitScope, InitTokens, Options, ShareInfos, ShareScopeMap, ShareStrategy, Shared, UserOptions } from "../type/config.js";
+//#region src/shared/index.d.ts
+declare class SharedHandler {
+  host: ModuleFederation;
+  shareScopeMap: ShareScopeMap;
+  hooks: PluginSystem<{
+    beforeRegisterShare: SyncWaterfallHook<{
+      pkgName: string;
+      shared: Shared;
+      origin: ModuleFederation;
+    }>;
+    afterResolve: AsyncWaterfallHook<LoadRemoteMatch>;
+    beforeLoadShare: AsyncWaterfallHook<{
+      pkgName: string;
+      shareInfo?: Shared;
+      shared: Options["shared"];
+      origin: ModuleFederation;
+    }>;
+    loadShare: AsyncHook<[ModuleFederation, string, ShareInfos], false | void | Promise<false | void>>;
+    afterLoadShare: SyncHook<[{
+      pkgName: string;
+      shareInfo?: Partial<Shared>;
+      selectedShared?: Partial<Shared>;
+      shared: Options["shared"];
+      shareScopeMap: ShareScopeMap;
+      lifecycle: "loadShare" | "loadShareSync";
+      origin: ModuleFederation;
+    }], void>;
+    errorLoadShare: SyncHook<[{
+      pkgName: string;
+      shareInfo?: Partial<Shared>;
+      shared: Options["shared"];
+      shareScopeMap: ShareScopeMap;
+      lifecycle: "loadShare" | "loadShareSync";
+      origin: ModuleFederation;
+      error?: unknown;
+      recovered?: boolean;
+    }], void>;
+    resolveShare: SyncWaterfallHook<{
+      shareScopeMap: ShareScopeMap;
+      scope: string;
+      pkgName: string;
+      version: string;
+      shareInfo: Shared;
+      GlobalFederation: Federation;
+      resolver: () => {
+        shared: Shared;
+        useTreesShaking: boolean;
+      } | undefined;
+    }>;
+    initContainerShareScopeMap: SyncWaterfallHook<{
+      shareScope: ShareScopeMap[string];
+      options: Options;
+      origin: ModuleFederation;
+      scopeName: string;
+      hostShareScopeMap?: ShareScopeMap;
+    }>;
+  }>;
+  initTokens: InitTokens;
+  constructor(host: ModuleFederation);
+  private emitAfterLoadShare;
+  private emitErrorLoadShare;
+  registerShared(globalOptions: Options, userOptions: UserOptions): {
+    newShareInfos: ShareInfos;
+    allShareInfos: {
+      [pkgName: string]: Shared[];
+    };
+  };
+  loadShare<T>(pkgName: string, extraOptions?: {
+    customShareInfo?: Partial<Shared>;
+    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
+  }): Promise<false | (() => T | undefined)>;
+  /**
+   * 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.
+   */
+  initializeSharing(shareScopeName?: string, extraOptions?: {
+    initScope?: InitScope;
+    from?: CallFrom;
+    strategy?: ShareStrategy;
+  }): Array<Promise<void>>;
+  loadShareSync<T>(pkgName: string, extraOptions?: {
+    from?: 'build' | 'runtime';
+    customShareInfo?: Partial<Shared>;
+    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
+  }): () => T | never;
+  initShareScopeMap(scopeName: string, shareScope: ShareScopeMap[string], extraOptions?: {
+    hostShareScopeMap?: ShareScopeMap;
+  }): void;
+  private setShared;
+  private _setGlobalShareScopeMap;
+}
+//#endregion
+export { SharedHandler };
+//# sourceMappingURL=index.d.ts.map

node_modules/@module-federation/runtime-core/dist/shared/index.js

@@ -0,0 +1,418 @@
+import { assert, error, warn } from "../utils/logger.js";
+import { DEFAULT_SCOPE } from "../constant.js";
+import { addUseIn, directShare, formatShareConfigs, getGlobalShareScope, getRegisteredShare, getTargetSharedOptions, shouldUseTreeShaking } from "../utils/share.js";
+import { optionsToMFContext } from "../utils/context.js";
+import "../utils/index.js";
+import { SyncHook } from "../utils/hooks/syncHook.js";
+import { AsyncHook } from "../utils/hooks/asyncHook.js";
+import { SyncWaterfallHook } from "../utils/hooks/syncWaterfallHook.js";
+import { AsyncWaterfallHook } from "../utils/hooks/asyncWaterfallHooks.js";
+import { PluginSystem } from "../utils/hooks/pluginSystem.js";
+import "../utils/hooks/index.js";
+import { RUNTIME_005, RUNTIME_006, runtimeDescMap } from "@module-federation/error-codes";
+
+//#region src/shared/index.ts
+var SharedHandler = class {
+	constructor(host) {
+		this.hooks = new PluginSystem({
+			beforeRegisterShare: new SyncWaterfallHook("beforeRegisterShare"),
+			afterResolve: new AsyncWaterfallHook("afterResolve"),
+			beforeLoadShare: new AsyncWaterfallHook("beforeLoadShare"),
+			loadShare: new AsyncHook(),
+			afterLoadShare: new SyncHook("afterLoadShare"),
+			errorLoadShare: new SyncHook("errorLoadShare"),
+			resolveShare: new SyncWaterfallHook("resolveShare"),
+			initContainerShareScopeMap: new SyncWaterfallHook("initContainerShareScopeMap")
+		});
+		this.host = host;
+		this.shareScopeMap = {};
+		this.initTokens = {};
+		this._setGlobalShareScopeMap(host.options);
+	}
+	emitAfterLoadShare({ lifecycle, pkgName, shareInfo, selectedShared }) {
+		try {
+			this.hooks.lifecycle.afterLoadShare.emit({
+				pkgName,
+				shareInfo,
+				selectedShared,
+				shared: this.host.options.shared,
+				shareScopeMap: this.shareScopeMap,
+				lifecycle,
+				origin: this.host
+			});
+		} catch (error) {
+			warn(error);
+		}
+	}
+	emitErrorLoadShare({ lifecycle, pkgName, shareInfo, error, recovered }) {
+		try {
+			this.hooks.lifecycle.errorLoadShare.emit({
+				pkgName,
+				shareInfo,
+				shared: this.host.options.shared,
+				shareScopeMap: this.shareScopeMap,
+				lifecycle,
+				origin: this.host,
+				error,
+				recovered
+			});
+		} catch (hookError) {
+			warn(hookError);
+		}
+	}
+	registerShared(globalOptions, userOptions) {
+		const { newShareInfos, allShareInfos } = formatShareConfigs(globalOptions, userOptions);
+		Object.keys(newShareInfos).forEach((sharedKey) => {
+			newShareInfos[sharedKey].forEach((sharedVal) => {
+				sharedVal.scope.forEach((sc) => {
+					this.hooks.lifecycle.beforeRegisterShare.emit({
+						origin: this.host,
+						pkgName: sharedKey,
+						shared: sharedVal
+					});
+					if (!this.shareScopeMap[sc]?.[sharedKey]) this.setShared({
+						pkgName: sharedKey,
+						lib: sharedVal.lib,
+						get: sharedVal.get,
+						loaded: sharedVal.loaded || Boolean(sharedVal.lib),
+						shared: sharedVal,
+						from: userOptions.name
+					});
+				});
+			});
+		});
+		return {
+			newShareInfos,
+			allShareInfos
+		};
+	}
+	async loadShare(pkgName, extraOptions) {
+		const { host } = this;
+		const shareOptions = getTargetSharedOptions({
+			pkgName,
+			extraOptions,
+			shareInfos: host.options.shared
+		});
+		let shareOptionsRes = shareOptions;
+		try {
+			if (shareOptions?.scope) await Promise.all(shareOptions.scope.map(async (shareScope) => {
+				await Promise.all(this.initializeSharing(shareScope, { strategy: shareOptions.strategy }));
+			}));
+			shareOptionsRes = (await this.hooks.lifecycle.beforeLoadShare.emit({
+				pkgName,
+				shareInfo: shareOptions,
+				shared: host.options.shared,
+				origin: host
+			})).shareInfo;
+			assert(shareOptionsRes, `Cannot find shared "${pkgName}" in host "${host.options.name}". Ensure the shared config for "${pkgName}" is declared in the federation plugin options and the host has been initialized before loading shares.`);
+			const resolvedShareOptions = shareOptionsRes;
+			const { shared: registeredShared, useTreesShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
+			if (registeredShared) {
+				const targetShared = directShare(registeredShared, useTreesShaking);
+				if (targetShared.lib) {
+					addUseIn(targetShared, host.options.name);
+					this.emitAfterLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						selectedShared: registeredShared
+					});
+					return targetShared.lib;
+				} else if (targetShared.loading && !targetShared.loaded) {
+					const factory = await targetShared.loading;
+					targetShared.loaded = true;
+					if (!targetShared.lib) targetShared.lib = factory;
+					addUseIn(targetShared, host.options.name);
+					this.emitAfterLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						selectedShared: registeredShared
+					});
+					return factory;
+				} else {
+					const asyncLoadProcess = async () => {
+						const factory = await targetShared.get();
+						addUseIn(targetShared, host.options.name);
+						targetShared.loaded = true;
+						targetShared.lib = factory;
+						return factory;
+					};
+					const loading = asyncLoadProcess();
+					this.setShared({
+						pkgName,
+						loaded: false,
+						shared: registeredShared,
+						from: host.options.name,
+						lib: null,
+						loading,
+						treeShaking: useTreesShaking ? targetShared : void 0
+					});
+					const factory = await loading;
+					this.emitAfterLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						selectedShared: registeredShared
+					});
+					return factory;
+				}
+			} else {
+				if (extraOptions?.customShareInfo) {
+					this.emitErrorLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						recovered: true
+					});
+					return false;
+				}
+				const _useTreeShaking = shouldUseTreeShaking(resolvedShareOptions.treeShaking);
+				const targetShared = directShare(resolvedShareOptions, _useTreeShaking);
+				const asyncLoadProcess = async () => {
+					const factory = await targetShared.get();
+					targetShared.lib = factory;
+					targetShared.loaded = true;
+					addUseIn(targetShared, host.options.name);
+					const { shared: gShared, useTreesShaking: gUseTreeShaking } = getRegisteredShare(this.shareScopeMap, pkgName, resolvedShareOptions, this.hooks.lifecycle.resolveShare) || {};
+					if (gShared) {
+						const targetGShared = directShare(gShared, gUseTreeShaking);
+						targetGShared.lib = factory;
+						targetGShared.loaded = true;
+						gShared.from = resolvedShareOptions.from;
+					}
+					return factory;
+				};
+				const loading = asyncLoadProcess();
+				this.setShared({
+					pkgName,
+					loaded: false,
+					shared: resolvedShareOptions,
+					from: host.options.name,
+					lib: null,
+					loading,
+					treeShaking: _useTreeShaking ? targetShared : void 0
+				});
+				const factory = await loading;
+				this.emitAfterLoadShare({
+					lifecycle: "loadShare",
+					pkgName,
+					shareInfo: resolvedShareOptions,
+					selectedShared: resolvedShareOptions
+				});
+				return factory;
+			}
+		} catch (shareError) {
+			this.emitErrorLoadShare({
+				lifecycle: "loadShare",
+				pkgName,
+				shareInfo: shareOptionsRes,
+				error: shareError
+			});
+			throw shareError;
+		}
+	}
+	/**
+	* 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.
+	*/
+	initializeSharing(shareScopeName = DEFAULT_SCOPE, extraOptions) {
+		const { host } = this;
+		const from = extraOptions?.from;
+		const strategy = extraOptions?.strategy;
+		let initScope = 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;
+		if (!shareScope[shareScopeName]) shareScope[shareScopeName] = {};
+		const scope = shareScope[shareScopeName];
+		const register = (name, shared) => {
+			const { version, eager } = shared;
+			scope[name] = scope[name] || {};
+			const versions = scope[name];
+			const activeVersion = versions[version] && directShare(versions[version]);
+			const activeVersionEager = Boolean(activeVersion && ("eager" in activeVersion && activeVersion.eager || "shareConfig" in activeVersion && activeVersion.shareConfig?.eager));
+			if (!activeVersion || activeVersion.strategy !== "loaded-first" && !activeVersion.loaded && (Boolean(!eager) !== !activeVersionEager ? eager : hostName > versions[version].from)) versions[version] = shared;
+		};
+		const initRemoteModule = async (key) => {
+			const { module } = await host.remoteHandler.getRemoteModuleAndOptions({ id: key });
+			let remoteEntryExports = void 0;
+			try {
+				remoteEntryExports = await module.getEntry();
+			} catch (error) {
+				remoteEntryExports = await host.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+					id: key,
+					error,
+					from: "runtime",
+					lifecycle: "beforeLoadShare",
+					remote: module.remoteInfo,
+					origin: host
+				});
+				if (!remoteEntryExports) return;
+			} finally {
+				if (remoteEntryExports?.init && !module.initing) {
+					module.remoteEntryExports = remoteEntryExports;
+					await module.init(void 0, void 0, initScope);
+				}
+			}
+		};
+		Object.keys(host.options.shared).forEach((shareName) => {
+			host.options.shared[shareName].forEach((shared) => {
+				if (shared.scope.includes(shareScopeName)) register(shareName, shared);
+			});
+		});
+		if (host.options.shareStrategy === "version-first" || strategy === "version-first") host.options.remotes.forEach((remote) => {
+			if (remote.shareScope === shareScopeName) promises.push(initRemoteModule(remote.name));
+		});
+		return promises;
+	}
+	loadShareSync(pkgName, extraOptions) {
+		const { host } = this;
+		const shareOptions = getTargetSharedOptions({
+			pkgName,
+			extraOptions,
+			shareInfos: host.options.shared
+		});
+		try {
+			if (shareOptions?.scope) shareOptions.scope.forEach((shareScope) => {
+				this.initializeSharing(shareScope, { strategy: shareOptions.strategy });
+			});
+			const { shared: registeredShared } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare) || {};
+			if (registeredShared) {
+				if (typeof registeredShared.lib === "function") {
+					addUseIn(registeredShared, host.options.name);
+					if (!registeredShared.loaded) {
+						registeredShared.loaded = true;
+						if (registeredShared.from === host.options.name) shareOptions.loaded = true;
+					}
+					this.emitAfterLoadShare({
+						lifecycle: "loadShareSync",
+						pkgName,
+						shareInfo: shareOptions,
+						selectedShared: registeredShared
+					});
+					return registeredShared.lib;
+				}
+				if (typeof registeredShared.get === "function") {
+					const module = registeredShared.get();
+					if (!(module instanceof Promise)) {
+						addUseIn(registeredShared, host.options.name);
+						this.setShared({
+							pkgName,
+							loaded: true,
+							from: host.options.name,
+							lib: module,
+							shared: registeredShared
+						});
+						this.emitAfterLoadShare({
+							lifecycle: "loadShareSync",
+							pkgName,
+							shareInfo: shareOptions,
+							selectedShared: registeredShared
+						});
+						return module;
+					}
+				}
+			}
+			if (shareOptions.lib) {
+				if (!shareOptions.loaded) shareOptions.loaded = true;
+				this.emitAfterLoadShare({
+					lifecycle: "loadShareSync",
+					pkgName,
+					shareInfo: shareOptions,
+					selectedShared: shareOptions
+				});
+				return shareOptions.lib;
+			}
+			if (shareOptions.get) {
+				const module = shareOptions.get();
+				if (module instanceof Promise) error(extraOptions?.from === "build" ? RUNTIME_005 : RUNTIME_006, runtimeDescMap, {
+					hostName: host.options.name,
+					sharedPkgName: pkgName
+				}, void 0, optionsToMFContext(host.options));
+				shareOptions.lib = module;
+				this.setShared({
+					pkgName,
+					loaded: true,
+					from: host.options.name,
+					lib: shareOptions.lib,
+					shared: shareOptions
+				});
+				this.emitAfterLoadShare({
+					lifecycle: "loadShareSync",
+					pkgName,
+					shareInfo: shareOptions,
+					selectedShared: shareOptions
+				});
+				return shareOptions.lib;
+			}
+			error(RUNTIME_006, runtimeDescMap, {
+				hostName: host.options.name,
+				sharedPkgName: pkgName
+			}, void 0, optionsToMFContext(host.options));
+		} catch (shareError) {
+			this.emitErrorLoadShare({
+				lifecycle: "loadShareSync",
+				pkgName,
+				shareInfo: shareOptions,
+				error: shareError
+			});
+			throw shareError;
+		}
+	}
+	initShareScopeMap(scopeName, shareScope, extraOptions = {}) {
+		const { host } = this;
+		this.shareScopeMap[scopeName] = shareScope;
+		this.hooks.lifecycle.initContainerShareScopeMap.emit({
+			shareScope,
+			options: host.options,
+			origin: host,
+			scopeName,
+			hostShareScopeMap: extraOptions.hostShareScopeMap
+		});
+	}
+	setShared({ pkgName, shared, from, lib, loading, loaded, get, treeShaking }) {
+		const { version, scope = "default", ...shareInfo } = shared;
+		const scopes = Array.isArray(scope) ? scope : [scope];
+		const mergeAttrs = (shared) => {
+			const merge = (s, key, val) => {
+				if (val && !s[key]) s[key] = val;
+			};
+			const targetShared = treeShaking ? shared.treeShaking : shared;
+			merge(targetShared, "loaded", loaded);
+			merge(targetShared, "loading", loading);
+			merge(targetShared, "get", get);
+		};
+		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]) this.shareScopeMap[sc][pkgName][version] = {
+				version,
+				scope: [sc],
+				...shareInfo,
+				lib
+			};
+			const registeredShared = this.shareScopeMap[sc][pkgName][version];
+			mergeAttrs(registeredShared);
+			if (from && registeredShared.from !== from) registeredShared.from = from;
+		});
+	}
+	_setGlobalShareScopeMap(hostOptions) {
+		const globalShareScopeMap = getGlobalShareScope();
+		const identifier = hostOptions.id || hostOptions.name;
+		if (identifier && !globalShareScopeMap[identifier]) globalShareScopeMap[identifier] = this.shareScopeMap;
+	}
+};
+
+//#endregion
+export { SharedHandler };
+//# sourceMappingURL=index.js.map