convoker 0.3.0 → 0.3.2

package/dist/prompt/index.js

@@ -0,0 +1,273 @@
+import { DEFAULT_THEME } from "../color";
+import { validate } from "../standard-schema";
+import { InputValidationError } from "../error";
+import { isDeno, isNode, isBun } from "../utils";
+import * as raw from "./raw";
+let theme = DEFAULT_THEME;
+/**
+ * Sets the theme of the prompts.
+ * @param t The new theme.
+ */
+export 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.
+ */
+export async function text(opts) {
+    const th = opts.theme ?? theme;
+    const message = th.primary(opts.message) + " ";
+    const answer = await raw.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.
+ */
+export async function password(opts) {
+    const th = opts.theme ?? theme;
+    const first = await raw.readLine(th.primary(opts.message) + " ", undefined, {
+        masked: true,
+        maskChar: opts.mask ?? "*",
+    });
+    if (opts.confirm) {
+        const second = await raw.readLine(th.secondary("Confirm password: "), undefined, {
+            masked: true,
+            maskChar: opts.mask ?? "*",
+        });
+        if (first !== second)
+            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.
+ */
+export async function select(opts) {
+    const th = opts.theme ?? theme;
+    const options = opts.options;
+    let index = opts.initialIndex ?? 0;
+    const render = () => {
+        raw.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 raw.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;
+            raw.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.
+ */
+export async function multiselect(opts) {
+    const th = opts.theme ?? theme;
+    const options = opts.options;
+    let index = opts.initialIndex ?? 0;
+    const selected = new Set();
+    const render = () => {
+        raw.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 raw.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);
+            raw.clearLines(options.length + 1);
+            console.log(th.success(`${opts.message} ${chosen.length} selected`));
+            return chosen;
+        }
+        raw.cursorUp(options.length);
+        render();
+    }
+}
+/**
+ * Prompts the user to search through a list of options.
+ * @param opts Options for search input.
+ * @returns The selected option.
+ */
+export 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) {
+        raw.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 raw.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.
+ */
+export 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 raw.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.
+ */
+export 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 {
+        // fallback: cross-runtime multiline input
+        const value = await raw.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 tmpDir = Deno.env.get("TMPDIR") ?? "/tmp";
+        const path = `${tmpDir}/${tmpFile}`;
+        await Deno.writeTextFile(path, initial ?? "");
+        const editor = Deno.env.get("EDITOR") ?? "vi";
+        const p = new Deno.Command(editor, {
+            args: [path],
+            stdin: "inherit",
+            stdout: "inherit",
+            stderr: "inherit",
+        }).spawn();
+        const status = await p.status;
+        if (!status.success)
+            throw new Error(`${editor} exited with ${status.code}`);
+        const text = await Deno.readTextFile(path);
+        await Deno.remove(path).catch(() => { });
+        return text;
+    }
+    if (isBun) {
+        const { $ } = await import("bun");
+        const path = `/tmp/${tmpFile}`;
+        await Bun.write(path, initial ?? "");
+        const editor = process.env.EDITOR ?? "vi";
+        await $ `${editor} ${path}`;
+        const text = await Bun.file(path).text();
+        await Bun.write(path, ""); // or remove if supported
+        return text;
+    }
+    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 = process.env.EDITOR ||
+            process.env.VISUAL ||
+            (process.platform === "win32" ? "notepad" : "vi");
+        return new Promise((resolve, reject) => {
+            const child = spawn(editor, [path], { stdio: "inherit" });
+            child.on("exit", async (code) => {
+                if (code !== 0) {
+                    reject(new Error(`${editor} 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.");
+}
+export { raw };

package/dist/prompt/raw.js

@@ -1,9 +1,105 @@
-import "../chunks/utils-DdmSEjLc.js";
-import { c as s, e as o, b as c, a as i, r as n } from "../chunks/__vite-browser-external-DQYBmsno.js";
-export {
-  s as clearLines,
-  o as cursorDown,
-  c as cursorUp,
-  i as readKey,
-  n as readLine
-};
+import { isDeno } from "../utils";
+/**
+ * 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.
+ */
+export async function readLine(message = "", def, opts) {
+    // Deno
+    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 || "";
+    }
+    // Node / Bun
+    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);
+                const mask = opts.maskChar ?? "*";
+                write(mask.repeat(str.length));
+            };
+        }
+        rl.question(message, (answer) => {
+            rl.close();
+            resolve(answer || def || "");
+        });
+    });
+}
+/**
+ * Reads a single key from stdin.
+ * @returns The key that was read.
+ */
+export 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 === "\u001b[A")
+                return resolve("up");
+            if (s === "\u001b[B")
+                return resolve("down");
+            if (s === "\u001b[C")
+                return resolve("right");
+            if (s === "\u001b[D")
+                return resolve("left");
+            return resolve(s);
+        });
+    });
+}
+/**
+ * Clears `lines` amount of lines.
+ * @param lines Amount of lines to clear.
+ */
+export 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.
+ */
+export function cursorUp(n = 1) {
+    process.stdout.write(`\x1b[${n}A`);
+}
+/**
+ * Moves the cursor down `n` times.
+ * @param n The amount of steps to move.
+ */
+export function cursorDown(n = 1) {
+    process.stdout.write(`\x1b[${n}B`);
+}

package/dist/standard-schema.d.ts

@@ -0,0 +1,62 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export 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"];
+}
+/**
+ * Validates a value.
+ * @param entry The Standard Schema validator.
+ * @param value The value to validate.
+ * @returns The validated value.
+ */
+export declare function validate<T extends StandardSchemaV1<any, any>>(entry: T, value: any): Promise<T extends StandardSchemaV1<any, infer Out> ? Out : never>;

package/dist/standard-schema.js

@@ -0,0 +1,16 @@
+// * https://standardschema.dev * //
+import { InputValidationError } from "./error";
+/**
+ * Validates a value.
+ * @param entry The Standard Schema validator.
+ * @param value The value to validate.
+ * @returns The validated value.
+ */
+export async function validate(entry, value) {
+    const result = await entry["~standard"].validate(value);
+    if (result.issues) {
+        const msgs = result.issues.map((i) => i.message);
+        throw new InputValidationError(msgs);
+    }
+    return result.value;
+}

package/dist/utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * If the runtime is Node.js.
+ */
+export declare const isNode: boolean;
+/**
+ * If the runtime is Deno.
+ */
+export declare const isDeno: boolean;
+/**
+ * If the runtime is Bun.
+ */
+export declare const isBun: boolean;
+/**
+ * All TypeScript primitive types.
+ */
+type Primitive = string | number | boolean | symbol | null | undefined | bigint;
+/**
+ * Merges two objects deeply.
+ */
+export type DeepMerge<T, U> = T extends Primitive ? U : U extends Primitive ? U : T extends Array<infer TItem> ? U extends Array<infer UItem> ? Array<DeepMerge<TItem, UItem>> : U : T extends object ? U extends object ? {
+    [K in keyof T | keyof U]: K extends keyof U ? K extends keyof T ? DeepMerge<T[K], U[K]> : U[K] : K extends keyof T ? T[K] : never;
+} : U : U;
+/**
+ * Merges two objects deeply.
+ * @param source The source object.
+ * @param target The target object.
+ * @returns The merged objects.
+ */
+export declare function merge<T, U>(source: T, target: U): DeepMerge<T, U>;
+export {};

package/dist/utils.js

@@ -0,0 +1,56 @@
+/**
+ * If the runtime is Node.js.
+ */
+export const isNode = typeof process !== "undefined" &&
+    process.versions != null &&
+    process.versions.node != null;
+/**
+ * If the runtime is Deno.
+ */
+export const isDeno = typeof Deno !== "undefined" && typeof Deno.version?.deno === "string";
+/**
+ * If the runtime is Bun.
+ */
+export 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.
+ */
+export function merge(source, target) {
+    if (Array.isArray(source) && Array.isArray(target)) {
+        // Replace arrays
+        return target;
+    }
+    if (isPlainObject(source) && isPlainObject(target)) {
+        const result = {};
+        const keys = new Set([...Object.keys(source), ...Object.keys(target)]);
+        keys.forEach((key) => {
+            const sourceVal = source[key];
+            const targetVal = target[key];
+            if (sourceVal !== undefined && targetVal !== undefined) {
+                result[key] = merge(sourceVal, targetVal);
+            }
+            else if (targetVal !== undefined) {
+                result[key] = targetVal;
+            }
+            else {
+                result[key] = sourceVal;
+            }
+        });
+        return result;
+    }
+    // For class instances or primitives, always use target
+    return target;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "convoker",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "A simple, type safe CLI framework for TypeScript.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -22,7 +22,7 @@
       "default": "./dist/color.js"
     },
     "./prompt": {
-      "types": "./dist/prompt.js",
+      "types": "./dist/prompt/index.d.ts",
       "default": "./dist/prompt/index.js"
     },
     "./prompt/raw": {
@@ -52,16 +52,15 @@
     "eslint": "^9.36.0",
     "globals": "^16.4.0",
     "prettier": "^3.6.2",
+    "tsc-alias": "^1.8.16",
     "typescript": "^5.9.2",
     "typescript-eslint": "^8.45.0",
     "valibot": "^1.1.0",
-    "vite": "^7.1.12",
-    "vite-plugin-dts": "^4.5.4",
     "vitest": "^3.2.4"
   },
   "scripts": {
     "test": "vitest tests",
-    "build": "tsc -b && vite build",
+    "build": "tsc -b tsconfig.app.json && tsc-alias -p tsconfig.app.json",
     "format": "prettier --check .",
     "format!": "prettier --write .",
     "lint": "eslint .",

package/dist/chunks/__vite-browser-external-DQYBmsno.js

@@ -1,80 +0,0 @@
-import { i as c } from "./utils-DdmSEjLc.js";
-async function d(e = "", t, u) {
-  if (c) {
-    await Deno.stdout.write(new TextEncoder().encode(e));
-    const a = new TextDecoder(), i = new Uint8Array(1024);
-    let n = "";
-    for (; ; ) {
-      const o = await Deno.stdin.read(i);
-      if (!o) break;
-      const s = a.decode(i.subarray(0, o));
-      if (s.includes(`
-`)) {
-        n += s.split(`
-`)[0];
-        break;
-      }
-      n += s;
-    }
-    return n.trim() || t || "";
-  }
-  const r = await Promise.resolve().then(() => x);
-  return new Promise((a) => {
-    const i = r.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      terminal: !0
-    });
-    if (u?.masked) {
-      const n = i._writeToOutput.bind(i);
-      i._writeToOutput = (o) => {
-        if (o.match(/^\x1b/) || o.endsWith(`
-`) || o.endsWith("\r")) return n(o);
-        const s = u.maskChar ?? "*";
-        n(s.repeat(o.length));
-      };
-    }
-    i.question(e, (n) => {
-      i.close(), a(n || t || "");
-    });
-  });
-}
-async function f() {
-  return new Promise((e) => {
-    const t = process.stdin;
-    t.setRawMode(!0), t.resume(), t.once("data", (u) => {
-      const r = u.toString();
-      return t.setRawMode(!1), t.pause(), e(r === "\r" || r === `
-` ? "enter" : r === " " ? "space" : r === "\x1B[A" ? "up" : r === "\x1B[B" ? "down" : r === "\x1B[C" ? "right" : r === "\x1B[D" ? "left" : r);
-    });
-  });
-}
-function p(e = 1) {
-  for (let t = 0; t < e; t++) process.stdout.write("\x1B[2K\x1B[1A");
-  process.stdout.write("\x1B[2K\r");
-}
-function w(e = 1) {
-  process.stdout.write(`\x1B[${e}A`);
-}
-function l(e = 1) {
-  process.stdout.write(`\x1B[${e}B`);
-}
-const m = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  clearLines: p,
-  cursorDown: l,
-  cursorUp: w,
-  readKey: f,
-  readLine: d
-}, Symbol.toStringTag, { value: "Module" })), x = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null
-}, Symbol.toStringTag, { value: "Module" }));
-export {
-  x as _,
-  f as a,
-  w as b,
-  p as c,
-  m as d,
-  l as e,
-  d as r
-};