emaui/node_modules/@module-federation/dts-plugin/dist/esm/fork-dev-worker.mjs

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-BgxOTFXQ.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-z82OgzMe.mjs";
import "./consumeTypes-DCGF9bG3.mjs";
import "./core.mjs";
import { t as getIpFromEntry } from "./utils-CkPvDGOy.mjs";
import { decodeName } from "@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 === 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 = 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) => {
	handleDevWorkerMessage(message, {
		moduleServer,
		log: fileLog
	});
});
exposeRpc(forkDevWorker);

//#endregion
export { forkDevWorker };