@module-federation/vite 1.23.4 → 1.23.6

package/README.md

@@ -9,7 +9,7 @@
 <br />
 
 <a href="https://github.com/sponsors/gioboa">
-  <img src="./docs/sponsors.png" alt="Sponsors" />
+  <img src="./docs/sponsors.png" alt="Sponsors" width="677" />
 </a>
 
 ## Become a sponsor
@@ -257,6 +257,21 @@ You can specify the place the host initialization file is injected with the **ho
 The **moduleParseTimeout** option allows you to configure the maximum time to wait for module parsing during the build process.
 The **moduleParseIdleTimeout** option is an alternative that resets the timer on every parsed module. It only fires when there has been no module activity for the configured duration, making it suitable for large codebases where the total build time exceeds the fixed timeout.
 
+## SSR runtime initialization
+
+For applications with configured remotes, SSR entries and modules importing
+`@module-federation/runtime` initialize the owning runtime before plain
+`getInstance()` or `loadRemote()` calls run. Startup registers remotes and shares
+without fetching remote entries or manifests, or requesting a root expose. Remote
+loading stays lazy, including with `loaded-first`. Apps without remotes receive no
+SSR host bootstrap. Cold development SSR follows the existing Vite 8+ support gate;
+independent SSR builds are supported on Vite 5–8.
+
+Dependencies externalized by Vite keep Node's own runtime resolution. Their runtime
+imports are not bound to the application's instance by this bootstrap.
+Include runtime-consuming dependencies in Vite's `ssr.noExternal` when they need
+to use the application's runtime instance.
+
 ## SSR entry loading strategy
 
 SSR hosts can choose how HTTP ESM remote entries are evaluated during build and preview:

package/lib/{dtsConstants-DSTzyKSG.js → dtsConstants-CDuC8Bb7.js}

@@ -1,10 +1,11 @@
-import { d as getNodeModulesSuffix, r as getSharedRuntimeKey } from "./sharedKeyMatcher-Od_nYxJA.js";
-import { r as mfWarn, t as createModuleFederationError } from "./logger-DOwfTlw5.js";
+import { r as mfWarn, t as createModuleFederationError, u as normalizePathForImport } from "./logger-D67aJYOe.js";
+import { d as getNodeModulesSuffix, r as getSharedRuntimeKey } from "./sharedKeyMatcher-C04bVN1q.js";
 import { existsSync, readFileSync, readdirSync, realpathSync } from "fs";
 import { createRequire } from "module";
 import * as path$1 from "node:path";
 import { fileURLToPath, pathToFileURL } from "url";
 import { createHash } from "node:crypto";
+import { isIPv6 } from "node:net";
 //#region src/utils/reactShares.ts
 /** Property under which React 19 exposes its internals object. */
 const REACT_CLIENT_INTERNALS_KEY = "__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE";
@@ -37,6 +38,7 @@ function getDependencyCacheKey(cwd, dependencyName) {
 const installedPackageJsonCache = /* @__PURE__ */ new Map();
 const dependentsLookupCache = /* @__PURE__ */ new Map();
 const reachableDependencyNames = /* @__PURE__ */ new Map();
+const pnpmStorePackageIndexCache = /* @__PURE__ */ new Map();
 function setPackageDetectionCwd(cwd) {
 	packageDetectionCwd = cwd;
 }
@@ -93,22 +95,34 @@ function substituteExportsWildcard(target, patternMatch) {
 	}
 	return target;
 }
+/** Splits an exports pattern at its wildcard. Node substitutes only the first one, so a second never matches. */
+function splitExportsPattern(pattern) {
+	const wildcardIndex = pattern.indexOf("*");
+	if (wildcardIndex === -1) return void 0;
+	const trailer = pattern.slice(wildcardIndex + 1);
+	if (trailer.includes("*")) return void 0;
+	return {
+		base: pattern.slice(0, wildcardIndex),
+		trailer
+	};
+}
+/** The text `value` substitutes for the wildcard of a pattern split by `splitExportsPattern`. */
+function matchExportsPatternPart(value, { base, trailer }) {
+	if (!value.startsWith(base) || !value.endsWith(trailer)) return void 0;
+	if (value.length <= base.length + trailer.length) return void 0;
+	return value.slice(base.length, value.length - trailer.length);
+}
 function matchExportsSubpath(record, subpath) {
 	if (subpath in record) return record[subpath];
 	let bestKey;
 	let bestBaseLength = -1;
 	let bestKeyLength = -1;
 	for (const key of Object.keys(record)) {
-		const wildcardIndex = key.indexOf("*");
-		if (wildcardIndex === -1) continue;
-		const patternBase = key.slice(0, wildcardIndex);
-		const patternTrailer = key.slice(wildcardIndex + 1);
-		if (patternTrailer.includes("*")) continue;
-		if (!subpath.startsWith(patternBase) || !subpath.endsWith(patternTrailer)) continue;
-		if (subpath.length <= patternBase.length + patternTrailer.length) continue;
-		if (patternBase.length > bestBaseLength || patternBase.length === bestBaseLength && key.length > bestKeyLength) {
+		const pattern = splitExportsPattern(key);
+		if (!pattern || matchExportsPatternPart(subpath, pattern) === void 0) continue;
+		if (pattern.base.length > bestBaseLength || pattern.base.length === bestBaseLength && key.length > bestKeyLength) {
 			bestKey = key;
-			bestBaseLength = patternBase.length;
+			bestBaseLength = pattern.base.length;
 			bestKeyLength = key.length;
 		}
 	}
@@ -139,6 +153,74 @@ function isPackageExportAvailable(pkg, opts = {}) {
 	if (installed?.packageJson.exports == null) return true;
 	return resolveExportsEntry(getPackageExportsTarget(pkg, packageName, installed.packageJson.exports), opts.conditions) !== void 0;
 }
+function stripRelativePrefix(target) {
+	return normalizePathForImport(target).replace(/^\.\//, "");
+}
+/**
+* Specifiers the installed package publishes for the file at `relFilePath` — a path below the
+* package root, such as `dist/button.js` — ordered most specific first.
+*
+* `exports` maps specifiers to files, so a specifier rebuilt from a resolved path is only valid
+* when the package happens to publish its files at the paths they occupy on disk. A package that
+* remaps directories (`"./*": "./dist/*.js"`) publishes `pkg/button` and never
+* `pkg/dist/button.js`, so the rebuilt specifier names a file the package does not export.
+* Reversing the map recovers the specifiers that do resolve back to that file.
+*
+* Candidates are ordered by the same precedence `matchExportsSubpath` applies when resolving
+* forwards — exact keys, then the longest pattern prefix, then the longest key — so a caller
+* that takes the first match picks the same specifier for a file in every build, and in every
+* container that shares the package.
+*
+* Empty when the package exports nothing that resolves to the file, which is the case for its
+* internals and for subpaths an explicit `null` blocks. Lenient when the package cannot be found
+* or has no `exports`, matching `isPackageExportAvailable`: every file is then reachable at its
+* own path, so the path is the specifier.
+*/
+function getPackageExportSpecifiersForFile(packageName, relFilePath, opts = {}) {
+	const file = `./${stripRelativePrefix(relFilePath)}`;
+	const toSpecifier = (subpath) => subpath === "." ? packageName : `${packageName}${subpath.slice(1)}`;
+	const exportsField = getInstalledPackageJson(packageName, opts)?.packageJson.exports;
+	if (exportsField == null) return [toSpecifier(file)];
+	if (typeof exportsField === "string") return stripRelativePrefix(exportsField) === stripRelativePrefix(file) ? [packageName] : [];
+	if (typeof exportsField !== "object") return [];
+	const record = exportsField;
+	const subpathKeys = Object.keys(record).filter((key) => key.startsWith("."));
+	if (subpathKeys.length === 0) {
+		const target = resolveExportsEntry(record, opts.conditions);
+		return typeof target === "string" && stripRelativePrefix(target) === stripRelativePrefix(file) ? [packageName] : [];
+	}
+	const candidates = [];
+	for (const key of subpathKeys) {
+		if (!key.includes("*")) {
+			candidates.push({
+				subpath: key,
+				isPattern: false,
+				baseLength: key.length,
+				keyLength: key.length
+			});
+			continue;
+		}
+		const keyPattern = splitExportsPattern(key);
+		if (!keyPattern) continue;
+		const target = resolveExportsEntry(record[key], opts.conditions);
+		const targetPattern = typeof target === "string" ? splitExportsPattern(target) : void 0;
+		if (!targetPattern) continue;
+		const patternMatch = matchExportsPatternPart(file, targetPattern);
+		if (patternMatch === void 0) continue;
+		candidates.push({
+			subpath: keyPattern.base + patternMatch + keyPattern.trailer,
+			isPattern: true,
+			baseLength: keyPattern.base.length,
+			keyLength: key.length
+		});
+	}
+	const verified = candidates.filter((candidate) => {
+		const target = resolveExportsEntry(getPackageExportsTarget(toSpecifier(candidate.subpath), packageName, record), opts.conditions);
+		return typeof target === "string" && stripRelativePrefix(target) === stripRelativePrefix(file);
+	});
+	verified.sort((a, b) => Number(a.isPattern) - Number(b.isPattern) || b.baseLength - a.baseLength || b.keyLength - a.keyLength || (a.subpath < b.subpath ? -1 : a.subpath > b.subpath ? 1 : 0));
+	return [...new Set(verified.map((candidate) => toSpecifier(candidate.subpath)))];
+}
 /**
 * Escaping rules:
 * Convert using the format __${mapping}__, where _ and $ are not allowed in npm package names but can be used in variable names.
@@ -414,7 +496,6 @@ function getInstalledPackageJson(pkg, opts) {
 	return result;
 }
 function tryReadPackageJson(packageJsonPath, expectedName) {
-	if (!existsSync(packageJsonPath)) return void 0;
 	try {
 		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
 		if (expectedName !== void 0 && packageJson.name !== expectedName) return void 0;
@@ -428,19 +509,6 @@ function tryReadPackageJson(packageJsonPath, expectedName) {
 	}
 }
 function resolveInstalledPackageJson(pkg, cwd, packageName, opts) {
-	const findPackageInPnpmStore = (startDir) => {
-		for (const dir of ancestorDirs(startDir)) {
-			const pnpmStoreDir = path$1.join(dir, "node_modules", ".pnpm");
-			if (!existsSync(pnpmStoreDir)) continue;
-			try {
-				for (const entry of readdirSync(pnpmStoreDir, { withFileTypes: true })) {
-					if (!entry.isDirectory()) continue;
-					const candidate = tryReadPackageJson(path$1.join(pnpmStoreDir, entry.name, "node_modules", packageName, "package.json"));
-					if (candidate?.packageJson.name === packageName) return candidate;
-				}
-			} catch {}
-		}
-	};
 	let resolvedPath;
 	try {
 		const rootPackageJson = path$1.join(cwd, "package.json");
@@ -462,7 +530,54 @@ function resolveInstalledPackageJson(pkg, cwd, packageName, opts) {
 		const directCandidate = tryReadPackageJson(path$1.join(dir, "node_modules", packageName, "package.json"), packageName);
 		if (directCandidate) return directCandidate;
 	}
-	return findPackageInDependents(packageName, cwd) ?? findPackageInPnpmStore(cwd);
+	return findPackageInDependents(packageName, cwd) ?? findPackageInPnpmStore(packageName, cwd);
+}
+function readDirEntries(dir) {
+	try {
+		return readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+function isDirOrLink(entry) {
+	return entry.isDirectory() || entry.isSymbolicLink();
+}
+function getPnpmStorePackageIndex(startDir) {
+	const cached = pnpmStorePackageIndexCache.get(startDir);
+	if (cached) return cached;
+	const index = /* @__PURE__ */ new Map();
+	const add = (name, packageJsonPath) => {
+		const paths = index.get(name);
+		if (paths) paths.push(packageJsonPath);
+		else index.set(name, [packageJsonPath]);
+	};
+	for (const dir of ancestorDirs(startDir)) {
+		const pnpmStoreDir = path$1.join(dir, "node_modules", ".pnpm");
+		for (const entry of readDirEntries(pnpmStoreDir)) {
+			if (!entry.isDirectory()) continue;
+			const storeNodeModules = path$1.join(pnpmStoreDir, entry.name, "node_modules");
+			for (const packageEntry of readDirEntries(storeNodeModules)) {
+				if (!isDirOrLink(packageEntry)) continue;
+				const entryDir = path$1.join(storeNodeModules, packageEntry.name);
+				if (!packageEntry.name.startsWith("@")) {
+					add(packageEntry.name, path$1.join(entryDir, "package.json"));
+					continue;
+				}
+				for (const scopedEntry of readDirEntries(entryDir)) {
+					if (!isDirOrLink(scopedEntry)) continue;
+					add(`${packageEntry.name}/${scopedEntry.name}`, path$1.join(entryDir, scopedEntry.name, "package.json"));
+				}
+			}
+		}
+	}
+	pnpmStorePackageIndexCache.set(startDir, index);
+	return index;
+}
+function findPackageInPnpmStore(packageName, startDir) {
+	for (const packageJsonPath of getPnpmStorePackageIndex(startDir).get(packageName) ?? []) {
+		const candidate = tryReadPackageJson(packageJsonPath, packageName);
+		if (candidate) return candidate;
+	}
 }
 /**
 * A package installed only under a dependent is invisible to the walks above.
@@ -529,12 +644,13 @@ function warnOnAmbiguousDependents(packageName, candidates) {
 	const versions = [...viaByVersion].map(([version, via]) => `${version} (via ${via})`);
 	mfWarn(`Shared package "${packageName}" is not a dependency of the project, and its closest dependents install different versions: ${versions.join(", ")}. The fallback uses ${versions[0]}. Add "${packageName}" to the project's dependencies or set its shared "import" to choose the version.`);
 }
+const realpath = process.platform === "win32" ? realpathSync : realpathSync.native;
 /** The package Node's `node_modules` lookup finds from `fromDir`, read at its real path. */
 function findPackageFrom(packageName, fromDir) {
 	const entry = findNodeModulesEntry(packageName, fromDir);
 	if (!entry) return void 0;
 	try {
-		return tryReadPackageJson(path$1.join(realpathSync(entry), "package.json"), packageName);
+		return tryReadPackageJson(path$1.join(realpath(entry), "package.json"), packageName);
 	} catch {
 		return;
 	}
@@ -609,14 +725,11 @@ function getInstalledPackageEntry(pkg, opts) {
 	const explicitEntry = resolveExportsEntry(getPackageExportsTarget(pkg, packageName, packageJson.exports), opts?.conditions) || (typeof packageJson.module === "string" ? packageJson.module : void 0) || (typeof packageJson.main === "string" ? packageJson.main : void 0) || "index.js";
 	return path$1.join(installed.dir, explicitEntry);
 }
-/**
-* Detect whether the current runtime is Vite 8+ by checking for a Vite version flag
-* on the plugin hook context, with Rolldown metadata kept as a compatibility fallback.
-*/
+/** Detect Vite 8+ (Rolldown) from the Vite version on the plugin hook context. */
 function getIsRolldown(ctx) {
 	const viteVersion = ctx?.meta?.viteVersion;
 	const viteMajor = Number(String(viteVersion ?? "").split(".")[0]);
-	return Number.isFinite(viteMajor) && viteMajor >= 8 || !!ctx?.meta?.rolldownVersion;
+	return Number.isFinite(viteMajor) && viteMajor >= 8;
 }
 /**
 * Rolldown 1.2.10 added `codeSplitting.groups[].debugName` and warns when a group's
@@ -661,7 +774,34 @@ function hasPackageDependency(dependencyName, cwd = packageDetectionCwd || proce
 	}
 }
 //#endregion
+//#region src/utils/devServerHost.ts
+const UNSPECIFIED_HOSTS = /* @__PURE__ */ new Set(["0.0.0.0", "::"]);
+/**
+* Hostname for client-facing HTTP/WS origins built from Vite `server.host`.
+*
+* Unspecified bind addresses (`0.0.0.0`, `::`) map to `localhost`, matching
+* Vite's own printed local URL. IPv6 addresses are wrapped in brackets so
+* `http://[::1]:5173` / `ws://[::1]:5173` parse as valid URLs.
+*/
+function formatDevServerHostForOrigin(host) {
+	if (typeof host !== "string" || UNSPECIFIED_HOSTS.has(host)) return "localhost";
+	if (host.startsWith("[") && host.endsWith("]")) return host;
+	return isIPv6(host) ? `[${host}]` : host;
+}
+const FILE_EVENTS = [
+	"change",
+	"add",
+	"unlink"
+];
+/** Runs `listener` on every file change, add, or unlink; returns a function that unsubscribes it. */
+function watchFileEvents(watcher, listener) {
+	for (const event of FILE_EVENTS) watcher.on(event, listener);
+	return () => {
+		for (const event of FILE_EVENTS) watcher.off(event, listener);
+	};
+}
+//#endregion
 //#region src/utils/dtsConstants.ts
 const DEFAULT_PUBLIC_TYPES_FOLDER = "@mf-types";
 //#endregion
-export { isReactCoreShare as C, REACT_DOM_CLIENT_SHARE as S, resolveModulePath as _, getIsRolldown as a, supportsCodeSplittingGroupDebugName as b, getPackageNameFromNodeModulePath as c, isNuxtProjectRoot as d, isPackageExportAvailable as f, resolveImportPath as g, packageNameEncode as h, getInstalledPackageJson as i, getSharedCacheDescriptor as l, packageNameDecode as m, getDependencyNames as n, getPackageDetectionCwd as o, isPackageInstalled as p, getInstalledPackageEntry as r, getPackageName as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, hasPackageDependency as u, setPackageDetectionCwd as v, REACT_CLIENT_INTERNALS_KEY as x, sharedCacheHelperCode as y };
+export { supportsCodeSplittingGroupDebugName as C, isReactCoreShare as E, sharedCacheHelperCode as S, REACT_DOM_CLIENT_SHARE as T, packageNameDecode as _, getInstalledPackageEntry as a, resolveModulePath as b, getPackageDetectionCwd as c, getPackageNameFromNodeModulePath as d, getSharedCacheDescriptor as f, isPackageInstalled as g, isPackageExportAvailable as h, getDependencyNames as i, getPackageExportSpecifiersForFile as l, isNuxtProjectRoot as m, formatDevServerHostForOrigin as n, getInstalledPackageJson as o, hasPackageDependency as p, watchFileEvents as r, getIsRolldown as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, getPackageName as u, packageNameEncode as v, REACT_CLIENT_INTERNALS_KEY as w, setPackageDetectionCwd as x, resolveImportPath as y };