@module-federation/dts-plugin 0.0.0-chore-bump-node-22-20260710161714

package/dist/index.js

@@ -0,0 +1,517 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_Action = require('./Action-CzhPMw2i.js');
+const require_Broker = require('./Broker-CaenCqdn.js');
+const require_expose_rpc = require('./expose-rpc-BpRiu3VK.js');
+const require_consumeTypes = require('./consumeTypes-Dle9g2SZ.js');
+require('./core.js');
+let fs = require("fs");
+fs = require_Action.__toESM(fs);
+let url = require("url");
+let path = require("path");
+path = require_Action.__toESM(path);
+let fs_promises = require("fs/promises");
+let _module_federation_sdk = require("@module-federation/sdk");
+
+//#region src/dev-worker/DevWorker.ts
+const __filename$2 = (0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+const __dirname$2 = path.default.dirname(__filename$2);
+var DevWorker = class {
+	constructor(options) {
+		this._options = require_expose_rpc.cloneDeepOptions(options);
+		this.removeUnSerializationOptions();
+		this._rpcWorker = require_consumeTypes.createRpcWorker(path.default.resolve(__dirname$2, "./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: require_expose_rpc.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 {
+		await (0, fs_promises.rm)(path.resolve(process.cwd(), ".mf/typesGenerate.log"), {
+			force: true,
+			recursive: true
+		});
+	} 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.default.relative(compiler.context, compiler.outputPath || compiler.options.output.path);
+	} catch (err) {
+		return "";
+	}
+}
+
+//#endregion
+//#region src/plugins/DevPlugin.ts
+const __filename$1 = (0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+const __dirname$1 = path.default.dirname(__filename$1);
+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.default.dirname(filePath);
+		fs.default.mkdirSync(dir, { recursive: true });
+	} 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 = fs.default.readFileSync(path.default.join(__dirname$1, "./iife/launch-web-client.iife.js")).toString("utf-8").replace(require_Action.WEB_CLIENT_OPTIONS_IDENTIFIER, JSON.stringify(options));
+		fs.default.writeFileSync(filePath, liveReloadEntryWithOptions);
+	}
+	_stopWhenSIGTERMOrSIGINT() {
+		process.on("SIGTERM", () => {
+			require_Broker.logger.info(`${this._options.name} Process(${process.pid}) SIGTERM, mf server will exit...`);
+			this._exit(PROCESS_EXIT_CODE.SUCCESS);
+		});
+		process.on("SIGINT", () => {
+			require_Broker.logger.info(`${this._options.name} Process(${process.pid}) SIGINT, mf server will exit...`);
+			this._exit(PROCESS_EXIT_CODE.SUCCESS);
+		});
+	}
+	_handleUnexpectedExit() {
+		process.on("unhandledRejection", (error) => {
+			require_Broker.logger.error(error);
+			require_Broker.logger.error(`Process(${process.pid}) unhandledRejection, mf server will exit...`);
+			this._exit(PROCESS_EXIT_CODE.FAILURE);
+		});
+		process.on("uncaughtException", (error) => {
+			require_Broker.logger.error(error);
+			require_Broker.logger.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 = (0, _module_federation_sdk.normalizeOptions)(true, {
+			disableLiveReload: true,
+			disableHotTypesReload: false,
+			disableDynamicRemoteTypeHints: false
+		}, "mfOptions.dev")(dev);
+		if (!isDev() || normalizedDev === false) return;
+		new compiler.webpack.DefinePlugin({ FEDERATION_IPV4: JSON.stringify(require_Broker.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.default.resolve(__dirname$1, "dynamic-remote-type-hints-plugin.js"));
+		}
+		if (!normalizedDev.disableLiveReload) {
+			const TEMP_DIR = path.default.join(`${process.cwd()}/node_modules`, _module_federation_sdk.TEMP_DIR);
+			const filepath = path.default.join(TEMP_DIR, `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 = (0, _module_federation_sdk.normalizeOptions)(require_expose_rpc.isTSProject(dts, compiler.context), {
+			generateTypes: defaultGenerateTypes,
+			consumeTypes: defaultConsumeTypes,
+			extraOptions: {},
+			displayErrorInTerminal: this.dtsOptions?.displayErrorInTerminal
+		}, "mfOptions.dts")(dts);
+		const normalizedGenerateTypes = (0, _module_federation_sdk.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 = (0, _module_federation_sdk.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 = (0, _module_federation_sdk.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
+	};
+	require_expose_rpc.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) => {
+		require_consumeTypes.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;
+		}
+		_module_federation_sdk.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;
+				_module_federation_sdk.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 = (0, _module_federation_sdk.normalizeOptions)(true, DEFAULT_GENERATE_TYPES, "mfOptions.dts.generateTypes")(dtsOptions.generateTypes);
+	if (!normalizedGenerateTypes) return;
+	const normalizedConsumeTypes = (0, _module_federation_sdk.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;
+	require_expose_rpc.validateOptions(finalOptions.remote);
+	return finalOptions;
+};
+const getGenerateTypesFn = (dtsManagerOptions) => {
+	let fn = require_expose_rpc.generateTypes;
+	if (dtsManagerOptions.remote.compileInChildProcess) fn = require_consumeTypes.generateTypesInChildProcess;
+	return fn;
+};
+const generateTypesAPI = ({ dtsManagerOptions }) => {
+	return getGenerateTypesFn(dtsManagerOptions)(dtsManagerOptions).then(async () => {
+		await callAfterGenerateHook({
+			dtsManagerOptions,
+			generatedTypes: require_expose_rpc.retrieveTypesAssetsInfo(dtsManagerOptions.remote)
+		});
+	});
+};
+const callAfterGenerateHook = async ({ dtsManagerOptions, generatedTypes }) => {
+	const afterGenerate = dtsManagerOptions.remote.afterGenerate;
+	if (!afterGenerate) return;
+	try {
+		await afterGenerate(generatedTypes);
+	} catch (error) {
+		if (dtsManagerOptions.remote.abortOnError === false) {
+			if (dtsManagerOptions.displayErrorInTerminal) _module_federation_sdk.logger.error(error);
+			return;
+		}
+		throw error;
+	}
+};
+const WINDOWS_ABSOLUTE_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
+const isSafeRelativePath = (relativePath) => {
+	return Boolean(relativePath) && !relativePath.startsWith("..") && !path.default.isAbsolute(relativePath) && !WINDOWS_ABSOLUTE_PATH_REGEXP.test(relativePath);
+};
+const resolveEmitAssetName = ({ compilerOutputPath, assetPath, fallbackName }) => {
+	if (!assetPath) return fallbackName;
+	const relativePath = path.default.relative(compilerOutputPath, assetPath);
+	return isSafeRelativePath(relativePath) ? relativePath : fallbackName;
+};
+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 compilerOutputPath = path.default.resolve(context, outputDir);
+		const emitTypesFiles = async (compilation) => {
+			try {
+				const { zipTypesPath, apiTypesPath, zipName, apiFileName } = require_expose_rpc.retrieveTypesAssetsInfo(dtsManagerOptions.remote);
+				const emitZipName = resolveEmitAssetName({
+					compilerOutputPath,
+					assetPath: zipTypesPath,
+					fallbackName: zipName
+				});
+				const emitApiFileName = resolveEmitAssetName({
+					compilerOutputPath,
+					assetPath: apiTypesPath,
+					fallbackName: apiFileName
+				});
+				if (isProd && emitZipName && compilation.getAsset(emitZipName)) {
+					callback();
+					return;
+				}
+				_module_federation_sdk.logger.debug("start generating types...");
+				await generateTypesAPI({ dtsManagerOptions });
+				_module_federation_sdk.logger.debug("generate types success!");
+				if (isProd) {
+					if (zipTypesPath && !compilation.getAsset(emitZipName) && fs.default.existsSync(zipTypesPath)) compilation.emitAsset(emitZipName, new compiler.webpack.sources.RawSource(fs.default.readFileSync(zipTypesPath)));
+					if (apiTypesPath && !compilation.getAsset(emitApiFileName) && fs.default.existsSync(apiTypesPath)) compilation.emitAsset(emitApiFileName, new compiler.webpack.sources.RawSource(fs.default.readFileSync(apiTypesPath)));
+					callback();
+				} else {
+					const isEEXIST = (err) => {
+						return err.code == "EEXIST";
+					};
+					if (zipTypesPath && fs.default.existsSync(zipTypesPath)) {
+						const zipContent = fs.default.readFileSync(zipTypesPath);
+						const zipOutputPath = path.default.join(compiler.outputPath, emitZipName);
+						await new Promise((resolve, reject) => {
+							compiler.outputFileSystem.mkdir(path.default.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.default.existsSync(apiTypesPath)) {
+						const apiContent = fs.default.readFileSync(apiTypesPath);
+						const apiOutputPath = path.default.join(compiler.outputPath, emitApiFileName);
+						await new Promise((resolve, reject) => {
+							compiler.outputFileSystem.mkdir(path.default.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);
+				_module_federation_sdk.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 (0, _module_federation_sdk.normalizeOptions)(require_expose_rpc.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
+exports.DtsPlugin = DtsPlugin;
+exports.consumeTypesAPI = consumeTypesAPI;
+exports.generateTypesAPI = generateTypesAPI;
+exports.isTSProject = require_expose_rpc.isTSProject;
+exports.normalizeConsumeTypesOptions = normalizeConsumeTypesOptions;
+exports.normalizeDtsOptions = normalizeDtsOptions;
+exports.normalizeGenerateTypesOptions = normalizeGenerateTypesOptions;

package/dist/start-broker.d.ts

@@ -0,0 +1,44 @@
+//#region src/server/broker/Broker.d.ts
+declare class Broker {
+  static readonly WEB_SOCKET_CONNECT_MAGIC_ID = "1hpzW-zo2z-o8io-gfmV1-2cb1d82";
+  static readonly DEFAULT_WEB_SOCKET_PORT = 16322;
+  static readonly DEFAULT_SECURE_WEB_SOCKET_PORT = 16324;
+  static readonly DEFAULT_WAITING_TIME: number;
+  private _publisherMap;
+  private _webClientMap;
+  private _webSocketServer?;
+  private _secureWebSocketServer?;
+  private _tmpSubscriberShelter;
+  private _scheduleJob;
+  constructor();
+  get hasPublishers(): boolean;
+  private _startWsServer;
+  private _takeAction;
+  private _addPublisher;
+  private _updatePublisher;
+  private _fetchTypes;
+  private _addDynamicRemote;
+  private _addSubscriber;
+  private _removeSubscriber;
+  private _removePublisher;
+  private _addWebClient;
+  private _notifyWebClient;
+  private _addTmpSubScriberRelation;
+  private _getTmpSubScribers;
+  private _consumeTmpSubScribers;
+  private _clearTmpSubScriberRelation;
+  private _clearTmpSubScriberRelations;
+  private _disconnect;
+  private _setSchedule;
+  private _clearSchedule;
+  private _stopWhenSIGTERMOrSIGINT;
+  private _handleUnexpectedExit;
+  start(): Promise<void>;
+  exit(): void;
+  broadcast(message: unknown): void;
+}
+//#endregion
+//#region src/server/broker/startBroker.d.ts
+declare function getBroker(): Broker | undefined;
+//#endregion
+export { getBroker };

package/dist/start-broker.js

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_Broker = require('./Broker-CaenCqdn.js');
+
+//#region src/server/broker/startBroker.ts
+let broker;
+function getBroker() {
+	return broker;
+}
+async function startBroker() {
+	if (getBroker()) return;
+	broker = new require_Broker.Broker();
+	await broker.start();
+	process.send?.("ready");
+}
+process.on("message", (message) => {
+	if (message === "start") {
+		require_Broker.fileLog(`startBroker... ${process.pid}`, "StartBroker", "info");
+		startBroker();
+	}
+});
+
+//#endregion
+exports.getBroker = getBroker;

package/dist/utils-7KqCZHbb.js

@@ -0,0 +1,19 @@
+
+//#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
+Object.defineProperty(exports, 'getIpFromEntry', {
+  enumerable: true,
+  get: function () {
+    return getIpFromEntry;
+  }
+});