@module-federation/vite 1.23.0 → 1.23.2

package/lib/logger-DOwfTlw5.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, isAbsoluteUrl as c, resolveHashPlaceholderFileName as d, createCodePositionMap as i, normalizePathForImport as l, mfError as n, createSourceMap as o, mfWarn as r, EXTERNAL_URL_RE as s, createModuleFederationError as t, rebaseImport as u };

package/lib/{pluginDts-VSLhAx6d.js → pluginDts-DnEX3cp_.js}

@@ -1,9 +1,9 @@
-import { n as normalizePathForImport } from "./buildPaths-BoaQTkxt.js";
-import { T as mfError, g as resolveImportPath, u as hasPackageDependency, w as createModuleFederationError } from "./dtsConstants-DEMpRfBz.js";
+import { l as normalizePathForImport, n as mfError, t as createModuleFederationError } from "./logger-DOwfTlw5.js";
+import { g as resolveImportPath, u as hasPackageDependency } from "./dtsConstants-r5OfegUr.js";
 import fs from "fs";
 import * as path$1 from "node:path";
-import os from "os";
 import { normalizeOptions } from "@module-federation/sdk";
+import os from "os";
 import { consumeTypesAPI, generateTypesAPI, isTSProject, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions } from "@module-federation/dts-plugin";
 import { rpc } from "@module-federation/dts-plugin/core";
 //#region src/plugins/pluginDts.ts