@module-federation/vite 1.22.1 → 1.23.1

package/lib/logger--uKHOVjR.js

@@ -0,0 +1,366 @@
+//#region src/utils/buildPaths.ts
+/**
+* Rebase an import path for a bootstrap file that moved from root into `dir`.
+*
+* When entryFileNames places entries in a subdirectory (e.g. `static/js/`),
+* the bootstrap file moves there too. Paths that resolved from the HTML root
+* must resolve from the new directory instead.
+*
+* Cases: `/static/js/hostInit.js` → `./hostInit.js` (strip dir prefix)
+*        `./src/main.tsx`          → `../../src/main.tsx` (climb back up for each dir level)
+*        `https://cdn.example.com` → unchanged         (absolute URL)
+*/
+function rebaseImport(importSrc, dir) {
+	if (!dir) return importSrc;
+	if (isAbsoluteUrl(importSrc)) return importSrc;
+	const normalizedDir = dir.replace(/^\/+|\/+$/g, "");
+	if (!normalizedDir) return importSrc;
+	const stripDirPrefix = (src, prefix) => {
+		if (src === prefix) return "";
+		if (src.startsWith(prefix + "/")) return src.slice(prefix.length);
+	};
+	const absoluteRemainder = stripDirPrefix(importSrc, "/" + normalizedDir);
+	if (absoluteRemainder !== void 0) {
+		const remainder = absoluteRemainder.replace(/^\/+/, "");
+		return remainder ? "./" + remainder : "./";
+	}
+	const relativeRemainder = stripDirPrefix(importSrc, normalizedDir);
+	if (relativeRemainder !== void 0) {
+		const remainder = relativeRemainder.replace(/^\/+/, "");
+		return remainder ? "./" + remainder : "./";
+	}
+	const upLevels = normalizedDir.split("/").filter(Boolean).length;
+	const prefix = upLevels > 0 ? "../".repeat(upLevels) : "./";
+	if (importSrc.startsWith("./")) return prefix + importSrc.slice(2);
+	if (importSrc.startsWith("/")) return prefix + importSrc.slice(1);
+	return prefix + importSrc;
+}
+function normalizePathForImport(path) {
+	return path.replace(/\\/g, "/");
+}
+const EXTERNAL_URL_RE = /^(?:[a-z]+:|\/\/)/i;
+function isAbsoluteUrl(src) {
+	if (/^[a-z]:[\\/]/i.test(src)) return false;
+	return EXTERNAL_URL_RE.test(src);
+}
+const HASH_PLACEHOLDER_RE = /(?:[._-]?\[hash(?::\d+)?\])/g;
+function hasFileExtension(fileName) {
+	return fileName.slice(Math.max(fileName.lastIndexOf("/"), fileName.lastIndexOf("\\")) + 1).lastIndexOf(".") > 0;
+}
+/**
+* Resolve a bundler `filename` template that still contains `[hash]` placeholders
+* into the concrete, stable file name Module Federation serves.
+*
+* The federation entries are emitted by us rather than hashed by the bundler, so
+* the placeholder is dropped instead of being substituted. When stripping it also
+* removes the extension (`mf-[hash:8]` → `mf`), `.js` is appended so the result
+* stays a loadable module. The extension check deliberately looks at the basename
+* only — a dotted directory (`assets/v1.2/entry`) must not be mistaken for one.
+*/
+function resolveHashPlaceholderFileName(fileName) {
+	if (!fileName.includes("[hash")) return fileName;
+	const normalized = fileName.replace(HASH_PLACEHOLDER_RE, "");
+	return hasFileExtension(normalized) ? normalized : `${normalized}.js`;
+}
+//#endregion
+//#region src/utils/codeRewriter.ts
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var CodeRewriter = class {
+	original;
+	replacements = [];
+	constructor(original) {
+		this.original = original;
+	}
+	overwrite(start, end, content) {
+		if (start < 0 || end < start || end > this.original.length) throw new Error(`Invalid overwrite range: ${start}-${end}`);
+		this.replacements.push({
+			start,
+			end,
+			content
+		});
+	}
+	toString() {
+		return applyReplacements(this.original, this.getSortedReplacements()).code;
+	}
+	generateMap(source = "") {
+		const { code, replacements } = applyReplacements(this.original, this.getSortedReplacements());
+		return {
+			version: 3,
+			sources: [source],
+			sourcesContent: [this.original],
+			names: [],
+			mappings: generateLineMappings(code, this.original, replacements)
+		};
+	}
+	getSortedReplacements() {
+		return [...this.replacements].sort((a, b) => a.start - b.start || a.end - b.end);
+	}
+};
+function createSourceMap(code, source = "") {
+	return {
+		version: 3,
+		sources: [source],
+		sourcesContent: [code],
+		names: [],
+		mappings: generateLineMappings(code, code, [])
+	};
+}
+function applyReplacements(original, replacements) {
+	let code = "";
+	let cursor = 0;
+	let delta = 0;
+	const applied = [];
+	for (const replacement of replacements) {
+		if (replacement.start < cursor) throw new Error("Overlapping overwrite ranges are not supported");
+		code += original.slice(cursor, replacement.start);
+		const generatedStart = replacement.start + delta;
+		code += replacement.content;
+		const generatedEnd = generatedStart + replacement.content.length;
+		applied.push({
+			...replacement,
+			generatedStart,
+			generatedEnd
+		});
+		cursor = replacement.end;
+		delta += replacement.content.length - (replacement.end - replacement.start);
+	}
+	code += original.slice(cursor);
+	return {
+		code,
+		replacements: applied
+	};
+}
+function generateLineMappings(generated, original, replacements) {
+	const generatedLineStarts = getLineStarts(generated);
+	const originalLineStarts = getLineStarts(original);
+	let previousOriginalLine = 0;
+	let previousOriginalColumn = 0;
+	let mappings = "";
+	generatedLineStarts.forEach((generatedOffset, lineIndex) => {
+		if (lineIndex > 0) mappings += ";";
+		const originalOffset = generatedOffsetToOriginalOffset(generatedOffset, replacements);
+		const originalLine = findLine(originalLineStarts, originalOffset);
+		const originalColumn = originalOffset - originalLineStarts[originalLine];
+		mappings += encodeSegment([
+			0,
+			0,
+			originalLine - previousOriginalLine,
+			originalColumn - previousOriginalColumn
+		]);
+		previousOriginalLine = originalLine;
+		previousOriginalColumn = originalColumn;
+	});
+	return mappings;
+}
+function generatedOffsetToOriginalOffset(offset, replacements) {
+	let delta = 0;
+	for (const replacement of replacements) {
+		if (offset < replacement.generatedStart) break;
+		if (offset < replacement.generatedEnd) return replacement.start;
+		delta += replacement.content.length - (replacement.end - replacement.start);
+	}
+	return offset - delta;
+}
+function getLineStarts(code) {
+	const starts = [0];
+	for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) starts.push(i + 1);
+	return starts;
+}
+function findLine(lineStarts, offset) {
+	let low = 0;
+	let high = lineStarts.length - 1;
+	while (low <= high) {
+		const mid = low + high >> 1;
+		if (lineStarts[mid] <= offset) low = mid + 1;
+		else high = mid - 1;
+	}
+	return Math.max(0, high);
+}
+function encodeSegment(values) {
+	return values.map(encodeVlq).join("");
+}
+function encodeVlq(value) {
+	let vlq = value < 0 ? (-value << 1) + 1 : value << 1;
+	let encoded = "";
+	do {
+		let digit = vlq & 31;
+		vlq >>>= 5;
+		if (vlq > 0) digit |= 32;
+		encoded += BASE64_CHARS[digit];
+	} while (vlq > 0);
+	return encoded;
+}
+//#endregion
+//#region src/utils/codePositionMap.ts
+const REGEX_PREFIX_KEYWORDS = /* @__PURE__ */ new Set([
+	"await",
+	"case",
+	"delete",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"throw",
+	"typeof",
+	"void",
+	"yield"
+]);
+function isJsxClosingTagSlash(code, slashIndex) {
+	if (code[slashIndex - 1] !== "<") return false;
+	let cursor = slashIndex + 1;
+	while (/\s/.test(code[cursor] || "")) cursor++;
+	if (code[cursor] === ">") return true;
+	const tagStart = cursor;
+	while (/[-:.$_\u200C\u200D\p{ID_Continue}]/u.test(code[cursor] || "")) cursor++;
+	if (cursor === tagStart) return false;
+	while (/\s/.test(code[cursor] || "")) cursor++;
+	return code[cursor] === ">";
+}
+/** Mark comments, string/template literals, and regular expressions as non-code. */
+function createCodePositionMap(code, onComment) {
+	const positions = Array(code.length).fill(true);
+	const mask = (start, end) => {
+		for (let index = start; index < end; index++) positions[index] = false;
+	};
+	let canStartRegex = true;
+	for (let index = 0; index < code.length;) {
+		const char = code[index];
+		const next = code[index + 1];
+		if (/\s/.test(char)) {
+			index++;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			const start = index;
+			index += 2;
+			while (index < code.length && code[index] !== "\n" && code[index] !== "\r") index++;
+			mask(start, index);
+			onComment?.(start, index);
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			const start = index;
+			index += 2;
+			while (index < code.length && !(code[index] === "*" && code[index + 1] === "/")) index++;
+			index = Math.min(code.length, index + 2);
+			mask(start, index);
+			onComment?.(start, index);
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			const quote = char;
+			const start = index++;
+			while (index < code.length) {
+				if (code[index] === "\\") {
+					index += 2;
+					continue;
+				}
+				if (code[index] === quote) {
+					index++;
+					break;
+				}
+				index++;
+			}
+			mask(start, index);
+			canStartRegex = false;
+			continue;
+		}
+		const closesJsxTag = isJsxClosingTagSlash(code, index);
+		if (char === "/" && canStartRegex && !closesJsxTag) {
+			const start = index;
+			let cursor = index + 1;
+			let escaped = false;
+			let inCharacterClass = false;
+			let closed = false;
+			for (; cursor < code.length; cursor++) {
+				const regexChar = code[cursor];
+				if (regexChar === "\n" || regexChar === "\r") break;
+				if (escaped) {
+					escaped = false;
+					continue;
+				}
+				if (regexChar === "\\") {
+					escaped = true;
+					continue;
+				}
+				if (regexChar === "[") {
+					inCharacterClass = true;
+					continue;
+				}
+				if (regexChar === "]" && inCharacterClass) {
+					inCharacterClass = false;
+					continue;
+				}
+				if (regexChar === "/" && !inCharacterClass) {
+					cursor++;
+					while (/[$_\p{ID_Continue}]/u.test(code[cursor] || "")) cursor++;
+					closed = true;
+					break;
+				}
+			}
+			if (closed) {
+				mask(start, cursor);
+				index = cursor;
+				canStartRegex = false;
+				continue;
+			}
+		}
+		if (/[$_\p{ID_Start}]/u.test(char)) {
+			const start = index++;
+			while (/[$_\u200C\u200D\p{ID_Continue}]/u.test(code[index] || "")) index++;
+			canStartRegex = REGEX_PREFIX_KEYWORDS.has(code.slice(start, index));
+			continue;
+		}
+		if (/\d/.test(char)) {
+			index++;
+			while (/[\w.]/.test(code[index] || "")) index++;
+			canStartRegex = false;
+			continue;
+		}
+		if ((char === "+" || char === "-") && next === char) {
+			index += 2;
+			continue;
+		}
+		if (char === "!" && next !== "=") {
+			index++;
+			continue;
+		}
+		if (char === ")" || char === "]" || char === "}") canStartRegex = false;
+		else if (char !== ".") canStartRegex = true;
+		index++;
+	}
+	return positions;
+}
+//#endregion
+//#region src/utils/logger.ts
+const MODULE_FEDERATION_LOG_PREFIX = "[Module Federation]";
+function formatModuleFederationMessage(message) {
+	return `${MODULE_FEDERATION_LOG_PREFIX} ${message}`;
+}
+function createModuleFederationError(message) {
+	return new Error(formatModuleFederationMessage(message));
+}
+function toConsoleArgs(message, rest = []) {
+	if (typeof message === "string") return [formatModuleFederationMessage(message), ...rest];
+	if (message === void 0) return [MODULE_FEDERATION_LOG_PREFIX, ...rest];
+	return [
+		MODULE_FEDERATION_LOG_PREFIX,
+		message,
+		...rest
+	];
+}
+const moduleFederationConsole = {
+	log(message, ...rest) {
+		console.log(...toConsoleArgs(message, rest));
+	},
+	warn(message, ...rest) {
+		console.warn(...toConsoleArgs(message, rest));
+	},
+	error(message, ...rest) {
+		console.error(...toConsoleArgs(message, rest));
+	}
+};
+const mfWarn = moduleFederationConsole.warn;
+const mfError = moduleFederationConsole.error;
+//#endregion
+export { CodeRewriter as a, normalizePathForImport as c, createCodePositionMap as i, rebaseImport as l, mfError as n, createSourceMap as o, mfWarn as r, EXTERNAL_URL_RE as s, createModuleFederationError as t, resolveHashPlaceholderFileName as u };

package/lib/{pluginDts-CQ088qGF.js → pluginDts-DxgS2FEd.js}

@@ -1,5 +1,5 @@
-import { n as normalizePathForImport } from "./buildPaths-BoaQTkxt.js";
-import { h as resolveImportPath, l as hasPackageDependency, v as createModuleFederationError, y as mfError } from "./dtsConstants-dDsHZFC1.js";
+import { c as normalizePathForImport, n as mfError, t as createModuleFederationError } from "./logger--uKHOVjR.js";
+import { g as resolveImportPath, u as hasPackageDependency } from "./dtsConstants-Bs4FukGL.js";
 import fs from "fs";
 import * as path$1 from "node:path";
 import os from "os";

package/lib/{sharedKeyMatcher-BRzBCbuR.js → sharedKeyMatcher-Od_nYxJA.js}

@@ -129,11 +129,38 @@ function resolvePublicPath(options, viteBase, originalBase) {
 }
 //#endregion
 //#region src/utils/sharedKeyMatcher.ts
-function matchesSharedSource(source, key) {
-	const keyBase = key.endsWith("/") ? key.slice(0, -1) : key;
+function getSharedRequest(key, shareItem) {
+	const request = shareItem?.shareConfig?.request;
+	return typeof request === "string" ? request : key;
+}
+/** `prefix` ends with `/` and `source` is its base or a subpath under it. */
+function isUnderPrefix(prefix, source) {
+	return prefix.endsWith("/") && (source === prefix.slice(0, -1) || source.startsWith(prefix));
+}
+/**
+* Resolve the runtime share-scope key for a concrete request. The configured
+* property name is the default runtime key; `shareKey` only changes it when
+* explicitly provided. Prefix requests carry their concrete suffix to the
+* runtime key as required by the Module Federation shared contract.
+*/
+function getSharedRuntimeKey(source, shareItem) {
+	const name = typeof shareItem?.name === "string" ? shareItem.name : void 0;
+	const request = getSharedRequest(name ?? source, shareItem);
+	const configuredShareKey = shareItem?.shareConfig?.shareKey;
+	const sourceMatchesRequest = source === request || isUnderPrefix(request, source);
+	const shareKey = typeof configuredShareKey === "string" ? configuredShareKey : name !== void 0 && sourceMatchesRequest ? name : source;
+	if (!request.endsWith("/")) return shareKey;
+	const requestBase = request.slice(0, -1);
+	if (source === requestBase) return shareKey.endsWith("/") ? shareKey.slice(0, -1) : shareKey;
+	if (source.startsWith(`${requestBase}/`)) return shareKey + source.slice(request.length);
+	return isUnderPrefix(shareKey, source) ? source : shareKey;
+}
+function matchesSharedSource(source, key, shareItem) {
+	const request = getSharedRequest(key, shareItem);
+	const keyBase = request.endsWith("/") ? request.slice(0, -1) : request;
 	if (keyBase === "vue" && (source === "vue/dist/vue.esm-bundler.js" || source === "vue/dist/vue.runtime.esm-bundler.js")) return true;
-	if (key.endsWith("/")) return source === keyBase || source.startsWith(`${keyBase}/`);
-	if (getCommonSharedSubpaths(keyBase).includes(source)) return true;
+	if (request.endsWith("/")) return source === keyBase || source.startsWith(`${keyBase}/`);
+	if (shareItem?.shareConfig?.request === void 0 && shareItem?.shareConfig?.shareKey === void 0 && getCommonSharedSubpaths(keyBase).includes(source)) return true;
 	return source === keyBase;
 }
 const emptySharedKeyMatcher = { find: () => void 0 };
@@ -157,26 +184,28 @@ function getSharedKeyMatcher(shared) {
 	const cached = sharedKeyMatcherCache.get(shared);
 	if (cached) return cached;
 	const keys = Object.keys(shared);
-	const exactKeys = new Set(keys);
+	const exactKeys = /* @__PURE__ */ new Map();
 	const commonSubpathKeys = /* @__PURE__ */ new Map();
 	const wildcardKeys = [];
 	let vueKey;
 	for (const key of keys) {
-		const keyBase = key.endsWith("/") ? key.slice(0, -1) : key;
 		const shareItem = shared[key];
+		const request = getSharedRequest(key, shareItem);
+		const keyBase = request.endsWith("/") ? request.slice(0, -1) : request;
+		if (!exactKeys.has(request) || request === key) exactKeys.set(request, key);
 		if (!vueKey && keyBase === "vue") vueKey = key;
-		if (key.endsWith("/")) wildcardKeys.push({
+		if (request.endsWith("/")) wildcardKeys.push({
 			key,
 			base: keyBase
 		});
-		if (shareItem?.shareConfig?.import !== false) {
+		if (shareItem?.shareConfig?.import !== false && shareItem?.shareConfig?.request === void 0 && shareItem?.shareConfig?.shareKey === void 0) {
 			for (const subpath of getCommonSharedSubpaths(keyBase)) if (!commonSubpathKeys.has(subpath)) commonSubpathKeys.set(subpath, key);
 		}
 	}
 	const sourceCache = /* @__PURE__ */ new Map();
 	const matcher = { find(source) {
 		if (sourceCache.has(source)) return sourceCache.get(source);
-		let result = exactKeys.has(source) ? source : void 0;
+		let result = exactKeys.get(source);
 		if (!result && vueKey) {
 			if (source === "vue/dist/vue.esm-bundler.js" || source === "vue/dist/vue.runtime.esm-bundler.js") result = vueKey;
 		}
@@ -189,4 +218,4 @@ function getSharedKeyMatcher(shared) {
 	return matcher;
 }
 //#endregion
-export { stripViteFsPrefix as _, ensureTrailingSlash as a, getCommonSharedSubpaths as c, isNodeModulePath as d, isNuxtClientBase as f, stripQueryAndHash as g, resolvePublicPath as h, VITE_FS_PREFIX as i, getNodeModulesSuffix as l, normalizeNodeModulePath as m, invalidateSharedKeyMatcher as n, filterId as o, isViteOptimizableEntry as p, matchesSharedSource as r, getBasePath as s, findSharedKey as t, isAssetLikeImport as u };
+export { resolvePublicPath as _, matchesSharedSource as a, filterId as c, getNodeModulesSuffix as d, isAssetLikeImport as f, normalizeNodeModulePath as g, isViteOptimizableEntry as h, invalidateSharedKeyMatcher as i, getBasePath as l, isNuxtClientBase as m, getSharedRequest as n, VITE_FS_PREFIX as o, isNodeModulePath as p, getSharedRuntimeKey as r, ensureTrailingSlash as s, findSharedKey as t, getCommonSharedSubpaths as u, stripQueryAndHash as v, stripViteFsPrefix as y };