nitro 3.0.260311-beta → 3.0.260415-beta

package/dist/_libs/citty.mjs

@@ -1,5 +1,4 @@
 import { parseArgs } from "node:util";
-//#region node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/_chunks/libs/scule.mjs
 const NUMBER_CHAR_RE = /\d/;
 const STR_SPLITTERS = [
 	"-",
@@ -64,8 +63,9 @@ function camelCase(str, opts) {
 function kebabCase(str, joiner) {
 	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
 }
-//#endregion
-//#region node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/index.mjs
+function snakeCase(str) {
+	return kebabCase(str || "", "_");
+}
 function toArray(val) {
 	if (Array.isArray(val)) return val;
 	return val === void 0 ? [] : [val];
@@ -111,6 +111,12 @@ function parseRawArgs(args = [], opts = {}) {
 		for (const alias of aliases) if (booleans.has(alias)) return "boolean";
 		return "string";
 	}
+	function isStringType(name) {
+		if (strings.has(name)) return true;
+		const aliases = mainToAliases.get(name) || [];
+		for (const alias of aliases) if (strings.has(alias)) return true;
+		return false;
+	}
 	const allOptions = new Set([
 		...booleans,
 		...strings,
@@ -154,7 +160,12 @@ function parseRawArgs(args = [], opts = {}) {
 	}
 	const out = { _: [] };
 	out._ = parsed.positionals;
-	for (const [key, value] of Object.entries(parsed.values)) out[key] = value;
+	for (const [key, value] of Object.entries(parsed.values)) {
+		let coerced = value;
+		if (getType(key) === "boolean" && typeof value === "string") coerced = value !== "false";
+		else if (isStringType(key) && typeof value === "boolean") coerced = "";
+		out[key] = coerced;
+	}
 	for (const [name] of Object.entries(negatedFlags)) {
 		out[name] = false;
 		const mainName = aliasToMain.get(name);
@@ -165,6 +176,7 @@ function parseRawArgs(args = [], opts = {}) {
 	for (const [alias, main] of aliasToMain.entries()) {
 		if (out[alias] !== void 0 && out[main] === void 0) out[main] = out[alias];
 		if (out[main] !== void 0 && out[alias] === void 0) out[alias] = out[main];
+		if (out[alias] !== out[main] && defaults[main] === out[main]) out[main] = out[alias];
 	}
 	return out;
 }
@@ -226,6 +238,9 @@ function resolveArgs(argsDef) {
 	});
 	return args;
 }
+async function resolvePlugins(plugins) {
+	return Promise.all(plugins.map((p) => resolveValue(p)));
+}
 function defineCommand(def) {
 	return def;
 }
@@ -238,35 +253,92 @@ async function runCommand(cmd, opts) {
 		data: opts.data,
 		cmd
 	};
-	if (typeof cmd.setup === "function") await cmd.setup(context);
+	const plugins = await resolvePlugins(cmd.plugins ?? []);
 	let result;
+	let runError;
 	try {
+		for (const plugin of plugins) await plugin.setup?.(context);
+		if (typeof cmd.setup === "function") await cmd.setup(context);
 		const subCommands = await resolveValue(cmd.subCommands);
 		if (subCommands && Object.keys(subCommands).length > 0) {
-			const subCommandArgIndex = opts.rawArgs.findIndex((arg) => !arg.startsWith("-"));
-			const subCommandName = opts.rawArgs[subCommandArgIndex];
-			if (subCommandName) {
-				if (!subCommands[subCommandName]) throw new CLIError(`Unknown command ${cyan(subCommandName)}`, "E_UNKNOWN_COMMAND");
-				const subCommand = await resolveValue(subCommands[subCommandName]);
-				if (subCommand) await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
-			} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+			const subCommandArgIndex = findSubCommandIndex(opts.rawArgs, cmdArgs);
+			const explicitName = opts.rawArgs[subCommandArgIndex];
+			if (explicitName) {
+				const subCommand = await _findSubCommand(subCommands, explicitName);
+				if (!subCommand) throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
+				await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+			} else {
+				const defaultSubCommand = await resolveValue(cmd.default);
+				if (defaultSubCommand) {
+					if (cmd.run) throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
+					const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
+					if (!subCommand) throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
+					await runCommand(subCommand, { rawArgs: opts.rawArgs });
+				} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+			}
 		}
 		if (typeof cmd.run === "function") result = await cmd.run(context);
-	} finally {
-		if (typeof cmd.cleanup === "function") await cmd.cleanup(context);
+	} catch (error) {
+		runError = error;
 	}
+	const cleanupErrors = [];
+	if (typeof cmd.cleanup === "function") try {
+		await cmd.cleanup(context);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	for (const plugin of [...plugins].reverse()) try {
+		await plugin.cleanup?.(context);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	if (runError) throw runError;
+	if (cleanupErrors.length === 1) throw cleanupErrors[0];
+	if (cleanupErrors.length > 1) throw new Error("Multiple cleanup errors", { cause: cleanupErrors });
 	return { result };
 }
 async function resolveSubCommand(cmd, rawArgs, parent) {
 	const subCommands = await resolveValue(cmd.subCommands);
 	if (subCommands && Object.keys(subCommands).length > 0) {
-		const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
+		const subCommandArgIndex = findSubCommandIndex(rawArgs, await resolveValue(cmd.args || {}));
 		const subCommandName = rawArgs[subCommandArgIndex];
-		const subCommand = await resolveValue(subCommands[subCommandName]);
+		const subCommand = await _findSubCommand(subCommands, subCommandName);
 		if (subCommand) return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
 	}
 	return [cmd, parent];
 }
+async function _findSubCommand(subCommands, name) {
+	if (name in subCommands) return resolveValue(subCommands[name]);
+	for (const sub of Object.values(subCommands)) {
+		const resolved = await resolveValue(sub);
+		const meta = await resolveValue(resolved?.meta);
+		if (meta?.alias) {
+			if (toArray(meta.alias).includes(name)) return resolved;
+		}
+	}
+}
+function findSubCommandIndex(rawArgs, argsDef) {
+	for (let i = 0; i < rawArgs.length; i++) {
+		const arg = rawArgs[i];
+		if (arg === "--") return -1;
+		if (arg.startsWith("-")) {
+			if (!arg.includes("=") && _isValueFlag(arg, argsDef)) i++;
+			continue;
+		}
+		return i;
+	}
+	return -1;
+}
+function _isValueFlag(flag, argsDef) {
+	const name = flag.replace(/^-{1,2}/, "");
+	const normalized = camelCase(name);
+	for (const [key, def] of Object.entries(argsDef)) {
+		if (def.type !== "string" && def.type !== "enum") continue;
+		if (normalized === camelCase(key)) return true;
+		if ((Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : []).includes(name)) return true;
+	}
+	return false;
+}
 async function showUsage(cmd, parent) {
 	try {
 		console.log(await renderUsage(cmd, parent) + "\n");
@@ -287,22 +359,17 @@ async function renderUsage(cmd, parent) {
 	for (const arg of cmdArgs) if (arg.type === "positional") {
 		const name = arg.name.toUpperCase();
 		const isRequired = arg.required !== false && arg.default === void 0;
-		const defaultHint = arg.default ? `="${arg.default}"` : "";
-		posLines.push([
-			cyan(name + defaultHint),
-			arg.description || "",
-			arg.valueHint ? `<${arg.valueHint}>` : ""
-		]);
+		posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
 		usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
 	} else {
 		const isRequired = arg.required === true && arg.default === void 0;
-		const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "") + (arg.type === "enum" && arg.options ? `=<${arg.options.join("|")}>` : "");
-		argLines.push([cyan(argStr + (isRequired ? " (required)" : "")), arg.description || ""]);
+		const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
+		argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
 		if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
 			const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
-			argLines.push([cyan(negativeArgStr + (isRequired ? " (required)" : "")), arg.negativeDescription || ""]);
+			argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
 		}
-		if (isRequired) usageLine.push(argStr);
+		if (isRequired) usageLine.push(`--${arg.name}` + renderValueHint(arg));
 	}
 	if (cmd.subCommands) {
 		const commandNames = [];
@@ -310,8 +377,10 @@ async function renderUsage(cmd, parent) {
 		for (const [name, sub] of Object.entries(subCommands)) {
 			const meta = await resolveValue((await resolveValue(sub))?.meta);
 			if (meta?.hidden) continue;
-			commandsLines.push([cyan(name), meta?.description || ""]);
-			commandNames.push(name);
+			const aliases = toArray(meta?.alias);
+			const label = [name, ...aliases].join(", ");
+			commandsLines.push([cyan(label), meta?.description || ""]);
+			commandNames.push(name, ...aliases);
 		}
 		usageLine.push(commandNames.join("|"));
 	}
@@ -337,14 +406,31 @@ async function renderUsage(cmd, parent) {
 	}
 	return usageLines.filter((l) => typeof l === "string").join("\n");
 }
+function renderValueHint(arg) {
+	const valueHint = arg.valueHint ? `=<${arg.valueHint}>` : "";
+	const fallbackValueHint = valueHint || `=<${snakeCase(arg.name)}>`;
+	if (!arg.type || arg.type === "positional" || arg.type === "boolean") return valueHint;
+	if (arg.type === "enum" && arg.options?.length) return `=<${arg.options.join("|")}>`;
+	return fallbackValueHint;
+}
+function renderDescription(arg, required) {
+	const requiredHint = required ? gray("(Required)") : "";
+	const defaultHint = arg.default === void 0 ? "" : gray(`(Default: ${arg.default})`);
+	return [
+		arg.description,
+		requiredHint,
+		defaultHint
+	].filter(Boolean).join(" ");
+}
 async function runMain(cmd, opts = {}) {
 	const rawArgs = opts.rawArgs || process.argv.slice(2);
 	const showUsage$1 = opts.showUsage || showUsage;
 	try {
-		if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+		const builtinFlags = await _resolveBuiltinFlags(cmd);
+		if (builtinFlags.help.length > 0 && rawArgs.some((arg) => builtinFlags.help.includes(arg))) {
 			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
 			process.exit(0);
-		} else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
+		} else if (rawArgs.length === 1 && builtinFlags.version.includes(rawArgs[0])) {
 			const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
 			if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
 			console.log(meta.version);
@@ -357,5 +443,22 @@ async function runMain(cmd, opts = {}) {
 		process.exit(1);
 	}
 }
-//#endregion
+async function _resolveBuiltinFlags(cmd) {
+	const argsDef = await resolveValue(cmd.args || {});
+	const userNames = /* @__PURE__ */ new Set();
+	const userAliases = /* @__PURE__ */ new Set();
+	for (const [name, def] of Object.entries(argsDef)) {
+		userNames.add(name);
+		for (const alias of toArray(def.alias)) userAliases.add(alias);
+	}
+	return {
+		help: _getBuiltinFlags("help", "h", userNames, userAliases),
+		version: _getBuiltinFlags("version", "v", userNames, userAliases)
+	};
+}
+function _getBuiltinFlags(long, short, userNames, userAliases) {
+	if (userNames.has(long) || userAliases.has(long)) return [];
+	if (userNames.has(short) || userAliases.has(short)) return [`--${long}`];
+	return [`--${long}`, `-${short}`];
+}
 export { runMain as n, defineCommand as t };

package/dist/_libs/commondir+is-reference.mjs

@@ -2,8 +2,7 @@ import { i as __toESM, r as __require, t as __commonJSMin } from "../_common.mjs
 import { P as Builder, S as MagicString, c as walk, i as createFilter, o as extractAssignedNames, r as attachScopes, s as makeLegalIdentifier } from "../_build/common.mjs";
 import { existsSync, readFileSync, statSync } from "fs";
 import { basename, dirname, extname, join, relative, resolve, sep } from "path";
-//#region node_modules/.pnpm/commondir@1.0.1/node_modules/commondir/index.js
-var require_commondir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var import_commondir = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var path$1 = __require("path");
 	module.exports = function(basedir, relfiles) {
 		if (relfiles) var files = relfiles.map(function(r) {
@@ -18,9 +17,7 @@ var require_commondir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}, files[0].split(/\/+|\\+/));
 		return res.length > 1 ? res.join("/") : "/";
 	};
-}));
-//#endregion
-//#region node_modules/.pnpm/is-reference@1.2.1/node_modules/is-reference/dist/is-reference.es.js
+})))(), 1);
 function isReference(node, parent) {
 	if (node.type === "MemberExpression") return !node.computed && isReference(node.object, node);
 	if (node.type === "Identifier") {
@@ -40,9 +37,6 @@ function isReference(node, parent) {
 	}
 	return false;
 }
-//#endregion
-//#region node_modules/.pnpm/@rollup+plugin-commonjs@29.0.2_rollup@4.59.0/node_modules/@rollup/plugin-commonjs/dist/es/index.js
-var import_commondir = /* @__PURE__ */ __toESM(require_commondir(), 1);
 var version = "29.0.1";
 var peerDependencies = { rollup: "^2.68.0||^3.0.0||^4.0.0" };
 function tryParse(parse, code, id) {
@@ -1307,5 +1301,4 @@ function commonjs(options = {}) {
 		}
 	};
 }
-//#endregion
 export { commonjs as t };

package/dist/_libs/compatx.d.mts

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/compatx@0.2.0/node_modules/compatx/dist/index.d.mts
 /**
  * Known platform names
  */
@@ -43,5 +42,4 @@ type CompatibilityDateSpec = DateString | Partial<CompatibilityDates>;
 /**
  * Get compatibility updates applicable for the user given platform and date range.
  */
-//#endregion
 export { CompatibilityDates as n, DateString as r, CompatibilityDateSpec as t };

package/dist/_libs/compatx.mjs

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/compatx@0.2.0/node_modules/compatx/dist/index.mjs
 const platforms = [
 	"aws",
 	"azure",
@@ -41,5 +40,4 @@ function normalizeDate(date) {
 	if (date === "latest") return /* @__PURE__ */ new Date();
 	return new Date(date);
 }
-//#endregion
 export { resolveCompatibilityDates as n, resolveCompatibilityDatesFromEnv as r, formatCompatibilityDate as t };

package/dist/_libs/esbuild.d.mts

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/esbuild@0.27.3/node_modules/esbuild/lib/main.d.ts
 // Note: These declarations exist to avoid type errors when you omit "dom" from
 // "lib" in your "tsconfig.json" file. TypeScript confusingly declares the
 // global "WebAssembly" type in "lib.dom.d.ts" even though it has nothing to do

package/dist/_libs/escape-string-regexp.mjs

@@ -1,7 +1,5 @@
-//#region node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js
 function escapeStringRegexp(string) {
 	if (typeof string !== "string") throw new TypeError("Expected a string");
 	return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
 }
-//#endregion
 export { escapeStringRegexp as t };

package/dist/_libs/estree+pluginutils.d.mts

@@ -1,12 +1,8 @@
 import { Plugin } from "rollup";
-
-//#region node_modules/.pnpm/@rollup+pluginutils@5.3.0_rollup@4.59.0/node_modules/@rollup/pluginutils/types/index.d.ts
 /**
  * A valid `picomatch` glob pattern, or array of patterns.
  */
 type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
-//#endregion
-//#region node_modules/.pnpm/@rollup+plugin-commonjs@29.0.2_rollup@4.59.0/node_modules/@rollup/plugin-commonjs/types/index.d.ts
 type RequireReturnsDefaultOption = boolean | 'auto' | 'preferred' | 'namespace';
 type DefaultIsModuleExportsOption = boolean | 'auto';
 interface RollupCommonJSOptions {
@@ -237,5 +233,4 @@ interface RollupCommonJSOptions {
  * Convert CommonJS modules to ES6, so they can be included in a Rollup bundle
  */
 declare function commonjs(options?: RollupCommonJSOptions): Plugin;
-//#endregion
 export { commonjs as t };

package/dist/_libs/estree-walker.mjs

@@ -1,98 +1,37 @@
-//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
-/**
-* @typedef { import('estree').Node} Node
-* @typedef {{
-*   skip: () => void;
-*   remove: () => void;
-*   replace: (node: Node) => void;
-* }} WalkerContext
-*/
 var WalkerBase = class {
 	constructor() {
-		/** @type {boolean} */
 		this.should_skip = false;
-		/** @type {boolean} */
 		this.should_remove = false;
-		/** @type {Node | null} */
 		this.replacement = null;
-		/** @type {WalkerContext} */
 		this.context = {
 			skip: () => this.should_skip = true,
 			remove: () => this.should_remove = true,
 			replace: (node) => this.replacement = node
 		};
 	}
-	/**
-	* @template {Node} Parent
-	* @param {Parent | null | undefined} parent
-	* @param {keyof Parent | null | undefined} prop
-	* @param {number | null | undefined} index
-	* @param {Node} node
-	*/
 	replace(parent, prop, index, node) {
-		if (parent && prop) if (index != null)
- /** @type {Array<Node>} */ parent[prop][index] = node;
-		else
- /** @type {Node} */ parent[prop] = node;
+		if (parent && prop) if (index != null) parent[prop][index] = node;
+		else parent[prop] = node;
 	}
-	/**
-	* @template {Node} Parent
-	* @param {Parent | null | undefined} parent
-	* @param {keyof Parent | null | undefined} prop
-	* @param {number | null | undefined} index
-	*/
 	remove(parent, prop, index) {
-		if (parent && prop) if (index !== null && index !== void 0)
- /** @type {Array<Node>} */ parent[prop].splice(index, 1);
+		if (parent && prop) if (index !== null && index !== void 0) parent[prop].splice(index, 1);
 		else delete parent[prop];
 	}
 };
-//#endregion
-//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js
-/**
-* @typedef { import('estree').Node} Node
-* @typedef { import('./walker.js').WalkerContext} WalkerContext
-* @typedef {(
-*    this: WalkerContext,
-*    node: Node,
-*    parent: Node | null,
-*    key: string | number | symbol | null | undefined,
-*    index: number | null | undefined
-* ) => void} SyncHandler
-*/
 var SyncWalker = class extends WalkerBase {
-	/**
-	*
-	* @param {SyncHandler} [enter]
-	* @param {SyncHandler} [leave]
-	*/
 	constructor(enter, leave) {
 		super();
-		/** @type {boolean} */
 		this.should_skip = false;
-		/** @type {boolean} */
 		this.should_remove = false;
-		/** @type {Node | null} */
 		this.replacement = null;
-		/** @type {WalkerContext} */
 		this.context = {
 			skip: () => this.should_skip = true,
 			remove: () => this.should_remove = true,
 			replace: (node) => this.replacement = node
 		};
-		/** @type {SyncHandler | undefined} */
 		this.enter = enter;
-		/** @type {SyncHandler | undefined} */
 		this.leave = leave;
 	}
-	/**
-	* @template {Node} Parent
-	* @param {Node} node
-	* @param {Parent | null} parent
-	* @param {keyof Parent} [prop]
-	* @param {number | null} [index]
-	* @returns {Node | null}
-	*/
 	visit(node, parent, prop, index) {
 		if (node) {
 			if (this.enter) {
@@ -116,10 +55,8 @@ var SyncWalker = class extends WalkerBase {
 				if (skipped) return node;
 				if (removed) return null;
 			}
-			/** @type {keyof Node} */
 			let key;
 			for (key in node) {
-				/** @type {unknown} */
 				const value = node[key];
 				if (value && typeof value === "object") {
 					if (Array.isArray(value)) {
@@ -153,32 +90,10 @@ var SyncWalker = class extends WalkerBase {
 		return node;
 	}
 };
-/**
-* Ducktype a node.
-*
-* @param {unknown} value
-* @returns {value is Node}
-*/
 function isNode(value) {
 	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
 }
-//#endregion
-//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js
-/**
-* @typedef {import('estree').Node} Node
-* @typedef {import('./sync.js').SyncHandler} SyncHandler
-* @typedef {import('./async.js').AsyncHandler} AsyncHandler
-*/
-/**
-* @param {Node} ast
-* @param {{
-*   enter?: SyncHandler
-*   leave?: SyncHandler
-* }} walker
-* @returns {Node | null}
-*/
 function walk(ast, { enter, leave }) {
 	return new SyncWalker(enter, leave).visit(ast, null);
 }
-//#endregion
 export { walk as t };