tui-cap 0.1.0

package/dist/edits.js

@@ -0,0 +1,527 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDITS_SCHEMA_VERSION = void 0;
+exports.defaultEdits = defaultEdits;
+exports.editsPathFor = editsPathFor;
+exports.normalizeEdits = normalizeEdits;
+exports.readEdits = readEdits;
+exports.writeEdits = writeEdits;
+exports.fingerprintMatches = fingerprintMatches;
+exports.rowText = rowText;
+exports.inkedEndCol = inkedEndCol;
+exports.rowIsBlank = rowIsBlank;
+exports.scoreRow = scoreRow;
+exports.matchRows = matchRows;
+exports.buildDisplay = buildDisplay;
+exports.toDisplayGrid = toDisplayGrid;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Per-recording content-edit sidecar (`<name>.edits.json`). Like `.anim.json`,
+ * the capture's `.ans`/`.timing.json` stay immutable raw data; this file holds
+ * the user's non-destructive edits to the *content* of a recording: recoloured
+ * or rewritten runs of text, and inserted/removed vertical spacing.
+ *
+ * Edits cannot be keyed by `(frame,row,col)` because frames scroll, repaint and
+ * stream in over time. Each edit is instead anchored to the *text content* of
+ * the row it was created on (raw line text + absolute column span + surrounding
+ * context) and re-matched against every frame at render time, so a single edit
+ * follows its line across the whole recording.
+ */
+exports.EDITS_SCHEMA_VERSION = 1;
+/* ------------------------------------------------------------- defaults/io */
+function defaultEdits(fp) {
+    return {
+        schemaVersion: exports.EDITS_SCHEMA_VERSION,
+        recording: {
+            ansMtime: fp?.ansMtime ?? 0,
+            cols: fp?.cols ?? 0,
+            rows: fp?.rows ?? 0,
+        },
+        revision: 0,
+        edits: [],
+    };
+}
+/** Sibling sidecar path for a capture: `foo.ans` -> `foo.edits.json`. */
+function editsPathFor(captureFile) {
+    const dir = node_path_1.default.dirname(captureFile);
+    const base = node_path_1.default.basename(captureFile, node_path_1.default.extname(captureFile));
+    return node_path_1.default.join(dir, `${base}.edits.json`);
+}
+const HEX = /^#[0-9a-fA-F]{6}$/;
+function str(value, fallback = '') {
+    return typeof value === 'string' ? value : fallback;
+}
+function int(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.round(value) : fallback;
+}
+function hexOrNull(value) {
+    return typeof value === 'string' && HEX.test(value) ? value.toLowerCase() : null;
+}
+let idCounter = 0;
+function freshId() {
+    idCounter += 1;
+    return `e${Date.now().toString(36)}${idCounter.toString(36)}`;
+}
+function normalizeAnchor(src) {
+    const startCol = Math.max(0, int(src.startCol, 0));
+    const endColRaw = Math.max(0, int(src.endCol, startCol));
+    return {
+        id: str(src.id) || freshId(),
+        rawLineText: str(src.rawLineText),
+        startCol,
+        endCol: Math.max(startCol, endColRaw),
+        anchorText: str(src.anchorText),
+        leftContext: str(src.leftContext),
+        rightContext: str(src.rightContext),
+        lineAbove: str(src.lineAbove),
+        lineBelow: str(src.lineBelow),
+        srcFrame: Math.max(0, int(src.srcFrame, 0)),
+        srcRow: Math.max(0, int(src.srcRow, 0)),
+        applyToAll: src.applyToAll === true,
+    };
+}
+function normalizeEdit(input) {
+    if (!input || typeof input !== 'object')
+        return null;
+    const src = input;
+    const anchor = normalizeAnchor(src);
+    if (src.kind === 'spacing') {
+        const blankLines = int(src.blankLines, 0);
+        if (blankLines === 0)
+            return null; // a no-op spacing edit carries no intent
+        return { ...anchor, kind: 'spacing', blankLines };
+    }
+    // default to a text edit
+    const text = typeof src.text === 'string' ? src.text : null;
+    const fg = hexOrNull(src.fg);
+    const bg = hexOrNull(src.bg);
+    // A text edit with neither a replacement nor a colour is a no-op; drop it.
+    if (text === null && fg === null && bg === null)
+        return null;
+    return { ...anchor, kind: 'text', text, fg, bg };
+}
+/**
+ * Coerce arbitrary input (e.g. a request body) into a valid edits document,
+ * clamping fields and dropping malformed/no-op edits. Never throws.
+ */
+function normalizeEdits(input, fp) {
+    const src = (input && typeof input === 'object' ? input : {});
+    const base = defaultEdits(fp);
+    const rec = (src.recording && typeof src.recording === 'object'
+        ? src.recording
+        : {});
+    const recording = {
+        ansMtime: Math.max(0, int(rec.ansMtime, base.recording.ansMtime)),
+        cols: Math.max(0, int(rec.cols, base.recording.cols)),
+        rows: Math.max(0, int(rec.rows, base.recording.rows)),
+    };
+    const edits = [];
+    if (Array.isArray(src.edits)) {
+        for (const raw of src.edits) {
+            const e = normalizeEdit(raw);
+            if (e)
+                edits.push(e);
+        }
+    }
+    return {
+        schemaVersion: exports.EDITS_SCHEMA_VERSION,
+        recording,
+        revision: Math.max(0, int(src.revision, 0)),
+        edits,
+    };
+}
+/**
+ * Read a recording's edits, or null when there's no sidecar yet. Never throws —
+ * a garbled file is treated as absent so the GUI falls back to defaults.
+ */
+async function readEdits(captureFile) {
+    try {
+        const raw = await (0, promises_1.readFile)(editsPathFor(captureFile), 'utf8');
+        return normalizeEdits(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+/** Write a recording's edits sidecar. Returns the sidecar path. */
+async function writeEdits(captureFile, doc) {
+    const out = editsPathFor(captureFile);
+    await (0, promises_1.writeFile)(out, `${JSON.stringify(normalizeEdits(doc), null, 2)}\n`, 'utf8');
+    return out;
+}
+/**
+ * True when a saved edits document still applies to the current capture. A
+ * re-record changes the `.ans` mtime or replay dims; mismatched edits are
+ * skipped rather than smeared across new content. A zeroed fingerprint (older
+ * sidecar, or freshly created in-memory) is treated as "unknown" → compatible.
+ */
+function fingerprintMatches(doc, fp) {
+    const r = doc.recording;
+    if (r.ansMtime === 0 && r.cols === 0 && r.rows === 0)
+        return true;
+    return r.cols === fp.cols && r.rows === fp.rows;
+}
+/* ----------------------------------------------------------- grid helpers */
+/** Whether a cell carries visible ink (a non-space glyph). */
+function isInked(cell) {
+    return cell.char.trim() !== '';
+}
+/** The row's text in column order; trailing whitespace trimmed. */
+function rowText(cells) {
+    let s = '';
+    let col = 0;
+    for (const cell of cells) {
+        while (col < cell.col) {
+            s += ' ';
+            col += 1;
+        }
+        s += cell.char;
+        col = cell.col + Math.max(1, cell.width);
+    }
+    return s.replace(/\s+$/, '');
+}
+/** Rightmost inked column (exclusive); 0 for a blank row. */
+function inkedEndCol(cells) {
+    let end = 0;
+    for (const cell of cells) {
+        if (isInked(cell))
+            end = Math.max(end, cell.col + Math.max(1, cell.width));
+    }
+    return end;
+}
+/** A row is blank when it has no inked cells. */
+function rowIsBlank(cells) {
+    return cells.every((c) => !isInked(c));
+}
+/** The substring of a row covering [start,end) absolute columns, space-padded. */
+function columnSlice(cells, start, end) {
+    const out = [];
+    for (let c = start; c < end; c++)
+        out.push(' ');
+    for (const cell of cells) {
+        const w = Math.max(1, cell.width);
+        if (cell.col + w <= start || cell.col >= end)
+            continue;
+        const idx = cell.col - start;
+        if (idx >= 0 && idx < out.length)
+            out[idx] = cell.char;
+        // blank out the continuation column of a wide cell within the slice
+        for (let k = 1; k < w; k++) {
+            const j = idx + k;
+            if (j >= 0 && j < out.length)
+                out[j] = '';
+        }
+    }
+    return out.join('');
+}
+/* ----------------------------------------------------- grapheme + widths */
+const SEGMENTER = typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function'
+    ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+    : null;
+function graphemes(text) {
+    if (SEGMENTER)
+        return Array.from(SEGMENTER.segment(text), (s) => s.segment);
+    return Array.from(text);
+}
+const WIDE = /[\u1100-\u115F\u2329\u232A\u2E80-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6]/;
+const PICTO = /\p{Extended_Pictographic}/u;
+/** Column width of a single grapheme: 2 for wide/emoji, else 1. */
+function graphemeWidth(g) {
+    const cp = g.codePointAt(0);
+    if (cp === undefined)
+        return 1;
+    if (cp >= 0x1f300 || PICTO.test(g) || WIDE.test(g))
+        return 2;
+    return 1;
+}
+const SCORE_THRESHOLD = 0.5;
+const MIN_VISIBLE = 6;
+function trimmed(s) {
+    return s.replace(/\s+$/, '');
+}
+/**
+ * Score how well `cells` (a candidate row) matches an edit's anchor, and report
+ * the visible column span the edit should apply to. Returns score 0 when the row
+ * is not a credible match (so it is skipped).
+ */
+function scoreRow(grid, row, edit) {
+    const none = { row, score: 0, visibleStart: edit.startCol, visibleEnd: edit.endCol };
+    const cells = grid.lines[row];
+    if (!cells)
+        return none;
+    const text = rowText(cells);
+    const raw = trimmed(edit.rawLineText);
+    if (raw.length === 0)
+        return none;
+    const ink = inkedEndCol(cells);
+    let score = 0;
+    let visibleStart = edit.startCol;
+    let visibleEnd = edit.endCol;
+    if (text === raw) {
+        score = 1; // exact content
+    }
+    else if (raw.startsWith(text) && text.length > 0) {
+        // Typing-in / streaming: this frame shows a prefix of the final line. Only
+        // trust it once enough has streamed in to be unambiguous, and only apply to
+        // the part of the span that has actually appeared.
+        const guard = Math.max(MIN_VISIBLE, Math.floor(raw.length * 0.4));
+        if (ink < guard)
+            return none;
+        visibleEnd = Math.min(edit.endCol, ink);
+        if (visibleEnd <= edit.startCol)
+            return none; // span not yet visible
+        score = 0.45 + 0.25 * (ink / raw.length);
+    }
+    else if (text.startsWith(raw) && raw.length >= MIN_VISIBLE) {
+        // This frame shows the anchor line plus trailing growth (still the line).
+        score = 0.7;
+    }
+    else {
+        return none;
+    }
+    // Context bonuses (cheap disambiguation for repeated/shared-prefix lines).
+    if (edit.leftContext) {
+        const before = columnSlice(cells, Math.max(0, edit.startCol - edit.leftContext.length), edit.startCol);
+        if (before.endsWith(edit.leftContext))
+            score += 0.1;
+    }
+    if (edit.rightContext) {
+        const after = columnSlice(cells, edit.endCol, edit.endCol + edit.rightContext.length);
+        if (after.startsWith(edit.rightContext))
+            score += 0.1;
+    }
+    if (edit.lineAbove && row > 0 && trimmed(rowText(grid.lines[row - 1])) === edit.lineAbove) {
+        score += 0.15;
+    }
+    if (edit.lineBelow && row + 1 < grid.lines.length && trimmed(rowText(grid.lines[row + 1])) === edit.lineBelow) {
+        score += 0.15;
+    }
+    if (edit.anchorText) {
+        const span = columnSlice(cells, edit.startCol, Math.min(edit.endCol, visibleEnd));
+        if (trimmed(span) && edit.anchorText.startsWith(trimmed(span)))
+            score += 0.1;
+    }
+    // Row proximity: a tiny tiebreaker only (rows scroll, so weight content far higher).
+    const rowCount = Math.max(1, grid.lines.length);
+    score += 0.05 * (1 - Math.min(1, Math.abs(row - edit.srcRow) / rowCount));
+    return { row, score, visibleStart, visibleEnd };
+}
+/**
+ * Find the row(s) an edit applies to within a single frame. Returns the single
+ * best match above the confidence threshold, or — when `applyToAll` is set —
+ * every match above it (for intentionally repeated lines).
+ */
+function matchRows(grid, edit) {
+    const matches = [];
+    for (let row = 0; row < grid.lines.length; row++) {
+        const m = scoreRow(grid, row, edit);
+        if (m.score >= SCORE_THRESHOLD)
+            matches.push(m);
+    }
+    if (matches.length === 0)
+        return [];
+    if (edit.applyToAll)
+        return matches;
+    let best = matches[0];
+    for (const m of matches) {
+        if (m.score > best.score || (m.score === best.score && Math.abs(m.row - edit.srcRow) < Math.abs(best.row - edit.srcRow))) {
+            best = m;
+        }
+    }
+    return [best];
+}
+/* ----------------------------------------------------------------- apply */
+function cloneCell(cell) {
+    return { ...cell };
+}
+function spaceCell(col, style = {}) {
+    return {
+        char: ' ',
+        col,
+        width: 1,
+        fg: style.fg ?? null,
+        bg: style.bg ?? null,
+        bold: false,
+        italic: false,
+        underline: false,
+        dim: false,
+        strike: false,
+        inverse: false,
+        invisible: false,
+    };
+}
+/**
+ * Recolour the cells fully inside [start,end). Cells that only partially overlap
+ * a boundary (a wide glyph straddling the edge) are left untouched so we never
+ * recolour half a cell. Returns a new row; never mutates the input.
+ */
+function recolorRow(cells, start, end, fg, bg) {
+    return cells.map((cell) => {
+        const w = Math.max(1, cell.width);
+        const inside = cell.col >= start && cell.col + w <= end;
+        if (!inside)
+            return cell;
+        const next = cloneCell(cell);
+        if (fg !== undefined)
+            next.fg = fg;
+        if (bg !== undefined)
+            next.bg = bg;
+        return next;
+    });
+}
+/**
+ * Overwrite the characters in [start,end) with `text`, laid out grapheme by
+ * grapheme in terminal columns and clipped/padded to the span (layout
+ * preserving). Wide glyphs are never split: a width-2 grapheme that would
+ * overflow the last column is dropped, and any pre-existing wide cell straddling
+ * a boundary is cleared to spaces. Returns a new row; never mutates the input.
+ */
+function overwriteRow(cells, start, end, text, fg, bg) {
+    if (end <= start)
+        return cells;
+    let width = end;
+    for (const cell of cells)
+        width = Math.max(width, cell.col + Math.max(1, cell.width));
+    // Slot model: index === column. null = empty, 'cont' = wide continuation.
+    const slots = new Array(width).fill(null);
+    for (const cell of cells) {
+        slots[cell.col] = cell;
+        for (let k = 1; k < Math.max(1, cell.width); k++)
+            slots[cell.col + k] = 'cont';
+    }
+    // Style inherited by the replacement + padding: the first cell of the span.
+    const head = cells.find((c) => c.col <= start && c.col + Math.max(1, c.width) > start);
+    const inherit = head
+        ? { fg: fg ?? head.fg, bg: bg ?? head.bg }
+        : { fg, bg };
+    // Free any cell whose footprint overlaps the span (including straddlers), and
+    // refill the columns it vacated *outside* the span with spaces.
+    for (let c = 0; c < width; c++) {
+        const slot = slots[c];
+        if (slot && slot !== 'cont') {
+            const w = Math.max(1, slot.width);
+            if (slot.col < end && slot.col + w > start) {
+                for (let k = 0; k < w; k++) {
+                    const col = slot.col + k;
+                    slots[col] = col >= start && col < end ? null : spaceCell(col, { fg: slot.fg, bg: slot.bg });
+                }
+            }
+        }
+    }
+    // Lay the replacement graphemes from `start`, clipped at `end`.
+    let col = start;
+    for (const g of graphemes(text)) {
+        const gw = graphemeWidth(g);
+        if (col + gw > end)
+            break;
+        slots[col] = {
+            char: g,
+            col,
+            width: gw,
+            fg: inherit.fg ?? null,
+            bg: inherit.bg ?? null,
+            bold: head?.bold ?? false,
+            italic: head?.italic ?? false,
+            underline: head?.underline ?? false,
+            dim: head?.dim ?? false,
+            strike: head?.strike ?? false,
+            inverse: head?.inverse ?? false,
+            invisible: head?.invisible ?? false,
+        };
+        for (let k = 1; k < gw; k++)
+            slots[col + k] = 'cont';
+        col += gw;
+    }
+    // Pad the remainder of the span with inheriting spaces.
+    for (; col < end; col++)
+        slots[col] = spaceCell(col, inherit);
+    const out = [];
+    for (let c = 0; c < width; c++) {
+        const slot = slots[c];
+        if (slot === 'cont')
+            continue;
+        out.push(slot ?? spaceCell(c));
+    }
+    return out;
+}
+/** Apply one text edit to a single matched row. */
+function applyTextEditToRow(cells, edit, match) {
+    const start = match.visibleStart;
+    const end = match.visibleEnd;
+    let next = cells;
+    if (edit.text !== null) {
+        next = overwriteRow(next, start, end, edit.text, edit.fg, edit.bg);
+    }
+    else if (edit.fg !== null || edit.bg !== null) {
+        next = recolorRow(next, start, end, edit.fg ?? undefined, edit.bg ?? undefined);
+    }
+    return next;
+}
+/**
+ * Apply every edit in `edits` to `grid`, returning a new display grid plus the
+ * raw-row provenance of each display row. Text edits run first (they never
+ * change row count), then spacing edits (which do). Pure: the input grid and its
+ * cells are never mutated.
+ */
+function buildDisplay(grid, edits) {
+    const lines = grid.lines.map((row) => row);
+    const sourceRows = grid.lines.map((_, i) => i);
+    if (edits.length === 0) {
+        return { grid: { cols: grid.cols, rows: grid.rows, lines }, sourceRows };
+    }
+    let work = { cols: grid.cols, rows: grid.rows, lines };
+    // 1. Text edits.
+    for (const edit of edits) {
+        if (edit.kind !== 'text')
+            continue;
+        const matches = matchRows(work, edit);
+        for (const m of matches) {
+            lines[m.row] = applyTextEditToRow(lines[m.row], edit, m);
+        }
+    }
+    // 2. Spacing edits (row-count changes). Apply from the bottom up so earlier
+    //    insertions don't shift the indices of later matches within one edit.
+    for (const edit of edits) {
+        if (edit.kind !== 'spacing')
+            continue;
+        work = { cols: work.cols, rows: lines.length, lines };
+        const matches = matchRows(work, edit).sort((a, b) => b.row - a.row);
+        for (const m of matches) {
+            if (edit.blankLines > 0) {
+                const blanks = [];
+                const provenance = [];
+                for (let k = 0; k < edit.blankLines; k++) {
+                    blanks.push([]);
+                    provenance.push(null);
+                }
+                lines.splice(m.row + 1, 0, ...blanks);
+                sourceRows.splice(m.row + 1, 0, ...provenance);
+            }
+            else if (edit.blankLines < 0) {
+                let removable = 0;
+                const max = -edit.blankLines;
+                while (removable < max && lines[m.row + 1 + removable] && rowIsBlank(lines[m.row + 1 + removable])) {
+                    removable += 1;
+                }
+                if (removable > 0) {
+                    lines.splice(m.row + 1, removable);
+                    sourceRows.splice(m.row + 1, removable);
+                }
+            }
+        }
+    }
+    return { grid: { cols: grid.cols, rows: lines.length, lines }, sourceRows };
+}
+/**
+ * Apply every edit in `edits` to `grid`, returning a new display grid. Thin
+ * wrapper over {@link buildDisplay} for callers that don't need row provenance.
+ */
+function toDisplayGrid(grid, edits) {
+    if (edits.length === 0)
+        return grid;
+    return buildDisplay(grid, edits).grid;
+}

package/dist/fonts.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FONT_ADVANCE_TABLE = void 0;
+exports.primaryFamily = primaryFamily;
+exports.advanceForFont = advanceForFont;
+exports.buildFontFaceCss = buildFontFaceCss;
+const node_fs_1 = require("node:fs");
+/**
+ * Per-column advance as a fraction of font size, for common monospace fonts.
+ * These should be each font's TRUE metric (advanceWidth / unitsPerEm), not a
+ * hand-tuned value: renderers that honour `textLength` (Chrome, Illustrator, the
+ * raster exporter) flow text to the grid regardless, but Figma ignores
+ * `textLength` and draws glyphs at the font's real advance — so only a
+ * real-metric grid keeps Figma's text aligned with the column-pinned background
+ * rects and borders. SF Mono is measured exact (1266/2048); others are close
+ * approximations pending per-font measurement. Keys are lower-cased.
+ */
+exports.FONT_ADVANCE_TABLE = {
+    'monaspace neon': 0.6,
+    'monaspace argon': 0.6,
+    'monaspace xenon': 0.6,
+    'jetbrains mono': 0.6,
+    'fira code': 0.601,
+    'sf mono': 0.618164,
+    'sfmono-regular': 0.618164,
+    'cascadia code': 0.6,
+    'cascadia mono': 0.6,
+    menlo: 0.602,
+    monaco: 0.602,
+    consolas: 0.5,
+    'source code pro': 0.6,
+    'roboto mono': 0.6,
+    'ibm plex mono': 0.6,
+};
+/** The first family in a CSS font-family stack, with quotes/space trimmed. */
+function primaryFamily(stack) {
+    const first = stack.split(',')[0] ?? stack;
+    return first.trim().replace(/^['"]|['"]$/g, '').trim();
+}
+/** Known advance for a font stack's primary family, or undefined if unknown. */
+function advanceForFont(stack) {
+    return exports.FONT_ADVANCE_TABLE[primaryFamily(stack).toLowerCase()];
+}
+function isRemoteOrData(source) {
+    return /^(https?:|data:)/i.test(source);
+}
+/** CSS `format(...)` hint and MIME type derived from a font file extension. */
+function fontKind(source) {
+    const ext = (source.split(/[?#]/)[0].match(/\.([a-z0-9]+)$/i)?.[1] ?? '').toLowerCase();
+    switch (ext) {
+        case 'woff2':
+            return { format: 'woff2', mime: 'font/woff2' };
+        case 'woff':
+            return { format: 'woff', mime: 'font/woff' };
+        case 'otf':
+            return { format: 'opentype', mime: 'font/otf' };
+        case 'ttf':
+        default:
+            return { format: 'truetype', mime: 'font/ttf' };
+    }
+}
+/**
+ * Build an `@font-face` CSS rule embedding (or referencing) the given font so
+ * Figma-free targets (Illustrator, Chrome, raster) resolve the exact metrics.
+ *
+ * - `data:` / `http(s):` sources are referenced as-is (the SVG is not
+ *   self-contained for URLs, by design).
+ * - A local file path is base64-embedded into a `data:` URI by default so the
+ *   SVG stays portable; pass `{ embed: false }` to reference the path instead.
+ */
+function buildFontFaceCss(family, source, opts = {}) {
+    const { format, mime } = fontKind(source);
+    let src;
+    if (isRemoteOrData(source)) {
+        src = `url('${source}') format('${format}')`;
+    }
+    else if (opts.embed === false) {
+        src = `url('${source}') format('${format}')`;
+    }
+    else {
+        const b64 = (0, node_fs_1.readFileSync)(source).toString('base64');
+        src = `url('data:${mime};base64,${b64}') format('${format}')`;
+    }
+    return (`@font-face{font-family:'${family}';` +
+        `font-style:normal;font-weight:400 700;font-display:swap;` +
+        `src:${src};}`);
+}