@toddzheng024/dscode-bundle 0.7.12 → 0.7.13

package/vendor/tui/lib/render/ime-cursor.mjs

@@ -0,0 +1,135 @@
+/**
+ * IME cursor anchoring for the composer.
+ *
+ * Ink keeps the real terminal cursor hidden and parks it just below the
+ * dynamic tree (after the status row). IME composition text and candidate
+ * windows anchor to that real cursor cell - VS Code's integrated terminal
+ * positions its hidden IME textarea there, and Windows consoles behave the
+ * same - so CJK input appeared at the bottom of the screen instead of at the
+ * caret. The anchor moves the real cursor onto the caret cell without
+ * touching Ink's relative erase ledger:
+ *
+ * - the displacement is owned: before any foreign write or re-anchor, the
+ *   wrapper cancels it (cursor down, column 1), so every writer - Ink's
+ *   log-update rewrites, the resize replay, protocol pushes - keeps seeing
+ *   the cursor exactly where it was left;
+ * - log-update frame chunks (which start with the erase-line sequence) get
+ *   the anchor re-appended inside the same write, so a repaint can never
+ *   leave the cursor behind - in particular the caret blink keeps the anchor
+ *   stable while an IME composition is open, because the terminal parses the
+ *   rewrite and the re-anchor as one atomic update.
+ *
+ * @module @deepseek-ai/dsh-code/render/ime-cursor
+ */
+import { useEffect, useRef } from 'react';
+import { useStdout } from 'ink';
+/** Cancel `rows` of owned upward displacement and return to column 1. */
+export function imeCursorRestore(rows) {
+    return rows > 0 ? `\x1b[${rows}B\r` : '';
+}
+/** Move onto the caret cell: `rows` up from Ink's parked row, 0-based column. */
+export function imeCursorMove(rows, column) {
+    return rows > 0 ? `\x1b[${rows}A\x1b[${column + 1}G` : '';
+}
+/**
+ * Rows between the caret cell and Ink's parked cursor row: the band's bottom
+ * blank row, the editor window rows below the caret, the status footer, and
+ * Ink's own below-frame row. Rows above the composer (gutter, live content)
+ * never enter this distance.
+ */
+export function imeCursorRowsUp(input) {
+    return Math.max(1, input.editorWindowRows - input.caretRowInWindow + input.rowsBelowComposer);
+}
+/** log-update chunks start with the erase-line sequence; a chunk without it
+ * leaves no frame behind, so the next commit re-applies the anchor. */
+const FRAME_CHUNK_MARKER = '\x1b[2K';
+const ANCHOR_STATE = Symbol.for('dsh-code.ime-cursor-anchor');
+/**
+ * Take over `stream.write` so the anchor displacement stays invisible to every
+ * other writer. Idempotent per stream: a second install returns the live
+ * handle. Returns `undefined` on non-TTY streams where anchoring is meaningless.
+ */
+export function installImeCursorAnchor(stream) {
+    if (stream?.isTTY !== true)
+        return undefined;
+    const target = stream;
+    const installed = target[ANCHOR_STATE];
+    if (installed !== undefined)
+        return installed;
+    const originalWrite = target.write.bind(target);
+    let rows = 0;
+    let column = -1;
+    let detached = false;
+    const anchor = {
+        anchor(nextRows, nextColumn) {
+            if (detached)
+                return;
+            if (nextRows <= 0) {
+                if (rows !== 0)
+                    originalWrite(imeCursorRestore(rows));
+                rows = 0;
+                column = -1;
+                return;
+            }
+            if (rows === nextRows && column === nextColumn)
+                return;
+            originalWrite(imeCursorRestore(rows) + imeCursorMove(nextRows, nextColumn));
+            rows = nextRows;
+            column = nextColumn;
+        },
+        release() {
+            if (detached)
+                return;
+            detached = true;
+            if (rows !== 0)
+                originalWrite(imeCursorRestore(rows));
+            rows = 0;
+            column = -1;
+            target.write = originalWrite;
+            delete target[ANCHOR_STATE];
+        },
+    };
+    target.write = ((chunk, ...rest) => {
+        const ownedRows = rows;
+        const ownedColumn = column;
+        if (ownedRows === 0 || typeof chunk !== 'string') {
+            if (ownedRows !== 0) {
+                originalWrite(imeCursorRestore(ownedRows));
+                rows = 0;
+                column = -1;
+            }
+            return originalWrite(chunk, ...rest);
+        }
+        const reanchor = chunk.startsWith(FRAME_CHUNK_MARKER);
+        rows = reanchor ? ownedRows : 0;
+        column = reanchor ? ownedColumn : -1;
+        return originalWrite(imeCursorRestore(ownedRows) + chunk + (reanchor ? imeCursorMove(ownedRows, ownedColumn) : ''), ...rest);
+    });
+    target[ANCHOR_STATE] = anchor;
+    return anchor;
+}
+/**
+ * Keep the real terminal cursor on the composer's caret cell while `active`
+ * (the editable composer). The second effect runs after every commit without
+ * a dep list: frame rewrites restore the anchor themselves, but any other
+ * write (protocol push, resize replay) leaves the cursor at Ink's parked
+ * position, and the next commit re-anchors it.
+ */
+export function useImeCursorAnchor(active, rows, column) {
+    const { stdout } = useStdout();
+    const anchorRef = useRef(undefined);
+    useEffect(() => {
+        if (stdout === undefined)
+            return undefined;
+        const installed = installImeCursorAnchor(stdout);
+        anchorRef.current = installed;
+        return () => {
+            installed?.release();
+            if (anchorRef.current === installed)
+                anchorRef.current = undefined;
+        };
+    }, [stdout]);
+    useEffect(() => {
+        anchorRef.current?.anchor(active && rows > 0 ? rows : 0, column);
+    });
+}

package/vendor/tui/lib/render/inspector.mjs

@@ -0,0 +1,93 @@
+/** Pure viewport, selection, and scrolling rules for exclusive TUI panels. */
+/** Composer (3) + two-row status chrome, plus one optional fixed-height local notice row. */
+const INSPECTOR_CHROME_ROWS = 6;
+/** One transcript-to-composer gutter, collapsed on short terminals. */
+export function layoutGutterRows(rows) {
+    return Math.max(1, Math.floor(rows)) >= 14 ? 1 : 0;
+}
+/**
+ * Rows left for live transcript and streaming after pinning the composer and
+ * status at the bottom. Variable chrome (menu, notice, todos, agents, extra
+ * status row, extra editor rows) is deducted here so those rows cover the
+ * live region instead of growing the tree and moving the bottom bar.
+ */
+export function liveRegionBudget(chrome) {
+    const terminal = Math.max(1, Math.floor(chrome.terminalRows));
+    const editor = Math.max(1, Math.floor(chrome.composerRows));
+    const band = editor + 2;
+    const status = chrome.statusBarRows === 2 ? 2 : 1;
+    const menu = Math.max(0, Math.floor(chrome.menuRows));
+    const gutter = chrome.gutterRows;
+    const notice = chrome.notice ? 1 : 0;
+    const todo = chrome.todo ? 1 : 0;
+    const agents = chrome.agents ? 1 : 0;
+    // Two spare rows: Ink's parked cursor, plus one so the painted tree never
+    // reaches stdout.rows (equality takes the full-terminal clear path).
+    const inkSpare = 2;
+    return Math.max(1, terminal - band - status - menu - gutter - notice - todo - agents - inkSpare);
+}
+/**
+ * Keep the inspector plus its persistent status/composer chrome below
+ * `stdout.rows`: at equality Ink clears the terminal and rewrites all
+ * accumulated `<Static>` output on every frame.
+ */
+export function panelViewport(columns, rows) {
+    const safeColumns = Math.max(1, Math.floor(columns));
+    const safeRows = Math.max(1, Math.floor(rows));
+    // Two spare rows cover Ink's first-frame transition from existing Static
+    // scrollback into a tall dynamic panel. A one-row margin is insufficient:
+    // the transition can still take the full-terminal rewrite path at rows - 1.
+    const maxHeight = Math.max(0, Math.min(safeRows - 2 - INSPECTOR_CHROME_ROWS - layoutGutterRows(safeRows), Math.floor(safeRows / 2)));
+    const compact = maxHeight < 5 || safeColumns < 8;
+    const gapRows = !compact && maxHeight >= 7 ? 2 : 0;
+    // A terminal may autowrap a glyph written into its final column. Ink still
+    // accounts for that border as one logical row, so the next dynamic update
+    // erases too few physical rows and leaves stacked frames behind. Codex
+    // renders overlays within an inset surface; reserve the final column here
+    // so every Ink panel follows the same contract.
+    const outerColumns = compact ? safeColumns : Math.max(1, safeColumns - 1);
+    return {
+        maxHeight,
+        bodyRows: compact ? 0 : maxHeight - 4 - gapRows,
+        gapRows,
+        contentColumns: compact ? Math.max(1, safeColumns - 1) : Math.max(1, outerColumns - 4),
+        outerColumns,
+        compact,
+    };
+}
+/** Backward-compatible name for the Ctrl+O-specific caller and tests. */
+export function inspectorViewport(columns, rows) {
+    return panelViewport(columns, rows);
+}
+/** Clamp a first-visible row to the range representable by one viewport. */
+export function clampScroll(offset, totalRows, visibleRows) {
+    const total = Math.max(0, Math.floor(totalRows));
+    const size = Math.max(0, Math.floor(visibleRows));
+    const last = Math.max(0, total - size);
+    return Math.max(0, Math.min(Math.floor(offset), last));
+}
+/** Move a viewport by a signed row delta without escaping its content. */
+export function moveScroll(offset, delta, totalRows, visibleRows) {
+    return clampScroll(offset + delta, totalRows, visibleRows);
+}
+/** Keep one focused row visible while preserving the current window when possible. */
+export function revealRow(offset, row, totalRows, visibleRows) {
+    const size = Math.max(1, Math.floor(visibleRows));
+    const target = Math.max(0, Math.min(Math.floor(row), Math.max(0, totalRows - 1)));
+    if (target < offset)
+        return clampScroll(target, totalRows, size);
+    if (target >= offset + size)
+        return clampScroll(target - size + 1, totalRows, size);
+    return clampScroll(offset, totalRows, size);
+}
+/** Center a selected list row where possible, clamped at both ends. */
+export function selectionWindow(cursor, totalRows, visibleRows) {
+    return clampScroll(cursor - Math.floor(Math.max(1, visibleRows) / 2), totalRows, visibleRows);
+}
+/** Follow appended history only while the inspector cursor was at the tail. */
+export function followInspectorCursor(cursor, previousLength, nextLength) {
+    const nextLast = Math.max(0, nextLength - 1);
+    if (cursor >= Math.max(0, previousLength - 1))
+        return nextLast;
+    return Math.min(cursor, nextLast);
+}