@cloudflare/vite-plugin 1.39.1 → 1.40.0

package/bin/cf-vite

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../dist/cf-vite.mjs");

package/dist/cf-vite.mjs

@@ -0,0 +1,113 @@
+import { parseArgs } from "node:util";
+import { createServer } from "vite";
+
+//#region src/cf-vite.ts
+/**
+* `cf-vite` delegate binary entry point for `@cloudflare/vite-plugin`.
+*
+* EXPERIMENTAL / internal: spawned by Cloudflare's "cf-dev" parent
+* process, not invoked directly by end users. Contract may change.
+*
+* Usage: `<pkgRoot>/bin/cf-vite <verb> [flags...]`. `dev` is the only
+* verb today; future verbs follow the same shape. Unknown/missing verbs
+* exit 2 (also the parent's version-detection signal).
+*
+* Spawn contract for `dev`: parent uses `stdio: "inherit"` and forwards
+* SIGINT/SIGTERM. Accepted flags mirror the sibling `cf-wrangler`
+* delegate (`--config`, `--mode`, `--port`, `--host`, `--local`) so the
+* parent can drive either impl interchangeably; everything else lives in
+* the user's `vite.config.ts` / `wrangler.jsonc`. `cf-vite` boots Vite
+* via `createServer()` against the user's own config (expected to
+* include `cloudflare()`); flags are bridged to it as documented inline.
+*
+* Exit codes: 0 graceful, 2 unknown verb / parse error, 130 SIGINT,
+* 143 SIGTERM.
+*/
+var ArgParseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ArgParseError";
+	}
+};
+/** Strict argv parser; mirrors `cf-wrangler`'s flags (unknown → throw). */
+function parseArgs$1(argv) {
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args: argv,
+			options: {
+				config: { type: "string" },
+				mode: { type: "string" },
+				host: { type: "string" },
+				port: { type: "string" },
+				local: { type: "boolean" }
+			},
+			strict: true,
+			allowPositionals: false
+		});
+	} catch (err) {
+		throw new ArgParseError(err instanceof Error ? err.message : String(err));
+	}
+	const out = {};
+	if (parsed.values.config !== void 0) out.config = parsed.values.config;
+	if (parsed.values.mode !== void 0) out.mode = parsed.values.mode;
+	if (parsed.values.host !== void 0) out.host = parsed.values.host;
+	if (parsed.values.port !== void 0) {
+		const raw = parsed.values.port;
+		const n = Number(raw);
+		if (!Number.isInteger(n) || n < 0 || n > 65535) throw new ArgParseError(`--port expects an integer between 0 and 65535, got "${raw}"`);
+		out.port = n;
+	}
+	if (parsed.values.local !== void 0) out.local = parsed.values.local;
+	return out;
+}
+async function main() {
+	const verb = process.argv[2];
+	const userArgv = process.argv.slice(3);
+	if (verb !== "dev") {
+		process.stderr.write(`Error: unknown subcommand "${verb ?? ""}".\nUsage: cf-vite dev [args]\n`);
+		return 2;
+	}
+	let args;
+	try {
+		args = parseArgs$1(userArgv);
+	} catch (err) {
+		if (err instanceof ArgParseError) {
+			process.stderr.write(`Error: ${err.message}\n`);
+			return 2;
+		}
+		throw err;
+	}
+	if (args.config !== void 0) process.env.CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH = args.config;
+	if (args.local) process.env.CLOUDFLARE_VITE_FORCE_LOCAL = "true";
+	const serverOptions = {};
+	if (args.port !== void 0) serverOptions.port = args.port;
+	if (args.host !== void 0) serverOptions.host = args.host;
+	const inlineConfig = { server: serverOptions };
+	if (args.mode !== void 0) inlineConfig.mode = args.mode;
+	const server = await createServer(inlineConfig);
+	await server.listen();
+	server.printUrls();
+	server.bindCLIShortcuts({ print: true });
+	let closing = false;
+	const shutdown = (signal) => {
+		if (closing) return;
+		closing = true;
+		(async () => {
+			try {
+				await server.close();
+				process.exit(0);
+			} catch {
+				process.exit(signal === "SIGINT" ? 130 : 143);
+			}
+		})();
+	};
+	process.on("SIGINT", () => shutdown("SIGINT"));
+	process.on("SIGTERM", () => shutdown("SIGTERM"));
+	return new Promise(() => {});
+}
+const exitCode = await main();
+process.exit(exitCode);
+
+//#endregion
+export {  };