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

package/dist/fork-dev-worker.d.ts

@@ -0,0 +1,16 @@
+import { a as DTSManagerOptions } from "./DtsWorker-Bt7-_SGH.js";
+
+//#region src/dev-worker/DevWorker.d.ts
+interface DevWorkerOptions extends DTSManagerOptions {
+  name: string;
+  disableLiveReload?: boolean;
+  disableHotTypesReload?: boolean;
+}
+//#endregion
+//#region src/dev-worker/forkDevWorker.d.ts
+interface Options extends DevWorkerOptions {
+  name: string;
+}
+declare function forkDevWorker(options: Options, action?: string): Promise<void>;
+//#endregion
+export { forkDevWorker };

package/dist/fork-dev-worker.js

@@ -0,0 +1,114 @@
+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');
+require('./consumeTypes-Dle9g2SZ.js');
+require('./core.js');
+const require_utils = require('./utils-7KqCZHbb.js');
+let _module_federation_sdk = require("@module-federation/sdk");
+
+//#region src/dev-worker/handleWorkerMessage.ts
+function handleDevWorkerMessage(message, options = {}) {
+	const { moduleServer, processExit = process.exit, pid = process.pid, log = () => void 0 } = options;
+	log(`ChildProcess(${pid}), message: ${JSON.stringify(message)} `, "forkDevWorker", "info");
+	if (message.type === require_expose_rpc.RpcGMCallTypes.EXIT) {
+		log(`ChildProcess(${pid}) SIGTERM, Federation DevServer will exit...`, "forkDevWorker", "error");
+		moduleServer?.exit();
+		processExit(0);
+	}
+}
+
+//#endregion
+//#region src/dev-worker/forkDevWorker.ts
+let typesManager, serverAddress, moduleServer, cacheOptions;
+function getLocalRemoteNames(options, encodeNameIdentifier) {
+	if (!options) return [];
+	let hostConfig;
+	try {
+		hostConfig = require_expose_rpc.retrieveHostConfig(options);
+	} catch (e) {
+		require_Broker.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 ? (0, _module_federation_sdk.decodeName)(remoteInfo.name, encodeNameIdentifier) : remoteInfo.name;
+		const ip = require_utils.getIpFromEntry(remoteInfo.url, require_Broker.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 || {};
+	require_Broker.fileLog(`sync remote module ${name}, types to ${cacheOptions?.name},typesManager.updateTypes run`, "forkDevWorker", "info");
+	if (!disableLiveReload && moduleServer) moduleServer.update({
+		updateKind: require_Broker.UpdateKind.RELOAD_PAGE,
+		updateMode: require_Action.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 (require_expose_rpc.getDTSManagerConstructor(remote?.implementation))({
+			remote,
+			host,
+			extraOptions
+		});
+		if (!options.disableHotTypesReload && remote) {
+			const { remoteOptions, tsConfig } = require_expose_rpc.retrieveRemoteConfig(remote);
+			const mfTypesZipPath = require_expose_rpc.retrieveTypesZipPath(require_expose_rpc.retrieveMfTypesPath(tsConfig, remoteOptions), remoteOptions);
+			await Promise.all([require_expose_rpc.createHttpServer({ typeTarPath: mfTypesZipPath }).then((res) => {
+				serverAddress = res.serverAddress;
+			}), typesManager.generateTypes()]).catch((err) => {
+				require_Broker.fileLog(`${name} module generateTypes done, localServerAddress:  ${JSON.stringify(err)}`, "forkDevWorker", "error");
+			});
+			require_Broker.fileLog(`${name} module generateTypes done, localServerAddress:  ${serverAddress}`, "forkDevWorker", "info");
+		}
+		moduleServer = new require_expose_rpc.ModuleFederationDevServer({
+			name,
+			remotes: getLocalRemoteNames(host, extraOptions?.["encodeNameIdentifier"]),
+			updateCallback,
+			remoteTypeTarPath: `${serverAddress}/${require_Action.DEFAULT_TAR_NAME}`
+		});
+		cacheOptions = options;
+	}
+	if (action === "update" && cacheOptions) {
+		require_Broker.fileLog(`remoteModule ${cacheOptions.name} receive devWorker update, start typesManager.updateTypes `, "forkDevWorker", "info");
+		if (!cacheOptions.disableLiveReload) moduleServer?.update({
+			updateKind: require_Broker.UpdateKind.RELOAD_PAGE,
+			updateMode: require_Action.UpdateMode.POSITIVE
+		});
+		if (!cacheOptions.disableHotTypesReload) typesManager?.updateTypes({
+			updateMode: require_Action.UpdateMode.POSITIVE,
+			remoteName: cacheOptions.name
+		}).then(() => {
+			moduleServer?.update({
+				updateKind: require_Broker.UpdateKind.UPDATE_TYPE,
+				updateMode: require_Action.UpdateMode.POSITIVE
+			});
+		});
+	}
+}
+process.on("message", (message) => {
+	handleDevWorkerMessage(message, {
+		moduleServer,
+		log: require_Broker.fileLog
+	});
+});
+require_expose_rpc.exposeRpc(forkDevWorker);
+
+//#endregion
+exports.forkDevWorker = forkDevWorker;

package/dist/fork-generate-dts.d.ts

@@ -0,0 +1,6 @@
+import { n as DtsWorkerOptions } from "./DtsWorker-Bt7-_SGH.js";
+
+//#region src/core/lib/forkGenerateDts.d.ts
+declare function forkGenerateDts(options: DtsWorkerOptions): Promise<void>;
+//#endregion
+export { forkGenerateDts };

package/dist/fork-generate-dts.js

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+require('./Broker-CaenCqdn.js');
+const require_expose_rpc = require('./expose-rpc-BpRiu3VK.js');
+
+//#region src/core/lib/forkGenerateDts.ts
+async function forkGenerateDts(options) {
+	return require_expose_rpc.generateTypes(options);
+}
+process.on("message", (message) => {
+	if (message.type === require_expose_rpc.RpcGMCallTypes.EXIT) process.exit(0);
+});
+require_expose_rpc.exposeRpc(forkGenerateDts);
+
+//#endregion
+exports.forkGenerateDts = forkGenerateDts;

package/dist/iife/launch-web-client.iife.js

@@ -0,0 +1,117 @@
+(function() {
+
+
+//#region src/server/constant.ts
+	const DEFAULT_WEB_SOCKET_PORT = 16322;
+	const WEB_SOCKET_CONNECT_MAGIC_ID = "1hpzW-zo2z-o8io-gfmV1-2cb1d82";
+
+//#endregion
+//#region src/server/message/Message.ts
+	var Message = class {
+		constructor(type, kind) {
+			this.type = type;
+			this.kind = kind;
+			this.time = Date.now();
+		}
+	};
+
+//#endregion
+//#region src/server/message/Action/Action.ts
+	let ActionKind = /* @__PURE__ */ function(ActionKind) {
+		ActionKind["ADD_SUBSCRIBER"] = "ADD_SUBSCRIBER";
+		ActionKind["EXIT_SUBSCRIBER"] = "EXIT_SUBSCRIBER";
+		ActionKind["ADD_PUBLISHER"] = "ADD_PUBLISHER";
+		ActionKind["UPDATE_PUBLISHER"] = "UPDATE_PUBLISHER";
+		ActionKind["NOTIFY_SUBSCRIBER"] = "NOTIFY_SUBSCRIBER";
+		ActionKind["EXIT_PUBLISHER"] = "EXIT_PUBLISHER";
+		ActionKind["ADD_WEB_CLIENT"] = "ADD_WEB_CLIENT";
+		ActionKind["NOTIFY_WEB_CLIENT"] = "NOTIFY_WEB_CLIENT";
+		ActionKind["FETCH_TYPES"] = "FETCH_TYPES";
+		ActionKind["ADD_DYNAMIC_REMOTE"] = "ADD_DYNAMIC_REMOTE";
+		return ActionKind;
+	}({});
+	var Action = class extends Message {
+		constructor(content, kind) {
+			super("Action", kind);
+			const { payload } = content;
+			this.payload = payload;
+		}
+	};
+
+//#endregion
+//#region src/server/message/Action/AddWebClient.ts
+	var AddWebClientAction = class extends Action {
+		constructor(payload) {
+			super({ payload }, ActionKind.ADD_WEB_CLIENT);
+		}
+	};
+
+//#endregion
+//#region src/server/message/API/API.ts
+	let APIKind = /* @__PURE__ */ function(APIKind) {
+		APIKind["UPDATE_SUBSCRIBER"] = "UPDATE_SUBSCRIBER";
+		APIKind["RELOAD_WEB_CLIENT"] = "RELOAD_WEB_CLIENT";
+		APIKind["FETCH_TYPES"] = "FETCH_TYPES";
+		return APIKind;
+	}({});
+
+//#endregion
+//#region ../../node_modules/.pnpm/isomorphic-ws@5.0.0_ws@8.21.0/node_modules/isomorphic-ws/browser.js
+	var ws = null;
+	if (typeof WebSocket !== "undefined") ws = WebSocket;
+	else if (typeof MozWebSocket !== "undefined") ws = MozWebSocket;
+	else if (typeof global !== "undefined") ws = global.WebSocket || global.MozWebSocket;
+	else if (typeof window !== "undefined") ws = window.WebSocket || window.MozWebSocket;
+	else if (typeof self !== "undefined") ws = self.WebSocket || self.MozWebSocket;
+	var browser_default = ws;
+
+//#endregion
+//#region src/server/createWebsocket.ts
+	function createWebsocket() {
+		return new browser_default(`ws://127.0.0.1:${DEFAULT_WEB_SOCKET_PORT}?WEB_SOCKET_CONNECT_MAGIC_ID=${WEB_SOCKET_CONNECT_MAGIC_ID}`);
+	}
+
+//#endregion
+//#region src/server/WebClient.ts
+	var WebClient = class {
+		constructor(options) {
+			this._webSocket = null;
+			this._name = options.name;
+			this.logPrefix = options.logPrefix || "";
+			this._connect();
+		}
+		_connect() {
+			console.log(`${this.logPrefix}Trying to connect to {cyan ws://127.0.0.1:${DEFAULT_WEB_SOCKET_PORT}}...}`);
+			this._webSocket = createWebsocket();
+			this._webSocket.onopen = () => {
+				console.log(`${this.logPrefix}Connected to {cyan ws://127.0.0.1:${DEFAULT_WEB_SOCKET_PORT}} success!`);
+				const startWebClient = new AddWebClientAction({ name: this._name });
+				this._webSocket && this._webSocket.send(JSON.stringify(startWebClient));
+			};
+			this._webSocket.onmessage = (message) => {
+				console.log(message);
+				const parsedMessage = JSON.parse(message.data.toString());
+				if (parsedMessage.type === "API") {
+					if (parsedMessage.kind === APIKind.RELOAD_WEB_CLIENT) {
+						const { payload: { name } } = parsedMessage;
+						if (name !== this._name) return;
+						this._reload();
+					}
+				}
+			};
+			this._webSocket.onerror = (err) => {
+				console.error(`${this.logPrefix}err: ${err}`);
+			};
+		}
+		_reload() {
+			console.log(`${this.logPrefix}reload`);
+			location.reload();
+		}
+	};
+
+//#endregion
+//#region src/server/launchWebClient.ts
+	new WebClient(__WEB_CLIENT_OPTIONS__);
+
+//#endregion
+})();

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+import { a as DTSManagerOptions } from "./DtsWorker-Bt7-_SGH.js";
+import { d as isTSProject } from "./constant-YOdZl7sj.js";
+import { moduleFederationPlugin } from "@module-federation/sdk";
+
+//#region src/plugins/DtsPlugin.d.ts
+declare const normalizeDtsOptions: (options: moduleFederationPlugin.ModuleFederationPluginOptions, context: string, defaultOptions?: {
+  defaultGenerateOptions?: moduleFederationPlugin.DtsRemoteOptions;
+  defaultConsumeOptions?: moduleFederationPlugin.DtsHostOptions;
+}) => false | moduleFederationPlugin.PluginDtsOptions;
+declare class DtsPlugin implements WebpackPluginInstance {
+  options: moduleFederationPlugin.ModuleFederationPluginOptions;
+  clonedOptions: moduleFederationPlugin.ModuleFederationPluginOptions;
+  constructor(options: moduleFederationPlugin.ModuleFederationPluginOptions);
+  apply(compiler: Compiler): void;
+  addRuntimePlugins(): void;
+}
+//#endregion
+//#region src/plugins/ConsumeTypesPlugin.d.ts
+declare const normalizeConsumeTypesOptions: ({
+  context,
+  dtsOptions,
+  pluginOptions
+}: {
+  context?: string;
+  dtsOptions: moduleFederationPlugin.PluginDtsOptions;
+  pluginOptions: moduleFederationPlugin.ModuleFederationPluginOptions;
+}) => {
+  host: {
+    typesFolder?: string;
+    abortOnError?: boolean;
+    remoteTypesFolder?: string;
+    deleteTypesFolder?: boolean;
+    maxRetries?: number;
+    consumeAPITypes?: boolean;
+    runtimePkgs?: string[];
+    remoteTypeUrls?: (() => Promise<moduleFederationPlugin.RemoteTypeUrls>) | moduleFederationPlugin.RemoteTypeUrls;
+    timeout?: number;
+    family?: 0 | 4 | 6;
+    typesOnBuild?: boolean;
+    implementation: string | undefined;
+    context: string | undefined;
+    moduleFederationConfig: moduleFederationPlugin.ModuleFederationPluginOptions;
+  };
+  extraOptions: Record<string, any>;
+  displayErrorInTerminal: boolean | undefined;
+} | undefined;
+declare const consumeTypesAPI: (dtsManagerOptions: DTSManagerOptions, cb?: (options: moduleFederationPlugin.RemoteTypeUrls) => void) => Promise<void>;
+//#endregion
+//#region src/plugins/GenerateTypesPlugin.d.ts
+declare const normalizeGenerateTypesOptions: ({
+  context,
+  outputDir,
+  dtsOptions,
+  pluginOptions
+}: {
+  context?: string;
+  outputDir?: string;
+  dtsOptions: moduleFederationPlugin.PluginDtsOptions;
+  pluginOptions: moduleFederationPlugin.ModuleFederationPluginOptions;
+}) => DTSManagerOptions | undefined;
+declare const generateTypesAPI: ({
+  dtsManagerOptions
+}: {
+  dtsManagerOptions: DTSManagerOptions;
+}) => Promise<void>;
+//#endregion
+export { DtsPlugin, consumeTypesAPI, generateTypesAPI, isTSProject, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions };