@pact-toolbox/unplugin/dist/utils-caVmxe1_.js

import { getNetworkPort, isLocalNetwork } from "@pact-toolbox/config";
import { PactToolboxNetwork, createPactToolboxNetwork } from "@pact-toolbox/network";
import { PactToolboxClient } from "@pact-toolbox/runtime";
import { isPortTaken, logger } from "@pact-toolbox/utils";

//#region src/plugin/utils.ts
const RUNNING_NETWORKS_KEY = Symbol.for("__PACT_TOOLBOX_RUNNING_NETWORKS__");
function getRunningNetworksRegistry() {
	if (!globalThis[RUNNING_NETWORKS_KEY]) globalThis[RUNNING_NETWORKS_KEY] = /* @__PURE__ */ new Map();
	return globalThis[RUNNING_NETWORKS_KEY];
}
async function isNetworkRunning(networkConfig) {
	const registry = getRunningNetworksRegistry();
	const registryKey = `${networkConfig.name || "unknown"}-${networkConfig.type}`;
	const registeredNetwork = registry.get(registryKey);
	if (registeredNetwork) {
		const portInUse = await isPortTaken(registeredNetwork.port);
		if (portInUse) return true;
		else {
			registry.delete(registryKey);
			return false;
		}
	}
	try {
		const port = getNetworkPort(networkConfig);
		return await isPortTaken(port);
	} catch {
		return false;
	}
}
function registerRunningNetwork(networkConfig, client, network) {
	const registry = getRunningNetworksRegistry();
	const registryKey = `${networkConfig.name || "unknown"}-${networkConfig.type}`;
	const port = getNetworkPort(networkConfig);
	registry.set(registryKey, {
		networkName: networkConfig.name || "unknown",
		port,
		startTime: Date.now(),
		client,
		network
	});
}
async function createPactToolboxNetwork$1({ isServe, isTest, client, networkConfig }, toolboxConfig, { startNetwork = true, onReady } = {}) {
	if (!isServe || isTest || !isLocalNetwork(networkConfig) || !startNetwork) {
		if (isServe && !isTest && onReady) await onReady(client);
		return {
			network: null,
			client
		};
	}
	const isRunning = await isNetworkRunning(networkConfig);
	if (isRunning) {
		if (onReady) await onReady(client);
		return {
			network: null,
			client
		};
	}
	let network;
	try {
		network = await createPactToolboxNetwork(toolboxConfig, {
			client,
			logAccounts: true,
			conflictStrategy: "ignore",
			isDetached: true,
			autoStart: startNetwork,
			cleanup: true
		});
		registerRunningNetwork(networkConfig, client, network);
	} catch (error) {
		if (error instanceof Error && error.message.includes("already running")) registerRunningNetwork(networkConfig, client, null);
		else {
			logger.error(`[startToolboxNetwork] Failed to start network ${networkConfig.name}:`, error);
			throw error;
		}
	}
	if (onReady) try {
		await onReady(client);
	} catch (error) {
		logger.error(`[startToolboxNetwork] onReady callback failed for ${networkConfig.name}:`, error);
	}
	return {
		network,
		client
	};
}
const PLUGIN_NAME = "pact-toolbox";
function isAggregateError(e) {
	return e instanceof AggregateError;
}
function prettyPrintError(label, error) {
	console.error(`\n\x1b[31m[${label}]\x1b[0m`);
	if (isAggregateError(error)) {
		console.error("\x1B[31mMultiple errors occurred:\x1B[0m");
		error.errors.forEach((err, index) => {
			console.error(`\x1b[31m[${index + 1}]\x1b[0m ${err instanceof Error ? err.message : String(err)}`);
			if (err instanceof Error && err.stack) console.error(`\x1b[90m${err.stack.split("\n").slice(1).join("\n")}\x1b[0m`);
		});
	} else if (error instanceof Error) {
		console.error(`\x1b[31m${error.message}\x1b[0m`);
		if (error.stack) console.error(`\x1b[90m${error.stack.split("\n").slice(1).join("\n")}\x1b[0m`);
	} else console.error(`\x1b[31m${String(error)}\x1b[0m`);
}

//#endregion
export { PLUGIN_NAME, createPactToolboxNetwork$1 as createPactToolboxNetwork, isAggregateError, prettyPrintError };
//# sourceMappingURL=utils-caVmxe1_.js.map