convoker 0.3.2 → 0.3.4

package/dist/prompt/raw.js

@@ -1,105 +0,0 @@
-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

@@ -1,62 +0,0 @@
-/** 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

@@ -1,16 +0,0 @@
-// * 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

@@ -1,30 +0,0 @@
-/**
- * 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

@@ -1,56 +0,0 @@
-/**
- * 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;
-}