toolcraft 0.0.38 → 0.0.40

package/node_modules/toolcraft-design/dist/prompts/interactive/select.d.ts

@@ -0,0 +1,18 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface SelectOption<Value> {
+    value: Value;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+}
+export interface SelectOptions<Value> {
+    message: string;
+    options: Array<SelectOption<Value>>;
+    initialValue?: Value;
+    maxItems?: number;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function findNonDisabled<Value>(start: number, direction: 1 | -1, options: Array<SelectOption<Value>>): number;
+export declare function selectPrompt<Value>(opts: SelectOptions<Value>): Promise<Value | typeof CANCEL>;

package/node_modules/toolcraft-design/dist/prompts/interactive/select.js

@@ -0,0 +1,89 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol } from "./glyphs.js";
+import { Prompt } from "./core.js";
+import { limitOptions } from "./pagination.js";
+class SelectPrompt extends Prompt {
+    options;
+    constructor(opts) {
+        if (opts.options.length === 0) {
+            throw new Error("Select prompt requires at least one option.");
+        }
+        if (opts.options.every((option) => option.disabled)) {
+            throw new Error("Select prompt requires at least one enabled option.");
+        }
+        const initialIndex = Math.max(opts.options.findIndex((option) => option.value === opts.initialValue), 0);
+        const cursor = findNonDisabled(initialIndex, 1, opts.options);
+        super({
+            ...opts,
+            initialValue: opts.options[cursor]?.value,
+            render: (prompt) => renderSelectPrompt(prompt, opts)
+        }, false);
+        this.options = opts.options;
+        this._cursor = cursor;
+        this.setValue(this.options[this._cursor]?.value);
+        this.on("cursor", (action) => {
+            if (action === "up" || action === "left") {
+                this._cursor = findNonDisabled(this._cursor - 1, -1, this.options);
+            }
+            else if (action === "down" || action === "right") {
+                this._cursor = findNonDisabled(this._cursor + 1, 1, this.options);
+            }
+            this.setValue(this.options[this._cursor]?.value);
+        });
+    }
+    get visibleOptions() {
+        return this.options;
+    }
+    promptNonTty() {
+        if (process.env.POE_NO_PROMPT === "1") {
+            return Promise.resolve(this.value);
+        }
+        return super.promptNonTty();
+    }
+}
+export function findNonDisabled(start, direction, options) {
+    if (options.every((option) => option.disabled)) {
+        return start;
+    }
+    let index = start;
+    for (let checked = 0; checked < options.length; checked += 1) {
+        index = (index + options.length) % options.length;
+        if (!options[index]?.disabled) {
+            return index;
+        }
+        index += direction;
+    }
+    return start;
+}
+function renderOption(option, active, submitted, cancelled) {
+    const hint = option.hint ? color.dim(` (${option.hint})`) : "";
+    if (submitted)
+        return color.dim(option.label);
+    if (cancelled)
+        return color.dim.strikethrough(option.label);
+    if (option.disabled)
+        return `${color.gray(GLYPHS.radioInactive)} ${color.gray.strikethrough(option.label)}${hint}`;
+    if (active)
+        return `${color.green(GLYPHS.radioActive)} ${option.label}${hint}`;
+    return `${color.dim(GLYPHS.radioInactive)} ${color.dim(option.label)}${hint}`;
+}
+function renderSelectPrompt(prompt, opts) {
+    if (prompt.state === "submit" || prompt.state === "cancel") {
+        const option = prompt.visibleOptions[prompt.cursor];
+        const rendered = option ? renderOption(option, false, prompt.state === "submit", prompt.state === "cancel") : "";
+        const end = prompt.state === "submit" ? color.green(GLYPHS.barEnd) : color.red(GLYPHS.barEnd);
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${rendered}\n${end}`;
+    }
+    const lines = limitOptions({
+        cursor: prompt.cursor,
+        options: prompt.visibleOptions,
+        output: opts.output ?? process.stdout,
+        maxItems: opts.maxItems,
+        columnPadding: 3,
+        style: (option, active) => renderOption(option, active, false, false)
+    }).map((line) => `${color.cyan(GLYPHS.bar)}  ${line}`);
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${lines.join("\n")}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function selectPrompt(opts) {
+    return new SelectPrompt(opts).prompt();
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/test-helpers.d.ts

@@ -0,0 +1,21 @@
+import { PassThrough, Writable } from "node:stream";
+export interface PromptHarness {
+    input: PassThrough & {
+        isTTY?: boolean;
+        setRawMode?: (enabled: boolean) => void;
+    };
+    output: Writable & {
+        columns?: number;
+        rows?: number;
+        isTTY?: boolean;
+        frames: string[];
+    };
+    rawModes: boolean[];
+    getOutput: () => string;
+}
+export declare function createPromptHarness(options?: {
+    tty?: boolean;
+    columns?: number;
+    rows?: number;
+}): PromptHarness;
+export declare function tick(): Promise<void>;

package/node_modules/toolcraft-design/dist/prompts/interactive/test-helpers.js

@@ -0,0 +1,32 @@
+import { PassThrough, Writable } from "node:stream";
+export function createPromptHarness(options = {}) {
+    const chunks = [];
+    const frames = [];
+    const rawModes = [];
+    const input = new PassThrough();
+    const output = new Writable({
+        write(chunk, _encoding, callback) {
+            const value = String(chunk);
+            chunks.push(value);
+            frames.push(value);
+            callback();
+        }
+    });
+    input.isTTY = options.tty ?? true;
+    input.setRawMode = (enabled) => {
+        rawModes.push(enabled);
+    };
+    output.isTTY = options.tty ?? true;
+    output.columns = options.columns ?? 80;
+    output.rows = options.rows ?? 20;
+    output.frames = frames;
+    return {
+        input,
+        output,
+        rawModes,
+        getOutput: () => chunks.join("")
+    };
+}
+export async function tick() {
+    await new Promise((resolve) => setImmediate(resolve));
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/text.d.ts

@@ -0,0 +1,12 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface TextOptions {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function textPrompt(opts: TextOptions): Promise<string | typeof CANCEL>;

package/node_modules/toolcraft-design/dist/prompts/interactive/text.js

@@ -0,0 +1,60 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol, symbolBar } from "./glyphs.js";
+import { Prompt } from "./core.js";
+class TextPrompt extends Prompt {
+    constructor(opts) {
+        const initialUserInput = opts.initialValue ?? "";
+        super({
+            ...opts,
+            initialValue: initialUserInput,
+            initialUserInput,
+            render: (prompt) => renderTextPrompt(prompt, opts),
+            validate: opts.validate
+        });
+        this.on("userInput", (value) => this.setValue(value));
+        this.on("finalize", () => {
+            if (this.state === "submit") {
+                this.setValue(this.value || opts.defaultValue || "");
+            }
+        });
+    }
+    get userInputWithCursor() {
+        if (this.state === "submit") {
+            return this.userInput;
+        }
+        const before = this.userInput.slice(0, this.cursor);
+        const current = this.userInput[this.cursor];
+        const after = this.userInput.slice(this.cursor + 1);
+        if (current) {
+            return `${before}${color.inverse(current)}${after}`;
+        }
+        return `${before}${color.inverse("█")}`;
+    }
+    promptNonTty() {
+        return this.readNonTtyLine();
+    }
+}
+function renderHeader(prompt, message) {
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${message}`;
+}
+function renderTextPrompt(prompt, opts) {
+    const value = prompt.value ?? "";
+    if (prompt.state === "submit") {
+        return `${renderHeader(prompt, opts.message)}\n${color.gray(GLYPHS.bar)}  ${color.dim(value)}\n${color.green(GLYPHS.barEnd)}`;
+    }
+    if (prompt.state === "cancel") {
+        return `${renderHeader(prompt, opts.message)}\n${color.gray(GLYPHS.bar)}  ${color.dim.strikethrough(value)}\n${color.red(GLYPHS.barEnd)}`;
+    }
+    const input = prompt.userInput.length > 0
+        ? prompt.userInputWithCursor
+        : opts.placeholder
+            ? `${color.inverse(opts.placeholder[0] ?? " ")}${color.dim(opts.placeholder.slice(1))}`
+            : color.inverse("_");
+    if (prompt.state === "error") {
+        return `${renderHeader(prompt, opts.message)}\n${symbolBar(prompt.state)}  ${input}\n${color.yellow(GLYPHS.barEnd)}  ${color.yellow(prompt.error)}`;
+    }
+    return `${renderHeader(prompt, opts.message)}\n${symbolBar(prompt.state)}  ${input}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function textPrompt(opts) {
+    return new TextPrompt(opts).prompt();
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/wrap.d.ts

@@ -0,0 +1,4 @@
+export declare function getColumns(output: NodeJS.WritableStream): number;
+export declare function getRows(output: NodeJS.WritableStream): number;
+export declare function wrapTextWithPrefix(output: NodeJS.WritableStream, text: string, prefix: string, startPrefix?: string): string;
+export declare function wrapFrame(output: NodeJS.WritableStream, frame: string): string;

package/node_modules/toolcraft-design/dist/prompts/interactive/wrap.js

@@ -0,0 +1,18 @@
+import { wrapAnsi } from "fast-wrap-ansi";
+import stringWidth from "fast-string-width";
+export function getColumns(output) {
+    return Math.max(1, output.columns ?? 80);
+}
+export function getRows(output) {
+    return Math.max(1, output.rows ?? 20);
+}
+export function wrapTextWithPrefix(output, text, prefix, startPrefix = prefix) {
+    const width = Math.max(1, getColumns(output) - stringWidth(prefix));
+    return wrapAnsi(text, width, { hard: true, trim: false })
+        .split("\n")
+        .map((line, index) => `${index === 0 ? startPrefix : prefix}${line}`)
+        .join("\n");
+}
+export function wrapFrame(output, frame) {
+    return wrapAnsi(frame, getColumns(output), { hard: true, trim: false });
+}

package/node_modules/toolcraft-design/dist/prompts/primitives/cancel.d.ts

@@ -1,2 +1,2 @@
-export { isCancel } from "@clack/prompts";
+export { isCancel } from "../interactive/cancel-symbol.js";
 export declare function cancel(msg?: string): void;

package/node_modules/toolcraft-design/dist/prompts/primitives/cancel.js

@@ -1,5 +1,5 @@
 import { color } from "../../components/color.js";
-export { isCancel } from "@clack/prompts";
+export { isCancel } from "../interactive/cancel-symbol.js";
 import { resolveOutputFormat } from "../../internal/output-format.js";
 export function cancel(msg = "") {
     if (resolveOutputFormat() !== "terminal") {