@module-federation/vite 1.20.5 → 1.20.7

package/lib/pluginDts-BNCg4Gri.js

@@ -0,0 +1,312 @@
+import { n as normalizePathForImport } from "./buildPaths-BkaQHrd2.js";
+import { _ as mfError, g as createModuleFederationError, l as hasPackageDependency, p as resolveImportPath } from "./dtsConstants-DyJrx8ah.js";
+import fs from "fs";
+import * as path$1 from "node:path";
+import { normalizeOptions } from "@module-federation/sdk";
+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
+const DEFAULT_DEV_OPTIONS = {
+	disableLiveReload: true,
+	disableHotTypesReload: false,
+	disableDynamicRemoteTypeHints: false
+};
+const DYNAMIC_HINTS_PLUGIN = "@module-federation/dts-plugin/dynamic-remote-type-hints-plugin";
+const getIPv4 = () => process.env["FEDERATION_IPV4"] || "127.0.0.1";
+const DEV_TYPES_FOLDER = ".dev-server";
+const forkDevWorkerPath = (() => {
+	return resolveImportPath("@module-federation/dts-plugin/dist/fork-dev-worker.js");
+})();
+var DevWorker = class {
+	worker = rpc.createRpcWorker(forkDevWorkerPath, {}, void 0, false);
+	constructor(options) {
+		this.worker.connect(options);
+	}
+	update() {
+		this.worker.process?.send?.({
+			type: rpc.RpcGMCallTypes.CALL,
+			id: this.worker.id,
+			args: [void 0, "update"]
+		});
+	}
+	exit() {
+		this.worker.terminate();
+	}
+};
+const normalizeDevOptions = (dev) => {
+	if (dev === false) return false;
+	if (dev === true || typeof dev === "undefined") return { ...DEFAULT_DEV_OPTIONS };
+	return {
+		...DEFAULT_DEV_OPTIONS,
+		...dev
+	};
+};
+const buildDtsModuleFederationConfig = (options) => {
+	const exposes = {};
+	Object.entries(options.exposes).forEach(([key, value]) => {
+		if (value.import) exposes[key] = value.import;
+	});
+	const remotes = {};
+	Object.entries(options.remotes).forEach(([key, remote]) => {
+		if (!remote.entry) return;
+		const entryGlobalName = remote.entryGlobalName?.startsWith("http") || remote.entryGlobalName?.includes(".json") ? remote.name || key : remote.entryGlobalName || remote.name || key;
+		remotes[key] = `${entryGlobalName}@${remote.entry}`;
+	});
+	return {
+		...options,
+		exposes,
+		remotes
+	};
+};
+const resolveOutputDir = (config) => {
+	const { outDir } = config.build;
+	if (path$1.isAbsolute(outDir)) return normalizePathForImport(path$1.relative(config.root, outDir));
+	return outDir;
+};
+const ensureRuntimePlugin = (options, pluginId) => {
+	if (!options.runtimePlugins.some((plugin) => {
+		if (typeof plugin === "string") return plugin === pluginId;
+		return plugin[0] === pluginId;
+	})) options.runtimePlugins.push(pluginId);
+};
+const getExposeImportPaths = (options) => {
+	return Object.values(options.exposes).map((value) => {
+		return value.import;
+	}).filter((value) => Boolean(value));
+};
+const usesVueSfcExposes = (options) => {
+	return getExposeImportPaths(options).some((value) => value.endsWith(".vue"));
+};
+const resolveDtsPluginOptions = (dts, options, context) => {
+	if (dts === false) return false;
+	const inferredGenerateTypesDefaults = { generateAPITypes: true };
+	if (usesVueSfcExposes(options) && hasPackageDependency("vue-tsc", context)) inferredGenerateTypesDefaults.compilerInstance = "vue-tsc";
+	if (dts === true || typeof dts === "undefined") return { generateTypes: inferredGenerateTypesDefaults };
+	const generateTypes = dts.generateTypes;
+	return {
+		...dts,
+		generateTypes: generateTypes === false ? false : {
+			...inferredGenerateTypesDefaults,
+			...generateTypes === true || typeof generateTypes === "undefined" ? {} : generateTypes
+		}
+	};
+};
+const getBasePath = (base) => {
+	if (base.startsWith("http://") || base.startsWith("https://")) return new URL(base).pathname.replace(/\/$/, "") || "/";
+	return base.replace(/\/$/, "") || "/";
+};
+const joinBaseAndAsset = (base, assetFileName) => {
+	const basePath = getBasePath(base);
+	return `${basePath === "/" ? "" : basePath}/${assetFileName}`.replace(/\/{2,}/g, "/");
+};
+const getDevDtsAssetPaths = (options) => {
+	const { outputDir, publicTypesFolder, root, base } = options;
+	return {
+		apiFilePath: path$1.resolve(root, outputDir, `${DEV_TYPES_FOLDER}.d.ts`),
+		apiRequestPath: joinBaseAndAsset(base, `${publicTypesFolder}.d.ts`),
+		zipFilePath: path$1.resolve(root, outputDir, `${DEV_TYPES_FOLDER}.zip`),
+		zipRequestPath: joinBaseAndAsset(base, `${publicTypesFolder}.zip`)
+	};
+};
+const createDevDtsAssetMiddleware = (assetPaths) => {
+	return (req, res, next) => {
+		const requestPath = req.url?.split("?")[0];
+		const isZipRequest = requestPath === assetPaths.zipRequestPath;
+		const isApiRequest = requestPath === assetPaths.apiRequestPath;
+		if (!isZipRequest && !isApiRequest) {
+			next();
+			return;
+		}
+		const filePath = isZipRequest ? assetPaths.zipFilePath : assetPaths.apiFilePath;
+		if (!fs.existsSync(filePath)) {
+			res.statusCode = 404;
+			res.end();
+			return;
+		}
+		res.statusCode = 200;
+		res.setHeader("Content-Type", isZipRequest ? "application/x-gzip" : "application/typescript");
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
+		const stream = fs.createReadStream(filePath);
+		stream.on("error", () => {
+			if (!res.headersSent) res.statusCode = 500;
+			res.end();
+		});
+		res.on("close", () => {
+			stream.destroy();
+		});
+		stream.pipe(res);
+	};
+};
+const normalizeDevDtsOptions = (dts, context) => {
+	return normalizeOptions(isTSProject(dts, context), {
+		generateTypes: { compileInChildProcess: true },
+		consumeTypes: { consumeAPITypes: true },
+		extraOptions: {},
+		displayErrorInTerminal: typeof dts === "object" && dts ? dts.displayErrorInTerminal : void 0
+	}, "mfOptions.dts")(dts);
+};
+const logDtsError = (error, dtsOptions) => {
+	if (dtsOptions === false) return;
+	if (typeof dtsOptions === "object" && dtsOptions && dtsOptions.displayErrorInTerminal === false) return;
+	mfError(error);
+};
+function pluginDts(options) {
+	if (options.dts === false) return [];
+	const baseDtsModuleFederationConfig = buildDtsModuleFederationConfig(options);
+	const getDtsModuleFederationConfig = (context) => ({
+		...baseDtsModuleFederationConfig,
+		dts: resolveDtsPluginOptions(options.dts, options, context)
+	});
+	let resolvedConfig;
+	let devWorker;
+	let normalizedDevOptions;
+	let hasGeneratedBundle = false;
+	return [{
+		name: "module-federation-dts-dev",
+		apply: "serve",
+		config(config) {
+			normalizedDevOptions = normalizeDevOptions(options.dev);
+			if (!normalizedDevOptions) return;
+			if (normalizedDevOptions.disableDynamicRemoteTypeHints) return;
+			ensureRuntimePlugin(options, DYNAMIC_HINTS_PLUGIN);
+			const define = config.define ? { ...config.define } : {};
+			if (!("FEDERATION_IPV4" in define)) define.FEDERATION_IPV4 = JSON.stringify(getIPv4());
+			config.define = define;
+		},
+		configResolved(config) {
+			resolvedConfig = config;
+		},
+		configureServer(server) {
+			if (!normalizedDevOptions || !resolvedConfig) return;
+			const devOptions = normalizedDevOptions;
+			if (devOptions.disableDynamicRemoteTypeHints && devOptions.disableHotTypesReload && devOptions.disableLiveReload) return;
+			if (!options.name) throw createModuleFederationError("name is required if you want to enable dev server!");
+			const outputDir = resolveOutputDir(resolvedConfig);
+			const dtsModuleFederationConfig = getDtsModuleFederationConfig(resolvedConfig.root);
+			const normalizedDtsOptions = normalizeDevDtsOptions(dtsModuleFederationConfig.dts, resolvedConfig.root);
+			if (typeof normalizedDtsOptions !== "object") return;
+			const normalizedGenerateTypes = normalizeOptions(Boolean(normalizedDtsOptions), { compileInChildProcess: true }, "mfOptions.dts.generateTypes")(normalizedDtsOptions.generateTypes);
+			const remote = normalizedGenerateTypes === false ? void 0 : {
+				implementation: normalizedDtsOptions.implementation,
+				context: resolvedConfig.root,
+				outputDir,
+				moduleFederationConfig: { ...dtsModuleFederationConfig },
+				hostRemoteTypesFolder: normalizedGenerateTypes.typesFolder || "@mf-types",
+				...normalizedGenerateTypes,
+				typesFolder: DEV_TYPES_FOLDER
+			};
+			if (remote) server.middlewares.use(createDevDtsAssetMiddleware(getDevDtsAssetPaths({
+				outputDir,
+				publicTypesFolder: remote.hostRemoteTypesFolder || "@mf-types",
+				root: resolvedConfig.root,
+				base: resolvedConfig.base
+			})));
+			if (remote && !remote.tsConfigPath && normalizedDtsOptions.tsConfigPath) remote.tsConfigPath = normalizedDtsOptions.tsConfigPath;
+			const normalizedConsumeTypes = normalizeOptions(Boolean(normalizedDtsOptions), { consumeAPITypes: true }, "mfOptions.dts.consumeTypes")(normalizedDtsOptions.consumeTypes);
+			const host = normalizedConsumeTypes === false ? void 0 : {
+				implementation: normalizedDtsOptions.implementation,
+				context: resolvedConfig.root,
+				moduleFederationConfig: dtsModuleFederationConfig,
+				typesFolder: normalizedConsumeTypes.typesFolder || "@mf-types",
+				abortOnError: false,
+				...normalizedConsumeTypes
+			};
+			const extraOptions = normalizedDtsOptions.extraOptions || {};
+			if (!remote && !host && devOptions.disableLiveReload) return;
+			const startDevWorker = async () => {
+				let remoteTypeUrls;
+				if (host) remoteTypeUrls = await new Promise((resolve) => {
+					consumeTypesAPI({
+						host,
+						extraOptions,
+						displayErrorInTerminal: normalizedDtsOptions.displayErrorInTerminal
+					}, resolve);
+				});
+				devWorker = new DevWorker({
+					name: options.name,
+					remote,
+					host: host ? {
+						...host,
+						remoteTypeUrls
+					} : void 0,
+					extraOptions,
+					disableLiveReload: devOptions.disableLiveReload,
+					disableHotTypesReload: devOptions.disableHotTypesReload
+				});
+				const update = () => devWorker?.update();
+				server.watcher.on("change", update);
+				server.watcher.on("add", update);
+				server.watcher.on("unlink", update);
+				server.httpServer?.once("close", () => {
+					devWorker?.exit();
+					server.watcher.off("change", update);
+					server.watcher.off("add", update);
+					server.watcher.off("unlink", update);
+				});
+			};
+			startDevWorker().catch((error) => {
+				logDtsError(error, normalizedDtsOptions);
+			});
+		}
+	}, {
+		name: "module-federation-dts-build",
+		apply: "build",
+		configResolved(config) {
+			resolvedConfig = config;
+		},
+		async generateBundle() {
+			if (hasGeneratedBundle) return;
+			hasGeneratedBundle = true;
+			if (!resolvedConfig) return;
+			let normalizedDtsOptions;
+			try {
+				normalizedDtsOptions = normalizeDtsOptions(getDtsModuleFederationConfig(resolvedConfig.root), resolvedConfig.root);
+			} catch (error) {
+				logDtsError(error, options.dts);
+				return;
+			}
+			if (typeof normalizedDtsOptions !== "object") return;
+			const context = resolvedConfig.root;
+			const outputDir = resolveOutputDir(resolvedConfig);
+			let consumeOptions;
+			try {
+				consumeOptions = normalizeConsumeTypesOptions({
+					context,
+					dtsOptions: normalizedDtsOptions,
+					pluginOptions: getDtsModuleFederationConfig(resolvedConfig.root)
+				});
+			} catch (error) {
+				logDtsError(error, normalizedDtsOptions);
+				return;
+			}
+			if (consumeOptions?.host?.typesOnBuild) try {
+				await consumeTypesAPI(consumeOptions);
+			} catch (error) {
+				logDtsError(error, normalizedDtsOptions);
+			}
+			let generateOptions;
+			try {
+				generateOptions = normalizeGenerateTypesOptions({
+					context,
+					outputDir,
+					dtsOptions: normalizedDtsOptions,
+					pluginOptions: getDtsModuleFederationConfig(resolvedConfig.root)
+				});
+			} catch (error) {
+				logDtsError(error, normalizedDtsOptions);
+				return;
+			}
+			if (!generateOptions) return;
+			try {
+				await generateTypesAPI({ dtsManagerOptions: generateOptions });
+			} catch (error) {
+				logDtsError(error, normalizedDtsOptions);
+			}
+		}
+	}];
+}
+//#endregion
+export { pluginDts as default };

package/lib/{ssrEntryLoader-Ccr0zMrr.js → ssrEntryLoader-0NnTjWR1.js}

@@ -133,7 +133,9 @@ async function nodeImport(id) {
 ));
 	return importCache.get(id);
 }
-const isNodeServer = () => typeof globalThis.process?.versions?.node === "string";
+const isNodeServer = () => {
+	return import.meta.env?.SSR ?? typeof globalThis.process?.versions?.node === "string";
+};
 const runnerCache = /* @__PURE__ */ new Map();
 function getSortedRecordEntries(record) {
 	return Object.entries(record).sort(([left], [right]) => left.localeCompare(right));
@@ -196,16 +198,17 @@ async function getOrCreateRunner(remoteOrigin, resolvedShared, fetchTimeoutMs, f
 			return new ModuleRunner({
 				hmr: false,
 				transport: { async invoke(payload) {
-					if (payload.data.name === "fetchModule") {
-						const sharedExternal = await resolveSharedExternal(payload.data.data[0], resolvedShared);
-						if (sharedExternal) return { result: sharedExternal };
-					}
 					const text = await readResponseTextBounded(await fetchWithTimeout(runnerEndpoint, {
 						method: "POST",
 						headers: { "Content-Type": "application/json" },
 						body: JSON.stringify(payload)
 					}, fetchTimeoutMs), fetchMaxBytes, runnerEndpoint);
-					return JSON.parse(text);
+					const result = JSON.parse(text);
+					if ("error" in result && payload.data.name === "fetchModule") {
+						const sharedExternal = await resolveSharedExternal(payload.data.data[0], resolvedShared);
+						if (sharedExternal) return { result: sharedExternal };
+					}
+					return result;
 				} }
 			}, new ESModulesEvaluator());
 		} catch {
@@ -567,7 +570,7 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 		if (!res.ok) throw new SsrEntryHttpError(url, res.status, res.statusText, getBodyPreview(code));
 		const base = url.replace(/\/[^/]*$/, "/");
 		const relImports = [];
-		const relRegex = /(?:from|export\s*\*\s*from|import\s*(?:\(|\s))\s*["'`]([^"'`\s]+)["'`]/g;
+		const relRegex = /(?:from|export\s*\*\s*from|import\s*\(?\s*)\s*["'`]([^"'`\s]+)["'`]/g;
 		let m;
 		while ((m = relRegex.exec(code)) !== null) if ((m[1].startsWith("./") || m[1].startsWith("../")) && !isVitePreloadHelperSpecifier(m[1])) relImports.push(new URL(m[1], base).href);
 		const subMap = /* @__PURE__ */ new Map();
@@ -603,7 +606,7 @@ async function importTempModule(filePath, versionKey) {
 }
 let warnedVmUnavailable = false;
 async function tryVmStrategy(ssrEntry, options) {
-	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-DTJITp2Z.js");
+	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-B0fCaHs5.js");
 	if (!await isVmStrategyAvailable()) {
 		if (!warnedVmUnavailable) {
 			warnedVmUnavailable = true;

package/lib/{ssrVmStrategy-DTJITp2Z.js → ssrVmStrategy-B0fCaHs5.js}

@@ -1,5 +1,5 @@
 import { a as getCommonSharedSubpaths } from "./pathNormalization-DvgU8LIp.js";
-import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-Ccr0zMrr.js";
+import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-0NnTjWR1.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.

package/lib/utils/ssrEntryLoader.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.20.5",
+  "version": "1.20.7",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",
@@ -93,4 +93,4 @@
     "vite": "8.2.0",
     "vitest": "4.1.10"
   }
-}
+}