@module-federation/vite 1.16.6 → 1.16.7

package/lib/pluginDts-Cpmdbbr0.js

@@ -0,0 +1,632 @@
+import "node:module";
+import fs, { existsSync, readFileSync, readdirSync } from "fs";
+import { createRequire as createRequire$1 } from "module";
+import * as path$1 from "node:path";
+import { fileURLToPath, pathToFileURL } from "url";
+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 \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#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);
+}
+//#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));
+	}
+};
+moduleFederationConsole.log;
+const mfWarn = moduleFederationConsole.warn;
+const mfError = moduleFederationConsole.error;
+//#endregion
+//#region src/utils/packageUtils.ts
+const dependencyPresenceCache = /* @__PURE__ */ new Map();
+let packageDetectionCwd;
+function getDependencyCacheKey(cwd, dependencyName) {
+	return `${cwd}:${dependencyName}`;
+}
+function setPackageDetectionCwd(cwd) {
+	packageDetectionCwd = cwd;
+}
+function getPackageDetectionCwd() {
+	return packageDetectionCwd || process.cwd();
+}
+function resolveImportPath(specifier) {
+	const resolved = import.meta.resolve(specifier);
+	if (!resolved.startsWith("file:")) return resolved;
+	const filePath = fileURLToPath(resolved);
+	if (!existsSync(filePath)) {
+		const error = /* @__PURE__ */ new Error(`Cannot find module '${specifier}'`);
+		error.code = "MODULE_NOT_FOUND";
+		throw error;
+	}
+	return filePath;
+}
+const DEFAULT_EXPORT_CONDITIONS = [
+	"browser",
+	"import",
+	"module",
+	"default",
+	"require"
+];
+function resolveExportsEntry(exportsField, conditions = DEFAULT_EXPORT_CONDITIONS) {
+	if (typeof exportsField === "string") return exportsField;
+	if (!exportsField || typeof exportsField !== "object") return void 0;
+	const record = exportsField;
+	const rootExport = record["."];
+	if (rootExport) return resolveExportsEntry(rootExport);
+	for (const condition of conditions) {
+		const target = resolveExportsEntry(record[condition], conditions);
+		if (target) return target;
+	}
+	for (const target of Object.values(record)) {
+		const resolved = resolveExportsEntry(target, conditions);
+		if (resolved) return resolved;
+	}
+}
+function getPackageExportsTarget(pkg, packageName, exportsField) {
+	if (typeof exportsField === "string") return pkg === packageName ? exportsField : void 0;
+	if (!exportsField || typeof exportsField !== "object") return void 0;
+	const record = exportsField;
+	const subpath = pkg === packageName ? "." : `.${pkg.slice(packageName.length)}`;
+	if (subpath !== ".") return record[subpath];
+	return record["."] ?? (!Object.keys(record).some((key) => key.startsWith(".")) ? record : void 0);
+}
+/**
+* Escaping rules:
+* Convert using the format __${mapping}__, where _ and $ are not allowed in npm package names but can be used in variable names.
+*  @ => 1
+*  / => 2
+*  - => 3
+*  . => 4
+*/
+/**
+* Encodes a package name into a valid file name.
+* @param {string} name - The package name, e.g., "@scope/xx-xx.xx".
+* @returns {string} - The encoded file name.
+*/
+function packageNameEncode(name) {
+	if (typeof name !== "string") throw createModuleFederationError("A string package name is required");
+	return name.replace(/@/g, "_mf_0_").replace(/\//g, "_mf_1_").replace(/-/g, "_mf_2_").replace(/\./g, "_mf_3_");
+}
+/**
+* Decodes an encoded file name back to the original package name.
+* @param {string} encoded - The encoded file name, e.g., "_mf_0_scope_mf_1_xx_mf_2_xx_mf_3_xx".
+* @returns {string} - The decoded package name.
+*/
+function packageNameDecode(encoded) {
+	if (typeof encoded !== "string") throw createModuleFederationError("A string encoded file name is required");
+	return encoded.replace(/_mf_0_/g, "@").replace(/_mf_1_/g, "/").replace(/_mf_2_/g, "-").replace(/_mf_3_/g, ".");
+}
+/**
+* Removes any subpath from an npm package specifier and returns the package name only.
+* @param {string} packageString - The package specifier, e.g., "@scope/pkg/runtime" or "react/jsx-runtime".
+* @returns {string} - The base npm package name.
+*/
+function getPackageName(packageString) {
+	const match = packageString.match(/^(?:@[^/]+\/)?[^/]+/);
+	return match ? match[0] : packageString;
+}
+function getPackageNameFromNodeModulePath(source) {
+	const normalized = source.replace(/\\/g, "/");
+	const nodeModulesIndex = normalized.lastIndexOf("/node_modules/");
+	if (nodeModulesIndex < 0) return;
+	const parts = normalized.slice(nodeModulesIndex + 14).split("/");
+	if (!parts[0]) return;
+	if (parts[0].startsWith("@")) return parts[1] ? `${parts[0]}/${parts[1]}` : void 0;
+	return parts[0];
+}
+function getSharedCacheKey(pkg, shareItem) {
+	return shareItem.shareConfig.singleton || !shareItem.version ? pkg : `${pkg}@${shareItem.version}`;
+}
+function getInstalledPackageJson(pkg, opts) {
+	const cwd = opts?.cwd || getPackageDetectionCwd();
+	const packageName = opts?.packageName || getPackageName(pkg);
+	const tryReadPackageJson = (packageJsonPath) => {
+		if (!existsSync(packageJsonPath)) return void 0;
+		try {
+			return {
+				path: packageJsonPath,
+				dir: path$1.dirname(packageJsonPath),
+				packageJson: JSON.parse(readFileSync(packageJsonPath, "utf-8"))
+			};
+		} catch {
+			return;
+		}
+	};
+	const findPackageInPnpmStore = (startDir) => {
+		let currentDir = startDir;
+		const rootDir = path$1.parse(currentDir).root;
+		while (true) {
+			const pnpmStoreDir = path$1.join(currentDir, "node_modules", ".pnpm");
+			if (existsSync(pnpmStoreDir)) 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 {}
+			if (currentDir === rootDir) break;
+			currentDir = path$1.dirname(currentDir);
+		}
+	};
+	try {
+		const projectRequire = createRequire$1(pathToFileURL(path$1.join(cwd, "package.json")));
+		let resolvedPath;
+		if (opts?.fromResolvedEntry) resolvedPath = opts.fromResolvedEntry;
+		else try {
+			resolvedPath = projectRequire.resolve(pkg);
+		} catch {
+			resolvedPath = projectRequire.resolve(packageName);
+		}
+		let currentDir = path$1.dirname(resolvedPath);
+		const rootDir = path$1.parse(currentDir).root;
+		while (true) {
+			const packageJsonPath = path$1.join(currentDir, "package.json");
+			if (existsSync(packageJsonPath)) {
+				const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
+				try {
+					const packageJson = JSON.parse(packageJsonContent);
+					if (packageJson.name === packageName) return {
+						path: packageJsonPath,
+						dir: currentDir,
+						packageJson
+					};
+				} catch (error) {
+					if (!(error instanceof SyntaxError)) throw error;
+				}
+			}
+			if (currentDir === rootDir) break;
+			currentDir = path$1.dirname(currentDir);
+		}
+	} catch {
+		let currentDir = cwd;
+		const rootDir = path$1.parse(currentDir).root;
+		while (true) {
+			const directCandidate = tryReadPackageJson(path$1.join(currentDir, "node_modules", packageName, "package.json"));
+			if (directCandidate?.packageJson.name === packageName) return directCandidate;
+			if (currentDir === rootDir) break;
+			currentDir = path$1.dirname(currentDir);
+		}
+		return findPackageInPnpmStore(cwd);
+	}
+}
+function getInstalledPackageEntry(pkg, opts) {
+	const installed = getInstalledPackageJson(pkg, opts);
+	if (!installed) return void 0;
+	const cwd = opts?.cwd || getPackageDetectionCwd();
+	const packageName = opts?.packageName || getPackageName(pkg);
+	if (pkg !== packageName && opts?.resolveSubpathWithRequire !== false) try {
+		return createRequire$1(pathToFileURL(path$1.join(cwd, "package.json"))).resolve(pkg);
+	} catch {}
+	const packageJson = installed.packageJson;
+	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.
+*/
+function getIsRolldown(ctx) {
+	const viteVersion = ctx?.meta?.viteVersion;
+	const viteMajor = Number(String(viteVersion ?? "").split(".")[0]);
+	return Number.isFinite(viteMajor) && viteMajor >= 8 || !!ctx?.meta?.rolldownVersion;
+}
+/** Walk up from Vite `config.root` (Nuxt may point at `.nuxt` cache dirs). */
+function isNuxtProjectRoot(root) {
+	let dir = root;
+	for (let i = 0; i < 8; i++) {
+		if (hasPackageDependency("nuxt", dir) || hasPackageDependency("nuxt-nightly", dir)) return true;
+		const parent = path$1.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return false;
+}
+function hasPackageDependency(dependencyName, cwd = packageDetectionCwd || process.cwd()) {
+	const cacheKey = getDependencyCacheKey(cwd, dependencyName);
+	const cached = dependencyPresenceCache.get(cacheKey);
+	if (cached !== void 0) return cached;
+	try {
+		const packageJson = JSON.parse(readFileSync(path$1.join(cwd, "package.json"), "utf8"));
+		const hasDependency = [
+			packageJson.dependencies,
+			packageJson.devDependencies,
+			packageJson.peerDependencies,
+			packageJson.optionalDependencies
+		].some((deps) => !!deps?.[dependencyName]);
+		dependencyPresenceCache.set(cacheKey, hasDependency);
+		return hasDependency;
+	} catch {
+		dependencyPresenceCache.set(cacheKey, false);
+		return false;
+	}
+}
+//#endregion
+//#region src/plugins/pluginDts.ts
+var pluginDts_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_PUBLIC_TYPES_FOLDER: () => DEFAULT_PUBLIC_TYPES_FOLDER,
+	createDevDtsAssetMiddleware: () => createDevDtsAssetMiddleware,
+	default: () => pluginDts,
+	getDevDtsAssetPaths: () => getDevDtsAssetPaths,
+	resolveDtsPluginOptions: () => resolveDtsPluginOptions
+});
+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 DEFAULT_PUBLIC_TYPES_FOLDER = "@mf-types";
+const forkDevWorkerPath = 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;
+		remotes[key] = `${remote.entryGlobalName?.startsWith("http") || remote.entryGlobalName?.includes(".json") ? remote.name || key : remote.entryGlobalName || remote.name || key}@${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 { mfWarn as _, getIsRolldown as a, getPackageNameFromNodeModulePath as c, isNuxtProjectRoot as d, packageNameDecode as f, createModuleFederationError as g, setPackageDetectionCwd as h, getInstalledPackageJson as i, getSharedCacheKey as l, resolveImportPath as m, pluginDts_exports as n, getPackageDetectionCwd as o, packageNameEncode as p, getInstalledPackageEntry as r, getPackageName as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, hasPackageDependency as u, normalizePathForImport as v, rebaseImport as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.16.6",
+  "version": "1.16.7",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",