one/dist/cjs/cli/dev.cjs

One is a React framework for web, iOS, and Android apps.

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
	for (var name in all) __defProp(target, name, {
		get: all[name],
		enumerable: true
	});
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") {
		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: () => from[key],
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var dev_exports = {};
__export(dev_exports, { dev: () => dev });
module.exports = __toCommonJS(dev_exports);
var path = __toESM(require("node:path"), 1);
var import_picocolors = __toESM(require("picocolors"), 1);
var import_setServerGlobals = require("../server/setServerGlobals.cjs");
var import_virtualEntryConstants = require("../vite/plugins/virtualEntryConstants.cjs");
var import_checkNodeVersion = require("./checkNodeVersion.cjs");
var import_install_error_handlers = require("./install-error-handlers.cjs");
var import_label_process = require("./label-process.cjs");
(0, import_install_error_handlers.installPrepareStackTraceGuard)();
const DAEMON_PORT = 8081;
async function dev(args) {
	(0, import_label_process.labelProcess)("dev");
	(0, import_checkNodeVersion.checkNodeVersion)();
	(0, import_setServerGlobals.setServerGlobals)();
	const root = process.cwd();
	let daemonServerId;
	let useDaemon = false;
	const forcePort = process.env.ONE_FORCE_PORT ? +process.env.ONE_FORCE_PORT : void 0;
	const envPort = process.env.ONE_PORT ? +process.env.ONE_PORT : void 0;
	let effectivePort = forcePort ?? (args.port ? +args.port : void 0) ?? envPort;
	const { isDaemonRunning, registerWithDaemon, unregisterFromDaemon, writeServerFile, removeServerFile } = await import("../daemon/ipc.cjs");
	const { getBundleIdFromConfig, getAvailablePort } = await import("../daemon/utils.cjs");
	const daemonRunning = await isDaemonRunning();
	const bundleId = getBundleIdFromConfig(root) || path.basename(root);
	if (daemonRunning) {
		if (!effectivePort || effectivePort === DAEMON_PORT) {
			effectivePort = await getAvailablePort(8082, DAEMON_PORT);
			console.log(import_picocolors.default.cyan(`[daemon] Detected running daemon on :${DAEMON_PORT}`));
			console.log(import_picocolors.default.cyan(`[daemon] Using port :${effectivePort} for this server`));
			useDaemon = true;
		}
	}
	const { dev: dev2 } = await import("vxrn/dev");
	const { start, stop } = await dev2({
		mode: args.mode,
		clean: args.clean,
		root,
		debugBundle: args.debugBundle,
		debug: args.debug,
		extraConfig: args.extraConfig,
		server: {
			host: args.host,
			port: effectivePort
		},
		entries: { native: import_virtualEntryConstants.virtualEntryIdNative }
	});
	const { closePromise } = await start();
	if (useDaemon && bundleId) {
		try {
			daemonServerId = await registerWithDaemon({
				port: effectivePort,
				bundleId,
				root
			});
			console.log(import_picocolors.default.green(`[daemon] Registered as ${bundleId} (${daemonServerId}) \u2192 accessible via :${DAEMON_PORT}`));
			writeServerFile({
				port: effectivePort,
				bundleId,
				root,
				pid: process.pid
			});
		} catch (err) {
			console.log(import_picocolors.default.yellow(`[daemon] Failed to register: ${err}`));
		}
	}
	const cleanup = async () => {
		if (daemonServerId) {
			try {
				await unregisterFromDaemon(daemonServerId);
				removeServerFile(root);
			} catch {}
		}
		await stop();
	};
	process.on("beforeExit", () => {
		cleanup();
	});
	process.on("SIGINT", async () => {
		try {
			await cleanup();
		} finally {
			process.exit(2);
		}
	});
	process.on("SIGTERM", async () => {
		try {
			await cleanup();
		} finally {
			process.exit(0);
		}
	});
	process.on("uncaughtException", (err) => {
		try {
			process.stderr.write(`[one dev] uncaught exception
${(0, import_install_error_handlers.formatErrorSafely)(err)}
`);
		} catch {}
	});
	process.on("unhandledRejection", (err) => {
		try {
			process.stderr.write(`[one dev] unhandled rejection
${(0, import_install_error_handlers.formatErrorSafely)(err)}
`);
		} catch {}
	});
	await closePromise;
}