@module-federation/runtime-core 2.0.1 → 2.2.0

package/dist/plugins/generate-preload-assets.js

@@ -0,0 +1,182 @@
+import { arrayOptions, getFMId, getRemoteEntryInfoFromSnapshot, isPureRemoteEntry, isRemoteInfoWithEntry } from "../utils/tool.js";
+import { getInfoWithoutType, getPreloaded, setPreloaded } from "../global.js";
+import { getRegisteredShare } from "../utils/share.js";
+import "../utils/index.js";
+import { defaultPreloadArgs, normalizePreloadExposes } from "../utils/preload.js";
+import { assignRemoteInfo } from "./snapshot/index.js";
+import { getResourceUrl, isBrowserEnvValue, isManifestProvider } from "@module-federation/sdk";
+
+//#region src/plugins/generate-preload-assets.ts
+function splitId(id) {
+	const splitInfo = id.split(":");
+	if (splitInfo.length === 1) return {
+		name: splitInfo[0],
+		version: void 0
+	};
+	else if (splitInfo.length === 2) return {
+		name: splitInfo[0],
+		version: splitInfo[1]
+	};
+	else return {
+		name: splitInfo[1],
+		version: splitInfo[2]
+	};
+}
+function traverseModuleInfo(globalSnapshot, remoteInfo, traverse, isRoot, memo = {}, remoteSnapshot) {
+	const { value: snapshotValue } = getInfoWithoutType(globalSnapshot, getFMId(remoteInfo));
+	const effectiveRemoteSnapshot = remoteSnapshot || snapshotValue;
+	if (effectiveRemoteSnapshot && !isManifestProvider(effectiveRemoteSnapshot)) {
+		traverse(effectiveRemoteSnapshot, remoteInfo, isRoot);
+		if (effectiveRemoteSnapshot.remotesInfo) {
+			const remoteKeys = Object.keys(effectiveRemoteSnapshot.remotesInfo);
+			for (const key of remoteKeys) {
+				if (memo[key]) continue;
+				memo[key] = true;
+				const subRemoteInfo = splitId(key);
+				const remoteValue = effectiveRemoteSnapshot.remotesInfo[key];
+				traverseModuleInfo(globalSnapshot, {
+					name: subRemoteInfo.name,
+					version: remoteValue.matchedVersion
+				}, traverse, false, memo, void 0);
+			}
+		}
+	}
+}
+const isExisted = (type, url) => {
+	return document.querySelector(`${type}[${type === "link" ? "href" : "src"}="${url}"]`);
+};
+function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, remoteSnapshot) {
+	const cssAssets = [];
+	const jsAssets = [];
+	const entryAssets = [];
+	const loadedSharedJsAssets = /* @__PURE__ */ new Set();
+	const loadedSharedCssAssets = /* @__PURE__ */ new Set();
+	const { options } = origin;
+	const { preloadConfig: rootPreloadConfig } = preloadOptions;
+	const { depsRemote } = rootPreloadConfig;
+	traverseModuleInfo(globalSnapshot, remote, (moduleInfoSnapshot, remoteInfo, isRoot) => {
+		let preloadConfig;
+		if (isRoot) preloadConfig = rootPreloadConfig;
+		else if (Array.isArray(depsRemote)) {
+			const findPreloadConfig = depsRemote.find((remoteConfig) => {
+				if (remoteConfig.nameOrAlias === remoteInfo.name || remoteConfig.nameOrAlias === remoteInfo.alias) return true;
+				return false;
+			});
+			if (!findPreloadConfig) return;
+			preloadConfig = defaultPreloadArgs(findPreloadConfig);
+		} else if (depsRemote === true) preloadConfig = rootPreloadConfig;
+		else return;
+		const remoteEntryUrl = getResourceUrl(moduleInfoSnapshot, getRemoteEntryInfoFromSnapshot(moduleInfoSnapshot).url);
+		if (remoteEntryUrl) entryAssets.push({
+			name: remoteInfo.name,
+			moduleInfo: {
+				name: remoteInfo.name,
+				entry: remoteEntryUrl,
+				type: "remoteEntryType" in moduleInfoSnapshot ? moduleInfoSnapshot.remoteEntryType : "global",
+				entryGlobalName: "globalName" in moduleInfoSnapshot ? moduleInfoSnapshot.globalName : remoteInfo.name,
+				shareScope: "",
+				version: "version" in moduleInfoSnapshot ? moduleInfoSnapshot.version : void 0
+			},
+			url: remoteEntryUrl
+		});
+		let moduleAssetsInfo = "modules" in moduleInfoSnapshot ? moduleInfoSnapshot.modules : [];
+		const normalizedPreloadExposes = normalizePreloadExposes(preloadConfig.exposes);
+		if (normalizedPreloadExposes.length && "modules" in moduleInfoSnapshot) moduleAssetsInfo = moduleInfoSnapshot?.modules?.reduce((assets, moduleAssetInfo) => {
+			if (normalizedPreloadExposes?.indexOf(moduleAssetInfo.moduleName) !== -1) assets.push(moduleAssetInfo);
+			return assets;
+		}, []);
+		function handleAssets(assets) {
+			const assetsRes = assets.map((asset) => getResourceUrl(moduleInfoSnapshot, asset));
+			if (preloadConfig.filter) return assetsRes.filter(preloadConfig.filter);
+			return assetsRes;
+		}
+		if (moduleAssetsInfo) {
+			const assetsLength = moduleAssetsInfo.length;
+			for (let index = 0; index < assetsLength; index++) {
+				const assetsInfo = moduleAssetsInfo[index];
+				const exposeFullPath = `${remoteInfo.name}/${assetsInfo.moduleName}`;
+				origin.remoteHandler.hooks.lifecycle.handlePreloadModule.emit({
+					id: assetsInfo.moduleName === "." ? remoteInfo.name : exposeFullPath,
+					name: remoteInfo.name,
+					remoteSnapshot: moduleInfoSnapshot,
+					preloadConfig,
+					remote: remoteInfo,
+					origin
+				});
+				if (getPreloaded(exposeFullPath)) continue;
+				if (preloadConfig.resourceCategory === "all") {
+					cssAssets.push(...handleAssets(assetsInfo.assets.css.async));
+					cssAssets.push(...handleAssets(assetsInfo.assets.css.sync));
+					jsAssets.push(...handleAssets(assetsInfo.assets.js.async));
+					jsAssets.push(...handleAssets(assetsInfo.assets.js.sync));
+				} else if (preloadConfig.resourceCategory === "sync") {
+					cssAssets.push(...handleAssets(assetsInfo.assets.css.sync));
+					jsAssets.push(...handleAssets(assetsInfo.assets.js.sync));
+				}
+				setPreloaded(exposeFullPath);
+			}
+		}
+	}, true, {}, remoteSnapshot);
+	if (remoteSnapshot.shared && remoteSnapshot.shared.length > 0) {
+		const collectSharedAssets = (shareInfo, snapshotShared) => {
+			const { shared: registeredShared } = getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare) || {};
+			if (registeredShared && typeof registeredShared.lib === "function") {
+				snapshotShared.assets.js.sync.forEach((asset) => {
+					loadedSharedJsAssets.add(asset);
+				});
+				snapshotShared.assets.css.sync.forEach((asset) => {
+					loadedSharedCssAssets.add(asset);
+				});
+			}
+		};
+		remoteSnapshot.shared.forEach((shared) => {
+			const shareInfos = options.shared?.[shared.sharedName];
+			if (!shareInfos) return;
+			const sharedOptions = shared.version ? shareInfos.find((s) => s.version === shared.version) : shareInfos;
+			if (!sharedOptions) return;
+			arrayOptions(sharedOptions).forEach((s) => {
+				collectSharedAssets(s, shared);
+			});
+		});
+	}
+	const needPreloadJsAssets = jsAssets.filter((asset) => !loadedSharedJsAssets.has(asset) && !isExisted("script", asset));
+	return {
+		cssAssets: cssAssets.filter((asset) => !loadedSharedCssAssets.has(asset) && !isExisted("link", asset)),
+		jsAssetsWithoutEntry: needPreloadJsAssets,
+		entryAssets: entryAssets.filter((entry) => !isExisted("script", entry.url))
+	};
+}
+const generatePreloadAssetsPlugin = function() {
+	return {
+		name: "generate-preload-assets-plugin",
+		async generatePreloadAssets(args) {
+			const { origin, preloadOptions, remoteInfo, remote, globalSnapshot, remoteSnapshot } = args;
+			if (!isBrowserEnvValue) return {
+				cssAssets: [],
+				jsAssetsWithoutEntry: [],
+				entryAssets: []
+			};
+			if (isRemoteInfoWithEntry(remote) && isPureRemoteEntry(remote)) return {
+				cssAssets: [],
+				jsAssetsWithoutEntry: [],
+				entryAssets: [{
+					name: remote.name,
+					url: remote.entry,
+					moduleInfo: {
+						name: remoteInfo.name,
+						entry: remote.entry,
+						type: remoteInfo.type || "global",
+						entryGlobalName: "",
+						shareScope: ""
+					}
+				}]
+			};
+			assignRemoteInfo(remoteInfo, remoteSnapshot);
+			return generatePreloadAssets(origin, preloadOptions, remoteInfo, globalSnapshot, remoteSnapshot);
+		}
+	};
+};
+
+//#endregion
+export { generatePreloadAssetsPlugin };
+//# sourceMappingURL=generate-preload-assets.js.map

package/dist/plugins/generate-preload-assets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-preload-assets.js","names":[],"sources":["../../src/plugins/generate-preload-assets.ts"],"sourcesContent":["import {\n  GlobalModuleInfo,\n  ModuleInfo,\n  ProviderModuleInfo,\n  isManifestProvider,\n  getResourceUrl,\n  isBrowserEnvValue,\n} from '@module-federation/sdk';\nimport {\n  EntryAssets,\n  ModuleFederationRuntimePlugin,\n  PreloadAssets,\n  PreloadConfig,\n  PreloadOptions,\n  RemoteInfoOptionalVersion,\n  Shared,\n  Remote,\n} from '../type';\nimport { assignRemoteInfo } from './snapshot';\nimport { getInfoWithoutType, getPreloaded, setPreloaded } from '../global';\nimport { ModuleFederation } from '../core';\nimport { defaultPreloadArgs, normalizePreloadExposes } from '../utils/preload';\nimport { getRegisteredShare } from '../utils/share';\nimport {\n  arrayOptions,\n  getFMId,\n  getRemoteEntryInfoFromSnapshot,\n  isPureRemoteEntry,\n  isRemoteInfoWithEntry,\n} from '../utils';\n\ndeclare global {\n  // eslint-disable-next-line no-var\n  var __INIT_VMOK_DEPLOY_GLOBAL_DATA__: boolean | undefined;\n}\n\n// name\n// name:version\nfunction splitId(id: string): {\n  name: string;\n  version: string | undefined;\n} {\n  const splitInfo = id.split(':');\n  if (splitInfo.length === 1) {\n    return {\n      name: splitInfo[0],\n      version: undefined,\n    };\n  } else if (splitInfo.length === 2) {\n    return {\n      name: splitInfo[0],\n      version: splitInfo[1],\n    };\n  } else {\n    return {\n      name: splitInfo[1],\n      version: splitInfo[2],\n    };\n  }\n}\n\n// Traverse all nodes in moduleInfo and traverse the entire snapshot\nfunction traverseModuleInfo(\n  globalSnapshot: GlobalModuleInfo,\n  remoteInfo: RemoteInfoOptionalVersion,\n  traverse: (\n    snapshotInfo: ModuleInfo,\n    remoteInfo: RemoteInfoOptionalVersion,\n    isRoot: boolean,\n  ) => void,\n  isRoot: boolean,\n  memo: Record<string, boolean> = {},\n  remoteSnapshot?: ModuleInfo,\n): void {\n  const id = getFMId(remoteInfo);\n  const { value: snapshotValue } = getInfoWithoutType(globalSnapshot, id);\n  const effectiveRemoteSnapshot = remoteSnapshot || snapshotValue;\n  if (effectiveRemoteSnapshot && !isManifestProvider(effectiveRemoteSnapshot)) {\n    traverse(effectiveRemoteSnapshot, remoteInfo, isRoot);\n    if (effectiveRemoteSnapshot.remotesInfo) {\n      const remoteKeys = Object.keys(effectiveRemoteSnapshot.remotesInfo);\n      for (const key of remoteKeys) {\n        if (memo[key]) {\n          continue;\n        }\n        memo[key] = true;\n        const subRemoteInfo = splitId(key);\n        const remoteValue = effectiveRemoteSnapshot.remotesInfo[key];\n        traverseModuleInfo(\n          globalSnapshot,\n          {\n            name: subRemoteInfo.name,\n            version: remoteValue.matchedVersion,\n          },\n          traverse,\n          false,\n          memo,\n          undefined,\n        );\n      }\n    }\n  }\n}\n\nconst isExisted = (type: 'link' | 'script', url: string) => {\n  return document.querySelector(\n    `${type}[${type === 'link' ? 'href' : 'src'}=\"${url}\"]`,\n  );\n};\n\n// eslint-disable-next-line max-lines-per-function\nexport function generatePreloadAssets(\n  origin: ModuleFederation,\n  preloadOptions: PreloadOptions[number],\n  remote: RemoteInfoOptionalVersion,\n  globalSnapshot: GlobalModuleInfo,\n  remoteSnapshot: ModuleInfo,\n): PreloadAssets {\n  const cssAssets: Array<string> = [];\n  const jsAssets: Array<string> = [];\n  const entryAssets: Array<EntryAssets> = [];\n  const loadedSharedJsAssets = new Set();\n  const loadedSharedCssAssets = new Set();\n  const { options } = origin;\n\n  const { preloadConfig: rootPreloadConfig } = preloadOptions;\n  const { depsRemote } = rootPreloadConfig;\n  const memo = {};\n  traverseModuleInfo(\n    globalSnapshot,\n    remote,\n    (moduleInfoSnapshot: ModuleInfo, remoteInfo, isRoot) => {\n      let preloadConfig: PreloadConfig;\n      if (isRoot) {\n        preloadConfig = rootPreloadConfig;\n      } else {\n        if (Array.isArray(depsRemote)) {\n          // eslint-disable-next-line array-callback-return\n          const findPreloadConfig = depsRemote.find((remoteConfig) => {\n            if (\n              remoteConfig.nameOrAlias === remoteInfo.name ||\n              remoteConfig.nameOrAlias === remoteInfo.alias\n            ) {\n              return true;\n            }\n            return false;\n          });\n          if (!findPreloadConfig) {\n            return;\n          }\n          preloadConfig = defaultPreloadArgs(findPreloadConfig);\n        } else if (depsRemote === true) {\n          preloadConfig = rootPreloadConfig;\n        } else {\n          return;\n        }\n      }\n\n      const remoteEntryUrl = getResourceUrl(\n        moduleInfoSnapshot,\n        getRemoteEntryInfoFromSnapshot(moduleInfoSnapshot).url,\n      );\n\n      if (remoteEntryUrl) {\n        entryAssets.push({\n          name: remoteInfo.name,\n          moduleInfo: {\n            name: remoteInfo.name,\n            entry: remoteEntryUrl,\n            type:\n              'remoteEntryType' in moduleInfoSnapshot\n                ? moduleInfoSnapshot.remoteEntryType\n                : 'global',\n            entryGlobalName:\n              'globalName' in moduleInfoSnapshot\n                ? moduleInfoSnapshot.globalName\n                : remoteInfo.name,\n            shareScope: '',\n            version:\n              'version' in moduleInfoSnapshot\n                ? moduleInfoSnapshot.version\n                : undefined,\n          },\n          url: remoteEntryUrl,\n        });\n      }\n\n      let moduleAssetsInfo: NonNullable<ProviderModuleInfo['modules']> =\n        'modules' in moduleInfoSnapshot ? moduleInfoSnapshot.modules : [];\n      const normalizedPreloadExposes = normalizePreloadExposes(\n        preloadConfig.exposes,\n      );\n      if (normalizedPreloadExposes.length && 'modules' in moduleInfoSnapshot) {\n        moduleAssetsInfo = moduleInfoSnapshot?.modules?.reduce(\n          (assets, moduleAssetInfo) => {\n            if (\n              normalizedPreloadExposes?.indexOf(moduleAssetInfo.moduleName) !==\n              -1\n            ) {\n              assets.push(moduleAssetInfo);\n            }\n            return assets;\n          },\n          [] as NonNullable<(typeof moduleInfoSnapshot)['modules']>,\n        );\n      }\n\n      function handleAssets(assets: string[]): string[] {\n        const assetsRes = assets.map((asset) =>\n          getResourceUrl(moduleInfoSnapshot, asset),\n        );\n        if (preloadConfig.filter) {\n          return assetsRes.filter(preloadConfig.filter);\n        }\n        return assetsRes;\n      }\n\n      if (moduleAssetsInfo) {\n        const assetsLength = moduleAssetsInfo.length;\n        for (let index = 0; index < assetsLength; index++) {\n          const assetsInfo = moduleAssetsInfo[index];\n          const exposeFullPath = `${remoteInfo.name}/${assetsInfo.moduleName}`;\n          origin.remoteHandler.hooks.lifecycle.handlePreloadModule.emit({\n            id:\n              assetsInfo.moduleName === '.' ? remoteInfo.name : exposeFullPath,\n            name: remoteInfo.name,\n            remoteSnapshot: moduleInfoSnapshot,\n            preloadConfig,\n            remote: remoteInfo as Remote,\n            origin,\n          });\n          const preloaded = getPreloaded(exposeFullPath);\n          if (preloaded) {\n            continue;\n          }\n\n          if (preloadConfig.resourceCategory === 'all') {\n            cssAssets.push(...handleAssets(assetsInfo.assets.css.async));\n            cssAssets.push(...handleAssets(assetsInfo.assets.css.sync));\n            jsAssets.push(...handleAssets(assetsInfo.assets.js.async));\n            jsAssets.push(...handleAssets(assetsInfo.assets.js.sync));\n          } else if (preloadConfig.resourceCategory === 'sync') {\n            cssAssets.push(...handleAssets(assetsInfo.assets.css.sync));\n            jsAssets.push(...handleAssets(assetsInfo.assets.js.sync));\n          }\n\n          setPreloaded(exposeFullPath);\n        }\n      }\n    },\n    true,\n    memo,\n    remoteSnapshot,\n  );\n\n  if (remoteSnapshot.shared && remoteSnapshot.shared.length > 0) {\n    const collectSharedAssets = (\n      shareInfo: Shared,\n      snapshotShared: ModuleInfo['shared'][0],\n    ) => {\n      const { shared: registeredShared } =\n        getRegisteredShare(\n          origin.shareScopeMap,\n          snapshotShared.sharedName,\n          shareInfo,\n          origin.sharedHandler.hooks.lifecycle.resolveShare,\n        ) || {};\n      // If the global share does not exist, or the lib function does not exist, it means that the shared has not been loaded yet and can be preloaded.\n\n      if (registeredShared && typeof registeredShared.lib === 'function') {\n        snapshotShared.assets.js.sync.forEach((asset) => {\n          loadedSharedJsAssets.add(asset);\n        });\n        snapshotShared.assets.css.sync.forEach((asset) => {\n          loadedSharedCssAssets.add(asset);\n        });\n      }\n    };\n    remoteSnapshot.shared.forEach((shared) => {\n      const shareInfos = options.shared?.[shared.sharedName];\n      if (!shareInfos) {\n        return;\n      }\n      // if no version, preload all shared\n      const sharedOptions = shared.version\n        ? shareInfos.find((s) => s.version === shared.version)\n        : shareInfos;\n\n      if (!sharedOptions) {\n        return;\n      }\n      const arrayShareInfo = arrayOptions(sharedOptions);\n      arrayShareInfo.forEach((s) => {\n        collectSharedAssets(s, shared);\n      });\n    });\n  }\n\n  const needPreloadJsAssets = jsAssets.filter(\n    (asset) => !loadedSharedJsAssets.has(asset) && !isExisted('script', asset),\n  );\n  const needPreloadCssAssets = cssAssets.filter(\n    (asset) => !loadedSharedCssAssets.has(asset) && !isExisted('link', asset),\n  );\n\n  return {\n    cssAssets: needPreloadCssAssets,\n    jsAssetsWithoutEntry: needPreloadJsAssets,\n    entryAssets: entryAssets.filter((entry) => !isExisted('script', entry.url)),\n  };\n}\n\nexport const generatePreloadAssetsPlugin: () => ModuleFederationRuntimePlugin =\n  function () {\n    return {\n      name: 'generate-preload-assets-plugin',\n      async generatePreloadAssets(args) {\n        const {\n          origin,\n          preloadOptions,\n          remoteInfo,\n          remote,\n          globalSnapshot,\n          remoteSnapshot,\n        } = args;\n        if (!isBrowserEnvValue) {\n          return {\n            cssAssets: [],\n            jsAssetsWithoutEntry: [],\n            entryAssets: [],\n          };\n        }\n\n        if (isRemoteInfoWithEntry(remote) && isPureRemoteEntry(remote)) {\n          return {\n            cssAssets: [],\n            jsAssetsWithoutEntry: [],\n            entryAssets: [\n              {\n                name: remote.name,\n                url: remote.entry,\n                moduleInfo: {\n                  name: remoteInfo.name,\n                  entry: remote.entry,\n                  type: remoteInfo.type || 'global',\n                  entryGlobalName: '',\n                  shareScope: '',\n                },\n              },\n            ],\n          };\n        }\n\n        assignRemoteInfo(remoteInfo, remoteSnapshot);\n\n        const assets = generatePreloadAssets(\n          origin,\n          preloadOptions,\n          remoteInfo,\n          globalSnapshot,\n          remoteSnapshot,\n        );\n\n        return assets;\n      },\n    };\n  };\n"],"mappings":"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"}

package/dist/plugins/snapshot/SnapshotHandler.cjs

@@ -0,0 +1,190 @@
+const require_logger = require('../../utils/logger.cjs');
+const require_tool = require('../../utils/tool.cjs');
+const require_global = require('../../global.cjs');
+const require_context = require('../../utils/context.cjs');
+require('../../utils/index.cjs');
+const require_asyncHook = require('../../utils/hooks/asyncHook.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_sdk = require("@module-federation/sdk");
+let _module_federation_error_codes = require("@module-federation/error-codes");
+
+//#region src/plugins/snapshot/SnapshotHandler.ts
+function getGlobalRemoteInfo(moduleInfo, origin) {
+	const hostGlobalSnapshot = require_global.getGlobalSnapshotInfoByModuleInfo({
+		name: origin.name,
+		version: origin.options.version
+	});
+	const globalRemoteInfo = hostGlobalSnapshot && "remotesInfo" in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && require_global.getInfoWithoutType(hostGlobalSnapshot.remotesInfo, moduleInfo.name).value;
+	if (globalRemoteInfo && globalRemoteInfo.matchedVersion) return {
+		hostGlobalSnapshot,
+		globalSnapshot: require_global.getGlobalSnapshot(),
+		remoteSnapshot: require_global.getGlobalSnapshotInfoByModuleInfo({
+			name: moduleInfo.name,
+			version: globalRemoteInfo.matchedVersion
+		})
+	};
+	return {
+		hostGlobalSnapshot: void 0,
+		globalSnapshot: require_global.getGlobalSnapshot(),
+		remoteSnapshot: require_global.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 require_pluginSystem.PluginSystem({
+			beforeLoadRemoteSnapshot: new require_asyncHook.AsyncHook("beforeLoadRemoteSnapshot"),
+			loadSnapshot: new require_asyncWaterfallHooks.AsyncWaterfallHook("loadGlobalSnapshot"),
+			loadRemoteSnapshot: new require_asyncWaterfallHooks.AsyncWaterfallHook("loadRemoteSnapshot"),
+			afterLoadSnapshot: new require_asyncWaterfallHooks.AsyncWaterfallHook("afterLoadSnapshot")
+		});
+		this.manifestLoading = require_global.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 = require_global.getGlobalSnapshotInfoByModuleInfo({
+			name: this.HostInstance.options.name,
+			version: this.HostInstance.options.version
+		});
+		if (!hostSnapshot) {
+			hostSnapshot = {
+				version: this.HostInstance.options.version || "",
+				remoteEntry: "",
+				remotesInfo: {}
+			};
+			require_global.addGlobalSnapshot({ [this.HostInstance.options.name]: hostSnapshot });
+		}
+		if (hostSnapshot && "remotesInfo" in hostSnapshot && !require_global.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 ((0, _module_federation_sdk.isManifestProvider)(globalRemoteSnapshot)) {
+			const remoteEntry = _module_federation_sdk.isBrowserEnvValue ? globalRemoteSnapshot.remoteEntry : globalRemoteSnapshot.ssrRemoteEntry || globalRemoteSnapshot.remoteEntry || "";
+			const moduleSnapshot = await this.getManifestJson(remoteEntry, moduleInfo, {});
+			const globalSnapshotRes = require_global.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 (require_tool.isRemoteInfoWithEntry(moduleInfo)) {
+			const moduleSnapshot = await this.getManifestJson(moduleInfo.entry, moduleInfo, {});
+			const globalSnapshotRes = require_global.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 require_logger.error(_module_federation_error_codes.RUNTIME_007, _module_federation_error_codes.runtimeDescMap, {
+			remoteName: moduleInfo.name,
+			remoteVersion: moduleInfo.version,
+			hostName: this.HostInstance.options.name,
+			globalSnapshot: JSON.stringify(globalSnapshotRes)
+		}, void 0, require_context.optionsToMFContext(this.HostInstance.options));
+		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];
+					require_logger.error(_module_federation_error_codes.RUNTIME_003, _module_federation_error_codes.runtimeDescMap, {
+						manifestUrl,
+						moduleName: moduleInfo.name,
+						hostName: this.HostInstance.options.name
+					}, `${err}`, require_context.optionsToMFContext(this.HostInstance.options));
+				}
+			}
+			require_logger.assert(manifestJson.metaData && manifestJson.exposes && manifestJson.shared, `"${manifestUrl}" is not a valid federation manifest for remote "${moduleInfo.name}". Missing required fields: ${[
+				!manifestJson.metaData && "metaData",
+				!manifestJson.exposes && "exposes",
+				!manifestJson.shared && "shared"
+			].filter(Boolean).join(", ")}.`);
+			this.manifestCache.set(manifestUrl, manifestJson);
+			return manifestJson;
+		};
+		const asyncLoadProcess = async () => {
+			const manifestJson = await getManifest();
+			const remoteSnapshot = (0, _module_federation_sdk.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
+exports.SnapshotHandler = SnapshotHandler;
+exports.getGlobalRemoteInfo = getGlobalRemoteInfo;
+//# sourceMappingURL=SnapshotHandler.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SnapshotHandler.cjs","names":["getGlobalSnapshotInfoByModuleInfo","getInfoWithoutType","getGlobalSnapshot","PluginSystem","AsyncHook","AsyncWaterfallHook","Global","isBrowserEnvValue","setGlobalSnapshotInfoByModuleInfo","isRemoteInfoWithEntry","RUNTIME_007","runtimeDescMap","optionsToMFContext","RUNTIME_003"],"sources":["../../../src/plugins/snapshot/SnapshotHandler.ts"],"sourcesContent":["import {\n  GlobalModuleInfo,\n  Manifest,\n  ModuleInfo,\n  generateSnapshotFromManifest,\n  isManifestProvider,\n  isBrowserEnvValue,\n} from '@module-federation/sdk';\nimport {\n  RUNTIME_003,\n  RUNTIME_007,\n  runtimeDescMap,\n} from '@module-federation/error-codes';\nimport { Options, Remote } from '../../type';\nimport { isRemoteInfoWithEntry, error, optionsToMFContext } 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 = isBrowserEnvValue\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          RUNTIME_007,\n          runtimeDescMap,\n          {\n            remoteName: moduleInfo.name,\n            remoteVersion: moduleInfo.version,\n            hostName: this.HostInstance.options.name,\n            globalSnapshot: JSON.stringify(globalSnapshotRes),\n          },\n          undefined,\n          optionsToMFContext(this.HostInstance.options),\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            RUNTIME_003,\n            runtimeDescMap,\n            {\n              manifestUrl,\n              moduleName: moduleInfo.name,\n              hostName: this.HostInstance.options.name,\n            },\n            `${err}`,\n            optionsToMFContext(this.HostInstance.options),\n          );\n        }\n      }\n\n      assert(\n        manifestJson.metaData && manifestJson.exposes && manifestJson.shared,\n        `\"${manifestUrl}\" is not a valid federation manifest for remote \"${moduleInfo.name}\". Missing required fields: ${[!manifestJson.metaData && 'metaData', !manifestJson.exposes && 'exposes', !manifestJson.shared && 'shared'].filter(Boolean).join(', ')}.`,\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/SnapshotHandler.d.ts

@@ -0,0 +1,66 @@
+import { AsyncHook } from "../../utils/hooks/asyncHook.js";
+import { AsyncWaterfallHook } from "../../utils/hooks/asyncWaterfallHooks.js";
+import { PluginSystem } from "../../utils/hooks/pluginSystem.js";
+import { getGlobalSnapshot } from "../../global.js";
+import { ModuleFederation } from "../../core.js";
+import { Options, Remote } from "../../type/config.js";
+import { GlobalModuleInfo, Manifest, ModuleInfo } from "@module-federation/sdk";
+
+//#region src/plugins/snapshot/SnapshotHandler.d.ts
+declare class SnapshotHandler {
+  loadingHostSnapshot: Promise<GlobalModuleInfo | void> | null;
+  HostInstance: ModuleFederation;
+  manifestCache: Map<string, Manifest>;
+  hooks: PluginSystem<{
+    beforeLoadRemoteSnapshot: AsyncHook<[{
+      options: Options;
+      moduleInfo: Remote;
+    }], void>;
+    loadSnapshot: AsyncWaterfallHook<{
+      options: Options;
+      moduleInfo: Remote;
+      hostGlobalSnapshot: GlobalModuleInfo[string] | undefined;
+      globalSnapshot: ReturnType<typeof getGlobalSnapshot>;
+      remoteSnapshot?: GlobalModuleInfo[string] | undefined;
+    }>;
+    loadRemoteSnapshot: AsyncWaterfallHook<{
+      options: Options;
+      moduleInfo: Remote;
+      manifestJson?: Manifest;
+      manifestUrl?: string;
+      remoteSnapshot: ModuleInfo;
+      from: "global" | "manifest";
+    }>;
+    afterLoadSnapshot: AsyncWaterfallHook<{
+      id?: string;
+      host: ModuleFederation;
+      options: Options;
+      moduleInfo: Remote;
+      remoteSnapshot: ModuleInfo;
+    }>;
+  }>;
+  loaderHook: ModuleFederation['loaderHook'];
+  manifestLoading: Record<string, Promise<ModuleInfo>>;
+  constructor(HostInstance: ModuleFederation);
+  loadRemoteSnapshotInfo({
+    moduleInfo,
+    id,
+    expose
+  }: {
+    moduleInfo: Remote;
+    id?: string;
+    expose?: string;
+  }): Promise<{
+    remoteSnapshot: ModuleInfo;
+    globalSnapshot: GlobalModuleInfo;
+  }> | never;
+  getGlobalRemoteInfo(moduleInfo: Remote): {
+    hostGlobalSnapshot: ModuleInfo | undefined;
+    globalSnapshot: ReturnType<typeof getGlobalSnapshot>;
+    remoteSnapshot: GlobalModuleInfo[string] | undefined;
+  };
+  private getManifestJson;
+}
+//#endregion
+export { SnapshotHandler };
+//# sourceMappingURL=SnapshotHandler.d.ts.map