@fedify/init 2.5.0-dev.2516 → 2.5.0-dev.2541

package/README.md

@@ -28,8 +28,10 @@ The initializer supports the following project configurations:
  -  **Web frameworks**: Bare-bones, [Astro], [Elysia], [Express], [Hono],
     [Next.js], [Nitro], [Nuxt], [SolidStart], [SvelteKit]
  -  **Package managers**: Deno, pnpm, Bun, Yarn, npm
- -  **Key-value stores**: In-Memory, Redis, PostgreSQL, Deno KV (Deno only)
- -  **Message queues**: In-Process, Redis, PostgreSQL, AMQP, Deno KV (Deno only)
+ -  **Key-value stores**: In-Memory, Redis, PostgreSQL, Deno KV (deprecated;
+    Deno only)
+ -  **Message queues**: In-Process, Redis, PostgreSQL, AMQP, Deno KV
+    (deprecated; Deno only)
 
 [Astro]: https://astro.build/
 [Elysia]: https://elysiajs.com/
@@ -70,13 +72,16 @@ import { initCommand, runInit } from "@fedify/init";
 Test
 ----
 
-The `test-init` task is useful for contributors working on `@fedify/init`,
+The `test:init` task is useful for contributors working on `@fedify/init`,
 especially when adding support for a new framework/library or modifying the
 scaffolding logic.  It tests the project initialization by running
-`fedify init` across all combinations of supported options on temporary
+`fedify init` across all combinations of supported options in temporary
 directories, verifying that the generated projects are valid.
 
-To run the test, use the mise task from the repository root:
+The harness runs on Node.js 22.18 or later, using
+`--experimental-transform-types` for the initializer source.  The default
+matrix includes Deno projects and requires Deno as well.  To run it, use the
+mise task from the repository root:
 
 ~~~~ sh
 mise run test:init
@@ -85,8 +90,13 @@ mise run test:init
 You can also filter specific options to test a subset of combinations:
 
 ~~~~ sh
-mise run test:init -w hono -p deno
+mise run test:init -- -w hono -p npm -k in-memory -m in-process
+mise run test:init -- -w hono -p deno
 ~~~~
 
+The first command tests only Node.js targets and needs no Deno executable or
+cache.  The second tests the Hono targets that use Deno.
+
 Use `--no-dry-run` to test with actual file creation and dependency
-installation, or `--no-hyd-run` to only log outputs without creating files.
+installation, or `--no-hyd-run` to preview generation without scaffolding apps
+or installing dependencies.  The harness writes log files for both modes.

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,26 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+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 __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, 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 __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __commonJSMin, __require, __toESM };

package/dist/action/configs.js

@@ -24,17 +24,29 @@ const logger = getLogger([
 * @param param0 - Destructured initialization data containing KV, MQ, initializer, and directory
 * @returns Configuration object with path and Deno-specific settings
 */
-const loadDenoConfig = (data) => ({
-	path: "deno.json",
-	data: {
-		...pick(["compilerOptions", "tasks"], data.initializer),
-		...getUnstable(data),
-		nodeModulesDir: "auto",
-		imports: joinDepsReg("deno")(getDependencies(data)),
-		lint: { plugins: ["jsr:@fedify/lint"] },
-		...data.testMode && !data.dryRun ? { links: getLinks(data) } : {}
-	}
-});
+const loadDenoConfig = (data) => {
+	const lintExcludes = getDenoKvLintExcludes(data);
+	return {
+		path: "deno.json",
+		data: {
+			...pick(["compilerOptions", "tasks"], data.initializer),
+			...getUnstable(data),
+			nodeModulesDir: "auto",
+			imports: joinDepsReg("deno")(getDependencies(data)),
+			lint: {
+				plugins: ["jsr:@fedify/lint"],
+				...lintExcludes.length > 0 ? { rules: { exclude: lintExcludes } } : {}
+			},
+			...data.testMode && !data.dryRun ? { links: getLinks(data) } : {}
+		}
+	};
+};
+/**
+* Deno Lint reports every plugin rule as an error, so `denokv` selections
+* would fail `deno lint` without opting out of the deprecation rules.  The
+* interactive prompt already labels the option as deprecated.
+*/
+const getDenoKvLintExcludes = ({ kvStore, messageQueue }) => [...kvStore === "denokv" ? ["fedify-lint/deno-kv-store-deprecated"] : [], ...messageQueue === "denokv" ? ["fedify-lint/deno-kv-message-queue-deprecated"] : []];
 const getUnstable = ({ kv: { denoUnstable: kv = [] }, mq: { denoUnstable: mq = [] } }) => {
 	const unstable = pipe(needsUnstableTemporal() ? ["temporal"] : [], concat(kv), concat(mq), uniq, toArray);
 	return isEmpty(unstable) ? {} : { unstable };

package/dist/ask/kv.js

@@ -22,17 +22,17 @@ const askKvStore = async (data) => ({
 });
 const unmatchedWhileTesting = ({ kvStore: kv, packageManager: pm }) => /* @__PURE__ */ new Error(`Key-value store '${kv}' is not compatible with package manager '${pm}'`);
 const noticeUnmatched = ({ kvStore: kv, packageManager: pm }) => printErrorMessage`Error: Key-value store '${kv}' is not compatible with package manager '${pm}'`;
-const choiceKvStore = (pm) => (kv) => ({
-	name: isKvSupportsPm({
+const choiceKvStore = (pm) => (kv) => {
+	const supported = isKvSupportsPm({
 		kvStore: kv,
 		packageManager: pm
-	}) ? kv : `${kv} (not supported with ${pm})`,
-	value: kv,
-	disabled: !isKvSupportsPm({
-		kvStore: kv,
-		packageManager: pm
-	})
-});
+	});
+	return {
+		name: kvStores[kv].deprecated ? `${kv} (deprecated)` : kv,
+		value: kv,
+		disabled: supported ? false : `(not supported with ${pm})`
+	};
+};
 const isKvSupportsPm = ({ kvStore, packageManager }) => kvStores[kvStore].packageManagers.includes(packageManager);
 //#endregion
-export { fillKvStore as default };
+export { choiceKvStore, fillKvStore as default };

package/dist/ask/mq.js

@@ -24,17 +24,17 @@ const unmatchedWhileTesting = ({ messageQueue: mq, packageManager: pm }) => /* @
 const noticeUnmatched = ({ messageQueue: mq, packageManager: pm }) => {
 	printErrorMessage`Error: Message queue '${mq}' is not compatible with package manager '${pm}'`;
 };
-const choiceMessageQueue = (packageManager) => (messageQueue) => ({
-	name: isMqSupportsPm({
+const choiceMessageQueue = (packageManager) => (messageQueue) => {
+	const supported = isMqSupportsPm({
 		messageQueue,
 		packageManager
-	}) ? messageQueue : `${messageQueue} (not supported with ${packageManager})`,
-	value: messageQueue,
-	disabled: !isMqSupportsPm({
-		messageQueue,
-		packageManager
-	})
-});
+	});
+	return {
+		name: messageQueues[messageQueue].deprecated ? `${messageQueue} (deprecated)` : messageQueue,
+		value: messageQueue,
+		disabled: supported ? false : `(not supported with ${packageManager})`
+	};
+};
 const isMqSupportsPm = ({ messageQueue, packageManager }) => messageQueues[messageQueue].packageManagers.includes(packageManager);
 //#endregion
-export { fillMessageQueue as default };
+export { choiceMessageQueue, fillMessageQueue as default };

package/dist/ask/pm.js

@@ -1,6 +1,6 @@
 import { PACKAGE_MANAGER } from "../const.js";
 import { printErrorMessage } from "../utils.js";
-import { checkAllRuntimes, getInstallUrl, isPackageManagerAvailable, isTest, runtimes } from "../lib.js";
+import { checkAllRuntimes, checkRuntimeVersion, getInstallUrl, isPackageManagerAvailable, isTest, resolveRequiredVersion, runtimes } from "../lib.js";
 import { pmToRt } from "../webframeworks/utils.js";
 import webFrameworks from "../webframeworks/mod.js";
 import process from "node:process";
@@ -18,7 +18,11 @@ import { print } from "@optique/run";
 * @returns A promise resolving to options with a guaranteed packageManager
 */
 const fillPackageManager = async ({ packageManager, ...options }) => {
-	const choices = await calculateChoices(options.webFramework);
+	const runtime = packageManager == null ? void 0 : pmToRt(packageManager);
+	const choices = isTest(options) && packageManager != null && runtime != null ? [await choicePackageManager(options.webFramework, packageManager, await checkRuntimeVersion({
+		...runtimes[runtime],
+		minVersion: resolveRequiredVersion(runtime, webFrameworks[options.webFramework].minRuntimeVersions?.[runtime])
+	}))] : await calculateChoices(options.webFramework);
 	if (packageManager != null) {
 		const choice = choices.find(({ value }) => value === packageManager);
 		if (choice.disabled == null) return {
@@ -35,7 +39,7 @@ const fillPackageManager = async ({ packageManager, ...options }) => {
 };
 const calculateChoices = async (wf) => {
 	const runtimeChecks = await checkAllRuntimes(webFrameworks[wf].minRuntimeVersions);
-	const choices = await Promise.all(PACKAGE_MANAGER.map(choicePackageManager(wf, runtimeChecks)));
+	const choices = await Promise.all(PACKAGE_MANAGER.map((pm) => choicePackageManager(wf, pm, runtimeChecks[pmToRt(pm)])));
 	if (choices.every((choice) => choice.disabled)) {
 		printErrorMessage`No package manager with a supported runtime is available for ${webFrameworks[wf].label}.`;
 		process.exit(1);
@@ -46,8 +50,7 @@ const askPackageManager = (choices) => select({
 	message: "Choose the package manager to use",
 	choices
 });
-const choicePackageManager = (wf, runtimeChecks) => async (value) => {
-	const check = runtimeChecks[pmToRt(value)];
+const choicePackageManager = async (wf, value, check) => {
 	const label = runtimes[pmToRt(value)].label;
 	const disabled = !isWfSupportsPm(wf, value) ? `not supported with ${webFrameworks[wf].label}` : check.status === "unsupported" ? `requires ${label} ${check.required} or later (detected: ${check.detected})` : check.status === "missing" ? `requires ${label} which is not installed` : check.status === "malformed" ? `could not detect ${label} version` : pmToRt(value) === "node" && !await isPackageManagerAvailable(value) ? `is not installed; install it from ${getInstallUrl(value)}` : "";
 	return disabled === "" ? {

package/dist/command.d.ts

@@ -43,5 +43,25 @@ declare const initCommand: _$_optique_core0.FluentParser<"sync", {
 }, ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
 /** The inferred value type produced by parsing the `fedify init` command. */
 type InitCommand = InferValue<typeof initCommand>;
+/**
+ * The `test-init` CLI command parser.
+ */
+declare const testInitCommand: _$_optique_core0.FluentParser<"sync", ({
+  readonly webFramework: readonly ("next" | "bare-bones" | "hono" | "nitro" | "elysia" | "astro" | "express" | "nuxt" | "solidstart" | "sveltekit" | undefined)[];
+  readonly packageManager: readonly ("deno" | "pnpm" | "bun" | "yarn" | "npm" | undefined)[];
+  readonly kvStore: readonly ("postgres" | "mysql" | "in-memory" | "redis" | "denokv" | undefined)[];
+  readonly messageQueue: readonly ("postgres" | "mysql" | "redis" | "denokv" | "in-process" | "amqp" | undefined)[];
+} & {
+  readonly noHydRun: boolean;
+}) | ({
+  readonly webFramework: readonly ("next" | "bare-bones" | "hono" | "nitro" | "elysia" | "astro" | "express" | "nuxt" | "solidstart" | "sveltekit" | undefined)[];
+  readonly packageManager: readonly ("deno" | "pnpm" | "bun" | "yarn" | "npm" | undefined)[];
+  readonly kvStore: readonly ("postgres" | "mysql" | "in-memory" | "redis" | "denokv" | undefined)[];
+  readonly messageQueue: readonly ("postgres" | "mysql" | "redis" | "denokv" | "in-process" | "amqp" | undefined)[];
+} & {
+  readonly noDryRun: boolean;
+}), ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
+/** The inferred value type produced by parsing the `test-init` command. */
+type TestInitCommand = InferValue<typeof testInitCommand>;
 //#endregion
-export { InitCommand, initCommand, initOptions };
+export { InitCommand, TestInitCommand, initCommand, initOptions, testInitCommand };

package/dist/json/kv.js

@@ -68,6 +68,7 @@ var kv_default = {
 		"packageManagers": ["deno"],
 		"imports": { "@fedify/denokv": { "DenoKvStore": "DenoKvStore" } },
 		"object": "new DenoKvStore(await Deno.openKv())",
+		"deprecated": true,
 		"denoUnstable": ["kv"]
 	}
 };

package/dist/json/kv.json

@@ -101,6 +101,7 @@
       }
     },
     "object": "new DenoKvStore(await Deno.openKv())",
+    "deprecated": true,
     "denoUnstable": [
       "kv"
     ]

package/dist/json/mq.js

@@ -86,6 +86,7 @@ var mq_default = {
 		"packageManagers": ["deno"],
 		"imports": { "@fedify/denokv": { "DenoKvMessageQueue": "DenoKvMessageQueue" } },
 		"object": "new DenoKvMessageQueue(await Deno.openKv())",
+		"deprecated": true,
 		"denoUnstable": ["kv"]
 	}
 };

package/dist/json/mq.json

@@ -129,6 +129,7 @@
       }
     },
     "object": "new DenoKvMessageQueue(await Deno.openKv())",
+    "deprecated": true,
     "denoUnstable": [
       "kv"
     ]

package/dist/lib.js

@@ -1,4 +1,4 @@
-import { version } from "./deno.js";
+import { version } from "./packages/init/deno.js";
 import kv_default from "./json/kv.js";
 import mq_default from "./json/mq.js";
 import rt_default from "./json/rt.js";
@@ -367,4 +367,4 @@ const isDirectory = async (path) => {
 /** Returns `true` if the current run is in test mode. */
 const isTest = ({ testMode }) => testMode;
 //#endregion
-export { PACKAGE_VERSION, checkAllRuntimes, createFile, getBuildCommand, getDevCommand, getInstallUrl, isDirectoryEmpty, isPackageManagerAvailable, isTest, kvStores, logger, messageQueues, packageManagers, readTemplate, resolveRequiredVersion, runtimes, throwUnlessNotExists, verifyRuntimeVersion };
+export { PACKAGE_VERSION, checkAllRuntimes, checkRuntimeVersion, createFile, getBuildCommand, getDevCommand, getInstallUrl, isDirectoryEmpty, isPackageManagerAvailable, isTest, kvStores, logger, messageQueues, packageManagers, readTemplate, resolveRequiredVersion, runtimes, throwUnlessNotExists, verifyRuntimeVersion };

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js

@@ -0,0 +1,29 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_parse } from "./lib/parse.js";
+import { require_enoent } from "./lib/enoent.js";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const cp = __require("child_process");
+	const parse = require_parse();
+	const enoent = require_enoent();
+	function spawn(command, args, options) {
+		const parsed = parse(command, args, options);
+		const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+		enoent.hookChildProcess(spawned, parsed);
+		return spawned;
+	}
+	function spawnSync(command, args, options) {
+		const parsed = parse(command, args, options);
+		const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+		result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+		return result;
+	}
+	module.exports = spawn;
+	module.exports.spawn = spawn;
+	module.exports.sync = spawnSync;
+	module.exports._parse = parse;
+	module.exports._enoent = enoent;
+}));
+//#endregion
+export default require_cross_spawn();
+export { require_cross_spawn };

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js

@@ -0,0 +1,42 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWin = process.platform === "win32";
+	function notFoundError(original, syscall) {
+		return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${syscall} ${original.command}`,
+			path: original.command,
+			spawnargs: original.args
+		});
+	}
+	function hookChildProcess(cp, parsed) {
+		if (!isWin) return;
+		const originalEmit = cp.emit;
+		cp.emit = function(name, arg1) {
+			if (name === "exit") {
+				const err = verifyENOENT(arg1, parsed);
+				if (err) return originalEmit.call(cp, "error", err);
+			}
+			return originalEmit.apply(cp, arguments);
+		};
+	}
+	function verifyENOENT(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
+		return null;
+	}
+	function verifyENOENTSync(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
+		return null;
+	}
+	module.exports = {
+		hookChildProcess,
+		verifyENOENT,
+		verifyENOENTSync,
+		notFoundError
+	};
+}));
+//#endregion
+export default require_enoent();
+export { require_enoent };

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js

@@ -0,0 +1,67 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_resolveCommand } from "./util/resolveCommand.js";
+import { require_escape } from "./util/escape.js";
+import { require_readShebang } from "./util/readShebang.js";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const resolveCommand = require_resolveCommand();
+	const escape = require_escape();
+	const readShebang = require_readShebang();
+	const isWin = process.platform === "win32";
+	const isExecutableRegExp = /\.(?:com|exe)$/i;
+	const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function detectShebang(parsed) {
+		parsed.file = resolveCommand(parsed);
+		const shebang = parsed.file && readShebang(parsed.file);
+		if (shebang) {
+			parsed.args.unshift(parsed.file);
+			parsed.command = shebang;
+			return resolveCommand(parsed);
+		}
+		return parsed.file;
+	}
+	function parseNonShell(parsed) {
+		if (!isWin) return parsed;
+		const commandFile = detectShebang(parsed);
+		const needsShell = !isExecutableRegExp.test(commandFile);
+		if (parsed.options.forceShell || needsShell) {
+			const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+			parsed.command = path.normalize(parsed.command);
+			parsed.command = escape.command(parsed.command);
+			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+			parsed.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[parsed.command].concat(parsed.args).join(" ")}"`
+			];
+			parsed.command = process.env.comspec || "cmd.exe";
+			parsed.options.windowsVerbatimArguments = true;
+		}
+		return parsed;
+	}
+	function parse(command, args, options) {
+		if (args && !Array.isArray(args)) {
+			options = args;
+			args = null;
+		}
+		args = args ? args.slice(0) : [];
+		options = Object.assign({}, options);
+		const parsed = {
+			command,
+			args,
+			options,
+			file: void 0,
+			original: {
+				command,
+				args
+			}
+		};
+		return options.shell ? parsed : parseNonShell(parsed);
+	}
+	module.exports = parse;
+}));
+//#endregion
+export default require_parse();
+export { require_parse };

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+	function escapeCommand(arg) {
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	function escapeArgument(arg, doubleEscapeMetaChars) {
+		arg = `${arg}`;
+		arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+		arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+		arg = `"${arg}"`;
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	module.exports.command = escapeCommand;
+	module.exports.argument = escapeArgument;
+}));
+//#endregion
+export default require_escape();
+export { require_escape };

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js

@@ -0,0 +1,22 @@
+import { __commonJSMin, __require } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_shebang_command } from "../../../../../shebang-command@2.0.0/node_modules/shebang-command/index.js";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = __require("fs");
+	const shebangCommand = require_shebang_command();
+	function readShebang(command) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd;
+		try {
+			fd = fs.openSync(command, "r");
+			fs.readSync(fd, buffer, 0, size, 0);
+			fs.closeSync(fd);
+		} catch (e) {}
+		return shebangCommand(buffer.toString());
+	}
+	module.exports = readShebang;
+}));
+//#endregion
+export default require_readShebang();
+export { require_readShebang };

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js

@@ -0,0 +1,36 @@
+import { __commonJSMin, __require } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_which } from "../../../../../which@2.0.2/node_modules/which/which.js";
+import { require_path_key } from "../../../../../path-key@3.1.1/node_modules/path-key/index.js";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const which = require_which();
+	const getPathKey = require_path_key();
+	function resolveCommandAttempt(parsed, withoutPathExt) {
+		const env = parsed.options.env || process.env;
+		const cwd = process.cwd();
+		const hasCustomCwd = parsed.options.cwd != null;
+		const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+		if (shouldSwitchCwd) try {
+			process.chdir(parsed.options.cwd);
+		} catch (err) {}
+		let resolved;
+		try {
+			resolved = which.sync(parsed.command, {
+				path: env[getPathKey({ env })],
+				pathExt: withoutPathExt ? path.delimiter : void 0
+			});
+		} catch (e) {} finally {
+			if (shouldSwitchCwd) process.chdir(cwd);
+		}
+		if (resolved) resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+		return resolved;
+	}
+	function resolveCommand(parsed) {
+		return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+	}
+	module.exports = resolveCommand;
+}));
+//#endregion
+export default require_resolveCommand();
+export { require_resolveCommand };

package/dist/node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js

@@ -0,0 +1,47 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_windows } from "./windows.js";
+import { require_mode } from "./mode.js";
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	__require("fs");
+	var core;
+	if (process.platform === "win32" || global.TESTING_WINDOWS) core = require_windows();
+	else core = require_mode();
+	module.exports = isexe;
+	isexe.sync = sync;
+	function isexe(path, options, cb) {
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		if (!cb) {
+			if (typeof Promise !== "function") throw new TypeError("callback not provided");
+			return new Promise(function(resolve, reject) {
+				isexe(path, options || {}, function(er, is) {
+					if (er) reject(er);
+					else resolve(is);
+				});
+			});
+		}
+		core(path, options || {}, function(er, is) {
+			if (er) {
+				if (er.code === "EACCES" || options && options.ignoreErrors) {
+					er = null;
+					is = false;
+				}
+			}
+			cb(er, is);
+		});
+	}
+	function sync(path, options) {
+		try {
+			return core.sync(path, options || {});
+		} catch (er) {
+			if (options && options.ignoreErrors || er.code === "EACCES") return false;
+			else throw er;
+		}
+	}
+}));
+//#endregion
+export default require_isexe();
+export { require_isexe };

package/dist/node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js

@@ -0,0 +1,33 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs = __require("fs");
+	function isexe(path, options, cb) {
+		fs.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs.statSync(path), options);
+	}
+	function checkStat(stat, options) {
+		return stat.isFile() && checkMode(stat, options);
+	}
+	function checkMode(stat, options) {
+		var mod = stat.mode;
+		var uid = stat.uid;
+		var gid = stat.gid;
+		var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+		var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+		var u = parseInt("100", 8);
+		var g = parseInt("010", 8);
+		var o = parseInt("001", 8);
+		var ug = u | g;
+		return mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+	}
+}));
+//#endregion
+export default require_mode();
+export { require_mode };

package/dist/node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js

@@ -0,0 +1,33 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs = __require("fs");
+	function checkPathExt(path, options) {
+		var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+		if (!pathext) return true;
+		pathext = pathext.split(";");
+		if (pathext.indexOf("") !== -1) return true;
+		for (var i = 0; i < pathext.length; i++) {
+			var p = pathext[i].toLowerCase();
+			if (p && path.substr(-p.length).toLowerCase() === p) return true;
+		}
+		return false;
+	}
+	function checkStat(stat, path, options) {
+		if (!stat.isSymbolicLink() && !stat.isFile()) return false;
+		return checkPathExt(path, options);
+	}
+	function isexe(path, options, cb) {
+		fs.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, path, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs.statSync(path), path, options);
+	}
+}));
+//#endregion
+export default require_windows();
+export { require_windows };

package/dist/node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js

@@ -0,0 +1,14 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pathKey = (options = {}) => {
+		const environment = options.env || process.env;
+		if ((options.platform || process.platform) !== "win32") return "PATH";
+		return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+	};
+	module.exports = pathKey;
+	module.exports.default = pathKey;
+}));
+//#endregion
+export default require_path_key();
+export { require_path_key };