mixdog 0.9.55 → 0.9.59

package/vendor/ink/build/wrap-text.js

@@ -1,5 +1,7 @@
 import wrapAnsi from 'wrap-ansi';
 import cliTruncate from 'cli-truncate';
+import sliceAnsi from 'slice-ansi';
+import stringWidth from 'string-width';
 import stripAnsi from 'strip-ansi';
 import { AMBIGUOUS_WIDE, displayStringWidth } from './display-width.js';
 const cache = {};
@@ -20,7 +22,7 @@ const SGR_RESET = '\u001B[0m';
 // OSC 8 hyperlink open (with a URL) and universal close. Cutting inside a link
 // must close it on head and re-open it on tail, exactly like an open SGR style.
 const OSC8_CLOSE = '\u001B]8;;\u0007';
-const OSC8_RE = /^\u001B\]8;;([^\u0007\u001B]*)(?:\u0007|\u001B\\)/;
+const OSC8_RE = /^\u001B\]8;([^\u0007\u001B]*);([^\u0007\u001B]*)(?:\u0007|\u001B\\)/;
 // Split one ANSI line at the first grapheme boundary where VISIBLE displayWidth
 // would exceed `max`. Walks grapheme CLUSTERS (not code points) so a clustered
 // glyph (e.g. `↔️` = U+2194 U+FE0F) is measured/kept whole. Returns
@@ -28,7 +30,7 @@ const OSC8_RE = /^\u001B\]8;;([^\u0007\u001B]*)(?:\u0007|\u001B\\)/;
 // style is still open at the cut so styling doesn't bleed); tail is the
 // remaining visible content, prefixed with the carried-over open SGR codes so
 // it renders with the same style it was cut from. ANSI escapes cost 0 width.
-const splitAtDisplayWidth = (line, max) => {
+const splitAtDisplayWidth = (line, max, forceFirst = true) => {
     if (displayStringWidth(line) <= max)
         return { head: line, tail: '' };
     let head = '';
@@ -59,7 +61,9 @@ const splitAtDisplayWidth = (line, max) => {
             else {
                 const osc = OSC8_RE.exec(m[0]);
                 if (osc)
-                    openLink = osc[1] ? m[0] : '';
+                    // Preserve the complete OSC 8 opener, including optional
+                    // params such as `id=x`, when carrying a link to the tail.
+                    openLink = osc[2] ? m[0] : '';
             }
             rest = rest.slice(m[0].length);
             continue;
@@ -69,7 +73,7 @@ const splitAtDisplayWidth = (line, max) => {
         // Progress guarantee: if nothing visible has landed on head yet, force
         // the first grapheme through even when it alone exceeds max (a 1-cluster
         // overflow is unavoidable and preferable to a zero-progress loop).
-        if (width + w > max && width > 0)
+        if (width + w > max && (width > 0 || !forceFirst))
             break;
         head += segment;
         width += w;
@@ -109,6 +113,43 @@ const reflowToDisplayWidth = (line, max) => {
 // truncate-end: cutting is the intended behavior — drop the overflow but still
 // cut on grapheme boundaries and close open styles.
 const hardCutToDisplayWidth = (line, max) => splitAtDisplayWidth(line, max).head;
+// Clipping cannot use wrapping's progress guarantee: a two-cell grapheme in a
+// one-cell remainder must be dropped, never forced through the clip edge.
+const strictCutToDisplayWidth = (line, max) => max <= 0
+    ? ''
+    : splitAtDisplayWidth(line, max, false).head;
+// [mixdog fork] Policy-aware ANSI slice for Output's horizontal clipping.
+// `slice-ansi` measures ambiguous glyphs with plain string-width, so its
+// from/to columns drift whenever a clipped transcript row contains ①/②/③.
+// Keep the same split primitive as wrapping so clipping and measurement use
+// identical terminal-cell boundaries.
+export const sliceTextByDisplayWidthWithPolicy = (line, from, to, wide) => {
+    const start = Math.max(0, Math.floor(Number(from) || 0));
+    const end = Math.max(start, Math.floor(Number(to) || 0));
+    const source = String(line ?? '');
+    const plain = stripAnsi(source);
+    // Preserve exact upstream bytes (including its choice of SGR close code)
+    // unless the active policy actually changes this line's measured width.
+    // The broad trigger regex also contains ←/↑/→/↓ and ↻, which the true
+    // policy deliberately excludes; a width-delta check keeps those lines on
+    // slice-ansi's byte-identical path.
+    if (!wide || displayStringWidth(plain) === stringWidth(plain))
+        return sliceAnsi(source, start, end);
+    if (end <= start)
+        return '';
+    let remainder = source;
+    if (start > 0) {
+        const prefix = splitAtDisplayWidth(remainder, start);
+        remainder = prefix.tail;
+        // If `start` lands inside a wide grapheme, consume that whole grapheme:
+        // rendering half of it at x1 would still cross the left clip boundary.
+        if (remainder && displayStringWidth(prefix.head) < start) {
+            remainder = splitAtDisplayWidth(remainder, 1).tail;
+        }
+    }
+    return strictCutToDisplayWidth(remainder, end - start);
+};
+export const sliceTextByDisplayWidth = (line, from, to) => sliceTextByDisplayWidthWithPolicy(line, from, to, AMBIGUOUS_WIDE);
 // Re-enforce the display-width budget on every produced line when the policy is
 // ON and the source contains a problem glyph. No-op otherwise (byte-identical
 // to upstream wrap-ansi output), so terminals without the wide policy are