@module-federation/runtime-core 2.0.0 → 2.1.0

package/dist/plugins/snapshot/SnapshotHandler.js

@@ -0,0 +1,183 @@
+import { assert, error } from "../../utils/logger.js";
+import { isRemoteInfoWithEntry } from "../../utils/tool.js";
+import { Global, addGlobalSnapshot, getGlobalSnapshot, getGlobalSnapshotInfoByModuleInfo, getInfoWithoutType, setGlobalSnapshotInfoByModuleInfo } from "../../global.js";
+import "../../utils/index.js";
+import { AsyncHook } from "../../utils/hooks/asyncHook.js";
+import { AsyncWaterfallHook } from "../../utils/hooks/asyncWaterfallHooks.js";
+import { PluginSystem } from "../../utils/hooks/pluginSystem.js";
+import "../../utils/hooks/index.js";
+import { generateSnapshotFromManifest, isBrowserEnv, isManifestProvider } from "@module-federation/sdk";
+import { RUNTIME_003, RUNTIME_007, getShortErrorMsg, runtimeDescMap } from "@module-federation/error-codes";
+
+//#region src/plugins/snapshot/SnapshotHandler.ts
+function getGlobalRemoteInfo(moduleInfo, origin) {
+	const hostGlobalSnapshot = getGlobalSnapshotInfoByModuleInfo({
+		name: origin.name,
+		version: origin.options.version
+	});
+	const globalRemoteInfo = hostGlobalSnapshot && "remotesInfo" in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, moduleInfo.name).value;
+	if (globalRemoteInfo && globalRemoteInfo.matchedVersion) return {
+		hostGlobalSnapshot,
+		globalSnapshot: getGlobalSnapshot(),
+		remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
+			name: moduleInfo.name,
+			version: globalRemoteInfo.matchedVersion
+		})
+	};
+	return {
+		hostGlobalSnapshot: void 0,
+		globalSnapshot: getGlobalSnapshot(),
+		remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
+			name: moduleInfo.name,
+			version: "version" in moduleInfo ? moduleInfo.version : void 0
+		})
+	};
+}
+var SnapshotHandler = class {
+	constructor(HostInstance) {
+		this.loadingHostSnapshot = null;
+		this.manifestCache = /* @__PURE__ */ new Map();
+		this.hooks = new PluginSystem({
+			beforeLoadRemoteSnapshot: new AsyncHook("beforeLoadRemoteSnapshot"),
+			loadSnapshot: new AsyncWaterfallHook("loadGlobalSnapshot"),
+			loadRemoteSnapshot: new AsyncWaterfallHook("loadRemoteSnapshot"),
+			afterLoadSnapshot: new AsyncWaterfallHook("afterLoadSnapshot")
+		});
+		this.manifestLoading = Global.__FEDERATION__.__MANIFEST_LOADING__;
+		this.HostInstance = HostInstance;
+		this.loaderHook = HostInstance.loaderHook;
+	}
+	async loadRemoteSnapshotInfo({ moduleInfo, id, expose }) {
+		const { options } = this.HostInstance;
+		await this.hooks.lifecycle.beforeLoadRemoteSnapshot.emit({
+			options,
+			moduleInfo
+		});
+		let hostSnapshot = getGlobalSnapshotInfoByModuleInfo({
+			name: this.HostInstance.options.name,
+			version: this.HostInstance.options.version
+		});
+		if (!hostSnapshot) {
+			hostSnapshot = {
+				version: this.HostInstance.options.version || "",
+				remoteEntry: "",
+				remotesInfo: {}
+			};
+			addGlobalSnapshot({ [this.HostInstance.options.name]: hostSnapshot });
+		}
+		if (hostSnapshot && "remotesInfo" in hostSnapshot && !getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name).value) {
+			if ("version" in moduleInfo || "entry" in moduleInfo) hostSnapshot.remotesInfo = {
+				...hostSnapshot?.remotesInfo,
+				[moduleInfo.name]: { matchedVersion: "version" in moduleInfo ? moduleInfo.version : moduleInfo.entry }
+			};
+		}
+		const { hostGlobalSnapshot, remoteSnapshot, globalSnapshot } = this.getGlobalRemoteInfo(moduleInfo);
+		const { remoteSnapshot: globalRemoteSnapshot, globalSnapshot: globalSnapshotRes } = await this.hooks.lifecycle.loadSnapshot.emit({
+			options,
+			moduleInfo,
+			hostGlobalSnapshot,
+			remoteSnapshot,
+			globalSnapshot
+		});
+		let mSnapshot;
+		let gSnapshot;
+		if (globalRemoteSnapshot) if (isManifestProvider(globalRemoteSnapshot)) {
+			const remoteEntry = isBrowserEnv() ? globalRemoteSnapshot.remoteEntry : globalRemoteSnapshot.ssrRemoteEntry || globalRemoteSnapshot.remoteEntry || "";
+			const moduleSnapshot = await this.getManifestJson(remoteEntry, moduleInfo, {});
+			const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo({
+				...moduleInfo,
+				entry: remoteEntry
+			}, moduleSnapshot);
+			mSnapshot = moduleSnapshot;
+			gSnapshot = globalSnapshotRes;
+		} else {
+			const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+				options: this.HostInstance.options,
+				moduleInfo,
+				remoteSnapshot: globalRemoteSnapshot,
+				from: "global"
+			});
+			mSnapshot = remoteSnapshotRes;
+			gSnapshot = globalSnapshotRes;
+		}
+		else if (isRemoteInfoWithEntry(moduleInfo)) {
+			const moduleSnapshot = await this.getManifestJson(moduleInfo.entry, moduleInfo, {});
+			const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo(moduleInfo, moduleSnapshot);
+			const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+				options: this.HostInstance.options,
+				moduleInfo,
+				remoteSnapshot: moduleSnapshot,
+				from: "global"
+			});
+			mSnapshot = remoteSnapshotRes;
+			gSnapshot = globalSnapshotRes;
+		} else error(getShortErrorMsg(RUNTIME_007, runtimeDescMap, {
+			hostName: moduleInfo.name,
+			hostVersion: moduleInfo.version,
+			globalSnapshot: JSON.stringify(globalSnapshotRes)
+		}));
+		await this.hooks.lifecycle.afterLoadSnapshot.emit({
+			id,
+			host: this.HostInstance,
+			options,
+			moduleInfo,
+			remoteSnapshot: mSnapshot
+		});
+		return {
+			remoteSnapshot: mSnapshot,
+			globalSnapshot: gSnapshot
+		};
+	}
+	getGlobalRemoteInfo(moduleInfo) {
+		return getGlobalRemoteInfo(moduleInfo, this.HostInstance);
+	}
+	async getManifestJson(manifestUrl, moduleInfo, extraOptions) {
+		const getManifest = async () => {
+			let manifestJson = this.manifestCache.get(manifestUrl);
+			if (manifestJson) return manifestJson;
+			try {
+				let res = await this.loaderHook.lifecycle.fetch.emit(manifestUrl, {});
+				if (!res || !(res instanceof Response)) res = await fetch(manifestUrl, {});
+				manifestJson = await res.json();
+			} catch (err) {
+				manifestJson = await this.HostInstance.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+					id: manifestUrl,
+					error: err,
+					from: "runtime",
+					lifecycle: "afterResolve",
+					origin: this.HostInstance
+				});
+				if (!manifestJson) {
+					delete this.manifestLoading[manifestUrl];
+					error(getShortErrorMsg(RUNTIME_003, runtimeDescMap, {
+						manifestUrl,
+						moduleName: moduleInfo.name,
+						hostName: this.HostInstance.options.name
+					}, `${err}`));
+				}
+			}
+			assert(manifestJson.metaData && manifestJson.exposes && manifestJson.shared, `${manifestUrl} is not a federation manifest`);
+			this.manifestCache.set(manifestUrl, manifestJson);
+			return manifestJson;
+		};
+		const asyncLoadProcess = async () => {
+			const manifestJson = await getManifest();
+			const remoteSnapshot = generateSnapshotFromManifest(manifestJson, { version: manifestUrl });
+			const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+				options: this.HostInstance.options,
+				moduleInfo,
+				manifestJson,
+				remoteSnapshot,
+				manifestUrl,
+				from: "manifest"
+			});
+			return remoteSnapshotRes;
+		};
+		if (!this.manifestLoading[manifestUrl]) this.manifestLoading[manifestUrl] = asyncLoadProcess().then((res) => res);
+		return this.manifestLoading[manifestUrl];
+	}
+};
+
+//#endregion
+export { SnapshotHandler, getGlobalRemoteInfo };
+//# sourceMappingURL=SnapshotHandler.js.map

package/dist/plugins/snapshot/SnapshotHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SnapshotHandler.js","names":[],"sources":["../../../src/plugins/snapshot/SnapshotHandler.ts"],"sourcesContent":["import {\n  GlobalModuleInfo,\n  Manifest,\n  ModuleInfo,\n  generateSnapshotFromManifest,\n  isManifestProvider,\n  isBrowserEnv,\n} from '@module-federation/sdk';\nimport {\n  getShortErrorMsg,\n  RUNTIME_003,\n  RUNTIME_007,\n  runtimeDescMap,\n} from '@module-federation/error-codes';\nimport { Options, Remote } from '../../type';\nimport { isRemoteInfoWithEntry, error } from '../../utils';\nimport {\n  getGlobalSnapshot,\n  setGlobalSnapshotInfoByModuleInfo,\n  Global,\n  addGlobalSnapshot,\n  getGlobalSnapshotInfoByModuleInfo,\n  getInfoWithoutType,\n} from '../../global';\nimport { PluginSystem, AsyncHook, AsyncWaterfallHook } from '../../utils/hooks';\nimport { ModuleFederation } from '../../core';\nimport { assert } from '../../utils/logger';\n\nexport function getGlobalRemoteInfo(\n  moduleInfo: Remote,\n  origin: ModuleFederation,\n): {\n  hostGlobalSnapshot: ModuleInfo | undefined;\n  globalSnapshot: ReturnType<typeof getGlobalSnapshot>;\n  remoteSnapshot: GlobalModuleInfo[string] | undefined;\n} {\n  const hostGlobalSnapshot = getGlobalSnapshotInfoByModuleInfo({\n    name: origin.name,\n    version: origin.options.version,\n  });\n\n  // get remote detail info from global\n  const globalRemoteInfo =\n    hostGlobalSnapshot &&\n    'remotesInfo' in hostGlobalSnapshot &&\n    hostGlobalSnapshot.remotesInfo &&\n    getInfoWithoutType(hostGlobalSnapshot.remotesInfo, moduleInfo.name).value;\n\n  if (globalRemoteInfo && globalRemoteInfo.matchedVersion) {\n    return {\n      hostGlobalSnapshot,\n      globalSnapshot: getGlobalSnapshot(),\n      remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({\n        name: moduleInfo.name,\n        version: globalRemoteInfo.matchedVersion,\n      }),\n    };\n  }\n\n  return {\n    hostGlobalSnapshot: undefined,\n    globalSnapshot: getGlobalSnapshot(),\n    remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({\n      name: moduleInfo.name,\n      version: 'version' in moduleInfo ? moduleInfo.version : undefined,\n    }),\n  };\n}\n\nexport class SnapshotHandler {\n  loadingHostSnapshot: Promise<GlobalModuleInfo | void> | null = null;\n  HostInstance: ModuleFederation;\n  manifestCache: Map<string, Manifest> = new Map();\n  hooks = new PluginSystem({\n    beforeLoadRemoteSnapshot: new AsyncHook<\n      [\n        {\n          options: Options;\n          moduleInfo: Remote;\n        },\n      ],\n      void\n    >('beforeLoadRemoteSnapshot'),\n    loadSnapshot: new AsyncWaterfallHook<{\n      options: Options;\n      moduleInfo: Remote;\n      hostGlobalSnapshot: GlobalModuleInfo[string] | undefined;\n      globalSnapshot: ReturnType<typeof getGlobalSnapshot>;\n      remoteSnapshot?: GlobalModuleInfo[string] | undefined;\n    }>('loadGlobalSnapshot'),\n    loadRemoteSnapshot: new AsyncWaterfallHook<{\n      options: Options;\n      moduleInfo: Remote;\n      manifestJson?: Manifest;\n      manifestUrl?: string;\n      remoteSnapshot: ModuleInfo;\n      from: 'global' | 'manifest';\n    }>('loadRemoteSnapshot'),\n    afterLoadSnapshot: new AsyncWaterfallHook<{\n      id?: string;\n      host: ModuleFederation;\n      options: Options;\n      moduleInfo: Remote;\n      remoteSnapshot: ModuleInfo;\n    }>('afterLoadSnapshot'),\n  });\n  loaderHook: ModuleFederation['loaderHook'];\n  manifestLoading: Record<string, Promise<ModuleInfo>> =\n    Global.__FEDERATION__.__MANIFEST_LOADING__;\n\n  constructor(HostInstance: ModuleFederation) {\n    this.HostInstance = HostInstance;\n    this.loaderHook = HostInstance.loaderHook;\n  }\n\n  // eslint-disable-next-line max-lines-per-function\n  async loadRemoteSnapshotInfo({\n    moduleInfo,\n    id,\n    expose,\n  }: {\n    moduleInfo: Remote;\n    id?: string;\n    expose?: string;\n  }):\n    | Promise<{\n        remoteSnapshot: ModuleInfo;\n        globalSnapshot: GlobalModuleInfo;\n      }>\n    | never {\n    const { options } = this.HostInstance;\n\n    await this.hooks.lifecycle.beforeLoadRemoteSnapshot.emit({\n      options,\n      moduleInfo,\n    });\n\n    let hostSnapshot = getGlobalSnapshotInfoByModuleInfo({\n      name: this.HostInstance.options.name,\n      version: this.HostInstance.options.version,\n    });\n\n    if (!hostSnapshot) {\n      hostSnapshot = {\n        version: this.HostInstance.options.version || '',\n        remoteEntry: '',\n        remotesInfo: {},\n      };\n      addGlobalSnapshot({\n        [this.HostInstance.options.name]: hostSnapshot,\n      });\n    }\n\n    // In dynamic loadRemote scenarios, incomplete remotesInfo delivery may occur. In such cases, the remotesInfo in the host needs to be completed in the snapshot at runtime.\n    // 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.\n    if (\n      hostSnapshot &&\n      'remotesInfo' in hostSnapshot &&\n      !getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name).value\n    ) {\n      if ('version' in moduleInfo || 'entry' in moduleInfo) {\n        hostSnapshot.remotesInfo = {\n          ...hostSnapshot?.remotesInfo,\n          [moduleInfo.name]: {\n            matchedVersion:\n              'version' in moduleInfo ? moduleInfo.version : moduleInfo.entry,\n          },\n        };\n      }\n    }\n\n    const { hostGlobalSnapshot, remoteSnapshot, globalSnapshot } =\n      this.getGlobalRemoteInfo(moduleInfo);\n    const {\n      remoteSnapshot: globalRemoteSnapshot,\n      globalSnapshot: globalSnapshotRes,\n    } = await this.hooks.lifecycle.loadSnapshot.emit({\n      options,\n      moduleInfo,\n      hostGlobalSnapshot,\n      remoteSnapshot,\n      globalSnapshot,\n    });\n\n    let mSnapshot;\n    let gSnapshot;\n    // global snapshot includes manifest or module info includes manifest\n    if (globalRemoteSnapshot) {\n      if (isManifestProvider(globalRemoteSnapshot)) {\n        const remoteEntry = isBrowserEnv()\n          ? globalRemoteSnapshot.remoteEntry\n          : globalRemoteSnapshot.ssrRemoteEntry ||\n            globalRemoteSnapshot.remoteEntry ||\n            '';\n        const moduleSnapshot = await this.getManifestJson(\n          remoteEntry,\n          moduleInfo,\n          {},\n        );\n        // eslint-disable-next-line @typescript-eslint/no-shadow\n        const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo(\n          {\n            ...moduleInfo,\n            // The global remote may be overridden\n            // Therefore, set the snapshot key to the global address of the actual request\n            entry: remoteEntry,\n          },\n          moduleSnapshot,\n        );\n        mSnapshot = moduleSnapshot;\n        gSnapshot = globalSnapshotRes;\n      } else {\n        const { remoteSnapshot: remoteSnapshotRes } =\n          await this.hooks.lifecycle.loadRemoteSnapshot.emit({\n            options: this.HostInstance.options,\n            moduleInfo,\n            remoteSnapshot: globalRemoteSnapshot,\n            from: 'global',\n          });\n        mSnapshot = remoteSnapshotRes;\n        gSnapshot = globalSnapshotRes;\n      }\n    } else {\n      if (isRemoteInfoWithEntry(moduleInfo)) {\n        // get from manifest.json and merge remote info from remote server\n        const moduleSnapshot = await this.getManifestJson(\n          moduleInfo.entry,\n          moduleInfo,\n          {},\n        );\n        // eslint-disable-next-line @typescript-eslint/no-shadow\n        const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo(\n          moduleInfo,\n          moduleSnapshot,\n        );\n        const { remoteSnapshot: remoteSnapshotRes } =\n          await this.hooks.lifecycle.loadRemoteSnapshot.emit({\n            options: this.HostInstance.options,\n            moduleInfo,\n            remoteSnapshot: moduleSnapshot,\n            from: 'global',\n          });\n\n        mSnapshot = remoteSnapshotRes;\n        gSnapshot = globalSnapshotRes;\n      } else {\n        error(\n          getShortErrorMsg(RUNTIME_007, runtimeDescMap, {\n            hostName: moduleInfo.name,\n            hostVersion: moduleInfo.version,\n            globalSnapshot: JSON.stringify(globalSnapshotRes),\n          }),\n        );\n      }\n    }\n\n    await this.hooks.lifecycle.afterLoadSnapshot.emit({\n      id,\n      host: this.HostInstance,\n      options,\n      moduleInfo,\n      remoteSnapshot: mSnapshot,\n    });\n\n    return {\n      remoteSnapshot: mSnapshot,\n      globalSnapshot: gSnapshot,\n    };\n  }\n\n  getGlobalRemoteInfo(moduleInfo: Remote): {\n    hostGlobalSnapshot: ModuleInfo | undefined;\n    globalSnapshot: ReturnType<typeof getGlobalSnapshot>;\n    remoteSnapshot: GlobalModuleInfo[string] | undefined;\n  } {\n    return getGlobalRemoteInfo(moduleInfo, this.HostInstance);\n  }\n\n  private async getManifestJson(\n    manifestUrl: string,\n    moduleInfo: Remote,\n    extraOptions: Record<string, any>,\n  ): Promise<ModuleInfo> {\n    const getManifest = async (): Promise<Manifest> => {\n      let manifestJson: Manifest | undefined =\n        this.manifestCache.get(manifestUrl);\n      if (manifestJson) {\n        return manifestJson;\n      }\n      try {\n        let res = await this.loaderHook.lifecycle.fetch.emit(manifestUrl, {});\n        if (!res || !(res instanceof Response)) {\n          res = await fetch(manifestUrl, {});\n        }\n        manifestJson = (await res.json()) as Manifest;\n      } catch (err) {\n        manifestJson =\n          (await this.HostInstance.remoteHandler.hooks.lifecycle.errorLoadRemote.emit(\n            {\n              id: manifestUrl,\n              error: err,\n              from: 'runtime',\n              lifecycle: 'afterResolve',\n              origin: this.HostInstance,\n            },\n          )) as Manifest | undefined;\n\n        if (!manifestJson) {\n          delete this.manifestLoading[manifestUrl];\n          error(\n            getShortErrorMsg(\n              RUNTIME_003,\n              runtimeDescMap,\n              {\n                manifestUrl,\n                moduleName: moduleInfo.name,\n                hostName: this.HostInstance.options.name,\n              },\n              `${err}`,\n            ),\n          );\n        }\n      }\n\n      assert(\n        manifestJson.metaData && manifestJson.exposes && manifestJson.shared,\n        `${manifestUrl} is not a federation manifest`,\n      );\n      this.manifestCache.set(manifestUrl, manifestJson);\n      return manifestJson;\n    };\n\n    const asyncLoadProcess = async () => {\n      const manifestJson = await getManifest();\n      const remoteSnapshot = generateSnapshotFromManifest(manifestJson, {\n        version: manifestUrl,\n      });\n\n      const { remoteSnapshot: remoteSnapshotRes } =\n        await this.hooks.lifecycle.loadRemoteSnapshot.emit({\n          options: this.HostInstance.options,\n          moduleInfo,\n          manifestJson,\n          remoteSnapshot,\n          manifestUrl,\n          from: 'manifest',\n        });\n      return remoteSnapshotRes;\n    };\n\n    if (!this.manifestLoading[manifestUrl]) {\n      this.manifestLoading[manifestUrl] = asyncLoadProcess().then((res) => res);\n    }\n    return this.manifestLoading[manifestUrl];\n  }\n}\n"],"mappings":"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"}

package/dist/plugins/snapshot/index.cjs

@@ -0,0 +1,62 @@
+const require_logger = require('../../utils/logger.cjs');
+const require_tool = require('../../utils/tool.cjs');
+require('../../utils/index.cjs');
+const require_preload = require('../../utils/preload.cjs');
+let _module_federation_sdk = require("@module-federation/sdk");
+
+//#region src/plugins/snapshot/index.ts
+function assignRemoteInfo(remoteInfo, remoteSnapshot) {
+	const remoteEntryInfo = require_tool.getRemoteEntryInfoFromSnapshot(remoteSnapshot);
+	if (!remoteEntryInfo.url) require_logger.error(`The attribute remoteEntry of ${remoteInfo.name} must not be undefined.`);
+	let entryUrl = (0, _module_federation_sdk.getResourceUrl)(remoteSnapshot, remoteEntryInfo.url);
+	if (!(0, _module_federation_sdk.isBrowserEnv)() && !entryUrl.startsWith("http")) entryUrl = `https:${entryUrl}`;
+	remoteInfo.type = remoteEntryInfo.type;
+	remoteInfo.entryGlobalName = remoteEntryInfo.globalName;
+	remoteInfo.entry = entryUrl;
+	remoteInfo.version = remoteSnapshot.version;
+	remoteInfo.buildVersion = remoteSnapshot.buildVersion;
+}
+function snapshotPlugin() {
+	return {
+		name: "snapshot-plugin",
+		async afterResolve(args) {
+			const { remote, pkgNameOrAlias, expose, origin, remoteInfo, id } = args;
+			if (!require_tool.isRemoteInfoWithEntry(remote) || !require_tool.isPureRemoteEntry(remote)) {
+				const { remoteSnapshot, globalSnapshot } = await origin.snapshotHandler.loadRemoteSnapshotInfo({
+					moduleInfo: remote,
+					id
+				});
+				assignRemoteInfo(remoteInfo, remoteSnapshot);
+				const preloadOptions = {
+					remote,
+					preloadConfig: {
+						nameOrAlias: pkgNameOrAlias,
+						exposes: [expose],
+						resourceCategory: "sync",
+						share: false,
+						depsRemote: false
+					}
+				};
+				const assets = await origin.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit({
+					origin,
+					preloadOptions,
+					remoteInfo,
+					remote,
+					remoteSnapshot,
+					globalSnapshot
+				});
+				if (assets) require_preload.preloadAssets(remoteInfo, origin, assets, false);
+				return {
+					...args,
+					remoteSnapshot
+				};
+			}
+			return args;
+		}
+	};
+}
+
+//#endregion
+exports.assignRemoteInfo = assignRemoteInfo;
+exports.snapshotPlugin = snapshotPlugin;
+//# sourceMappingURL=index.cjs.map

package/dist/plugins/snapshot/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["getRemoteEntryInfoFromSnapshot","isRemoteInfoWithEntry","isPureRemoteEntry"],"sources":["../../../src/plugins/snapshot/index.ts"],"sourcesContent":["import {\n  ModuleInfo,\n  getResourceUrl,\n  isBrowserEnv,\n} from '@module-federation/sdk';\nimport { ModuleFederationRuntimePlugin } from '../../type/plugin';\nimport {\n  error,\n  isPureRemoteEntry,\n  isRemoteInfoWithEntry,\n  getRemoteEntryInfoFromSnapshot,\n} from '../../utils';\nimport { PreloadOptions, RemoteInfo } from '../../type';\nimport { preloadAssets } from '../../utils/preload';\n\nexport function assignRemoteInfo(\n  remoteInfo: RemoteInfo,\n  remoteSnapshot: ModuleInfo,\n): void {\n  const remoteEntryInfo = getRemoteEntryInfoFromSnapshot(remoteSnapshot);\n  if (!remoteEntryInfo.url) {\n    error(\n      `The attribute remoteEntry of ${remoteInfo.name} must not be undefined.`,\n    );\n  }\n\n  let entryUrl = getResourceUrl(remoteSnapshot, remoteEntryInfo.url);\n\n  if (!isBrowserEnv() && !entryUrl.startsWith('http')) {\n    entryUrl = `https:${entryUrl}`;\n  }\n\n  remoteInfo.type = remoteEntryInfo.type;\n  remoteInfo.entryGlobalName = remoteEntryInfo.globalName;\n  remoteInfo.entry = entryUrl;\n  remoteInfo.version = remoteSnapshot.version;\n  remoteInfo.buildVersion = remoteSnapshot.buildVersion;\n}\n\nexport function snapshotPlugin(): ModuleFederationRuntimePlugin {\n  return {\n    name: 'snapshot-plugin',\n    async afterResolve(args) {\n      const { remote, pkgNameOrAlias, expose, origin, remoteInfo, id } = args;\n\n      if (!isRemoteInfoWithEntry(remote) || !isPureRemoteEntry(remote)) {\n        const { remoteSnapshot, globalSnapshot } =\n          await origin.snapshotHandler.loadRemoteSnapshotInfo({\n            moduleInfo: remote,\n            id,\n          });\n\n        assignRemoteInfo(remoteInfo, remoteSnapshot);\n        // preloading assets\n        const preloadOptions: PreloadOptions[0] = {\n          remote,\n          preloadConfig: {\n            nameOrAlias: pkgNameOrAlias,\n            exposes: [expose],\n            resourceCategory: 'sync',\n            share: false,\n            depsRemote: false,\n          },\n        };\n\n        const assets =\n          await origin.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit(\n            {\n              origin,\n              preloadOptions,\n              remoteInfo,\n              remote,\n              remoteSnapshot,\n              globalSnapshot,\n            },\n          );\n\n        if (assets) {\n          preloadAssets(remoteInfo, origin, assets, false);\n        }\n\n        return {\n          ...args,\n          remoteSnapshot,\n        };\n      }\n\n      return args;\n    },\n  };\n}\n"],"mappings":";;;;;;;AAeA,SAAgB,iBACd,YACA,gBACM;CACN,MAAM,kBAAkBA,4CAA+B,eAAe;AACtE,KAAI,CAAC,gBAAgB,IACnB,sBACE,gCAAgC,WAAW,KAAK,yBACjD;CAGH,IAAI,sDAA0B,gBAAgB,gBAAgB,IAAI;AAElE,KAAI,2CAAe,IAAI,CAAC,SAAS,WAAW,OAAO,CACjD,YAAW,SAAS;AAGtB,YAAW,OAAO,gBAAgB;AAClC,YAAW,kBAAkB,gBAAgB;AAC7C,YAAW,QAAQ;AACnB,YAAW,UAAU,eAAe;AACpC,YAAW,eAAe,eAAe;;AAG3C,SAAgB,iBAAgD;AAC9D,QAAO;EACL,MAAM;EACN,MAAM,aAAa,MAAM;GACvB,MAAM,EAAE,QAAQ,gBAAgB,QAAQ,QAAQ,YAAY,OAAO;AAEnE,OAAI,CAACC,mCAAsB,OAAO,IAAI,CAACC,+BAAkB,OAAO,EAAE;IAChE,MAAM,EAAE,gBAAgB,mBACtB,MAAM,OAAO,gBAAgB,uBAAuB;KAClD,YAAY;KACZ;KACD,CAAC;AAEJ,qBAAiB,YAAY,eAAe;IAE5C,MAAM,iBAAoC;KACxC;KACA,eAAe;MACb,aAAa;MACb,SAAS,CAAC,OAAO;MACjB,kBAAkB;MAClB,OAAO;MACP,YAAY;MACb;KACF;IAED,MAAM,SACJ,MAAM,OAAO,cAAc,MAAM,UAAU,sBAAsB,KAC/D;KACE;KACA;KACA;KACA;KACA;KACA;KACD,CACF;AAEH,QAAI,OACF,+BAAc,YAAY,QAAQ,QAAQ,MAAM;AAGlD,WAAO;KACL,GAAG;KACH;KACD;;AAGH,UAAO;;EAEV"}

package/dist/plugins/snapshot/index.js

@@ -0,0 +1,61 @@
+import { error } from "../../utils/logger.js";
+import { getRemoteEntryInfoFromSnapshot, isPureRemoteEntry, isRemoteInfoWithEntry } from "../../utils/tool.js";
+import "../../utils/index.js";
+import { preloadAssets } from "../../utils/preload.js";
+import { getResourceUrl, isBrowserEnv } from "@module-federation/sdk";
+
+//#region src/plugins/snapshot/index.ts
+function assignRemoteInfo(remoteInfo, remoteSnapshot) {
+	const remoteEntryInfo = getRemoteEntryInfoFromSnapshot(remoteSnapshot);
+	if (!remoteEntryInfo.url) error(`The attribute remoteEntry of ${remoteInfo.name} must not be undefined.`);
+	let entryUrl = getResourceUrl(remoteSnapshot, remoteEntryInfo.url);
+	if (!isBrowserEnv() && !entryUrl.startsWith("http")) entryUrl = `https:${entryUrl}`;
+	remoteInfo.type = remoteEntryInfo.type;
+	remoteInfo.entryGlobalName = remoteEntryInfo.globalName;
+	remoteInfo.entry = entryUrl;
+	remoteInfo.version = remoteSnapshot.version;
+	remoteInfo.buildVersion = remoteSnapshot.buildVersion;
+}
+function snapshotPlugin() {
+	return {
+		name: "snapshot-plugin",
+		async afterResolve(args) {
+			const { remote, pkgNameOrAlias, expose, origin, remoteInfo, id } = args;
+			if (!isRemoteInfoWithEntry(remote) || !isPureRemoteEntry(remote)) {
+				const { remoteSnapshot, globalSnapshot } = await origin.snapshotHandler.loadRemoteSnapshotInfo({
+					moduleInfo: remote,
+					id
+				});
+				assignRemoteInfo(remoteInfo, remoteSnapshot);
+				const preloadOptions = {
+					remote,
+					preloadConfig: {
+						nameOrAlias: pkgNameOrAlias,
+						exposes: [expose],
+						resourceCategory: "sync",
+						share: false,
+						depsRemote: false
+					}
+				};
+				const assets = await origin.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit({
+					origin,
+					preloadOptions,
+					remoteInfo,
+					remote,
+					remoteSnapshot,
+					globalSnapshot
+				});
+				if (assets) preloadAssets(remoteInfo, origin, assets, false);
+				return {
+					...args,
+					remoteSnapshot
+				};
+			}
+			return args;
+		}
+	};
+}
+
+//#endregion
+export { assignRemoteInfo, snapshotPlugin };
+//# sourceMappingURL=index.js.map

package/dist/plugins/snapshot/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/plugins/snapshot/index.ts"],"sourcesContent":["import {\n  ModuleInfo,\n  getResourceUrl,\n  isBrowserEnv,\n} from '@module-federation/sdk';\nimport { ModuleFederationRuntimePlugin } from '../../type/plugin';\nimport {\n  error,\n  isPureRemoteEntry,\n  isRemoteInfoWithEntry,\n  getRemoteEntryInfoFromSnapshot,\n} from '../../utils';\nimport { PreloadOptions, RemoteInfo } from '../../type';\nimport { preloadAssets } from '../../utils/preload';\n\nexport function assignRemoteInfo(\n  remoteInfo: RemoteInfo,\n  remoteSnapshot: ModuleInfo,\n): void {\n  const remoteEntryInfo = getRemoteEntryInfoFromSnapshot(remoteSnapshot);\n  if (!remoteEntryInfo.url) {\n    error(\n      `The attribute remoteEntry of ${remoteInfo.name} must not be undefined.`,\n    );\n  }\n\n  let entryUrl = getResourceUrl(remoteSnapshot, remoteEntryInfo.url);\n\n  if (!isBrowserEnv() && !entryUrl.startsWith('http')) {\n    entryUrl = `https:${entryUrl}`;\n  }\n\n  remoteInfo.type = remoteEntryInfo.type;\n  remoteInfo.entryGlobalName = remoteEntryInfo.globalName;\n  remoteInfo.entry = entryUrl;\n  remoteInfo.version = remoteSnapshot.version;\n  remoteInfo.buildVersion = remoteSnapshot.buildVersion;\n}\n\nexport function snapshotPlugin(): ModuleFederationRuntimePlugin {\n  return {\n    name: 'snapshot-plugin',\n    async afterResolve(args) {\n      const { remote, pkgNameOrAlias, expose, origin, remoteInfo, id } = args;\n\n      if (!isRemoteInfoWithEntry(remote) || !isPureRemoteEntry(remote)) {\n        const { remoteSnapshot, globalSnapshot } =\n          await origin.snapshotHandler.loadRemoteSnapshotInfo({\n            moduleInfo: remote,\n            id,\n          });\n\n        assignRemoteInfo(remoteInfo, remoteSnapshot);\n        // preloading assets\n        const preloadOptions: PreloadOptions[0] = {\n          remote,\n          preloadConfig: {\n            nameOrAlias: pkgNameOrAlias,\n            exposes: [expose],\n            resourceCategory: 'sync',\n            share: false,\n            depsRemote: false,\n          },\n        };\n\n        const assets =\n          await origin.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit(\n            {\n              origin,\n              preloadOptions,\n              remoteInfo,\n              remote,\n              remoteSnapshot,\n              globalSnapshot,\n            },\n          );\n\n        if (assets) {\n          preloadAssets(remoteInfo, origin, assets, false);\n        }\n\n        return {\n          ...args,\n          remoteSnapshot,\n        };\n      }\n\n      return args;\n    },\n  };\n}\n"],"mappings":";;;;;;;AAeA,SAAgB,iBACd,YACA,gBACM;CACN,MAAM,kBAAkB,+BAA+B,eAAe;AACtE,KAAI,CAAC,gBAAgB,IACnB,OACE,gCAAgC,WAAW,KAAK,yBACjD;CAGH,IAAI,WAAW,eAAe,gBAAgB,gBAAgB,IAAI;AAElE,KAAI,CAAC,cAAc,IAAI,CAAC,SAAS,WAAW,OAAO,CACjD,YAAW,SAAS;AAGtB,YAAW,OAAO,gBAAgB;AAClC,YAAW,kBAAkB,gBAAgB;AAC7C,YAAW,QAAQ;AACnB,YAAW,UAAU,eAAe;AACpC,YAAW,eAAe,eAAe;;AAG3C,SAAgB,iBAAgD;AAC9D,QAAO;EACL,MAAM;EACN,MAAM,aAAa,MAAM;GACvB,MAAM,EAAE,QAAQ,gBAAgB,QAAQ,QAAQ,YAAY,OAAO;AAEnE,OAAI,CAAC,sBAAsB,OAAO,IAAI,CAAC,kBAAkB,OAAO,EAAE;IAChE,MAAM,EAAE,gBAAgB,mBACtB,MAAM,OAAO,gBAAgB,uBAAuB;KAClD,YAAY;KACZ;KACD,CAAC;AAEJ,qBAAiB,YAAY,eAAe;IAE5C,MAAM,iBAAoC;KACxC;KACA,eAAe;MACb,aAAa;MACb,SAAS,CAAC,OAAO;MACjB,kBAAkB;MAClB,OAAO;MACP,YAAY;MACb;KACF;IAED,MAAM,SACJ,MAAM,OAAO,cAAc,MAAM,UAAU,sBAAsB,KAC/D;KACE;KACA;KACA;KACA;KACA;KACA;KACD,CACF;AAEH,QAAI,OACF,eAAc,YAAY,QAAQ,QAAQ,MAAM;AAGlD,WAAO;KACL,GAAG;KACH;KACD;;AAGH,UAAO;;EAEV"}

package/dist/remote/index.cjs

@@ -0,0 +1,303 @@
+const require_logger = require('../utils/logger.cjs');
+const require_global = require('../global.cjs');
+const require_constant = require('../constant.cjs');
+const require_share = require('../utils/share.cjs');
+const require_manifest = require('../utils/manifest.cjs');
+const require_load = require('../utils/load.cjs');
+require('../utils/index.cjs');
+const require_preload = require('../utils/preload.cjs');
+const require_index$1 = require('../module/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');
+const require_SnapshotHandler = require('../plugins/snapshot/SnapshotHandler.cjs');
+let _module_federation_sdk = require("@module-federation/sdk");
+let _module_federation_error_codes = require("@module-federation/error-codes");
+
+//#region src/remote/index.ts
+var RemoteHandler = class {
+	constructor(host) {
+		this.hooks = new require_pluginSystem.PluginSystem({
+			beforeRegisterRemote: new require_syncWaterfallHook.SyncWaterfallHook("beforeRegisterRemote"),
+			registerRemote: new require_syncWaterfallHook.SyncWaterfallHook("registerRemote"),
+			beforeRequest: new require_asyncWaterfallHooks.AsyncWaterfallHook("beforeRequest"),
+			onLoad: new require_asyncHook.AsyncHook("onLoad"),
+			handlePreloadModule: new require_syncHook.SyncHook("handlePreloadModule"),
+			errorLoadRemote: new require_asyncHook.AsyncHook("errorLoadRemote"),
+			beforePreloadRemote: new require_asyncHook.AsyncHook("beforePreloadRemote"),
+			generatePreloadAssets: new require_asyncHook.AsyncHook("generatePreloadAssets"),
+			afterPreloadRemote: new require_asyncHook.AsyncHook(),
+			loadEntry: new require_asyncHook.AsyncHook()
+		});
+		this.host = host;
+		this.idToRemoteMap = {};
+	}
+	formatAndRegisterRemote(globalOptions, userOptions) {
+		return (userOptions.remotes || []).reduce((res, remote) => {
+			this.registerRemote(remote, res, { force: false });
+			return res;
+		}, globalOptions.remotes);
+	}
+	setIdToRemoteMap(id, remoteMatchInfo) {
+		const { remote, expose } = remoteMatchInfo;
+		const { name, alias } = remote;
+		this.idToRemoteMap[id] = {
+			name: remote.name,
+			expose
+		};
+		if (alias && id.startsWith(name)) {
+			const idWithAlias = id.replace(name, alias);
+			this.idToRemoteMap[idWithAlias] = {
+				name: remote.name,
+				expose
+			};
+			return;
+		}
+		if (alias && id.startsWith(alias)) {
+			const idWithName = id.replace(alias, name);
+			this.idToRemoteMap[idWithName] = {
+				name: remote.name,
+				expose
+			};
+		}
+	}
+	async loadRemote(id, options) {
+		const { host } = this;
+		try {
+			const { loadFactory = true } = options || { loadFactory: true };
+			const { module, moduleOptions, remoteMatchInfo } = await this.getRemoteModuleAndOptions({ id });
+			const { pkgNameOrAlias, remote, expose, id: idRes, remoteSnapshot } = remoteMatchInfo;
+			const moduleOrFactory = await module.get(idRes, expose, options, remoteSnapshot);
+			const moduleWrapper = await this.hooks.lifecycle.onLoad.emit({
+				id: idRes,
+				pkgNameOrAlias,
+				expose,
+				exposeModule: loadFactory ? moduleOrFactory : void 0,
+				exposeModuleFactory: loadFactory ? void 0 : moduleOrFactory,
+				remote,
+				options: moduleOptions,
+				moduleInstance: module,
+				origin: host
+			});
+			this.setIdToRemoteMap(id, remoteMatchInfo);
+			if (typeof moduleWrapper === "function") return moduleWrapper;
+			return moduleOrFactory;
+		} catch (error) {
+			const { from = "runtime" } = options || { from: "runtime" };
+			const failOver = await this.hooks.lifecycle.errorLoadRemote.emit({
+				id,
+				error,
+				from,
+				lifecycle: "onLoad",
+				origin: host
+			});
+			if (!failOver) throw error;
+			return failOver;
+		}
+	}
+	async preloadRemote(preloadOptions) {
+		const { host } = this;
+		await this.hooks.lifecycle.beforePreloadRemote.emit({
+			preloadOps: preloadOptions,
+			options: host.options,
+			origin: host
+		});
+		const preloadOps = require_preload.formatPreloadArgs(host.options.remotes, preloadOptions);
+		await Promise.all(preloadOps.map(async (ops) => {
+			const { remote } = ops;
+			const remoteInfo = require_load.getRemoteInfo(remote);
+			const { globalSnapshot, remoteSnapshot } = await host.snapshotHandler.loadRemoteSnapshotInfo({ moduleInfo: remote });
+			const assets = await this.hooks.lifecycle.generatePreloadAssets.emit({
+				origin: host,
+				preloadOptions: ops,
+				remote,
+				remoteInfo,
+				globalSnapshot,
+				remoteSnapshot
+			});
+			if (!assets) return;
+			require_preload.preloadAssets(remoteInfo, host, assets);
+		}));
+	}
+	registerRemotes(remotes, options) {
+		const { host } = this;
+		remotes.forEach((remote) => {
+			this.registerRemote(remote, host.options.remotes, { force: options?.force });
+		});
+	}
+	async getRemoteModuleAndOptions(options) {
+		const { host } = this;
+		const { id } = options;
+		let loadRemoteArgs;
+		try {
+			loadRemoteArgs = await this.hooks.lifecycle.beforeRequest.emit({
+				id,
+				options: host.options,
+				origin: host
+			});
+		} catch (error) {
+			loadRemoteArgs = await this.hooks.lifecycle.errorLoadRemote.emit({
+				id,
+				options: host.options,
+				origin: host,
+				from: "runtime",
+				error,
+				lifecycle: "beforeRequest"
+			});
+			if (!loadRemoteArgs) throw error;
+		}
+		const { id: idRes } = loadRemoteArgs;
+		const remoteSplitInfo = require_manifest.matchRemoteWithNameAndExpose(host.options.remotes, idRes);
+		require_logger.assert(remoteSplitInfo, (0, _module_federation_error_codes.getShortErrorMsg)(_module_federation_error_codes.RUNTIME_004, _module_federation_error_codes.runtimeDescMap, {
+			hostName: host.options.name,
+			requestId: idRes
+		}));
+		const { remote: rawRemote } = remoteSplitInfo;
+		const remoteInfo = require_load.getRemoteInfo(rawRemote);
+		const matchInfo = await host.sharedHandler.hooks.lifecycle.afterResolve.emit({
+			id: idRes,
+			...remoteSplitInfo,
+			options: host.options,
+			origin: host,
+			remoteInfo
+		});
+		const { remote, expose } = matchInfo;
+		require_logger.assert(remote && expose, `The 'beforeRequest' hook was executed, but it failed to return the correct 'remote' and 'expose' values while loading ${idRes}.`);
+		let module = host.moduleCache.get(remote.name);
+		const moduleOptions = {
+			host,
+			remoteInfo
+		};
+		if (!module) {
+			module = new require_index$1.Module(moduleOptions);
+			host.moduleCache.set(remote.name, module);
+		}
+		return {
+			module,
+			moduleOptions,
+			remoteMatchInfo: matchInfo
+		};
+	}
+	registerRemote(remote, targetRemotes, options) {
+		const { host } = this;
+		const normalizeRemote = () => {
+			if (remote.alias) {
+				const findEqual = targetRemotes.find((item) => remote.alias && (item.name.startsWith(remote.alias) || item.alias?.startsWith(remote.alias)));
+				require_logger.assert(!findEqual, `The alias ${remote.alias} of remote ${remote.name} is not allowed to be the prefix of ${findEqual && findEqual.name} name or alias`);
+			}
+			if ("entry" in remote) {
+				if ((0, _module_federation_sdk.isBrowserEnv)() && !remote.entry.startsWith("http")) remote.entry = new URL(remote.entry, window.location.origin).href;
+			}
+			if (!remote.shareScope) remote.shareScope = require_constant.DEFAULT_SCOPE;
+			if (!remote.type) remote.type = require_constant.DEFAULT_REMOTE_TYPE;
+		};
+		this.hooks.lifecycle.beforeRegisterRemote.emit({
+			remote,
+			origin: host
+		});
+		const registeredRemote = targetRemotes.find((item) => item.name === remote.name);
+		if (!registeredRemote) {
+			normalizeRemote();
+			targetRemotes.push(remote);
+			this.hooks.lifecycle.registerRemote.emit({
+				remote,
+				origin: host
+			});
+		} else {
+			const messages = [`The remote "${remote.name}" is already registered.`, "Please note that overriding it may cause unexpected errors."];
+			if (options?.force) {
+				this.removeRemote(registeredRemote);
+				normalizeRemote();
+				targetRemotes.push(remote);
+				this.hooks.lifecycle.registerRemote.emit({
+					remote,
+					origin: host
+				});
+				(0, _module_federation_sdk.warn)(messages.join(" "));
+			}
+		}
+	}
+	removeRemote(remote) {
+		try {
+			const { host } = this;
+			const { name } = remote;
+			const remoteIndex = host.options.remotes.findIndex((item) => item.name === name);
+			if (remoteIndex !== -1) host.options.remotes.splice(remoteIndex, 1);
+			const loadedModule = host.moduleCache.get(remote.name);
+			if (loadedModule) {
+				const remoteInfo = loadedModule.remoteInfo;
+				const key = remoteInfo.entryGlobalName;
+				if (require_global.CurrentGlobal[key]) if (Object.getOwnPropertyDescriptor(require_global.CurrentGlobal, key)?.configurable) delete require_global.CurrentGlobal[key];
+				else require_global.CurrentGlobal[key] = void 0;
+				const remoteEntryUniqueKey = require_load.getRemoteEntryUniqueKey(loadedModule.remoteInfo);
+				if (require_global.globalLoading[remoteEntryUniqueKey]) delete require_global.globalLoading[remoteEntryUniqueKey];
+				host.snapshotHandler.manifestCache.delete(remoteInfo.entry);
+				let remoteInsId = remoteInfo.buildVersion ? (0, _module_federation_sdk.composeKeyWithSeparator)(remoteInfo.name, remoteInfo.buildVersion) : remoteInfo.name;
+				const remoteInsIndex = require_global.CurrentGlobal.__FEDERATION__.__INSTANCES__.findIndex((ins) => {
+					if (remoteInfo.buildVersion) return ins.options.id === remoteInsId;
+					else return ins.name === remoteInsId;
+				});
+				if (remoteInsIndex !== -1) {
+					const remoteIns = require_global.CurrentGlobal.__FEDERATION__.__INSTANCES__[remoteInsIndex];
+					remoteInsId = remoteIns.options.id || remoteInsId;
+					const globalShareScopeMap = require_share.getGlobalShareScope();
+					let isAllSharedNotUsed = true;
+					const needDeleteKeys = [];
+					Object.keys(globalShareScopeMap).forEach((instId) => {
+						const shareScopeMap = globalShareScopeMap[instId];
+						shareScopeMap && Object.keys(shareScopeMap).forEach((shareScope) => {
+							const shareScopeVal = shareScopeMap[shareScope];
+							shareScopeVal && Object.keys(shareScopeVal).forEach((shareName) => {
+								const sharedPkgs = shareScopeVal[shareName];
+								sharedPkgs && Object.keys(sharedPkgs).forEach((shareVersion) => {
+									const shared = sharedPkgs[shareVersion];
+									if (shared && typeof shared === "object" && shared.from === remoteInfo.name) if (shared.loaded || shared.loading) {
+										shared.useIn = shared.useIn.filter((usedHostName) => usedHostName !== remoteInfo.name);
+										if (shared.useIn.length) isAllSharedNotUsed = false;
+										else needDeleteKeys.push([
+											instId,
+											shareScope,
+											shareName,
+											shareVersion
+										]);
+									} else needDeleteKeys.push([
+										instId,
+										shareScope,
+										shareName,
+										shareVersion
+									]);
+								});
+							});
+						});
+					});
+					if (isAllSharedNotUsed) {
+						remoteIns.shareScopeMap = {};
+						delete globalShareScopeMap[remoteInsId];
+					}
+					needDeleteKeys.forEach(([insId, shareScope, shareName, shareVersion]) => {
+						delete globalShareScopeMap[insId]?.[shareScope]?.[shareName]?.[shareVersion];
+					});
+					require_global.CurrentGlobal.__FEDERATION__.__INSTANCES__.splice(remoteInsIndex, 1);
+				}
+				const { hostGlobalSnapshot } = require_SnapshotHandler.getGlobalRemoteInfo(remote, host);
+				if (hostGlobalSnapshot) {
+					const remoteKey = hostGlobalSnapshot && "remotesInfo" in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && require_global.getInfoWithoutType(hostGlobalSnapshot.remotesInfo, remote.name).key;
+					if (remoteKey) {
+						delete hostGlobalSnapshot.remotesInfo[remoteKey];
+						if (Boolean(require_global.Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey])) delete require_global.Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey];
+					}
+				}
+				host.moduleCache.delete(remote.name);
+			}
+		} catch (err) {
+			require_logger.logger.log("removeRemote fail: ", err);
+		}
+	}
+};
+
+//#endregion
+exports.RemoteHandler = RemoteHandler;
+//# sourceMappingURL=index.cjs.map