Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
const require_Action = require('./Action-CzhPMw2i.js');
const require_Broker = require('./Broker-DRFgFvXI.js');
const require_expose_rpc = require('./expose-rpc-mEaCWCcd.js');
require('./consumeTypes-CFK17Cck.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;