terminal-pilot 0.0.30 → 0.0.31

package/node_modules/toolcraft-design/dist/dashboard/ansi.js

@@ -0,0 +1,343 @@
+const ESC = "\u001b";
+export function hasAnsi(text) {
+    return text.includes(ESC);
+}
+/**
+ * Parse a block of text that may contain ANSI SGR escape codes into a sequence of
+ * logical lines split on "\n". Each line is a list of styled segments: contiguous
+ * printable runs of characters sharing the same style.
+ *
+ * Common cursor-affecting line controls are rendered into their visible result.
+ * `baseStyle` is used as the initial style and as the restore target for SGR reset / default color.
+ */
+export function parseAnsi(text, baseStyle) {
+    const base = normalizeStyle(baseStyle);
+    let style = { ...base };
+    let concealed = false;
+    const lines = [];
+    let cells = [];
+    let column = 0;
+    const finishLine = () => {
+        lines.push({ segments: cellsToSegments(cells) });
+        cells = [];
+        column = 0;
+    };
+    let index = 0;
+    while (index < text.length) {
+        const ch = text[index];
+        if (ch === ESC && text[index + 1] === "[") {
+            const paramsStart = index + 2;
+            let cursor = paramsStart;
+            while (cursor < text.length && !isCsiFinalByte(text[cursor])) {
+                cursor += 1;
+            }
+            if (cursor >= text.length) {
+                index = text.length;
+                break;
+            }
+            const params = text.slice(paramsStart, cursor);
+            const finalByte = text[cursor];
+            if (finalByte === "m") {
+                const sgr = applySgr(style, concealed, parseParams(params), base);
+                style = sgr.style;
+                concealed = sgr.concealed;
+            }
+            else if (finalByte === "K" && parseParams(params)[0] === 2) {
+                cells = [];
+            }
+            index = cursor + 1;
+            continue;
+        }
+        if (ch === ESC) {
+            const next = text[index + 1];
+            if (next === "]" || next === "P" || next === "X" || next === "^" || next === "_") {
+                index = skipStringTerminated(text, index + 2);
+                continue;
+            }
+            index += 2;
+            continue;
+        }
+        if (ch === "\r") {
+            column = 0;
+            index += 1;
+            continue;
+        }
+        if (ch === "\n") {
+            finishLine();
+            index += 1;
+            continue;
+        }
+        if (ch === "\b") {
+            column = Math.max(0, column - 1);
+            index += 1;
+            continue;
+        }
+        const code = ch.charCodeAt(0);
+        if (code < 0x20 && ch !== "\t") {
+            index += 1;
+            continue;
+        }
+        cells[column] = { ch: concealed ? " " : ch, style: { ...style } };
+        column += 1;
+        index += 1;
+    }
+    finishLine();
+    return lines;
+}
+function cellsToSegments(cells) {
+    const segments = [];
+    for (const cell of cells) {
+        const nextCell = cell ?? { ch: " ", style: {} };
+        const last = segments[segments.length - 1];
+        if (last && stylesEqual(last.style, nextCell.style)) {
+            last.text += nextCell.ch;
+        }
+        else {
+            segments.push({ text: nextCell.ch, style: { ...nextCell.style } });
+        }
+    }
+    return segments;
+}
+function isCsiFinalByte(ch) {
+    const code = ch.charCodeAt(0);
+    return code >= 0x40 && code <= 0x7e;
+}
+function skipStringTerminated(text, start) {
+    let index = start;
+    while (index < text.length) {
+        const ch = text[index];
+        if (ch === "\u0007") {
+            return index + 1;
+        }
+        if (ch === ESC && text[index + 1] === "\\") {
+            return index + 2;
+        }
+        index += 1;
+    }
+    return index;
+}
+function parseParams(params) {
+    if (params.length === 0) {
+        return [0];
+    }
+    return params.split(";").flatMap((part) => {
+        const colonParams = part.split(":");
+        if (colonParams.length > 2 && colonParams[1] === "2") {
+            colonParams.splice(2, 1);
+        }
+        return colonParams.map(parseParam);
+    });
+}
+function parseParam(part) {
+    if (part.length === 0) {
+        return 0;
+    }
+    const parsed = Number.parseInt(part, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+const BASIC_COLORS = [
+    "black",
+    "red",
+    "green",
+    "yellow",
+    "blue",
+    "magenta",
+    "cyan",
+    "white"
+];
+const BRIGHT_COLORS = [
+    "gray",
+    "redBright",
+    "greenBright",
+    "yellowBright",
+    "blueBright",
+    "magentaBright",
+    "cyanBright",
+    "whiteBright"
+];
+function applySgr(style, concealed, params, base) {
+    let next = { ...style };
+    let nextConcealed = concealed;
+    let index = 0;
+    while (index < params.length) {
+        const code = params[index];
+        if (code === 0) {
+            next = { ...base };
+            nextConcealed = false;
+            index += 1;
+            continue;
+        }
+        if (code === 1) {
+            next.bold = true;
+            index += 1;
+            continue;
+        }
+        if (code === 2) {
+            next.dim = true;
+            index += 1;
+            continue;
+        }
+        if (code === 7) {
+            next.inverse = true;
+            index += 1;
+            continue;
+        }
+        if (code === 22) {
+            delete next.bold;
+            delete next.dim;
+            index += 1;
+            continue;
+        }
+        if (code === 8) {
+            nextConcealed = true;
+            index += 1;
+            continue;
+        }
+        if (code === 28) {
+            nextConcealed = false;
+            index += 1;
+            continue;
+        }
+        if (code === 27) {
+            delete next.inverse;
+            index += 1;
+            continue;
+        }
+        if (code >= 30 && code <= 37) {
+            next.fg = BASIC_COLORS[code - 30];
+            index += 1;
+            continue;
+        }
+        if (code === 38) {
+            const mode = params[index + 1];
+            if (mode === 5) {
+                const palette = params[index + 2] ?? 0;
+                next.fg = convert256(palette);
+                index += 3;
+                continue;
+            }
+            if (mode === 2) {
+                const r = params[index + 2] ?? 0;
+                const g = params[index + 3] ?? 0;
+                const b = params[index + 4] ?? 0;
+                next.fg = rgbToHex(r, g, b);
+                index += 5;
+                continue;
+            }
+            index += 1;
+            continue;
+        }
+        if (code === 39) {
+            if (base.fg !== undefined) {
+                next.fg = base.fg;
+            }
+            else {
+                delete next.fg;
+            }
+            index += 1;
+            continue;
+        }
+        if (code >= 40 && code <= 47) {
+            next.bg = BASIC_COLORS[code - 40];
+            index += 1;
+            continue;
+        }
+        if (code === 48) {
+            const mode = params[index + 1];
+            if (mode === 5) {
+                const palette = params[index + 2] ?? 0;
+                next.bg = convert256(palette);
+                index += 3;
+                continue;
+            }
+            if (mode === 2) {
+                const r = params[index + 2] ?? 0;
+                const g = params[index + 3] ?? 0;
+                const b = params[index + 4] ?? 0;
+                next.bg = rgbToHex(r, g, b);
+                index += 5;
+                continue;
+            }
+            index += 1;
+            continue;
+        }
+        if (code === 49) {
+            if (base.bg !== undefined) {
+                next.bg = base.bg;
+            }
+            else {
+                delete next.bg;
+            }
+            index += 1;
+            continue;
+        }
+        if (code >= 90 && code <= 97) {
+            next.fg = BRIGHT_COLORS[code - 90];
+            index += 1;
+            continue;
+        }
+        if (code >= 100 && code <= 107) {
+            next.bg = BRIGHT_COLORS[code - 100];
+            index += 1;
+            continue;
+        }
+        index += 1;
+    }
+    return { style: next, concealed: nextConcealed };
+}
+function convert256(palette) {
+    if (palette < 0 || palette > 255) {
+        return "#000000";
+    }
+    if (palette < 8) {
+        return BASIC_COLORS[palette];
+    }
+    if (palette < 16) {
+        return BRIGHT_COLORS[palette - 8];
+    }
+    if (palette >= 232) {
+        const level = 8 + (palette - 232) * 10;
+        return rgbToHex(level, level, level);
+    }
+    const offset = palette - 16;
+    const r = Math.floor(offset / 36);
+    const g = Math.floor((offset % 36) / 6);
+    const b = offset % 6;
+    return rgbToHex(cubeLevel(r), cubeLevel(g), cubeLevel(b));
+}
+function cubeLevel(value) {
+    return value === 0 ? 0 : 55 + value * 40;
+}
+function rgbToHex(r, g, b) {
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function toHex(value) {
+    const clamped = Math.max(0, Math.min(255, Math.floor(value)));
+    return clamped.toString(16).padStart(2, "0");
+}
+function stylesEqual(left, right) {
+    return left.fg === right.fg
+        && left.bg === right.bg
+        && left.bold === right.bold
+        && left.dim === right.dim
+        && left.inverse === right.inverse;
+}
+function normalizeStyle(style) {
+    const next = {};
+    if (style?.fg !== undefined) {
+        next.fg = style.fg;
+    }
+    if (style?.bg !== undefined) {
+        next.bg = style.bg;
+    }
+    if (style?.bold !== undefined) {
+        next.bold = style.bold;
+    }
+    if (style?.dim !== undefined) {
+        next.dim = style.dim;
+    }
+    if (style?.inverse !== undefined) {
+        next.inverse = style.inverse;
+    }
+    return next;
+}

package/node_modules/toolcraft-design/dist/dashboard/buffer.d.ts

@@ -0,0 +1,25 @@
+import type { Cell, CellStyle, Rect } from "./types.js";
+export declare class ScreenBuffer {
+    private _width;
+    private _height;
+    private _cells;
+    constructor(width: number, height: number);
+    get width(): number;
+    get height(): number;
+    put(x: number, y: number, text: string, style?: CellStyle): void;
+    get(x: number, y: number): Cell;
+    clear(style?: CellStyle): void;
+    clearRect(rect: Rect, style?: CellStyle): void;
+    resize(width: number, height: number): void;
+    putInRect(rect: Rect, row: number, text: string, style?: CellStyle): void;
+    private index;
+    private isInBounds;
+    private isInBoundsX;
+    private isInBoundsY;
+}
+export declare function diff(prev: ScreenBuffer, next: ScreenBuffer): Array<{
+    x: number;
+    y: number;
+    cell: Cell;
+}>;
+export declare function cellToAnsi(cell: Cell): string;

package/node_modules/toolcraft-design/dist/dashboard/buffer.js

@@ -0,0 +1,219 @@
+import { color } from "../components/color.js";
+import { expandTabs, graphemes, graphemeWidth } from "./terminal-width.js";
+const EMPTY_CELL = { ch: " ", style: {} };
+export class ScreenBuffer {
+    _width;
+    _height;
+    _cells;
+    constructor(width, height) {
+        this._width = normalizeSize(width);
+        this._height = normalizeSize(height);
+        this._cells = createCells(this._width, this._height);
+    }
+    get width() {
+        return this._width;
+    }
+    get height() {
+        return this._height;
+    }
+    put(x, y, text, style) {
+        if (!this.isInBoundsY(y) || text.length === 0) {
+            return;
+        }
+        const normalizedStyle = normalizeStyle(style);
+        let offset = 0;
+        for (const ch of graphemes(expandTabs(text, Math.max(0, x)))) {
+            const targetX = x + offset;
+            const width = graphemeWidth(ch);
+            offset += width;
+            if (!this.isInBoundsX(targetX)) {
+                continue;
+            }
+            this._cells[this.index(targetX, y)] = { ch, style: normalizedStyle };
+            for (let continuation = 1; continuation < width; continuation += 1) {
+                if (this.isInBoundsX(targetX + continuation)) {
+                    this._cells[this.index(targetX + continuation, y)] = { ch: "", style: normalizedStyle };
+                }
+            }
+        }
+    }
+    get(x, y) {
+        if (!this.isInBounds(x, y)) {
+            return cloneCell(EMPTY_CELL);
+        }
+        return cloneCell(this._cells[this.index(x, y)] ?? EMPTY_CELL);
+    }
+    clear(style) {
+        this._cells = createCells(this._width, this._height, style);
+    }
+    clearRect(rect, style) {
+        const startX = Math.max(0, rect.x);
+        const startY = Math.max(0, rect.y);
+        const endX = Math.min(this._width, rect.x + Math.max(0, rect.width));
+        const endY = Math.min(this._height, rect.y + Math.max(0, rect.height));
+        const normalizedStyle = normalizeStyle(style);
+        for (let y = startY; y < endY; y += 1) {
+            for (let x = startX; x < endX; x += 1) {
+                this._cells[this.index(x, y)] = { ch: " ", style: normalizedStyle };
+            }
+        }
+    }
+    resize(width, height) {
+        const nextWidth = normalizeSize(width);
+        const nextHeight = normalizeSize(height);
+        const nextCells = createCells(nextWidth, nextHeight);
+        const copyWidth = Math.min(this._width, nextWidth);
+        const copyHeight = Math.min(this._height, nextHeight);
+        for (let y = 0; y < copyHeight; y += 1) {
+            for (let x = 0; x < copyWidth; x += 1) {
+                nextCells[(y * nextWidth) + x] = cloneCell(this._cells[this.index(x, y)] ?? EMPTY_CELL);
+            }
+        }
+        this._width = nextWidth;
+        this._height = nextHeight;
+        this._cells = nextCells;
+    }
+    putInRect(rect, row, text, style) {
+        if (row < 0 || row >= rect.height || text.length === 0 || rect.width <= 0) {
+            return;
+        }
+        const y = rect.y + row;
+        if (!this.isInBoundsY(y)) {
+            return;
+        }
+        const normalizedStyle = normalizeStyle(style);
+        const rectEndX = rect.x + rect.width;
+        let offset = 0;
+        for (const ch of graphemes(expandTabs(text))) {
+            const targetX = rect.x + offset;
+            const width = graphemeWidth(ch);
+            offset += width;
+            if (targetX + width > rectEndX) {
+                break;
+            }
+            if (!this.isInBoundsX(targetX)) {
+                continue;
+            }
+            this._cells[this.index(targetX, y)] = { ch, style: normalizedStyle };
+            for (let continuation = 1; continuation < width; continuation += 1) {
+                if (this.isInBoundsX(targetX + continuation)) {
+                    this._cells[this.index(targetX + continuation, y)] = { ch: "", style: normalizedStyle };
+                }
+            }
+        }
+    }
+    index(x, y) {
+        return (y * this._width) + x;
+    }
+    isInBounds(x, y) {
+        return this.isInBoundsX(x) && this.isInBoundsY(y);
+    }
+    isInBoundsX(x) {
+        return x >= 0 && x < this._width;
+    }
+    isInBoundsY(y) {
+        return y >= 0 && y < this._height;
+    }
+}
+export function diff(prev, next) {
+    const changes = [];
+    const width = Math.max(prev.width, next.width);
+    const height = Math.max(prev.height, next.height);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const previousCell = prev.get(x, y);
+            const nextCell = next.get(x, y);
+            if (!cellsEqual(previousCell, nextCell)) {
+                changes.push({ x, y, cell: nextCell });
+            }
+        }
+    }
+    return changes;
+}
+export function cellToAnsi(cell) {
+    if (cell.ch.length === 0) {
+        return "";
+    }
+    const style = cell.style ?? {};
+    let painter = color;
+    if (style.bold) {
+        painter = painter.bold;
+    }
+    if (style.dim) {
+        painter = painter.dim;
+    }
+    if (style.inverse) {
+        painter = painter.inverse;
+    }
+    if (style.underline) {
+        painter = painter.underline;
+    }
+    if (style.fg) {
+        painter = applyForegroundColor(painter, style.fg);
+    }
+    if (style.bg) {
+        painter = applyBackgroundColor(painter, style.bg);
+    }
+    return painter(cell.ch);
+}
+function createCells(width, height, style) {
+    const normalizedStyle = normalizeStyle(style);
+    return Array.from({ length: width * height }, () => ({ ch: " ", style: normalizedStyle }));
+}
+function cloneCell(cell) {
+    return {
+        ch: cell.ch,
+        style: normalizeStyle(cell.style)
+    };
+}
+function normalizeStyle(style) {
+    const next = {};
+    if (style?.fg !== undefined) {
+        next.fg = style.fg;
+    }
+    if (style?.bg !== undefined) {
+        next.bg = style.bg;
+    }
+    if (style?.bold !== undefined) {
+        next.bold = style.bold;
+    }
+    if (style?.dim !== undefined) {
+        next.dim = style.dim;
+    }
+    if (style?.inverse !== undefined) {
+        next.inverse = style.inverse;
+    }
+    if (style?.underline !== undefined) {
+        next.underline = style.underline;
+    }
+    return next;
+}
+function normalizeSize(value) {
+    return Math.max(0, Math.floor(value));
+}
+function cellsEqual(left, right) {
+    return left.ch === right.ch
+        && left.style.fg === right.style.fg
+        && left.style.bg === right.style.bg
+        && left.style.bold === right.style.bold
+        && left.style.dim === right.style.dim
+        && left.style.inverse === right.style.inverse
+        && left.style.underline === right.style.underline;
+}
+function applyForegroundColor(instance, ansiColor) {
+    if (ansiColor.startsWith("#")) {
+        return instance.hex(ansiColor);
+    }
+    const painter = instance[ansiColor];
+    return typeof painter === "function" ? painter : instance;
+}
+function applyBackgroundColor(instance, ansiColor) {
+    if (ansiColor.startsWith("#")) {
+        return instance.bgHex(ansiColor);
+    }
+    const methodName = ansiColor.startsWith("bg")
+        ? ansiColor
+        : `bg${ansiColor.charAt(0).toUpperCase()}${ansiColor.slice(1)}`;
+    const painter = instance[methodName];
+    return typeof painter === "function" ? painter : instance;
+}

package/node_modules/toolcraft-design/dist/dashboard/components/border.d.ts

@@ -0,0 +1,9 @@
+import { ScreenBuffer } from "../buffer.js";
+import type { DashboardLayout } from "../layout.js";
+import type { CellStyle } from "../types.js";
+export type BorderOptions = {
+    leftTitle?: string;
+    rightTitle?: string;
+    style: CellStyle;
+};
+export declare function renderBorder(buffer: ScreenBuffer, layout: DashboardLayout, opts: BorderOptions): void;