vinext 1.0.0-beta.8 → 1.0.0

package/dist/cli-args.d.ts

@@ -2,21 +2,14 @@
 /**
  * CLI argument parser for the vinext CLI.
  *
- * Parses flags for `vinext dev`, `vinext start`, `vinext build`, etc.
- * Validates that value-taking flags (`--port`, `--hostname`, `--mode`) have actual values
- * rather than silently consuming the next flag or returning NaN/undefined.
+ * Parses the shared flags used by vinext's non-Vite commands.
+ * Validates that value-taking flags have actual values rather than silently
+ * consuming the next flag or returning NaN/undefined.
  */
 type ParsedArgs = {
   port?: number;
   hostname?: string;
-  mode?: string;
   help?: boolean;
-  verbose?: boolean;
-  turbopack?: boolean;
-  experimental?: boolean;
-  prerenderAll?: boolean;
-  prerenderConcurrency?: number;
-  precompress?: boolean;
   positionals?: string[];
 };
 /**
@@ -24,10 +17,8 @@ type ParsedArgs = {
  *
  * Handles both `--flag value` and `--flag=value` forms for value-taking flags.
  *
- * Used by `vinext dev`, `build`, `start`, `lint`, `check`, and `init` commands.
- * The `deploy` command uses `parseDeployArgs` (a `node:util` wrapper) for its
- * own flag set including `--env`, `--skip-build`, etc.
+ * `vinext dev` and `vinext build` bypass this parser and delegate their
+ * arguments directly to Vite.
  */
-declare function parseArgs(args: string[]): ParsedArgs;
-//#endregion
-export { parseArgs };
+export declare function parseArgs(args: string[]): ParsedArgs;
+//#endregion

package/dist/cli-args.js

@@ -35,20 +35,13 @@ function parsePort(raw, flag) {
 	if (parsed < 0 || parsed > 65535) throw new Error(`${flag} expects a valid port (0-65535), but got "${raw}".`);
 	return parsed;
 }
-function parsePositiveIntegerArg(raw, flag) {
-	if (raw === "") throw new Error(`${flag} requires a value, but none was provided.`);
-	const parsed = Number(raw);
-	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${flag} expects a positive integer, but got "${raw}".`);
-	return parsed;
-}
 /**
 * Parse CLI arguments into a structured object.
 *
 * Handles both `--flag value` and `--flag=value` forms for value-taking flags.
 *
-* Used by `vinext dev`, `build`, `start`, `lint`, `check`, and `init` commands.
-* The `deploy` command uses `parseDeployArgs` (a `node:util` wrapper) for its
-* own flag set including `--env`, `--skip-build`, etc.
+* `vinext dev` and `vinext build` bypass this parser and delegate their
+* arguments directly to Vite.
 */
 function parseArgs(args) {
 	const result = {};
@@ -63,27 +56,6 @@ function parseArgs(args) {
 			case "-h":
 				result.help = true;
 				break;
-			case "--verbose":
-				result.verbose = true;
-				break;
-			case "--turbopack":
-				result.turbopack = true;
-				break;
-			case "--experimental-https":
-				result.experimental = true;
-				break;
-			case "--prerender-all":
-				result.prerenderAll = true;
-				break;
-			case "--prerender-concurrency": {
-				const raw = takeValue(arg, args, i);
-				i++;
-				result.prerenderConcurrency = parsePositiveIntegerArg(raw, arg);
-				break;
-			}
-			case "--precompress":
-				result.precompress = true;
-				break;
 			case "--port":
 			case "-p": {
 				const raw = takeValue(arg, args, i);
@@ -96,10 +68,6 @@ function parseArgs(args) {
 				result.hostname = takeValue(arg, args, i);
 				i++;
 				break;
-			case "--mode":
-				result.mode = takeValue(arg, args, i);
-				i++;
-				break;
 			default: {
 				const eqRaw = tryEqualsForm(arg, "port");
 				if (eqRaw !== null) {
@@ -112,17 +80,6 @@ function parseArgs(args) {
 					result.hostname = hostRaw;
 					break;
 				}
-				const modeRaw = tryEqualsForm(arg, "mode");
-				if (modeRaw !== null) {
-					if (modeRaw === "") throw new Error(`--mode requires a value, but none was provided.`);
-					result.mode = modeRaw;
-					break;
-				}
-				const prerenderConcurrencyRaw = tryEqualsForm(arg, "prerender-concurrency");
-				if (prerenderConcurrencyRaw !== null) {
-					result.prerenderConcurrency = parsePositiveIntegerArg(prerenderConcurrencyRaw, "--prerender-concurrency");
-					break;
-				}
 				if (!FLAG_PATTERN.test(arg)) addPositional(arg);
 				break;
 			}

package/dist/cli-dev-config.d.ts

@@ -1,11 +1,14 @@
-import { Plugin, ServerOptions } from "vite";
+import { Plugin, ResolvedConfig, ServerOptions, UserConfig } from "vite";
 //#region src/cli-dev-config.d.ts
-type DevServerCliOptions = {
+export declare const VINEXT_DEV_RESTART_CONFIG = "__vinextDevRestart";
+export declare const VINEXT_DEV_CLI_LIFECYCLE = "__vinextDevCliLifecycle";
+export declare function reserveViteCliDevInvocation(): boolean;
+export declare function claimViteCliDevInvocation(root: string, isRestart?: boolean, isReserved?: boolean): boolean;
+export type DevServerCliOptions = {
   port?: number;
   hostname?: string;
 };
-declare function applyDevServerDefaults(server: ServerOptions, options: DevServerCliOptions): void;
-declare function createDevServerConfigPlugin(options: DevServerCliOptions): Plugin;
-declare function normalizeDevServerHostname(host: string | boolean | undefined): string;
-//#endregion
-export { DevServerCliOptions, applyDevServerDefaults, createDevServerConfigPlugin, normalizeDevServerHostname };
+export declare function applyDevServerDefaults(server: ServerOptions, options: DevServerCliOptions): void;
+export declare function createDevServerLifecyclePlugin(options: DevServerCliOptions, isEnabled: (config: UserConfig | ResolvedConfig) => boolean): Plugin;
+export declare function normalizeDevServerHostname(host: string | boolean | undefined): string;
+//#endregion

package/dist/cli-dev-config.js

@@ -1,17 +1,57 @@
+import { toSlash } from "./deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { formatAlreadyRunningError, tryAcquireLockfile } from "./server/dev-lockfile.js";
+import { isViteCliInvocation } from "./utils/vite-cli-invocation.js";
+import fs from "node:fs";
 //#region src/cli-dev-config.ts
+const activeDevServerLocks = /* @__PURE__ */ new Map();
+let devInvocationRoot;
+let devInvocationReserved = false;
+const VINEXT_DEV_RESTART_CONFIG = "__vinextDevRestart";
+const VINEXT_DEV_CLI_LIFECYCLE = "__vinextDevCliLifecycle";
+function normalizeDevLifecycleRoot(root) {
+	try {
+		return toSlash(fs.realpathSync.native(root));
+	} catch {
+		return root;
+	}
+}
+function reserveViteCliDevInvocation() {
+	if (!isViteCliInvocation("dev") || devInvocationReserved) return false;
+	devInvocationReserved = true;
+	return true;
+}
+function claimViteCliDevInvocation(root, isRestart = false, isReserved = false) {
+	root = normalizeDevLifecycleRoot(root);
+	if (!isViteCliInvocation("dev")) return false;
+	if (!isRestart && (!isReserved || devInvocationRoot !== void 0)) return false;
+	devInvocationRoot = root;
+	return true;
+}
 function applyDevServerDefaults(server, options) {
 	server.port = options.port ?? server.port ?? 3e3;
 	server.host = options.hostname ?? server.host ?? "localhost";
 }
-function createDevServerConfigPlugin(options) {
+function createDevServerLifecyclePlugin(options, isEnabled) {
 	return {
-		name: "vinext:dev-server-config",
+		name: "vinext:dev-server-lifecycle",
 		enforce: "post",
 		config: {
 			order: "post",
 			handler(config) {
+				if (!isEnabled(config) || config.server?.middlewareMode) return;
 				applyDevServerDefaults(config.server ??= {}, options);
 			}
+		},
+		configureServer: {
+			order: "post",
+			handler(server) {
+				if (!isEnabled(server.config)) return;
+				if (!server.config.server.middlewareMode) {
+					if (options.port !== void 0) server.config.server.port = options.port;
+					if (options.hostname !== void 0) server.config.server.host = options.hostname;
+				}
+				configureDevServerLifecycle(server);
+			}
 		}
 	};
 }
@@ -19,5 +59,122 @@ function normalizeDevServerHostname(host) {
 	if (typeof host === "string") return host;
 	return host === true ? "0.0.0.0" : "localhost";
 }
+function configureDevServerLifecycle(server) {
+	const root = normalizeDevLifecycleRoot(server.config.root);
+	let activeLock;
+	const releaseLock = () => {
+		if (!activeLock) return;
+		const lock = activeLock;
+		activeLock = void 0;
+		lock.servers--;
+		if (lock.servers > 0 || lock.restarting) return;
+		lock.lockfile.release();
+		if (activeDevServerLocks.get(root) === lock) activeDevServerLocks.delete(root);
+	};
+	const releaseLifecycle = () => {
+		releaseLock();
+		if (!activeDevServerLocks.get(root)?.restarting && devInvocationRoot === root) {
+			devInvocationRoot = void 0;
+			devInvocationReserved = false;
+		}
+	};
+	const closeServer = server.close.bind(server);
+	server.close = async () => {
+		try {
+			await closeServer();
+		} finally {
+			releaseLifecycle();
+		}
+	};
+	const restartServer = server.restart.bind(server);
+	server.restart = async (forceOptimize) => {
+		const restartingLock = activeDevServerLocks.get(root);
+		if (restartingLock) restartingLock.restarting = true;
+		const inlineConfig = server.config.inlineConfig;
+		inlineConfig[VINEXT_DEV_RESTART_CONFIG] = true;
+		try {
+			await restartServer(forceOptimize);
+		} finally {
+			delete inlineConfig[VINEXT_DEV_RESTART_CONFIG];
+			delete server.config.inlineConfig[VINEXT_DEV_RESTART_CONFIG];
+			if (server.config["__vinextDevCliLifecycle"]) devInvocationRoot = normalizeDevLifecycleRoot(server.config.root);
+			else {
+				devInvocationRoot = void 0;
+				devInvocationReserved = false;
+			}
+			if (restartingLock) {
+				restartingLock.restarting = false;
+				if (restartingLock.servers === 0) {
+					restartingLock.lockfile.release();
+					if (activeDevServerLocks.get(root) === restartingLock) activeDevServerLocks.delete(root);
+				}
+			}
+		}
+	};
+	const listenServer = server.listen.bind(server);
+	server.listen = async (port, isRestart) => {
+		if (server.config.server.middlewareMode || process.env.VINEXT_NO_DEV_LOCK === "1") return listenServer(port, isRestart);
+		const configuredPort = port ?? server.config.server.port ?? 3e3;
+		const hostname = normalizeDevServerHostname(server.config.server.host);
+		const displayHostname = hostname === "0.0.0.0" ? "localhost" : hostname;
+		const restartingLock = activeDevServerLocks.get(root);
+		if (restartingLock?.restarting) activeLock = restartingLock;
+		else {
+			const startedAt = Date.now();
+			const acquired = tryAcquireLockfile({
+				root,
+				info: {
+					pid: process.pid,
+					port: configuredPort,
+					hostname,
+					appUrl: `http://${displayHostname}:${configuredPort}`,
+					startedAt,
+					cwd: root
+				}
+			});
+			if (!acquired.ok) throw new Error(formatAlreadyRunningError({
+				existing: acquired.existing,
+				cwd: root,
+				lockfilePath: acquired.lockfilePath
+			}));
+			activeLock = {
+				lockfile: acquired.lockfile,
+				restarting: false,
+				servers: 0,
+				startedAt
+			};
+			activeDevServerLocks.set(root, activeLock);
+		}
+		activeLock.servers++;
+		try {
+			return await listenServer(port, isRestart);
+		} catch (error) {
+			releaseLock();
+			throw error;
+		}
+	};
+	server.httpServer?.on("listening", () => {
+		if (!activeLock) return;
+		const port = server.config.server.port ?? 3e3;
+		const hostname = normalizeDevServerHostname(server.config.server.host);
+		const displayHostname = hostname === "0.0.0.0" ? "localhost" : hostname;
+		const lock = activeLock;
+		setImmediate(() => {
+			if (activeLock !== lock) return;
+			const address = server.httpServer?.address();
+			const actualPort = typeof address === "object" && address ? address.port : port;
+			const appUrl = server.resolvedUrls?.local[0]?.replace(/\/$/, "") ?? `http://${displayHostname}:${actualPort}`;
+			lock.lockfile.update({
+				pid: process.pid,
+				port: actualPort,
+				hostname,
+				appUrl,
+				startedAt: lock.startedAt,
+				cwd: root
+			});
+		});
+	});
+	server.httpServer?.on("close", releaseLock);
+}
 //#endregion
-export { applyDevServerDefaults, createDevServerConfigPlugin, normalizeDevServerHostname };
+export { VINEXT_DEV_CLI_LIFECYCLE, VINEXT_DEV_RESTART_CONFIG, applyDevServerDefaults, claimViteCliDevInvocation, createDevServerLifecyclePlugin, normalizeDevServerHostname, reserveViteCliDevInvocation };