@module-federation/dts-plugin 2.0.1 → 2.1.0

package/dist/esm/consumeTypes-D51rVbSt.mjs

@@ -0,0 +1,204 @@
+import { a as cloneDeepOptions, n as RpcGMCallTypes, o as getDTSManagerConstructor, s as isDebugMode, t as exposeRpc, x as __exportAll } from "./expose-rpc-DMhY1i8A.mjs";
+import path from "path";
+import { randomUUID } from "crypto";
+import * as child_process from "child_process";
+import * as process$2 from "process";
+
+//#region src/core/rpc/rpc-error.ts
+var RpcExitError = class extends Error {
+	constructor(message, code, signal) {
+		super(message);
+		this.code = code;
+		this.signal = signal;
+		this.name = "RpcExitError";
+	}
+};
+
+//#endregion
+//#region src/core/rpc/wrap-rpc.ts
+function createControlledPromise() {
+	let resolve = () => void 0;
+	let reject = () => void 0;
+	return {
+		promise: new Promise((aResolve, aReject) => {
+			resolve = aResolve;
+			reject = aReject;
+		}),
+		resolve,
+		reject
+	};
+}
+function wrapRpc(childProcess, options) {
+	return (async (...args) => {
+		if (!childProcess.send) throw new Error(`Process ${childProcess.pid} doesn't have IPC channels`);
+		else if (!childProcess.connected) throw new Error(`Process ${childProcess.pid} doesn't have open IPC channels`);
+		const { id, once } = options;
+		const { promise: resultPromise, resolve: resolveResult, reject: rejectResult } = createControlledPromise();
+		const { promise: sendPromise, resolve: resolveSend, reject: rejectSend } = createControlledPromise();
+		const handleMessage = (message) => {
+			if (message?.id === id) {
+				if (message.type === RpcGMCallTypes.RESOLVE) resolveResult(message.value);
+				else if (message.type === RpcGMCallTypes.REJECT) rejectResult(message.error);
+			}
+			if (once && childProcess?.kill) childProcess.kill("SIGTERM");
+		};
+		const handleClose = (code, signal) => {
+			rejectResult(new RpcExitError(code ? `Process ${childProcess.pid} exited with code ${code}${signal ? ` [${signal}]` : ""}` : `Process ${childProcess.pid} exited${signal ? ` [${signal}]` : ""}`, code, signal));
+			removeHandlers();
+		};
+		const removeHandlers = () => {
+			childProcess.off("message", handleMessage);
+			childProcess.off("close", handleClose);
+		};
+		if (once) childProcess.once("message", handleMessage);
+		else childProcess.on("message", handleMessage);
+		childProcess.on("close", handleClose);
+		childProcess.send({
+			type: RpcGMCallTypes.CALL,
+			id,
+			args
+		}, (error) => {
+			if (error) {
+				rejectSend(error);
+				removeHandlers();
+			} else resolveSend(void 0);
+		});
+		return sendPromise.then(() => resultPromise);
+	});
+}
+
+//#endregion
+//#region src/core/rpc/rpc-worker.ts
+const FEDERATION_WORKER_DATA_ENV_KEY = "VMOK_WORKER_DATA_ENV";
+function createRpcWorker(modulePath, data, memoryLimit, once) {
+	const options = {
+		env: {
+			...process$2.env,
+			[FEDERATION_WORKER_DATA_ENV_KEY]: JSON.stringify(data || {})
+		},
+		stdio: [
+			"inherit",
+			"inherit",
+			"inherit",
+			"ipc"
+		],
+		serialization: "advanced"
+	};
+	if (memoryLimit) options.execArgv = [`--max-old-space-size=${memoryLimit}`];
+	let childProcess, remoteMethod;
+	const id = randomUUID();
+	return {
+		connect(...args) {
+			if (childProcess && !childProcess.connected) {
+				childProcess.send({
+					type: RpcGMCallTypes.EXIT,
+					id
+				});
+				childProcess = void 0;
+				remoteMethod = void 0;
+			}
+			if (!childProcess?.connected) {
+				childProcess = child_process.fork(modulePath, options);
+				remoteMethod = wrapRpc(childProcess, {
+					id,
+					once
+				});
+			}
+			if (!remoteMethod) return Promise.reject(/* @__PURE__ */ new Error("Worker is not connected - cannot perform RPC."));
+			return remoteMethod(...args);
+		},
+		terminate() {
+			try {
+				if (childProcess.connected) childProcess.send({
+					type: RpcGMCallTypes.EXIT,
+					id
+				}, (err) => {
+					if (err) console.error("Error sending message:", err);
+				});
+			} catch (error) {
+				if (error.code === "EPIPE") console.error("Pipe closed before message could be sent:", error);
+				else console.error("Unexpected error:", error);
+			}
+			childProcess = void 0;
+			remoteMethod = void 0;
+		},
+		get connected() {
+			return Boolean(childProcess?.connected);
+		},
+		get process() {
+			return childProcess;
+		},
+		get id() {
+			return id;
+		}
+	};
+}
+function getRpcWorkerData() {
+	return JSON.parse(process$2.env[FEDERATION_WORKER_DATA_ENV_KEY] || "{}");
+}
+
+//#endregion
+//#region src/core/rpc/index.ts
+var rpc_exports = /* @__PURE__ */ __exportAll({
+	RpcExitError: () => RpcExitError,
+	RpcGMCallTypes: () => RpcGMCallTypes,
+	createRpcWorker: () => createRpcWorker,
+	exposeRpc: () => exposeRpc,
+	getRpcWorkerData: () => getRpcWorkerData,
+	wrapRpc: () => wrapRpc
+});
+
+//#endregion
+//#region src/core/lib/DtsWorker.ts
+var DtsWorker = class {
+	constructor(options) {
+		this._options = cloneDeepOptions(options);
+		this.removeUnSerializationOptions();
+		this.rpcWorker = createRpcWorker(path.resolve(__dirname, "./fork-generate-dts.js"), {}, void 0, true);
+		this._res = this.rpcWorker.connect(this._options);
+	}
+	removeUnSerializationOptions() {
+		if (this._options.remote?.moduleFederationConfig?.manifest) delete this._options.remote?.moduleFederationConfig?.manifest;
+		if (this._options.host?.moduleFederationConfig?.manifest) delete this._options.host?.moduleFederationConfig?.manifest;
+	}
+	get controlledPromise() {
+		const ensureChildProcessExit = () => {
+			try {
+				const pid = this.rpcWorker.process?.pid;
+				const rootPid = process.pid;
+				if (pid && rootPid !== pid) process.kill(pid, 0);
+			} catch (error) {
+				if (isDebugMode()) console.error(error);
+			}
+		};
+		return Promise.resolve(this._res).then(() => {
+			this.exit();
+			ensureChildProcessExit();
+		}).catch((err) => {
+			if (isDebugMode()) console.error(err);
+			ensureChildProcessExit();
+		});
+	}
+	exit() {
+		try {
+			this.rpcWorker?.terminate();
+		} catch (err) {
+			if (isDebugMode()) console.error(err);
+		}
+	}
+};
+
+//#endregion
+//#region src/core/lib/generateTypesInChildProcess.ts
+async function generateTypesInChildProcess(options) {
+	return new DtsWorker(options).controlledPromise;
+}
+
+//#endregion
+//#region src/core/lib/consumeTypes.ts
+async function consumeTypes(options) {
+	await new (getDTSManagerConstructor(options.host?.implementation))(options).consumeTypes();
+}
+
+//#endregion
+export { createRpcWorker as a, rpc_exports as i, generateTypesInChildProcess as n, DtsWorker as r, consumeTypes as t };

package/dist/esm/core.mjs

@@ -0,0 +1,5 @@
+import { _ as retrieveMfTypesPath, c as isTSProject, d as DTSManager, f as HOST_API_TYPES_FILE_NAME, g as retrieveTypesZipPath, h as retrieveHostConfig, i as retrieveRemoteConfig, l as retrieveTypesAssetsInfo, m as REMOTE_API_TYPES_FILE_NAME, o as getDTSManagerConstructor, p as REMOTE_ALIAS_IDENTIFIER, r as generateTypes, u as validateOptions, v as retrieveOriginalOutDir } from "./expose-rpc-DMhY1i8A.mjs";
+import "./Broker-BU4gToNr.mjs";
+import { i as rpc_exports, n as generateTypesInChildProcess, r as DtsWorker, t as consumeTypes } from "./consumeTypes-D51rVbSt.mjs";
+
+export { DTSManager, DtsWorker, HOST_API_TYPES_FILE_NAME, REMOTE_ALIAS_IDENTIFIER, REMOTE_API_TYPES_FILE_NAME, consumeTypes, generateTypes, generateTypesInChildProcess, getDTSManagerConstructor, isTSProject, retrieveHostConfig, retrieveMfTypesPath, retrieveOriginalOutDir, retrieveRemoteConfig, retrieveTypesAssetsInfo, retrieveTypesZipPath, rpc_exports as rpc, validateOptions };

package/dist/esm/dynamic-remote-type-hints-plugin.mjs

@@ -0,0 +1,73 @@
+import { c as WEB_SOCKET_CONNECT_MAGIC_ID, i as DEFAULT_WEB_SOCKET_PORT, n as ActionKind, t as Action } from "./Action-DNNg2YDh.mjs";
+import { t as getIpFromEntry } from "./utils-CkPvDGOy.mjs";
+import WebSocket from "isomorphic-ws";
+
+//#region src/server/message/Action/FetchTypes.ts
+var FetchTypesAction = class extends Action {
+	constructor(payload) {
+		super({ payload }, ActionKind.FETCH_TYPES);
+	}
+};
+
+//#endregion
+//#region src/server/message/Action/AddDynamicRemote.ts
+var AddDynamicRemoteAction = class extends Action {
+	constructor(payload) {
+		super({ payload }, ActionKind.ADD_DYNAMIC_REMOTE);
+	}
+};
+
+//#endregion
+//#region src/server/createWebsocket.ts
+function createWebsocket() {
+	return new WebSocket(`ws://127.0.0.1:${DEFAULT_WEB_SOCKET_PORT}?WEB_SOCKET_CONNECT_MAGIC_ID=${WEB_SOCKET_CONNECT_MAGIC_ID}`);
+}
+
+//#endregion
+//#region src/runtime-plugins/dynamic-remote-type-hints-plugin.ts
+const PLUGIN_NAME = "dynamic-remote-type-hints-plugin";
+function dynamicRemoteTypeHintsPlugin() {
+	let ws = createWebsocket();
+	let isConnected = false;
+	ws.onopen = () => {
+		isConnected = true;
+	};
+	ws.onerror = (err) => {
+		console.error(`[ ${PLUGIN_NAME} ] err: ${err}`);
+	};
+	return {
+		name: "dynamic-remote-type-hints-plugin",
+		registerRemote(args) {
+			const { remote, origin } = args;
+			try {
+				if (!isConnected) return args;
+				if (!("entry" in remote)) return args;
+				const defaultIpV4 = typeof FEDERATION_IPV4 === "string" ? FEDERATION_IPV4 : "127.0.0.1";
+				const remoteIp = getIpFromEntry(remote.entry, defaultIpV4);
+				const remoteInfo = {
+					name: remote.name,
+					url: remote.entry,
+					alias: remote.alias || remote.name
+				};
+				if (remoteIp) ws.send(JSON.stringify(new AddDynamicRemoteAction({
+					remoteIp,
+					remoteInfo,
+					name: origin.name,
+					ip: defaultIpV4
+				})));
+				ws.send(JSON.stringify(new FetchTypesAction({
+					name: origin.name,
+					ip: defaultIpV4,
+					remoteInfo
+				})));
+				return args;
+			} catch (err) {
+				console.error(new Error(err));
+				return args;
+			}
+		}
+	};
+}
+
+//#endregion
+export { dynamicRemoteTypeHintsPlugin as default };