@havocrao/picktui 0.1.0 → 0.1.1

package/dist/cjs/toml.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeTomlString = escapeTomlString;
+exports.quoteTomlString = quoteTomlString;
+exports.keyLiteral = keyLiteral;
+exports.parseToml = parseToml;
+/** 裸 key 允许的字符（对齐 TOML bare key；其余 key 编码时加引号）。 */
+const BARE_KEY_RE = /^[A-Za-z0-9_-]+$/;
+/** 转义字符串内容（写入值时用）。 */
+function escapeTomlString(s) {
+    let out = '';
+    for (const ch of s) {
+        switch (ch) {
+            case '\\':
+                out += '\\\\';
+                break;
+            case '"':
+                out += '\\"';
+                break;
+            case '\n':
+                out += '\\n';
+                break;
+            case '\t':
+                out += '\\t';
+                break;
+            case '\r':
+                out += '\\r';
+                break;
+            case '\b':
+                out += '\\b';
+                break;
+            case '\f':
+                out += '\\f';
+                break;
+            default:
+                out += ch;
+        }
+    }
+    return out;
+}
+/** 带引号的字符串字面量（含转义）。 */
+function quoteTomlString(s) {
+    return '"' + escapeTomlString(s) + '"';
+}
+/** 表头/键名编码：裸 key 直接输出，否则带引号。 */
+function keyLiteral(key) {
+    return BARE_KEY_RE.test(key) ? key : quoteTomlString(key);
+}
+/**
+ * 解析 TOML 子集。无法解析的行跳过（容错：状态文件损坏不阻断主流程）。
+ * 无任何可解析内容时返回 null。
+ */
+function parseToml(text) {
+    const doc = new Map();
+    let cur = null;
+    let sawContent = false;
+    for (const rawLine of text.split('\n')) {
+        const line = rawLine.trim();
+        if (line === '' || line.startsWith('#')) {
+            continue;
+        }
+        if (line.startsWith('[') && line.endsWith(']')) {
+            const name = parseQuotedOrBare(line.slice(1, -1).trim());
+            if (name === null) {
+                continue;
+            }
+            cur = new Map();
+            doc.set(name, cur);
+            sawContent = true;
+            continue;
+        }
+        if (cur === null) {
+            continue; // 表头之前的游离键：本包格式不存在，跳过
+        }
+        const eq = line.indexOf('=');
+        if (eq < 0) {
+            continue;
+        }
+        const keyRaw = line.slice(0, eq).trim();
+        const key = parseQuotedOrBare(keyRaw);
+        if (key === null) {
+            continue;
+        }
+        const valueRaw = line.slice(eq + 1).trim();
+        const value = parseTomlValue(valueRaw);
+        if (value === null) {
+            continue;
+        }
+        cur.set(key, value);
+        sawContent = true;
+    }
+    if (!sawContent) {
+        return null;
+    }
+    return doc;
+}
+/** 解析 `"quoted"` 或裸字符串；失败返回 null。 */
+function parseQuotedOrBare(s) {
+    if (s.startsWith('"')) {
+        return parseTomlString(s);
+    }
+    return s;
+}
+/** 解析一个 TOML 字符串字面量（从首个引号到闭合引号，含转义）。 */
+function parseTomlString(s) {
+    if (!s.startsWith('"')) {
+        return null;
+    }
+    let out = '';
+    let i = 1;
+    while (i < s.length) {
+        const ch = s[i];
+        if (ch === '"') {
+            return out;
+        }
+        if (ch === '\\') {
+            const esc = s[i + 1];
+            if (esc === undefined) {
+                return null;
+            }
+            switch (esc) {
+                case 'n':
+                    out += '\n';
+                    break;
+                case 't':
+                    out += '\t';
+                    break;
+                case 'r':
+                    out += '\r';
+                    break;
+                case 'b':
+                    out += '\b';
+                    break;
+                case 'f':
+                    out += '\f';
+                    break;
+                case '"':
+                    out += '"';
+                    break;
+                case '\\':
+                    out += '\\';
+                    break;
+                case 'u': {
+                    const hex = s.slice(i + 2, i + 6);
+                    if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+                        return null;
+                    }
+                    out += String.fromCodePoint(parseInt(hex, 16));
+                    i += 4;
+                    break;
+                }
+                default:
+                    return null; // 不识别的转义
+            }
+            i += 2;
+            continue;
+        }
+        // TOML 基本字符串不允许裸控制字符
+        if (ch < ' ' && ch !== '\t') {
+            return null;
+        }
+        out += ch;
+        i++;
+    }
+    return null; // 未闭合
+}
+/** 解析字符串或字符串数组字面量；失败返回 null。 */
+function parseTomlValue(raw) {
+    if (raw.startsWith('[')) {
+        if (!raw.endsWith(']')) {
+            return null;
+        }
+        const inner = raw.slice(1, -1).trim();
+        if (inner === '') {
+            return [];
+        }
+        const values = [];
+        let i = 0;
+        while (i < inner.length) {
+            const ch = inner[i];
+            if (ch === ',' || ch === ' ' || ch === '\t') {
+                i++;
+                continue;
+            }
+            if (ch === '"') {
+                const start = i;
+                let j = i + 1;
+                let escaped = false;
+                while (j < inner.length) {
+                    const c = inner[j];
+                    if (c === '"' && !escaped) {
+                        break;
+                    }
+                    if (c === '\\' && !escaped) {
+                        escaped = true;
+                    }
+                    else {
+                        escaped = false;
+                    }
+                    j++;
+                }
+                if (j >= inner.length) {
+                    return null;
+                }
+                const literal = parseTomlString(inner.slice(start, j + 1));
+                if (literal === null) {
+                    return null;
+                }
+                values.push(literal);
+                i = j + 1;
+            }
+            else {
+                return null; // 仅支持字符串数组
+            }
+        }
+        return values;
+    }
+    if (raw.startsWith('"')) {
+        return parseTomlString(raw);
+    }
+    return null; // 布尔/数字等非本包类型
+}

package/dist/cjs/tty.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyReader = void 0;
+exports.openTty = openTty;
+exports.enterInteractive = enterInteractive;
+exports.exitInteractive = exitInteractive;
+exports.renderFrame = renderFrame;
+exports.promptConfirm = promptConfirm;
+/**
+ * tty — 终端抽象（纯 Node 标准库，无第三方依赖）。
+ *
+ * 协议约定：交互 TUI 独立于宿主 stdout——posix 上打开 /dev/tty 渲染与输入，
+ * 宿主 stdout 只承载选中值（$(...) 安全）。无 /dev/tty 时（如 Windows）退化为
+ * 宿主自身的 stdio（isTTY 时才可用）；两者皆不可用时返回 null，由调用方走
+ * 非交互退化路径（与引擎行为一致）。
+ *
+ * 按键输入：raw mode + ANSI 转义序列解析（方向键/回车/tab/ctrl 组合/UTF-8 字符）。
+ */
+const node_fs_1 = require("node:fs");
+const node_string_decoder_1 = require("node:string_decoder");
+const node_tty_1 = require("node:tty");
+/** 尝试打开交互终端；不可用返回 null（调用方退化为非交互）。 */
+function openTty() {
+    // POSIX：/dev/tty 独立于宿主 stdout/stderr
+    try {
+        const fd = (0, node_fs_1.openSync)('/dev/tty', 'r+');
+        const read = new node_tty_1.ReadStream(fd);
+        const write = new node_tty_1.WriteStream(fd);
+        return {
+            read,
+            write,
+            columns: write.columns > 0 ? write.columns : 80,
+            rows: write.rows > 0 ? write.rows : 24,
+        };
+    }
+    catch {
+        // Windows 等无 /dev/tty：使用宿主 stdio（仅当确为交互终端）
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+            return {
+                read: process.stdin,
+                write: process.stdout,
+                columns: process.stdout.columns > 0 ? process.stdout.columns : 80,
+                rows: process.stdout.rows > 0 ? process.stdout.rows : 24,
+            };
+        }
+        return null;
+    }
+}
+/** 进入交互模式：备用屏幕 + 隐藏光标 + raw input。 */
+function enterInteractive(tty) {
+    tty.read.setRawMode(true);
+    tty.write.write('\x1b[?1049h\x1b[?25l\x1b[2J\x1b[H');
+}
+/** 退出交互模式：恢复原始终端状态。 */
+function exitInteractive(tty) {
+    tty.write.write('\x1b[?25h\x1b[?1049l');
+    tty.read.setRawMode(false);
+}
+/** 全量重绘一帧画面。 */
+function renderFrame(tty, frame) {
+    tty.write.write('\x1b[2J\x1b[H' + frame);
+}
+/** 单行确认询问（auto 首次确认）：canonical 输入整行 y/N，超时默认拒绝。 */
+function promptConfirm(tty, text, timeoutMs = 30000) {
+    tty.write.write(text);
+    return new Promise((resolve) => {
+        let buf = '';
+        const timer = setTimeout(() => {
+            cleanup();
+            tty.write.write('\r\n');
+            resolve(null);
+        }, timeoutMs);
+        const onData = (chunk) => {
+            const s = chunk.toString('utf8');
+            for (const ch of s) {
+                if (ch === '\r' || ch === '\n') {
+                    cleanup();
+                    tty.write.write('\r\n');
+                    resolve(buf);
+                    return;
+                }
+                buf += ch;
+            }
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            tty.read.removeListener('data', onData);
+        };
+        tty.read.on('data', onData);
+    });
+}
+/**
+ * KeyReader — raw 输入流 → 按键序列解析。
+ *
+ * 支持：ASCII 字符、UTF-8 多字节字符、回车/退格/控制键、CSI 序列
+ * （\x1b[A 上、\x1b[B 下、\x1b[C 右、\x1b[D 左）。
+ */
+class KeyReader {
+    decoder = new node_string_decoder_1.StringDecoder('utf8');
+    buf = '';
+    waiters = [];
+    closed = false;
+    constructor(readStream) {
+        readStream.on('data', (chunk) => {
+            this.buf += this.decoder.write(chunk);
+            this.pump();
+        });
+        readStream.on('end', () => this.pumpEnd());
+        readStream.on('error', () => this.pumpEnd());
+    }
+    /** 取下一个按键；流关闭返回 null。 */
+    next() {
+        if (this.buf !== '') {
+            const k = consumeKey(this.buf);
+            if (k !== null) {
+                this.buf = this.buf.slice(k.len);
+                return Promise.resolve(k.key);
+            }
+        }
+        if (this.closed) {
+            return Promise.resolve(null);
+        }
+        return new Promise((resolve) => this.waiters.push(resolve));
+    }
+    pumpEnd() {
+        this.closed = true;
+        while (this.waiters.length > 0) {
+            this.waiters.shift()(null);
+        }
+    }
+    pump() {
+        while (this.waiters.length > 0 && this.buf !== '') {
+            const k = consumeKey(this.buf);
+            if (k === null) {
+                return; // 等待更多字节
+            }
+            this.buf = this.buf.slice(k.len);
+            this.waiters.shift()(k.key);
+        }
+    }
+}
+exports.KeyReader = KeyReader;
+/** 从输入缓冲开头消费一个按键；字节不足返回 null（等待更多输入）。 */
+function consumeKey(buf) {
+    if (buf === '') {
+        return null;
+    }
+    const c = buf[0];
+    // 控制字符
+    switch (c) {
+        case '\r':
+            return { key: 'enter', len: 1 };
+        case '\t':
+            return { key: 'tab', len: 1 };
+        case '\x7f':
+        case '\x08':
+            return { key: 'backspace', len: 1 };
+        case '\x03':
+            return { key: 'ctrl+c', len: 1 };
+        case '\x10':
+            return { key: 'ctrl+p', len: 1 };
+        case '\x0e':
+            return { key: 'ctrl+n', len: 1 };
+        case '\x15':
+            return { key: 'ctrl+u', len: 1 };
+        case '\x17':
+            return { key: 'ctrl+w', len: 1 };
+        case ' ':
+            return { key: 'space', len: 1 };
+    }
+    // CSI 序列：\x1b[A / \x1b[B / \x1b[C / \x1b[D
+    if (c === '\x1b') {
+        if (buf.length === 1) {
+            return null; // 等待后续字节确认是否为序列开头
+        }
+        const d = buf[1];
+        if (d === '[') {
+            if (buf.length < 3) {
+                return null;
+            }
+            switch (buf[2]) {
+                case 'A':
+                    return { key: 'up', len: 3 };
+                case 'B':
+                    return { key: 'down', len: 3 };
+                case 'C':
+                case 'D':
+                    return { key: { type: 'char', value: '' }, len: 3 }; // 左右键忽略
+                default:
+                    return { key: 'esc', len: 3 };
+            }
+        }
+        return { key: 'esc', len: 1 };
+    }
+    // 可打印字符：单字节 ASCII 或 UTF-8 多字节
+    if (c.charCodeAt(0) < 0x20) {
+        return { key: { type: 'char', value: c }, len: 1 }; // 其余控制键忽略
+    }
+    const seqLen = utf8SeqLen(buf);
+    if (seqLen > buf.length) {
+        return null; // 多字节字符尚未收全
+    }
+    return { key: { type: 'char', value: buf.slice(0, seqLen) }, len: seqLen };
+}
+/** 计算 buf 起始 UTF-8 字符的字节长度（按首字节高 2 位判断）。 */
+function utf8SeqLen(buf) {
+    const b = buf.charCodeAt(0);
+    if (b < 0x80) {
+        return 1;
+    }
+    if ((b & 0xe0) === 0xc0) {
+        return 2;
+    }
+    if ((b & 0xf0) === 0xe0) {
+        return 3;
+    }
+    if ((b & 0xf8) === 0xf0) {
+        return 4;
+    }
+    return 1;
+}