@module-federation/dts-plugin 2.0.0 → 2.1.0

package/dist/esm/fork-dev-worker.mjs

@@ -0,0 +1,103 @@
+import { _ as retrieveMfTypesPath, b as ModuleFederationDevServer, g as retrieveTypesZipPath, h as retrieveHostConfig, i as retrieveRemoteConfig, n as RpcGMCallTypes, o as getDTSManagerConstructor, t as exposeRpc, y as createHttpServer } from "./expose-rpc-DMhY1i8A.mjs";
+import { o as UpdateMode, r as DEFAULT_TAR_NAME } from "./Action-DNNg2YDh.mjs";
+import { n as UpdateKind, o as getIPV4, s as fileLog } from "./Broker-BU4gToNr.mjs";
+import "./consumeTypes-D51rVbSt.mjs";
+import "./core.mjs";
+import { t as getIpFromEntry } from "./utils-CkPvDGOy.mjs";
+import { decodeName } from "@module-federation/sdk";
+
+//#region src/dev-worker/forkDevWorker.ts
+let typesManager, serverAddress, moduleServer, cacheOptions;
+function getLocalRemoteNames(options, encodeNameIdentifier) {
+	if (!options) return [];
+	let hostConfig;
+	try {
+		hostConfig = retrieveHostConfig(options);
+	} catch (e) {
+		fileLog(`getLocalRemoteNames: retrieveHostConfig failed: ${e.message}`, "forkDevWorker", "warn");
+		return [];
+	}
+	const { mapRemotesToDownload } = hostConfig;
+	return Object.keys(mapRemotesToDownload).reduce((sum, remoteModuleName) => {
+		const remoteInfo = mapRemotesToDownload[remoteModuleName];
+		const name = encodeNameIdentifier ? decodeName(remoteInfo.name, encodeNameIdentifier) : remoteInfo.name;
+		const ip = getIpFromEntry(remoteInfo.url, getIPV4());
+		if (!ip) return sum;
+		sum.push({
+			name,
+			entry: remoteInfo.url,
+			ip
+		});
+		return sum;
+	}, []);
+}
+async function updateCallback({ updateMode, name, remoteTypeTarPath, remoteInfo, once }) {
+	const { disableHotTypesReload, disableLiveReload } = cacheOptions || {};
+	fileLog(`sync remote module ${name}, types to ${cacheOptions?.name},typesManager.updateTypes run`, "forkDevWorker", "info");
+	if (!disableLiveReload && moduleServer) moduleServer.update({
+		updateKind: UpdateKind.RELOAD_PAGE,
+		updateMode: UpdateMode.PASSIVE
+	});
+	if (!disableHotTypesReload && typesManager) await typesManager.updateTypes({
+		updateMode,
+		remoteName: name,
+		remoteTarPath: remoteTypeTarPath,
+		remoteInfo,
+		once
+	});
+}
+async function forkDevWorker(options, action) {
+	if (!typesManager) {
+		const { name, remote, host, extraOptions } = options;
+		typesManager = new (getDTSManagerConstructor(remote?.implementation))({
+			remote,
+			host,
+			extraOptions
+		});
+		if (!options.disableHotTypesReload && remote) {
+			const { remoteOptions, tsConfig } = retrieveRemoteConfig(remote);
+			const mfTypesZipPath = retrieveTypesZipPath(retrieveMfTypesPath(tsConfig, remoteOptions), remoteOptions);
+			await Promise.all([createHttpServer({ typeTarPath: mfTypesZipPath }).then((res) => {
+				serverAddress = res.serverAddress;
+			}), typesManager.generateTypes()]).catch((err) => {
+				fileLog(`${name} module generateTypes done, localServerAddress:  ${JSON.stringify(err)}`, "forkDevWorker", "error");
+			});
+			fileLog(`${name} module generateTypes done, localServerAddress:  ${serverAddress}`, "forkDevWorker", "info");
+		}
+		moduleServer = new ModuleFederationDevServer({
+			name,
+			remotes: getLocalRemoteNames(host, extraOptions?.["encodeNameIdentifier"]),
+			updateCallback,
+			remoteTypeTarPath: `${serverAddress}/${DEFAULT_TAR_NAME}`
+		});
+		cacheOptions = options;
+	}
+	if (action === "update" && cacheOptions) {
+		fileLog(`remoteModule ${cacheOptions.name} receive devWorker update, start typesManager.updateTypes `, "forkDevWorker", "info");
+		if (!cacheOptions.disableLiveReload) moduleServer?.update({
+			updateKind: UpdateKind.RELOAD_PAGE,
+			updateMode: UpdateMode.POSITIVE
+		});
+		if (!cacheOptions.disableHotTypesReload) typesManager?.updateTypes({
+			updateMode: UpdateMode.POSITIVE,
+			remoteName: cacheOptions.name
+		}).then(() => {
+			moduleServer?.update({
+				updateKind: UpdateKind.UPDATE_TYPE,
+				updateMode: UpdateMode.POSITIVE
+			});
+		});
+	}
+}
+process.on("message", (message) => {
+	fileLog(`ChildProcess(${process.pid}), message: ${JSON.stringify(message)} `, "forkDevWorker", "info");
+	if (message.type === RpcGMCallTypes.EXIT) {
+		fileLog(`ChildProcess(${process.pid}) SIGTERM, Federation DevServer will exit...`, "forkDevWorker", "error");
+		moduleServer?.exit();
+		process.exit(0);
+	}
+});
+exposeRpc(forkDevWorker);
+
+//#endregion
+export { forkDevWorker };

package/dist/esm/fork-generate-dts.mjs

@@ -0,0 +1,14 @@
+import { n as RpcGMCallTypes, r as generateTypes, t as exposeRpc } from "./expose-rpc-DMhY1i8A.mjs";
+import "./Broker-BU4gToNr.mjs";
+
+//#region src/core/lib/forkGenerateDts.ts
+async function forkGenerateDts(options) {
+	return generateTypes(options);
+}
+process.on("message", (message) => {
+	if (message.type === RpcGMCallTypes.EXIT) process.exit(0);
+});
+exposeRpc(forkGenerateDts);
+
+//#endregion
+export { forkGenerateDts };

package/dist/esm/index.mjs

@@ -0,0 +1,465 @@
+import { a as cloneDeepOptions, c as isTSProject, l as retrieveTypesAssetsInfo, n as RpcGMCallTypes, r as generateTypes, u as validateOptions } from "./expose-rpc-DMhY1i8A.mjs";
+import { s as WEB_CLIENT_OPTIONS_IDENTIFIER } from "./Action-DNNg2YDh.mjs";
+import { c as logger$1, o as getIPV4 } from "./Broker-BU4gToNr.mjs";
+import { a as createRpcWorker, n as generateTypesInChildProcess, t as consumeTypes } from "./consumeTypes-D51rVbSt.mjs";
+import "./core.mjs";
+import * as fse$1 from "fs-extra";
+import fse from "fs-extra";
+import * as path$1 from "path";
+import path from "path";
+import fs from "fs";
+import { TEMP_DIR, infrastructureLogger, logger, normalizeOptions } from "@module-federation/sdk";
+
+//#region src/dev-worker/DevWorker.ts
+var DevWorker = class {
+	constructor(options) {
+		this._options = cloneDeepOptions(options);
+		this.removeUnSerializationOptions();
+		this._rpcWorker = createRpcWorker(path.resolve(__dirname, "./fork-dev-worker.js"), {}, void 0, false);
+		this._res = this._rpcWorker.connect(this._options);
+	}
+	removeUnSerializationOptions() {
+		delete this._options.host?.moduleFederationConfig?.manifest;
+		delete this._options.remote?.moduleFederationConfig?.manifest;
+	}
+	get controlledPromise() {
+		return this._res;
+	}
+	update() {
+		this._rpcWorker.process?.send?.({
+			type: RpcGMCallTypes.CALL,
+			id: this._rpcWorker.id,
+			args: [void 0, "update"]
+		});
+	}
+	exit() {
+		this._rpcWorker?.terminate();
+	}
+};
+
+//#endregion
+//#region src/dev-worker/createDevWorker.ts
+async function removeLogFile() {
+	try {
+		const logDir = path$1.resolve(process.cwd(), ".mf/typesGenerate.log");
+		await fse$1.remove(logDir);
+	} catch (err) {
+		console.error("removeLogFile error", "forkDevWorker", err);
+	}
+}
+function createDevWorker(options) {
+	removeLogFile();
+	return new DevWorker({ ...options });
+}
+
+//#endregion
+//#region src/plugins/utils.ts
+function isDev() {
+	return process.env["NODE_ENV"] === "development";
+}
+function isPrd() {
+	return process.env["NODE_ENV"] === "production";
+}
+function getCompilerOutputDir(compiler) {
+	try {
+		return path.relative(compiler.context, compiler.outputPath || compiler.options.output.path);
+	} catch (err) {
+		return "";
+	}
+}
+
+//#endregion
+//#region src/plugins/DevPlugin.ts
+var PROCESS_EXIT_CODE = /* @__PURE__ */ function(PROCESS_EXIT_CODE) {
+	PROCESS_EXIT_CODE[PROCESS_EXIT_CODE["SUCCESS"] = 0] = "SUCCESS";
+	PROCESS_EXIT_CODE[PROCESS_EXIT_CODE["FAILURE"] = 1] = "FAILURE";
+	return PROCESS_EXIT_CODE;
+}(PROCESS_EXIT_CODE || {});
+function ensureTempDir(filePath) {
+	try {
+		const dir = path.dirname(filePath);
+		fse.ensureDirSync(dir);
+	} catch (_err) {}
+}
+var DevPlugin = class DevPlugin {
+	constructor(options, dtsOptions, generateTypesPromise, fetchRemoteTypeUrlsPromise) {
+		this.name = "MFDevPlugin";
+		this._options = options;
+		this.generateTypesPromise = generateTypesPromise;
+		this.dtsOptions = dtsOptions;
+		this.fetchRemoteTypeUrlsPromise = fetchRemoteTypeUrlsPromise;
+	}
+	static ensureLiveReloadEntry(options, filePath) {
+		ensureTempDir(filePath);
+		const liveReloadEntryWithOptions = fse.readFileSync(path.join(__dirname, "./iife/launch-web-client.iife.js")).toString("utf-8").replace(WEB_CLIENT_OPTIONS_IDENTIFIER, JSON.stringify(options));
+		fse.writeFileSync(filePath, liveReloadEntryWithOptions);
+	}
+	_stopWhenSIGTERMOrSIGINT() {
+		process.on("SIGTERM", () => {
+			logger$1.info(`${this._options.name} Process(${process.pid}) SIGTERM, mf server will exit...`);
+			this._exit(PROCESS_EXIT_CODE.SUCCESS);
+		});
+		process.on("SIGINT", () => {
+			logger$1.info(`${this._options.name} Process(${process.pid}) SIGINT, mf server will exit...`);
+			this._exit(PROCESS_EXIT_CODE.SUCCESS);
+		});
+	}
+	_handleUnexpectedExit() {
+		process.on("unhandledRejection", (error) => {
+			logger$1.error(error);
+			logger$1.error(`Process(${process.pid}) unhandledRejection, mf server will exit...`);
+			this._exit(PROCESS_EXIT_CODE.FAILURE);
+		});
+		process.on("uncaughtException", (error) => {
+			logger$1.error(error);
+			logger$1.error(`Process(${process.pid}) uncaughtException, mf server will exit...`);
+			this._exit(PROCESS_EXIT_CODE.FAILURE);
+		});
+	}
+	_exit(exitCode = 0) {
+		this._devWorker?.exit();
+		process.exit(exitCode);
+	}
+	_afterEmit() {
+		this._devWorker?.update();
+	}
+	apply(compiler) {
+		const { _options: { name, dev, dts } } = this;
+		const normalizedDev = normalizeOptions(true, {
+			disableLiveReload: true,
+			disableHotTypesReload: false,
+			disableDynamicRemoteTypeHints: false
+		}, "mfOptions.dev")(dev);
+		if (!isDev() || normalizedDev === false) return;
+		new compiler.webpack.DefinePlugin({ FEDERATION_IPV4: JSON.stringify(getIPV4()) }).apply(compiler);
+		if (normalizedDev.disableHotTypesReload && normalizedDev.disableLiveReload && normalizedDev.disableDynamicRemoteTypeHints) return;
+		if (!name) throw new Error("name is required if you want to enable dev server!");
+		if (!normalizedDev.disableDynamicRemoteTypeHints) {
+			if (!this._options.runtimePlugins) this._options.runtimePlugins = [];
+			this._options.runtimePlugins.push(path.resolve(__dirname, "dynamic-remote-type-hints-plugin.js"));
+		}
+		if (!normalizedDev.disableLiveReload) {
+			const TEMP_DIR$1 = path.join(`${process.cwd()}/node_modules`, TEMP_DIR);
+			const filepath = path.join(TEMP_DIR$1, `live-reload.js`);
+			if (typeof compiler.options.entry === "object") {
+				DevPlugin.ensureLiveReloadEntry({ name }, filepath);
+				Object.keys(compiler.options.entry).forEach((entry) => {
+					const normalizedEntry = compiler.options.entry[entry];
+					if (typeof normalizedEntry === "object" && Array.isArray(normalizedEntry.import)) normalizedEntry.import.unshift(filepath);
+				});
+			}
+		}
+		const defaultGenerateTypes = { compileInChildProcess: true };
+		const defaultConsumeTypes = { consumeAPITypes: true };
+		const normalizedDtsOptions = normalizeOptions(isTSProject(dts, compiler.context), {
+			generateTypes: defaultGenerateTypes,
+			consumeTypes: defaultConsumeTypes,
+			extraOptions: {},
+			displayErrorInTerminal: this.dtsOptions?.displayErrorInTerminal
+		}, "mfOptions.dts")(dts);
+		const normalizedGenerateTypes = normalizeOptions(Boolean(normalizedDtsOptions), defaultGenerateTypes, "mfOptions.dts.generateTypes")(normalizedDtsOptions === false ? void 0 : normalizedDtsOptions.generateTypes);
+		const remote = normalizedGenerateTypes === false ? void 0 : {
+			implementation: normalizedDtsOptions === false ? void 0 : normalizedDtsOptions.implementation,
+			context: compiler.context,
+			outputDir: getCompilerOutputDir(compiler),
+			moduleFederationConfig: { ...this._options },
+			hostRemoteTypesFolder: normalizedGenerateTypes.typesFolder || "@mf-types",
+			...normalizedGenerateTypes,
+			typesFolder: `.dev-server`
+		};
+		const normalizedConsumeTypes = normalizeOptions(Boolean(normalizedDtsOptions), defaultConsumeTypes, "mfOptions.dts.consumeTypes")(normalizedDtsOptions === false ? void 0 : normalizedDtsOptions.consumeTypes);
+		const host = normalizedConsumeTypes === false ? void 0 : {
+			implementation: normalizedDtsOptions === false ? void 0 : normalizedDtsOptions.implementation,
+			context: compiler.context,
+			moduleFederationConfig: this._options,
+			typesFolder: normalizedConsumeTypes.typesFolder || "@mf-types",
+			abortOnError: false,
+			...normalizedConsumeTypes
+		};
+		const extraOptions = normalizedDtsOptions ? normalizedDtsOptions.extraOptions || {} : {};
+		if (!remote && !host && normalizedDev.disableLiveReload) return;
+		if (remote && !remote?.tsConfigPath && typeof normalizedDtsOptions === "object" && normalizedDtsOptions.tsConfigPath) remote.tsConfigPath = normalizedDtsOptions.tsConfigPath;
+		Promise.all([this.generateTypesPromise, this.fetchRemoteTypeUrlsPromise]).then(([_, remoteTypeUrls]) => {
+			this._devWorker = createDevWorker({
+				name,
+				remote,
+				host: {
+					moduleFederationConfig: {},
+					...host,
+					remoteTypeUrls
+				},
+				extraOptions,
+				disableLiveReload: normalizedDev.disableHotTypesReload,
+				disableHotTypesReload: normalizedDev.disableHotTypesReload
+			});
+		});
+		this._stopWhenSIGTERMOrSIGINT();
+		this._handleUnexpectedExit();
+		compiler.hooks.afterEmit.tap(this.name, this._afterEmit.bind(this));
+	}
+};
+
+//#endregion
+//#region src/plugins/ConsumeTypesPlugin.ts
+const DEFAULT_CONSUME_TYPES = {
+	abortOnError: false,
+	consumeAPITypes: true,
+	typesOnBuild: false
+};
+const normalizeConsumeTypesOptions = ({ context, dtsOptions, pluginOptions }) => {
+	const normalizedConsumeTypes = normalizeOptions(true, DEFAULT_CONSUME_TYPES, "mfOptions.dts.consumeTypes")(dtsOptions.consumeTypes);
+	if (!normalizedConsumeTypes) return;
+	const dtsManagerOptions = {
+		host: {
+			implementation: dtsOptions.implementation,
+			context,
+			moduleFederationConfig: pluginOptions,
+			...normalizedConsumeTypes
+		},
+		extraOptions: dtsOptions.extraOptions || {},
+		displayErrorInTerminal: dtsOptions.displayErrorInTerminal
+	};
+	validateOptions(dtsManagerOptions.host);
+	return dtsManagerOptions;
+};
+const consumeTypesAPI = async (dtsManagerOptions, cb) => {
+	return (typeof dtsManagerOptions.host.remoteTypeUrls === "function" ? dtsManagerOptions.host.remoteTypeUrls() : Promise.resolve(dtsManagerOptions.host.remoteTypeUrls)).then((remoteTypeUrls) => {
+		consumeTypes({
+			...dtsManagerOptions,
+			host: {
+				...dtsManagerOptions.host,
+				remoteTypeUrls
+			}
+		}).then(() => {
+			typeof cb === "function" && cb(remoteTypeUrls);
+		}).catch(() => {
+			typeof cb === "function" && cb(remoteTypeUrls);
+		});
+	});
+};
+var ConsumeTypesPlugin = class {
+	constructor(pluginOptions, dtsOptions, fetchRemoteTypeUrlsResolve) {
+		this.pluginOptions = pluginOptions;
+		this.dtsOptions = dtsOptions;
+		this.fetchRemoteTypeUrlsResolve = fetchRemoteTypeUrlsResolve;
+	}
+	apply(compiler) {
+		const { dtsOptions, pluginOptions, fetchRemoteTypeUrlsResolve } = this;
+		const dtsManagerOptions = normalizeConsumeTypesOptions({
+			context: compiler.context,
+			dtsOptions,
+			pluginOptions
+		});
+		if (!dtsManagerOptions) {
+			fetchRemoteTypeUrlsResolve(void 0);
+			return;
+		}
+		if (isPrd() && !dtsManagerOptions.host.typesOnBuild) {
+			fetchRemoteTypeUrlsResolve(void 0);
+			return;
+		}
+		infrastructureLogger.debug("start fetching remote types...");
+		const promise = consumeTypesAPI(dtsManagerOptions, fetchRemoteTypeUrlsResolve);
+		compiler.hooks.thisCompilation.tap("mf:generateTypes", (compilation) => {
+			compilation.hooks.processAssets.tapPromise({
+				name: "mf:generateTypes",
+				stage: compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER - 1
+			}, async () => {
+				await promise;
+				infrastructureLogger.debug("fetch remote types success!");
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/plugins/GenerateTypesPlugin.ts
+const DEFAULT_GENERATE_TYPES = {
+	generateAPITypes: true,
+	compileInChildProcess: true,
+	abortOnError: false,
+	extractThirdParty: false,
+	extractRemoteTypes: false
+};
+const normalizeGenerateTypesOptions = ({ context, outputDir, dtsOptions, pluginOptions }) => {
+	const normalizedGenerateTypes = normalizeOptions(true, DEFAULT_GENERATE_TYPES, "mfOptions.dts.generateTypes")(dtsOptions.generateTypes);
+	if (!normalizedGenerateTypes) return;
+	const normalizedConsumeTypes = normalizeOptions(true, {}, "mfOptions.dts.consumeTypes")(dtsOptions.consumeTypes);
+	const finalOptions = {
+		remote: {
+			implementation: dtsOptions.implementation,
+			context,
+			outputDir,
+			moduleFederationConfig: pluginOptions,
+			...normalizedGenerateTypes
+		},
+		host: normalizedConsumeTypes === false ? void 0 : {
+			context,
+			moduleFederationConfig: pluginOptions,
+			...normalizedConsumeTypes,
+			remoteTypeUrls: typeof normalizedConsumeTypes?.remoteTypeUrls === "object" ? normalizedConsumeTypes?.remoteTypeUrls : void 0
+		},
+		extraOptions: dtsOptions.extraOptions || {},
+		displayErrorInTerminal: dtsOptions.displayErrorInTerminal
+	};
+	if (dtsOptions.tsConfigPath && !finalOptions.remote.tsConfigPath) finalOptions.remote.tsConfigPath = dtsOptions.tsConfigPath;
+	validateOptions(finalOptions.remote);
+	return finalOptions;
+};
+const getGenerateTypesFn = (dtsManagerOptions) => {
+	let fn = generateTypes;
+	if (dtsManagerOptions.remote.compileInChildProcess) fn = generateTypesInChildProcess;
+	return fn;
+};
+const generateTypesAPI = ({ dtsManagerOptions }) => {
+	return getGenerateTypesFn(dtsManagerOptions)(dtsManagerOptions);
+};
+var GenerateTypesPlugin = class {
+	constructor(pluginOptions, dtsOptions, fetchRemoteTypeUrlsPromise, callback) {
+		this.pluginOptions = pluginOptions;
+		this.dtsOptions = dtsOptions;
+		this.fetchRemoteTypeUrlsPromise = fetchRemoteTypeUrlsPromise;
+		this.callback = callback;
+	}
+	apply(compiler) {
+		const { dtsOptions, pluginOptions, fetchRemoteTypeUrlsPromise, callback } = this;
+		const outputDir = getCompilerOutputDir(compiler);
+		const context = compiler.context;
+		const dtsManagerOptions = normalizeGenerateTypesOptions({
+			context,
+			outputDir,
+			dtsOptions,
+			pluginOptions
+		});
+		if (!dtsManagerOptions) {
+			callback();
+			return;
+		}
+		const isProd = !isDev();
+		const emitTypesFiles = async (compilation) => {
+			try {
+				const { zipTypesPath, apiTypesPath, zipName, apiFileName } = retrieveTypesAssetsInfo(dtsManagerOptions.remote);
+				if (isProd && zipName && compilation.getAsset(zipName)) {
+					callback();
+					return;
+				}
+				logger.debug("start generating types...");
+				await generateTypesAPI({ dtsManagerOptions });
+				logger.debug("generate types success!");
+				if (isProd) {
+					if (zipTypesPath && !compilation.getAsset(zipName) && fs.existsSync(zipTypesPath)) compilation.emitAsset(zipName, new compiler.webpack.sources.RawSource(fs.readFileSync(zipTypesPath)));
+					if (apiTypesPath && !compilation.getAsset(apiFileName) && fs.existsSync(apiTypesPath)) compilation.emitAsset(apiFileName, new compiler.webpack.sources.RawSource(fs.readFileSync(apiTypesPath)));
+					callback();
+				} else {
+					const isEEXIST = (err) => {
+						return err.code == "EEXIST";
+					};
+					if (zipTypesPath && fs.existsSync(zipTypesPath)) {
+						const zipContent = fs.readFileSync(zipTypesPath);
+						const zipOutputPath = path.join(compiler.outputPath, zipName);
+						await new Promise((resolve, reject) => {
+							compiler.outputFileSystem.mkdir(path.dirname(zipOutputPath), { recursive: true }, (err) => {
+								if (err && !isEEXIST(err)) reject(err);
+								else compiler.outputFileSystem.writeFile(zipOutputPath, zipContent, (writeErr) => {
+									if (writeErr && !isEEXIST(writeErr)) reject(writeErr);
+									else resolve();
+								});
+							});
+						});
+					}
+					if (apiTypesPath && fs.existsSync(apiTypesPath)) {
+						const apiContent = fs.readFileSync(apiTypesPath);
+						const apiOutputPath = path.join(compiler.outputPath, apiFileName);
+						await new Promise((resolve, reject) => {
+							compiler.outputFileSystem.mkdir(path.dirname(apiOutputPath), { recursive: true }, (err) => {
+								if (err && !isEEXIST(err)) reject(err);
+								else compiler.outputFileSystem.writeFile(apiOutputPath, apiContent, (writeErr) => {
+									if (writeErr && !isEEXIST(writeErr)) reject(writeErr);
+									else resolve();
+								});
+							});
+						});
+					}
+					callback();
+				}
+			} catch (err) {
+				callback();
+				if (dtsManagerOptions.displayErrorInTerminal) console.error(err);
+				logger.debug("generate types fail!");
+			}
+		};
+		compiler.hooks.thisCompilation.tap("mf:generateTypes", (compilation) => {
+			compilation.hooks.processAssets.tapPromise({
+				name: "mf:generateTypes",
+				stage: compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+			}, async () => {
+				await fetchRemoteTypeUrlsPromise;
+				const emitTypesFilesPromise = emitTypesFiles(compilation);
+				if (isProd) await emitTypesFilesPromise;
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/plugins/DtsPlugin.ts
+const normalizeDtsOptions = (options, context, defaultOptions) => {
+	return normalizeOptions(isTSProject(options.dts, context), {
+		generateTypes: defaultOptions?.defaultGenerateOptions || DEFAULT_GENERATE_TYPES,
+		consumeTypes: defaultOptions?.defaultConsumeOptions || DEFAULT_CONSUME_TYPES,
+		extraOptions: {},
+		displayErrorInTerminal: true
+	}, "mfOptions.dts")(options.dts);
+};
+const excludeDts = (filepath) => {
+	if (typeof filepath !== "string") return false;
+	const [_p, query] = filepath.split("?");
+	if (query && query.startsWith("exclude-mf-dts")) return true;
+	return false;
+};
+var DtsPlugin = class {
+	constructor(options) {
+		this.options = options;
+		this.clonedOptions = { ...options };
+	}
+	apply(compiler) {
+		const { options, clonedOptions } = this;
+		if (options.exposes && typeof options.exposes === "object") {
+			const cleanedExposes = {};
+			Object.entries(options.exposes).forEach(([key, value]) => {
+				if (typeof value === "string") {
+					const [filepath, _query] = value.split("?");
+					if (excludeDts(value)) return;
+					cleanedExposes[key] = filepath;
+				} else {
+					if (typeof value === "object" && Array.isArray(value.import) && value.import.some((v) => excludeDts(v))) return;
+					cleanedExposes[key] = value;
+				}
+			});
+			clonedOptions.exposes = cleanedExposes;
+		}
+		const normalizedDtsOptions = normalizeDtsOptions(clonedOptions, compiler.context);
+		if (typeof normalizedDtsOptions !== "object") return;
+		let fetchRemoteTypeUrlsResolve;
+		const fetchRemoteTypeUrlsPromise = new Promise((resolve) => {
+			fetchRemoteTypeUrlsResolve = resolve;
+		});
+		let generateTypesPromiseResolve;
+		new DevPlugin(clonedOptions, normalizedDtsOptions, new Promise((resolve) => {
+			generateTypesPromiseResolve = resolve;
+		}), fetchRemoteTypeUrlsPromise).apply(compiler);
+		new GenerateTypesPlugin(clonedOptions, normalizedDtsOptions, fetchRemoteTypeUrlsPromise, generateTypesPromiseResolve).apply(compiler);
+		new ConsumeTypesPlugin(clonedOptions, normalizedDtsOptions, fetchRemoteTypeUrlsResolve).apply(compiler);
+	}
+	addRuntimePlugins() {
+		const { options, clonedOptions } = this;
+		if (!clonedOptions.runtimePlugins) return;
+		if (!options.runtimePlugins) options.runtimePlugins = [];
+		clonedOptions.runtimePlugins.forEach((plugin) => {
+			options.runtimePlugins.includes(plugin) || options.runtimePlugins.push(plugin);
+		});
+	}
+};
+
+//#endregion
+export { DtsPlugin, consumeTypesAPI, generateTypesAPI, isTSProject, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions };

package/dist/esm/start-broker.mjs

@@ -0,0 +1,22 @@
+import { s as fileLog, t as Broker } from "./Broker-BU4gToNr.mjs";
+
+//#region src/server/broker/startBroker.ts
+let broker;
+function getBroker() {
+	return broker;
+}
+async function startBroker() {
+	if (getBroker()) return;
+	broker = new Broker();
+	await broker.start();
+	process.send?.("ready");
+}
+process.on("message", (message) => {
+	if (message === "start") {
+		fileLog(`startBroker... ${process.pid}`, "StartBroker", "info");
+		startBroker();
+	}
+});
+
+//#endregion
+export { getBroker };

package/dist/esm/utils-CkPvDGOy.mjs

@@ -0,0 +1,13 @@
+//#region src/dev-worker/utils.ts
+const DEFAULT_LOCAL_IPS = ["localhost", "127.0.0.1"];
+function getIpFromEntry(entry, ipv4) {
+	let ip;
+	entry.replace(/https?:\/\/([0-9|.]+|localhost):/, (str, matched) => {
+		ip = matched;
+		return str;
+	});
+	if (ip) return DEFAULT_LOCAL_IPS.includes(ip) ? ipv4 : ip;
+}
+
+//#endregion
+export { getIpFromEntry as t };