poe-code 3.0.177 → 3.0.179

package/packages/design-system/dist/dashboard/ansi.js

@@ -0,0 +1,298 @@
+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.
+ *
+ * Non-SGR CSI sequences and other control characters are discarded. `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 };
+    const lines = [];
+    let segments = [];
+    let pending = "";
+    const flushSegment = () => {
+        if (pending.length === 0) {
+            return;
+        }
+        const last = segments[segments.length - 1];
+        if (last && stylesEqual(last.style, style)) {
+            last.text += pending;
+        }
+        else {
+            segments.push({ text: pending, style: { ...style } });
+        }
+        pending = "";
+    };
+    const finishLine = () => {
+        flushSegment();
+        lines.push({ segments });
+        segments = [];
+    };
+    let index = 0;
+    while (index < text.length) {
+        const ch = text[index];
+        if (ch === ESC && text[index + 1] === "[") {
+            flushSegment();
+            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") {
+                style = applySgr(style, parseParams(params), base);
+            }
+            index = cursor + 1;
+            continue;
+        }
+        if (ch === ESC) {
+            flushSegment();
+            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") {
+            index += 1;
+            continue;
+        }
+        if (ch === "\n") {
+            finishLine();
+            index += 1;
+            continue;
+        }
+        const code = ch.charCodeAt(0);
+        if (code < 0x20 && ch !== "\t") {
+            index += 1;
+            continue;
+        }
+        pending += ch;
+        index += 1;
+    }
+    finishLine();
+    return lines;
+}
+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(";").map((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, params, base) {
+    let next = { ...style };
+    let index = 0;
+    while (index < params.length) {
+        const code = params[index];
+        if (code === 0) {
+            next = { ...base };
+            index += 1;
+            continue;
+        }
+        if (code === 1) {
+            next.bold = true;
+            index += 1;
+            continue;
+        }
+        if (code === 2) {
+            next.dim = true;
+            index += 1;
+            continue;
+        }
+        if (code === 22) {
+            delete next.bold;
+            delete next.dim;
+            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 next;
+}
+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;
+}
+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;
+    }
+    return next;
+}

package/packages/design-system/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/packages/design-system/dist/dashboard/buffer.js

@@ -0,0 +1,189 @@
+import chalk from "chalk";
+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 text) {
+            const targetX = x + offset;
+            offset += 1;
+            if (!this.isInBoundsX(targetX)) {
+                continue;
+            }
+            this._cells[this.index(targetX, 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 text) {
+            const targetX = rect.x + offset;
+            offset += 1;
+            if (targetX >= rectEndX) {
+                break;
+            }
+            if (!this.isInBoundsX(targetX)) {
+                continue;
+            }
+            this._cells[this.index(targetX, 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) {
+    const style = cell.style ?? {};
+    let painter = chalk;
+    if (style.bold) {
+        painter = painter.bold;
+    }
+    if (style.dim) {
+        painter = painter.dim;
+    }
+    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;
+    }
+    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;
+}
+function applyForegroundColor(instance, color) {
+    if (color.startsWith("#")) {
+        return instance.hex(color);
+    }
+    const painter = instance[color];
+    return typeof painter === "function" ? painter : instance;
+}
+function applyBackgroundColor(instance, color) {
+    if (color.startsWith("#")) {
+        return instance.bgHex(color);
+    }
+    const methodName = color.startsWith("bg")
+        ? color
+        : `bg${color.charAt(0).toUpperCase()}${color.slice(1)}`;
+    const painter = instance[methodName];
+    return typeof painter === "function" ? painter : instance;
+}

package/packages/design-system/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;

package/packages/design-system/dist/dashboard/components/border.js

@@ -0,0 +1,123 @@
+export function renderBorder(buffer, layout, opts) {
+    const outer = layout.outerBorder;
+    if (outer.width <= 0 || outer.height <= 0) {
+        return;
+    }
+    const left = outer.x;
+    const top = outer.y;
+    const right = outer.x + outer.width - 1;
+    const bottom = outer.y + outer.height - 1;
+    renderTopBorder(buffer, left, top, right, layout, opts);
+    renderSideBorders(buffer, left, right, top, bottom, opts.style);
+    renderBottomBorder(buffer, left, top, right, bottom, layout, opts.style);
+    renderVerticalDivider(buffer, layout, opts.style);
+    renderFooterDivider(buffer, left, right, bottom, layout, opts.style);
+}
+function renderTopBorder(buffer, left, top, right, layout, opts) {
+    if (left === right) {
+        buffer.put(left, top, "┌", opts.style);
+        return;
+    }
+    const hasTopJunction = hasInteriorRows(top, layout.outerBorder.y + layout.outerBorder.height - 1)
+        && hasPaneDivider(layout, left, right)
+        && layout.divider.top <= top + 1
+        && layout.divider.bottom >= top + 1;
+    if (!hasTopJunction) {
+        buffer.put(left, top, `┌${renderTopSegment(right - left - 1, opts.leftTitle)}┐`, opts.style);
+        return;
+    }
+    const leftWidth = layout.divider.x - left - 1;
+    const rightWidth = right - layout.divider.x - 1;
+    const row = [
+        "┌",
+        renderTopSegment(leftWidth, opts.leftTitle),
+        "┬",
+        renderTopSegment(rightWidth, opts.rightTitle),
+        "┐"
+    ].join("");
+    buffer.put(left, top, row, opts.style);
+}
+function renderSideBorders(buffer, left, right, top, bottom, style) {
+    for (let y = top + 1; y < bottom; y += 1) {
+        buffer.put(left, y, "│", style);
+        buffer.put(right, y, "│", style);
+    }
+}
+function renderBottomBorder(buffer, left, top, right, bottom, layout, style) {
+    if (bottom <= top) {
+        return;
+    }
+    if (left === right) {
+        buffer.put(left, bottom, "└", style);
+        return;
+    }
+    buffer.put(left, bottom, "└", style);
+    buffer.put(left + 1, bottom, "─".repeat(Math.max(0, right - left - 1)), style);
+    buffer.put(right, bottom, "┘", style);
+    if (hasInteriorRows(top, bottom)
+        && hasPaneDivider(layout, left, right)
+        && layout.divider.top <= bottom - 1
+        && layout.divider.bottom >= bottom - 1) {
+        buffer.put(layout.divider.x, bottom, "┴", style);
+    }
+}
+function renderVerticalDivider(buffer, layout, style) {
+    const left = layout.outerBorder.x;
+    const right = layout.outerBorder.x + layout.outerBorder.width - 1;
+    if (!hasPaneDivider(layout, left, right)) {
+        return;
+    }
+    const startY = Math.max(layout.divider.top, layout.outerBorder.y + 1);
+    const endY = Math.min(layout.divider.bottom, layout.outerBorder.y + layout.outerBorder.height - 2);
+    for (let y = startY; y <= endY; y += 1) {
+        buffer.put(layout.divider.x, y, "│", style);
+    }
+}
+function renderFooterDivider(buffer, left, right, bottom, layout, style) {
+    const y = layout.footerDivider.y;
+    if (y <= layout.outerBorder.y || y >= bottom) {
+        return;
+    }
+    const width = layout.footerDivider.right - layout.footerDivider.left + 1;
+    if (width > 0) {
+        buffer.put(layout.footerDivider.left, y, "─".repeat(width), style);
+    }
+    buffer.put(left, y, "├", style);
+    buffer.put(right, y, "┤", style);
+    if (!hasPaneDivider(layout, left, right)
+        || layout.divider.x < layout.footerDivider.left
+        || layout.divider.x > layout.footerDivider.right) {
+        return;
+    }
+    const connectsAbove = layout.divider.bottom >= y - 1 && layout.divider.top <= y;
+    const connectsBelow = layout.divider.bottom > y;
+    if (connectsAbove && connectsBelow) {
+        buffer.put(layout.divider.x, y, "┼", style);
+        return;
+    }
+    if (connectsAbove) {
+        buffer.put(layout.divider.x, y, "┴", style);
+    }
+}
+function renderTopSegment(width, title) {
+    if (width <= 0) {
+        return "";
+    }
+    if (!title) {
+        return "─".repeat(width);
+    }
+    const content = `─ ${title} `;
+    if (content.length >= width) {
+        return content.slice(0, width);
+    }
+    return `${content}${"─".repeat(width - content.length)}`;
+}
+function hasInteriorRows(top, bottom) {
+    return (bottom - top) > 1;
+}
+function hasPaneDivider(layout, left, right) {
+    return layout.leftPane.width > 0
+        && layout.rightPane.width > 0
+        && layout.divider.x > left
+        && layout.divider.x < right;
+}

package/packages/design-system/dist/dashboard/components/footer.d.ts

@@ -0,0 +1,8 @@
+import { ScreenBuffer } from "../buffer.js";
+import type { Rect } from "../types.js";
+export type FooterHint = {
+    key: string;
+    label: string;
+};
+export declare function renderFooter(buffer: ScreenBuffer, rect: Rect, hints: FooterHint[]): void;
+export declare function defaultHints(): FooterHint[];