@thegitai/cli 1.0.0-preview.3 → 1.0.0-preview.31

package/dist/src/ui/tui/terminal-writes.js

@@ -0,0 +1,48 @@
+const MAX_CAPTURED_CHARS = 1_000_000;
+let restore = null;
+let captured = [];
+let capturedChars = 0;
+function chunkToString(chunk, encoding) {
+    if (typeof chunk === 'string')
+        return chunk;
+    if (chunk instanceof Uint8Array) {
+        return Buffer.from(chunk).toString(typeof encoding === 'string' ? encoding : 'utf8');
+    }
+    return String(chunk ?? '');
+}
+export function captureTerminalWrites() {
+    if (restore)
+        return;
+    const streams = [process.stdout, process.stderr];
+    const originals = streams.map((stream) => stream.write.bind(stream));
+    for (const stream of streams) {
+        stream.write = (chunk, encoding, callback) => {
+            if (capturedChars < MAX_CAPTURED_CHARS) {
+                const text = chunkToString(chunk, encoding);
+                captured.push(text);
+                capturedChars += text.length;
+            }
+            const done = typeof encoding === 'function' ? encoding : callback;
+            if (typeof done === 'function')
+                done();
+            return true;
+        };
+    }
+    restore = () => {
+        streams.forEach((stream, index) => {
+            stream.write = originals[index];
+        });
+    };
+}
+export function releaseTerminalWrites() {
+    if (!restore)
+        return;
+    restore();
+    restore = null;
+    if (captured.length > 0) {
+        const text = captured.join('');
+        captured = [];
+        capturedChars = 0;
+        process.stderr.write(text);
+    }
+}

package/dist/src/ui/tui/text.js

@@ -1,5 +1,14 @@
+const CSI_PATTERN = /\u001B\[[0-9;?]*[ -\/]*[@-~]/g;
+const OSC_PATTERN = /\u001B\][^\u0007\u001B]*(?:\u0007|\u001B\\)?/g;
+const CONTROL_CHAR_PATTERN = /[\u0000-\u0008\u000B-\u001F\u007F]/g;
+export function stripControlCharacters(text) {
+    return String(text ?? '')
+        .replace(OSC_PATTERN, '')
+        .replace(CSI_PATTERN, '')
+        .replace(CONTROL_CHAR_PATTERN, '');
+}
 export function span(text, style = {}) {
-    return { text, ...style };
+    return { text: stripControlCharacters(text), ...style };
 }
 export function line(...spans) {
     return { spans };
@@ -14,10 +23,11 @@ export function wrapText(text, width) {
     const lines = [];
     for (const rawLine of text.split('\n')) {
         let remaining = rawLine;
-        while (remaining.length > safeWidth) {
-            let breakAt = remaining.lastIndexOf(' ', safeWidth);
+        while (displayWidth(remaining) > safeWidth) {
+            const head = sliceToWidth(remaining, safeWidth);
+            let breakAt = head.lastIndexOf(' ');
             if (breakAt <= 0)
-                breakAt = safeWidth;
+                breakAt = head.length;
             lines.push(remaining.slice(0, breakAt).trimEnd());
             remaining = remaining.slice(breakAt).trimStart();
         }
@@ -28,3 +38,147 @@ export function wrapText(text, width) {
 export function joinLines(blocks) {
     return blocks.flat();
 }
+function isZeroWidthCodePoint(codePoint) {
+    return (codePoint === 0x200d ||
+        (codePoint >= 0x0300 && codePoint <= 0x036f) ||
+        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+        (codePoint >= 0xfe20 && codePoint <= 0xfe2f));
+}
+function isWideCodePoint(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x115f) ||
+        codePoint === 0x231a ||
+        codePoint === 0x231b ||
+        (codePoint >= 0x23e9 && codePoint <= 0x23ec) ||
+        codePoint === 0x23f0 ||
+        codePoint === 0x23f3 ||
+        (codePoint >= 0x25fd && codePoint <= 0x25fe) ||
+        (codePoint >= 0x2614 && codePoint <= 0x2615) ||
+        (codePoint >= 0x2648 && codePoint <= 0x2653) ||
+        codePoint === 0x267f ||
+        codePoint === 0x2693 ||
+        codePoint === 0x26a1 ||
+        (codePoint >= 0x26aa && codePoint <= 0x26ab) ||
+        (codePoint >= 0x26bd && codePoint <= 0x26be) ||
+        (codePoint >= 0x26c4 && codePoint <= 0x26c5) ||
+        codePoint === 0x26ce ||
+        codePoint === 0x26d4 ||
+        codePoint === 0x26ea ||
+        (codePoint >= 0x26f2 && codePoint <= 0x26f3) ||
+        codePoint === 0x26f5 ||
+        codePoint === 0x26fa ||
+        codePoint === 0x26fd ||
+        codePoint === 0x2705 ||
+        (codePoint >= 0x270a && codePoint <= 0x270b) ||
+        codePoint === 0x2728 ||
+        codePoint === 0x274c ||
+        codePoint === 0x274e ||
+        (codePoint >= 0x2753 && codePoint <= 0x2755) ||
+        codePoint === 0x2757 ||
+        (codePoint >= 0x2795 && codePoint <= 0x2797) ||
+        codePoint === 0x27b0 ||
+        codePoint === 0x27bf ||
+        (codePoint >= 0x2b1b && codePoint <= 0x2b1c) ||
+        codePoint === 0x2b50 ||
+        codePoint === 0x2b55 ||
+        (codePoint >= 0x2e80 && codePoint <= 0x303e) ||
+        (codePoint >= 0x3041 && codePoint <= 0x33ff) ||
+        (codePoint >= 0x3400 && codePoint <= 0x4dbf) ||
+        (codePoint >= 0x4e00 && codePoint <= 0x9fff) ||
+        (codePoint >= 0xa000 && codePoint <= 0xa4cf) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+        (codePoint >= 0x1f680 && codePoint <= 0x1f6ff) ||
+        (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+        (codePoint >= 0x1fa70 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
+}
+export function displayWidth(text) {
+    const chars = [...String(text ?? '')];
+    let width = 0;
+    for (let index = 0; index < chars.length; index++) {
+        const codePoint = chars[index].codePointAt(0);
+        if (isZeroWidthCodePoint(codePoint))
+            continue;
+        const next = chars[index + 1]?.codePointAt(0);
+        if (next === 0xfe0f) {
+            width += 2;
+            index++;
+            continue;
+        }
+        if (next === 0xfe0e) {
+            width += 1;
+            index++;
+            continue;
+        }
+        width += isWideCodePoint(codePoint) ? 2 : 1;
+    }
+    return width;
+}
+export function sliceToWidth(text, width) {
+    const limit = Math.max(1, Math.floor(width));
+    const chars = [...String(text ?? '')];
+    let out = '';
+    let used = 0;
+    for (let index = 0; index < chars.length; index++) {
+        const char = chars[index];
+        const next = chars[index + 1];
+        const selector = next === '️' || next === '︎';
+        const cluster = selector ? `${char}${next}` : char;
+        const clusterWidth = displayWidth(cluster);
+        if (used + clusterWidth > limit)
+            break;
+        out += cluster;
+        used += clusterWidth;
+        if (selector)
+            index++;
+    }
+    if (!out)
+        return chars[0] ?? '';
+    return out;
+}
+export function padToWidth(text, width) {
+    const current = displayWidth(text);
+    if (current >= width)
+        return text;
+    return text + ' '.repeat(width - current);
+}
+export function wrapToWidth(text, width) {
+    const limit = Math.max(1, Math.floor(width));
+    const out = [];
+    for (const rawLine of String(text ?? '').split('\n')) {
+        let current = '';
+        const flush = () => {
+            out.push(current);
+            current = '';
+        };
+        for (const token of rawLine.split(/\s+/).filter(Boolean)) {
+            let rest = token;
+            while (displayWidth(rest) > limit) {
+                if (current)
+                    flush();
+                const head = sliceToWidth(rest, limit);
+                out.push(head);
+                rest = rest.slice(head.length);
+            }
+            if (!rest)
+                continue;
+            const candidate = current ? `${current} ${rest}` : rest;
+            if (displayWidth(candidate) > limit) {
+                flush();
+                current = rest;
+            }
+            else {
+                current = candidate;
+            }
+        }
+        flush();
+    }
+    return out.length > 0 ? out : [''];
+}