convoker 0.3.2 → 0.3.4

package/dist/prompt-Cvufljin.mjs

@@ -0,0 +1,248 @@
+import { t as __export } from "./chunk-z5eko27R.mjs";
+import { n as isDeno, r as isNode, t as isBun } from "./utils-ChmY93uA.mjs";
+import { t as DEFAULT_THEME } from "./color-OlJQTTxb.mjs";
+import { r as InputValidationError } from "./error-C1S1gs8L.mjs";
+import { t as validate } from "./standard-schema-DBXbMy6L.mjs";
+import { a as readKey, i as raw_exports, o as readLine, r as cursorUp, t as clearLines } from "./raw--889icsd.mjs";
+
+//#region src/prompt/index.ts
+var prompt_exports = /* @__PURE__ */ __export({
+	confirm: () => confirm,
+	editor: () => editor,
+	multiselect: () => multiselect,
+	password: () => password,
+	raw: () => raw_exports,
+	search: () => search,
+	select: () => select,
+	setTheme: () => setTheme,
+	text: () => text
+});
+let theme = DEFAULT_THEME;
+/**
+* Sets the theme of the prompts.
+* @param t The new theme.
+*/
+function setTheme(t) {
+	theme = t;
+}
+/**
+* Prompts the user for text input.
+* @param opts Options for text input.
+* @returns The text the user typed in, or the default.
+*/
+async function text(opts) {
+	const message = (opts.theme ?? theme).primary(opts.message) + " ";
+	const answer = await readLine(message, opts.default);
+	if (opts.minLength && answer.length < opts.minLength) throw new InputValidationError([`Must be at least ${opts.minLength} characters`]);
+	if (opts.maxLength && answer.length > opts.maxLength) throw new InputValidationError([`Must be at most ${opts.maxLength} characters`]);
+	if (typeof opts.validate === "function") {
+		if (!opts.validate(answer)) throw new InputValidationError(["Validation function returned a falsy value"]);
+	} else if (opts.validate) validate(opts.validate, answer);
+	return answer;
+}
+/**
+* Prompts the user for a password.
+* @param opts Options for password input.
+* @returns The password.
+*/
+async function password(opts) {
+	const th = opts.theme ?? theme;
+	const first = await readLine(th.primary(opts.message) + " ", void 0, {
+		masked: true,
+		maskChar: opts.mask ?? "*"
+	});
+	if (opts.confirm) {
+		if (first !== await readLine(th.secondary("Confirm password: "), void 0, {
+			masked: true,
+			maskChar: opts.mask ?? "*"
+		})) throw new Error(th.error("Passwords do not match"));
+	}
+	return first;
+}
+/**
+* Prompts the user to select a single option.
+* @param opts Options for select input.
+* @returns The selected option's value.
+*/
+async function select(opts) {
+	const th = opts.theme ?? theme;
+	const options = opts.options;
+	let index = opts.initialIndex ?? 0;
+	const render = () => {
+		clearLines(options.length + 1);
+		console.log(th.primary(opts.message));
+		for (let i = 0; i < options.length; i++) {
+			const o = options[i];
+			const prefix = i === index ? th.accent?.("> ") ?? "> " : "  ";
+			const label = o.disabled ? th.secondary(o.label) : th.foreground?.(o.label) ?? o.label;
+			console.log(prefix + label);
+		}
+	};
+	console.log(th.primary(opts.message));
+	options.forEach((o, i) => console.log(`${i === index ? "> " : "  "}${o.label}`));
+	while (true) {
+		const key = await readKey();
+		if (key === "up" && index > 0) index--;
+		else if (key === "down" && index < options.length - 1) index++;
+		else if (key === "enter") {
+			const choice = options[index];
+			if (choice.disabled) continue;
+			clearLines(options.length + 1);
+			console.log(th.success(`${th.symbols?.success ?? "✔"} ${choice.label}`));
+			return choice.value;
+		}
+		render();
+	}
+}
+/**
+* Prompts the user to select multiple options.
+* @param opts Options for select input.
+* @returns The selected options.
+*/
+async function multiselect(opts) {
+	const th = opts.theme ?? theme;
+	const options = opts.options;
+	let index = opts.initialIndex ?? 0;
+	const selected = /* @__PURE__ */ new Set();
+	const render = () => {
+		clearLines();
+		console.log(th.primary(opts.message));
+		options.forEach((opt, i) => {
+			const prefix = i === index ? th.accent?.("> ") ?? "> " : "  ";
+			const mark = selected.has(i) ? th.success("[x]") : "[ ]";
+			console.log(prefix + mark + " " + opt.label);
+		});
+	};
+	render();
+	while (true) {
+		const key = await readKey();
+		if (key === "up" && index > 0) index--;
+		else if (key === "down" && index < options.length - 1) index++;
+		else if (key === "space") if (selected.has(index)) selected.delete(index);
+		else selected.add(index);
+		else if (key === "return") {
+			const chosen = Array.from(selected).map((i) => options[i].value);
+			clearLines(options.length + 1);
+			console.log(th.success(`${opts.message} ${chosen.length} selected`));
+			return chosen;
+		}
+		cursorUp(options.length);
+		render();
+	}
+}
+/**
+* Prompts the user to search through a list of options.
+* @param opts Options for search input.
+* @returns The selected option.
+*/
+async function search(opts) {
+	const th = opts.theme ?? theme;
+	let query = "";
+	const filter = opts.filter ?? ((q, o) => o.label.toLowerCase().includes(q.toLowerCase()));
+	while (true) {
+		clearLines();
+		console.log(th.primary(opts.message));
+		const matches = opts.options.filter((o) => filter(query, o));
+		matches.forEach((o) => console.log("  " + (th.foreground?.(o.label) ?? o.label)));
+		const input = await readLine(th.secondary(`Search: ${query}`));
+		if (input === "") continue;
+		query = input;
+		if (matches.length === 1) return matches[0].value;
+	}
+}
+/**
+* Prompts the user to confirm an action.
+* @param opts Options for confirm input.
+* @returns If the user picked Yes.
+*/
+async function confirm(opts) {
+	const th = opts.theme ?? theme;
+	const yes = opts.yesLabel ?? "y";
+	const no = opts.noLabel ?? "n";
+	const def = opts.default ? yes : no;
+	const res = await readLine(`${th.primary(opts.message)} ${th.secondary(`[${yes}/${no}] (default: ${def})`)} `);
+	if (!res) return !!opts.default;
+	return /^y/i.test(res.trim());
+}
+/**
+* Opens the system editor, or asks for input in the terminal as fallback.
+* @param opts Options for opening the system editor.
+* @returns The result of the system editor.
+*/
+async function editor(opts) {
+	const th = opts.theme ?? {
+		primary: (s) => s,
+		secondary: (s) => s
+	};
+	console.log(th.primary(opts.message ?? "Please enter text:"));
+	console.log(th.secondary("Press Ctrl+D (or save & close editor) when done."));
+	try {
+		const result = await openSystemEditor(opts.initial ?? "");
+		if (opts.required && !result.trim()) throw new Error("Input required.");
+		return result;
+	} catch {
+		const value = await readLine("", opts.initial, { multiline: true });
+		if (opts.required && !value.trim()) throw new Error("Input required.");
+		return value;
+	}
+}
+/**
+* Opens the system editor on a temporary file.
+* @param initial Initial contents of the file.
+* @returns The contents of the file after saving.
+*/
+async function openSystemEditor(initial) {
+	const tmpFile = `edit-${Date.now()}.txt`;
+	if (isDeno) {
+		const path = `${Deno.env.get("TMPDIR") ?? "/tmp"}/${tmpFile}`;
+		await Deno.writeTextFile(path, initial ?? "");
+		const editor$1 = Deno.env.get("EDITOR") ?? "vi";
+		const status = await new Deno.Command(editor$1, {
+			args: [path],
+			stdin: "inherit",
+			stdout: "inherit",
+			stderr: "inherit"
+		}).spawn().status;
+		if (!status.success) throw new Error(`${editor$1} exited with ${status.code}`);
+		const text$1 = await Deno.readTextFile(path);
+		await Deno.remove(path).catch(() => {});
+		return text$1;
+	}
+	if (isBun) {
+		const { $ } = await import("bun");
+		const path = `/tmp/${tmpFile}`;
+		await Bun.write(path, initial ?? "");
+		await $`${process.env.EDITOR ?? "vi"} ${path}`;
+		const text$1 = await Bun.file(path).text();
+		await Bun.write(path, "");
+		return text$1;
+	}
+	if (isNode) {
+		const { tmpdir } = await import("node:os");
+		const { join } = await import("node:path");
+		const { promises: fs } = await import("node:fs");
+		const { spawn } = await import("node:child_process");
+		const path = join(tmpdir(), tmpFile);
+		await fs.writeFile(path, initial ?? "", "utf8");
+		const editor$1 = process.env.EDITOR || process.env.VISUAL || (process.platform === "win32" ? "notepad" : "vi");
+		return new Promise((resolve, reject) => {
+			spawn(editor$1, [path], { stdio: "inherit" }).on("exit", async (code) => {
+				if (code !== 0) {
+					reject(/* @__PURE__ */ new Error(`${editor$1} exited with code ${code}`));
+					return;
+				}
+				try {
+					const data = await fs.readFile(path, "utf8");
+					await fs.unlink(path).catch(() => {});
+					resolve(data);
+				} catch (err) {
+					reject(err);
+				}
+			});
+		});
+	}
+	throw new Error("Unsupported runtime for system editor.");
+}
+
+//#endregion
+export { prompt_exports as a, setTheme as c, password as i, text as l, editor as n, search as o, multiselect as r, select as s, confirm as t };

package/dist/raw--889icsd.mjs

@@ -0,0 +1,105 @@
+import { t as __export } from "./chunk-z5eko27R.mjs";
+import { n as isDeno } from "./utils-ChmY93uA.mjs";
+
+//#region src/prompt/raw.ts
+var raw_exports = /* @__PURE__ */ __export({
+	clearLines: () => clearLines,
+	cursorDown: () => cursorDown,
+	cursorUp: () => cursorUp,
+	readKey: () => readKey,
+	readLine: () => readLine
+});
+/**
+* Reads a line from standard input.
+* @param message The message.
+* @param def Default value.
+* @param opts Options for reading a line.
+* @returns The line that was read.
+*/
+async function readLine(message = "", def, opts) {
+	if (isDeno) {
+		await Deno.stdout.write(new TextEncoder().encode(message));
+		const decoder = new TextDecoder();
+		const buf = new Uint8Array(1024);
+		let input = "";
+		while (true) {
+			const n = await Deno.stdin.read(buf);
+			if (!n) break;
+			const chunk = decoder.decode(buf.subarray(0, n));
+			if (chunk.includes("\n")) {
+				input += chunk.split("\n")[0];
+				break;
+			}
+			input += chunk;
+		}
+		return input.trim() || def || "";
+	}
+	const readline = await import("node:readline");
+	return new Promise((resolve) => {
+		const rl = readline.createInterface({
+			input: process.stdin,
+			output: process.stdout,
+			terminal: true
+		});
+		if (opts?.masked) {
+			const write = rl._writeToOutput.bind(rl);
+			rl._writeToOutput = (str) => {
+				if (str.match(/^\x1b/)) return write(str);
+				if (str.endsWith("\n") || str.endsWith("\r")) return write(str);
+				write((opts.maskChar ?? "*").repeat(str.length));
+			};
+		}
+		rl.question(message, (answer) => {
+			rl.close();
+			resolve(answer || def || "");
+		});
+	});
+}
+/**
+* Reads a single key from stdin.
+* @returns The key that was read.
+*/
+async function readKey() {
+	return new Promise((resolve) => {
+		const stdin = process.stdin;
+		stdin.setRawMode(true);
+		stdin.resume();
+		stdin.once("data", (data) => {
+			const s = data.toString();
+			stdin.setRawMode(false);
+			stdin.pause();
+			if (s === "\r" || s === "\n") return resolve("enter");
+			if (s === " ") return resolve("space");
+			if (s === "\x1B[A") return resolve("up");
+			if (s === "\x1B[B") return resolve("down");
+			if (s === "\x1B[C") return resolve("right");
+			if (s === "\x1B[D") return resolve("left");
+			return resolve(s);
+		});
+	});
+}
+/**
+* Clears `lines` amount of lines.
+* @param lines Amount of lines to clear.
+*/
+function clearLines(lines = 1) {
+	for (let i = 0; i < lines; i++) process.stdout.write("\x1B[2K\x1B[1A");
+	process.stdout.write("\x1B[2K\r");
+}
+/**
+* Moves the cursor up `n` times.
+* @param n The amount of steps to move.
+*/
+function cursorUp(n = 1) {
+	process.stdout.write(`\x1b[${n}A`);
+}
+/**
+* Moves the cursor down `n` times.
+* @param n The amount of steps to move.
+*/
+function cursorDown(n = 1) {
+	process.stdout.write(`\x1b[${n}B`);
+}
+
+//#endregion
+export { readKey as a, raw_exports as i, cursorDown as n, readLine as o, cursorUp as r, clearLines as t };

package/dist/raw-BqvlveTU.d.mts

@@ -0,0 +1,37 @@
+declare namespace raw_d_exports {
+  export { clearLines, cursorDown, cursorUp, readKey, readLine };
+}
+/**
+ * Reads a line from standard input.
+ * @param message The message.
+ * @param def Default value.
+ * @param opts Options for reading a line.
+ * @returns The line that was read.
+ */
+declare function readLine(message?: string, def?: string, opts?: {
+  masked?: boolean;
+  maskChar?: string;
+  multiline?: boolean;
+}): Promise<string>;
+/**
+ * Reads a single key from stdin.
+ * @returns The key that was read.
+ */
+declare function readKey(): Promise<string>;
+/**
+ * Clears `lines` amount of lines.
+ * @param lines Amount of lines to clear.
+ */
+declare function clearLines(lines?: number): void;
+/**
+ * Moves the cursor up `n` times.
+ * @param n The amount of steps to move.
+ */
+declare function cursorUp(n?: number): void;
+/**
+ * Moves the cursor down `n` times.
+ * @param n The amount of steps to move.
+ */
+declare function cursorDown(n?: number): void;
+//#endregion
+export { readKey as a, raw_d_exports as i, cursorDown as n, readLine as o, cursorUp as r, clearLines as t };

package/dist/standard-schema-DBXbMy6L.mjs

@@ -0,0 +1,17 @@
+import { r as InputValidationError } from "./error-C1S1gs8L.mjs";
+
+//#region src/standard-schema.ts
+/**
+* Validates a value.
+* @param entry The Standard Schema validator.
+* @param value The value to validate.
+* @returns The validated value.
+*/
+async function validate(entry, value) {
+	const result = await entry["~standard"].validate(value);
+	if (result.issues) throw new InputValidationError(result.issues.map((i) => i.message));
+	return result.value;
+}
+
+//#endregion
+export { validate as t };

package/dist/standard-schema-DLeKaehR.d.mts

@@ -0,0 +1,58 @@
+//#region src/standard-schema.d.ts
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+//#endregion
+export { StandardSchemaV1 as t };

package/dist/utils-ChmY93uA.mjs

@@ -0,0 +1,45 @@
+//#region src/utils.ts
+/**
+* If the runtime is Node.js.
+*/
+const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+/**
+* If the runtime is Deno.
+*/
+const isDeno = typeof Deno !== "undefined" && typeof Deno.version?.deno === "string";
+/**
+* If the runtime is Bun.
+*/
+const isBun = typeof Bun !== "undefined" && typeof Bun.version === "string";
+/**
+* Checks if a value is a plain object.
+* @param value The value to check.
+* @returns If the value is a plain object.
+*/
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
+}
+/**
+* Merges two objects deeply.
+* @param source The source object.
+* @param target The target object.
+* @returns The merged objects.
+*/
+function merge(source, target) {
+	if (Array.isArray(source) && Array.isArray(target)) return target;
+	if (isPlainObject(source) && isPlainObject(target)) {
+		const result = {};
+		new Set([...Object.keys(source), ...Object.keys(target)]).forEach((key) => {
+			const sourceVal = source[key];
+			const targetVal = target[key];
+			if (sourceVal !== void 0 && targetVal !== void 0) result[key] = merge(sourceVal, targetVal);
+			else if (targetVal !== void 0) result[key] = targetVal;
+			else result[key] = sourceVal;
+		});
+		return result;
+	}
+	return target;
+}
+
+//#endregion
+export { merge as i, isDeno as n, isNode as r, isBun as t };

package/package.json

@@ -1,37 +1,41 @@
 {
   "name": "convoker",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "A simple, type safe CLI framework for TypeScript.",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/trailfrost/convoker"
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
     },
     "./command": {
-      "types": "./dist/command.d.ts",
-      "default": "./dist/command.js"
+      "types": "./dist/command.d.mts",
+      "import": "./dist/command.mjs"
     },
     "./input": {
-      "types": "./dist/types.d.ts",
-      "default": "./dist/input.js"
+      "types": "./dist/types.d.mts",
+      "import": "./dist/input.mjs"
     },
     "./color": {
-      "types": "./dist/color.d.ts",
-      "default": "./dist/color.js"
+      "types": "./dist/color.d.mts",
+      "import": "./dist/color.mjs"
     },
     "./prompt": {
-      "types": "./dist/prompt/index.d.ts",
-      "default": "./dist/prompt/index.js"
+      "types": "./dist/prompt/index.d.mts",
+      "import": "./dist/prompt/index.mjs"
     },
     "./prompt/raw": {
-      "types": "./dist/prompt/raw.d.ts",
-      "default": "./dist/prompt/raw.js"
+      "types": "./dist/prompt/raw.d.mts",
+      "import": "./dist/prompt/raw.mjs"
     },
     "./error": {
-      "types": "./dist/error.d.ts",
-      "default": "./dist/error.js"
+      "types": "./dist/error.d.mts",
+      "import": "./dist/error.mjs"
     }
   },
   "type": "module",
@@ -52,7 +56,7 @@
     "eslint": "^9.36.0",
     "globals": "^16.4.0",
     "prettier": "^3.6.2",
-    "tsc-alias": "^1.8.16",
+    "tsdown": "^0.16.0",
     "typescript": "^5.9.2",
     "typescript-eslint": "^8.45.0",
     "valibot": "^1.1.0",
@@ -60,7 +64,8 @@
   },
   "scripts": {
     "test": "vitest tests",
-    "build": "tsc -b tsconfig.app.json && tsc-alias -p tsconfig.app.json",
+    "build": "tsdown",
+    "check": "tsc -b tsconfig.app.json",
     "format": "prettier --check .",
     "format!": "prettier --write .",
     "lint": "eslint .",