@module-federation/vite 1.21.5 → 1.22.0

package/lib/{pluginDts-BhONN9dR.js → pluginDts-D7Faa4NJ.js}

@@ -1,5 +1,5 @@
-import { n as normalizePathForImport } from "./buildPaths-BkaQHrd2.js";
-import { _ as mfError, g as createModuleFederationError, l as hasPackageDependency, p as resolveImportPath } from "./dtsConstants-BsaLBaaK.js";
+import { n as normalizePathForImport } from "./buildPaths-BoaQTkxt.js";
+import { _ as mfError, g as createModuleFederationError, l as hasPackageDependency, p as resolveImportPath } from "./dtsConstants-BEGrtvcw.js";
 import fs from "fs";
 import * as path$1 from "node:path";
 import os from "os";
@@ -34,6 +34,7 @@ const getIPv4 = () => {
 	return (getIpv4Interfaces()[0] || { address: localIpv4 }).address;
 };
 const DEV_TYPES_FOLDER = ".dev-server";
+const UPDATE_DEBOUNCE_MS = 300;
 const forkDevWorkerPath = (() => {
 	return resolveImportPath("@module-federation/dts-plugin/dist/fork-dev-worker.js");
 })();
@@ -256,11 +257,16 @@ function pluginDts(options) {
 					disableLiveReload: devOptions.disableLiveReload,
 					disableHotTypesReload: devOptions.disableHotTypesReload
 				});
-				const update = () => devWorker?.update();
+				let updateTimer;
+				const update = () => {
+					clearTimeout(updateTimer);
+					updateTimer = setTimeout(() => devWorker?.update(), UPDATE_DEBOUNCE_MS);
+				};
 				server.watcher.on("change", update);
 				server.watcher.on("add", update);
 				server.watcher.on("unlink", update);
 				server.httpServer?.once("close", () => {
+					clearTimeout(updateTimer);
 					devWorker?.exit();
 					server.watcher.off("change", update);
 					server.watcher.off("add", update);

package/lib/{ssrEntryLoader-CqtaiDUp.js → ssrEntryLoader-CMVCDSsG.js}

@@ -1,4 +1,4 @@
-import { t as EXTERNAL_URL_RE } from "./buildPaths-BkaQHrd2.js";
+import { t as EXTERNAL_URL_RE } from "./buildPaths-BoaQTkxt.js";
 //#region src/utils/fetchWithTimeout.ts
 const DEFAULT_SSR_FETCH_TIMEOUT_MS = 1e4;
 const DEFAULT_SSR_FETCH_MAX_BYTES = 10 * 1024 * 1024;
@@ -188,7 +188,8 @@ async function resolveSharedExternal(id, resolvedShared) {
 }
 async function getOrCreateRunner(remoteOrigin, resolvedShared, fetchTimeoutMs, fetchMaxBytes) {
 	const cacheKey = getRunnerCacheKey(remoteOrigin, resolvedShared, fetchTimeoutMs, fetchMaxBytes);
-	if (runnerCache.has(cacheKey)) return runnerCache.get(cacheKey);
+	const cached = runnerCache.get(cacheKey);
+	if (cached) return cached.promise;
 	const promise = (async () => {
 		const viteRunner = await getModuleRunnerModule();
 		if (!viteRunner) return null;
@@ -215,7 +216,10 @@ async function getOrCreateRunner(remoteOrigin, resolvedShared, fetchTimeoutMs, f
 			return null;
 		}
 	})();
-	runnerCache.set(cacheKey, promise);
+	runnerCache.set(cacheKey, {
+		remoteOrigin,
+		promise
+	});
 	return promise;
 }
 const _path = () => nodeImport("path");
@@ -252,10 +256,19 @@ function parseRunnerInvokeResult(data) {
 * Version key for a resolved SSR entry. Derived from the remote's manifest
 * content so a redeploy at the same URL produces a different key, which in
 * turn produces different temp-file names — busting both our caches and
-* Node's ESM module cache. Convention-resolved entries (no manifest) get a
-* stable placeholder key and cannot be revalidated automatically.
+* Node's ESM module cache. Convention-resolved entries (no manifest) use a
+* stable placeholder key for ordinary loads; explicit `revalidate()` calls
+* advance a process-local generation so the next import is fresh.
 */
 const UNVERSIONED = "unversioned";
+const unversionedGenerations = /* @__PURE__ */ new Map();
+let unversionedGlobalGeneration = 0;
+function getUnversionedVersionKey(remoteEntryUrl) {
+	return `${UNVERSIONED}-${unversionedGlobalGeneration}-${unversionedGenerations.get(remoteEntryUrl) ?? 0}`;
+}
+function bumpUnversionedGeneration(remoteEntryUrl) {
+	unversionedGenerations.set(remoteEntryUrl, (unversionedGenerations.get(remoteEntryUrl) ?? 0) + 1);
+}
 function hashString(value) {
 	let hash = 2166136261;
 	for (let i = 0; i < value.length; i++) {
@@ -392,16 +405,16 @@ function buildSsrEntryCandidates(ctx, options = {}) {
 	if (!options.skipServerBuild) candidates.push({
 		url: `${remoteOrigin}/__mf_server__/${filename}.ssr.js`,
 		type: "module",
-		versionKey: UNVERSIONED
+		versionKey: getUnversionedVersionKey(ctx.entryUrl)
 	});
 	candidates.push({
 		url: `${base}.ssr.js`,
 		type: "module",
-		versionKey: UNVERSIONED
+		versionKey: getUnversionedVersionKey(ctx.entryUrl)
 	}, {
 		url: `${remoteOrigin}/__mf_ssr__/${filename}.ssr.js`,
 		type: "module",
-		versionKey: UNVERSIONED
+		versionKey: getUnversionedVersionKey(ctx.entryUrl)
 	});
 	return candidates;
 }
@@ -416,14 +429,14 @@ async function resolveSSREntryImpl(remoteEntryUrl, fetchTimeoutMs, fetchMaxBytes
 	if (isSsrEntry(remoteEntryUrl)) return {
 		url: remoteEntryUrl,
 		type: "module",
-		versionKey: UNVERSIONED
+		versionKey: getUnversionedVersionKey(remoteEntryUrl)
 	};
 	if (!isManifestEntry(remoteEntryUrl)) {
 		const filename = getEntryFilename(remoteEntryUrl);
 		const fromServerBuild = await headCheckSsrEntry({
 			url: `${remoteEntryUrl.replace(/\/[^/]+$/, "")}/__mf_server__/${filename}.ssr.js`,
 			type: "module",
-			versionKey: UNVERSIONED
+			versionKey: getUnversionedVersionKey(remoteEntryUrl)
 		}, fetchTimeoutMs);
 		if (fromServerBuild) return fromServerBuild;
 	}
@@ -457,7 +470,10 @@ async function getSSREntry(remoteEntryUrl, maxAgeMs, fetchTimeoutMs, fetchMaxByt
 	manifestFetchCache.delete(makeUrlCacheKey(getManifestUrl(remoteEntryUrl), fetchTimeoutMs, fetchMaxBytes));
 	const record = setSsrEntryCache(remoteEntryUrl, fetchTimeoutMs, fetchMaxBytes);
 	const next = await record.promise.catch(() => null);
-	if (previous && next && previous.versionKey !== next.versionKey) dropRemoteCaches(remoteEntryUrl);
+	if (previous && next && previous.versionKey !== next.versionKey) {
+		dropRemoteCaches(remoteEntryUrl);
+		await clearRunnerCaches(remoteEntryUrl);
+	}
 	return record.promise;
 }
 /**
@@ -477,6 +493,19 @@ function dropRemoteCaches(remoteEntryUrl) {
 		tempFilePathCache.delete(key);
 	}
 }
+async function clearRunnerCaches(remoteEntryUrl) {
+	let remoteOrigin;
+	if (remoteEntryUrl) try {
+		remoteOrigin = new URL(remoteEntryUrl).origin;
+	} catch {
+		return;
+	}
+	await Promise.all([...runnerCache.values()].filter((cached) => !remoteOrigin || cached.remoteOrigin === remoteOrigin).map(async (cached) => {
+		try {
+			(await cached.promise)?.clearCache?.();
+		} catch {}
+	}));
+}
 /**
 * Drop the loader's caches so the next `loadEntry` re-resolves and re-fetches
 * remote SSR entries. Pass a remote entry URL to scope the invalidation to one
@@ -489,16 +518,19 @@ function dropRemoteCaches(remoteEntryUrl) {
 */
 function revalidate(remoteEntryUrl) {
 	if (remoteEntryUrl) {
+		bumpUnversionedGeneration(remoteEntryUrl);
 		for (const key of ssrEntryCache.keys()) if (key.endsWith(`::${remoteEntryUrl}`)) ssrEntryCache.delete(key);
 		const manifestUrl = getManifestUrl(remoteEntryUrl);
 		for (const key of manifestFetchCache.keys()) if (key.endsWith(`::${manifestUrl}`)) manifestFetchCache.delete(key);
 		dropRemoteCaches(remoteEntryUrl);
 	} else {
+		unversionedGlobalGeneration += 1;
 		ssrEntryCache.clear();
 		manifestFetchCache.clear();
 		tempFileCache.clear();
 		tempFilePathCache.clear();
 	}
+	clearRunnerCaches(remoteEntryUrl);
 	const federation = globalThis.__FEDERATION__;
 	for (const instance of federation?.__INSTANCES__ ?? []) try {
 		instance?.moduleCache?.clear?.();
@@ -555,6 +587,9 @@ function transformSsrCode(code, base, sharedPkgMap) {
 function isVitePreloadHelperSpecifier(specifier) {
 	return specifier.includes("preload-helper");
 }
+function getTempFileImportUrl(filePath, versionKey) {
+	return `file://${filePath}?v=${encodeURIComponent(versionKey)}`;
+}
 /**
 * Fetch an HTTP ESM module, transform it, write it to a temp .js file and
 * return the file path. Recursively does the same for HTTP transitive imports
@@ -601,7 +636,7 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 		const subMap = /* @__PURE__ */ new Map();
 		await Promise.all([...new Set(relImports)].filter((u) => u.startsWith("http://") || u.startsWith("https://")).map(async (u) => {
 			const tmpPath = await fetchEsmToTempFile(u, tmpDir, visited, pending, sharedPkgMap, versionKey, fetchTimeoutMs, contextKey, fetchMaxBytes);
-			subMap.set(u, `file://${tmpPath}`);
+			subMap.set(u, getTempFileImportUrl(tmpPath, versionKey));
 		}));
 		code = transformSsrCode(code, base, sharedPkgMap);
 		for (const [httpUrl, fileUrl] of subMap) code = code.split(httpUrl).join(fileUrl);
@@ -631,7 +666,7 @@ async function importTempModule(filePath, versionKey) {
 }
 let warnedVmUnavailable = false;
 async function tryVmStrategy(ssrEntry, options) {
-	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-D4KB-y3H.js");
+	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-Cx9WlTsx.js");
 	if (!await isVmStrategyAvailable()) {
 		if (!warnedVmUnavailable) {
 			warnedVmUnavailable = true;

package/lib/{ssrVmStrategy-D4KB-y3H.js → ssrVmStrategy-Cx9WlTsx.js}

@@ -1,5 +1,5 @@
 import { t as findSharedKey } from "./sharedKeyMatcher-DiUzRVH1.js";
-import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-CqtaiDUp.js";
+import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-CMVCDSsG.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.
@@ -90,6 +90,7 @@ function createSyntheticModule(vm, specifier, namespace) {
 }
 const httpModuleCache = /* @__PURE__ */ new Map();
 const namespaceCache = /* @__PURE__ */ new Map();
+const linkQueues = /* @__PURE__ */ new WeakMap();
 const contextIds = /* @__PURE__ */ new WeakMap();
 let nextContextId = 1;
 function getContextId(context) {
@@ -153,10 +154,21 @@ async function linkModule(vm, specifier, referencingModule, options) {
 	if (url) return getHttpModule(vm, url, options);
 	return createSyntheticModule(vm, specifier, await loadBareModule(specifier, options));
 }
+async function linkModuleGraph(module, linker, cacheContext) {
+	const current = (linkQueues.get(cacheContext) ?? Promise.resolve()).catch(() => {}).then(async () => {
+		if (module.status === "unlinked") await module.link(linker);
+	});
+	linkQueues.set(cacheContext, current);
+	try {
+		await current;
+	} finally {
+		if (linkQueues.get(cacheContext) === current) linkQueues.delete(cacheContext);
+	}
+}
 async function importDynamically(vm, specifier, referencingModule, options) {
 	const linker = (spec, referencer) => linkModule(vm, spec, referencer, options);
 	const module = await linker(specifier, referencingModule);
-	if (module.status === "unlinked") await module.link(linker);
+	await linkModuleGraph(module, linker, options.cacheContext);
 	if (module.status === "linked") await module.evaluate();
 	return module;
 }
@@ -172,7 +184,7 @@ async function loadViaVmStrategy(entryUrl, options) {
 	if (!namespaceCache.has(cacheKey)) namespaceCache.set(cacheKey, (async () => {
 		const entryModule = await getHttpModule(vm, entryUrl, options);
 		const linker = (specifier, referencingModule) => linkModule(vm, specifier, referencingModule, options);
-		if (entryModule.status === "unlinked") await entryModule.link(linker);
+		await linkModuleGraph(entryModule, linker, options.cacheContext);
 		if (entryModule.status === "linked") await entryModule.evaluate();
 		return entryModule.namespace;
 	})().catch((error) => {

package/lib/utils/ssrEntryLoader.js

@@ -1,2 +1,2 @@
-import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-CqtaiDUp.js";
+import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-CMVCDSsG.js";
 export { SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.21.5",
+  "version": "1.22.0",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",
@@ -91,6 +91,6 @@
     "tsdown": "0.22.14",
     "typescript": "7.0.2",
     "vite": "8.2.0",
-    "vitest": "4.1.10"
+    "vitest": "4.1.11"
   }
 }