@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/ink/dom.js

@@ -0,0 +1,424 @@
+import { createLayoutNode } from './layout/engine.js';
+import { LayoutDisplay, LayoutMeasureMode } from './layout/node.js';
+import measureText from './measure-text.js';
+import { addPendingClear, nodeCache } from './node-cache.js';
+import squashTextNodes from './squash-text-nodes.js';
+import { expandTabs } from './tabstops.js';
+import wrapText from './wrap-text.js';
+/**
+ * Create an element node of the given kind, allocating its yoga layout node
+ * unless the kind renders without layout (`ink-virtual-text`, `ink-link`,
+ * `ink-progress`).
+ * @param nodeName - the element kind to create.
+ * @returns the new element node.
+ */
+export const createNode = (nodeName) => {
+    const needsYogaNode = nodeName !== 'ink-virtual-text' &&
+        nodeName !== 'ink-link' &&
+        nodeName !== 'ink-progress';
+    const node = {
+        nodeName,
+        style: {},
+        attributes: {},
+        childNodes: [],
+        parentNode: undefined,
+        yogaNode: needsYogaNode ? createLayoutNode() : undefined,
+        dirty: false,
+    };
+    if (nodeName === 'ink-text') {
+        node.yogaNode?.setMeasureFunc(measureTextNode.bind(null, node));
+    }
+    else if (nodeName === 'ink-raw-ansi') {
+        node.yogaNode?.setMeasureFunc(measureRawAnsiNode.bind(null, node));
+    }
+    return node;
+};
+/**
+ * Append a child element to a parent, moving it from its current parent if
+ * any and keeping the yoga tree in sync.
+ * @param node - the parent element.
+ * @param childNode - the element to append.
+ */
+export const appendChildNode = (node, childNode) => {
+    if (childNode.parentNode) {
+        removeChildNode(childNode.parentNode, childNode);
+    }
+    childNode.parentNode = node;
+    node.childNodes.push(childNode);
+    if (childNode.yogaNode) {
+        node.yogaNode?.insertChild(childNode.yogaNode, node.yogaNode.getChildCount());
+    }
+    markDirty(node);
+};
+/**
+ * Insert a child before an existing sibling, moving it from its current
+ * parent if any and keeping the yoga tree in sync. Nodes without a yoga
+ * node do not affect yoga indices.
+ * @param node - the parent element.
+ * @param newChildNode - the node to insert.
+ * @param beforeChildNode - the sibling the new node is inserted before;
+ *   when absent from the parent, the new node is appended.
+ */
+export const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
+    if (newChildNode.parentNode) {
+        removeChildNode(newChildNode.parentNode, newChildNode);
+    }
+    newChildNode.parentNode = node;
+    const index = node.childNodes.indexOf(beforeChildNode);
+    if (index >= 0) {
+        // Calculate yoga index BEFORE modifying childNodes.
+        // We can't use DOM index directly because some children (like ink-progress,
+        // ink-link, ink-virtual-text) don't have yogaNodes, so DOM indices don't
+        // match yoga indices.
+        let yogaIndex = 0;
+        if (newChildNode.yogaNode && node.yogaNode) {
+            for (let i = 0; i < index; i++) {
+                if (node.childNodes[i]?.yogaNode) {
+                    yogaIndex++;
+                }
+            }
+        }
+        node.childNodes.splice(index, 0, newChildNode);
+        if (newChildNode.yogaNode && node.yogaNode) {
+            node.yogaNode.insertChild(newChildNode.yogaNode, yogaIndex);
+        }
+        markDirty(node);
+        return;
+    }
+    node.childNodes.push(newChildNode);
+    if (newChildNode.yogaNode) {
+        node.yogaNode?.insertChild(newChildNode.yogaNode, node.yogaNode.getChildCount());
+    }
+    markDirty(node);
+};
+/**
+ * Remove a child node from a parent, clearing its yoga node, cached rects,
+ * and parent reference.
+ * @param node - the parent element.
+ * @param removeNode - the child node to remove.
+ */
+export const removeChildNode = (node, removeNode) => {
+    if (removeNode.yogaNode) {
+        removeNode.parentNode?.yogaNode?.removeChild(removeNode.yogaNode);
+    }
+    // Collect cached rects from the removed subtree so they can be cleared
+    collectRemovedRects(node, removeNode);
+    removeNode.parentNode = undefined;
+    const index = node.childNodes.indexOf(removeNode);
+    if (index >= 0) {
+        node.childNodes.splice(index, 1);
+    }
+    markDirty(node);
+};
+function collectRemovedRects(parent, removed, underAbsolute = false) {
+    if (removed.nodeName === '#text')
+        return;
+    const elem = removed;
+    // If this node or any ancestor in the removed subtree was absolute,
+    // its painted pixels may overlap non-siblings — flag for global blit
+    // disable. Normal-flow removals only affect direct siblings, which
+    // hasRemovedChild already handles.
+    const isAbsolute = underAbsolute || elem.style.position === 'absolute';
+    const cached = nodeCache.get(elem);
+    if (cached) {
+        addPendingClear(parent, cached, isAbsolute);
+        nodeCache.delete(elem);
+    }
+    for (const child of elem.childNodes) {
+        collectRemovedRects(parent, child, isAbsolute);
+    }
+}
+/**
+ * Set an attribute on an element, skipping `children` and unchanged values
+ * so unrelated renders do not mark the node dirty.
+ * @param node - the element to update.
+ * @param key - the attribute name.
+ * @param value - the attribute value.
+ */
+export const setAttribute = (node, key, value) => {
+    // Skip 'children' - React handles children via appendChild/removeChild,
+    // not attributes. React always passes a new children reference, so
+    // tracking it as an attribute would mark everything dirty every render.
+    if (key === 'children') {
+        return;
+    }
+    // Skip if unchanged
+    if (node.attributes[key] === value) {
+        return;
+    }
+    node.attributes[key] = value;
+    markDirty(node);
+};
+/**
+ * Replace an element's style, skipping the write when the new style is
+ * shallow-equal to the current one to avoid needless dirty marks.
+ * @param node - the node to update.
+ * @param style - the new style object.
+ */
+export const setStyle = (node, style) => {
+    // Compare style properties to avoid marking dirty unnecessarily.
+    // React creates new style objects on every render even when unchanged.
+    if (stylesEqual(node.style, style)) {
+        return;
+    }
+    node.style = style;
+    markDirty(node);
+};
+/**
+ * Replace an element's text styles, skipping the write when the new styles
+ * are shallow-equal to the current ones to avoid needless dirty marks.
+ * @param node - the element to update.
+ * @param textStyles - the new text styles.
+ */
+export const setTextStyles = (node, textStyles) => {
+    // Same dirty-check guard as setStyle: React (and buildTextStyles in Text.tsx)
+    // allocate a new textStyles object on every render even when values are
+    // unchanged, so compare by value to avoid markDirty -> yoga re-measurement
+    // on every Text re-render.
+    if (shallowEqual(node.textStyles, textStyles)) {
+        return;
+    }
+    node.textStyles = textStyles;
+    markDirty(node);
+};
+function stylesEqual(a, b) {
+    return shallowEqual(a, b);
+}
+function shallowEqual(a, b) {
+    // Fast path: same object reference (or both undefined)
+    if (a === b)
+        return true;
+    if (a === undefined || b === undefined)
+        return false;
+    // Get all keys from both objects
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    // Different number of properties
+    if (aKeys.length !== bKeys.length)
+        return false;
+    // Compare each property
+    for (const key of aKeys) {
+        if (a[key] !== b[key])
+            return false;
+    }
+    return true;
+}
+/**
+ * Create a text node holding the given string.
+ * @param text - the text content.
+ * @returns the new text node.
+ */
+export const createTextNode = (text) => {
+    const node = {
+        nodeName: '#text',
+        nodeValue: text,
+        yogaNode: undefined,
+        parentNode: undefined,
+        style: {},
+    };
+    setTextNodeValue(node, text);
+    return node;
+};
+const measureWrapCache = new WeakMap();
+const measureTextNode = function (node, width, widthMode) {
+    const rawText = node.nodeName === '#text' ? node.nodeValue : squashTextNodes(node);
+    // Expand tabs for measurement (worst case: 8 spaces each).
+    // Actual tab expansion happens in output.ts based on screen position.
+    const text = expandTabs(rawText);
+    const dimensions = measureText(text, width);
+    // Text fits into container, no need to wrap
+    if (dimensions.width <= width) {
+        return dimensions;
+    }
+    // This is happening when <Box> is shrinking child nodes and layout asks
+    // if we can fit this text node in a <1px space, so we just say "no"
+    if (dimensions.width >= 1 && width > 0 && width < 1) {
+        return dimensions;
+    }
+    // For text with embedded newlines (pre-wrapped content), avoid re-wrapping
+    // at measurement width when layout is asking for intrinsic size (Undefined mode).
+    // This prevents height inflation during min/max size checks.
+    //
+    // However, when layout provides an actual constraint (Exactly or AtMost mode),
+    // we must respect it and measure at that width. Otherwise, if the actual
+    // rendering width is smaller than the natural width, the text will wrap to
+    // more lines than layout expects, causing content to be truncated.
+    if (text.includes('\n') && widthMode === LayoutMeasureMode.Undefined) {
+        const effectiveWidth = Math.max(width, dimensions.width);
+        return measureText(text, effectiveWidth);
+    }
+    const textWrap = node.style.textWrap ?? 'wrap';
+    // Incremental path: same node, same width/wrap, text grew by append.
+    const cached = measureWrapCache.get(node);
+    if (cached !== undefined && cached.width === width && cached.wrap === textWrap) {
+        if (cached.text === text) {
+            // Same-frame repeat measure (yoga min/max probing) — free.
+            return cached.result;
+        }
+        if (text.startsWith(cached.text)) {
+            const tail = text.slice(cached.tailStart);
+            const tailWrapped = wrapText(tail, width, textWrap);
+            const tailDim = measureText(tailWrapped, width);
+            // Commit fully-terminated logical lines into the head so the tail
+            // stays bounded at one line of source text.
+            const lastNewline = tail.lastIndexOf('\n');
+            let { headHeight, tailStart } = cached;
+            let tailHeight = tailDim.height;
+            if (lastNewline > 0) {
+                const committed = wrapText(tail.slice(0, lastNewline + 1), width, textWrap);
+                headHeight += measureText(committed, width).height;
+                tailStart += lastNewline + 1;
+                tailHeight = measureText(wrapText(tail.slice(lastNewline + 1), width, textWrap), width).height;
+            }
+            const result = {
+                width: Math.max(cached.result.width, tailDim.width),
+                height: headHeight + tailHeight,
+            };
+            measureWrapCache.set(node, {
+                text,
+                width,
+                wrap: textWrap,
+                headHeight,
+                tailStart,
+                tailHeight,
+                result,
+            });
+            return result;
+        }
+        // Text replaced or shrunk (node reuse for a different message): fall
+        // through to the full path and overwrite the cache below.
+    }
+    const wrappedText = wrapText(text, width, textWrap);
+    const fullResult = measureText(wrappedText, width);
+    // Seed the incremental cache: commit everything before the last newline.
+    const lastNewline = text.lastIndexOf('\n');
+    const tailStart = lastNewline === -1 ? 0 : lastNewline + 1;
+    const headHeight = tailStart === 0
+        ? 0
+        : measureText(wrapText(text.slice(0, tailStart), width, textWrap), width).height;
+    measureWrapCache.set(node, {
+        text,
+        width,
+        wrap: textWrap,
+        headHeight,
+        tailStart,
+        tailHeight: fullResult.height - headHeight,
+        result: fullResult,
+    });
+    return fullResult;
+};
+// ink-raw-ansi nodes hold pre-rendered ANSI strings with known dimensions.
+// No stringWidth, no wrapping, no tab expansion — the producer (e.g. ColorDiff)
+// already wrapped to the target width and each line is exactly one terminal row.
+const measureRawAnsiNode = function (node) {
+    return {
+        width: node.attributes['rawWidth'],
+        height: node.attributes['rawHeight'],
+    };
+};
+/**
+ * Mark a node and all its ancestors as dirty for re-rendering.
+ * Also marks yoga dirty for text remeasurement if this is a text node.
+ * @param node - the node whose dirty chain to mark; a no-op when undefined.
+ */
+export const markDirty = (node) => {
+    let current = node;
+    let markedYoga = false;
+    while (current) {
+        if (current.nodeName !== '#text') {
+            ;
+            (current).dirty = true;
+            // Only mark yoga dirty on leaf nodes that have measure functions
+            if (!markedYoga &&
+                (current.nodeName === 'ink-text' ||
+                    current.nodeName === 'ink-raw-ansi') &&
+                current.yogaNode) {
+                current.yogaNode.markDirty();
+                markedYoga = true;
+            }
+        }
+        current = current.parentNode;
+    }
+};
+/**
+ * Walk to the root and call its onRender (the throttled scheduleRender).
+ * Use for DOM-level mutations (scrollTop changes) that should trigger an
+ * Ink frame without going through React's reconciler. Pair with markDirty()
+ * so the renderer knows which subtree to re-evaluate.
+ * @param node - the node to walk up from; a no-op when undefined.
+ */
+export const scheduleRenderFrom = (node) => {
+    let cur = node;
+    while (cur?.parentNode)
+        cur = cur.parentNode;
+    if (cur && cur.nodeName !== '#text')
+        (cur).onRender?.();
+};
+/**
+ * Replace a text node's value, skipping the write when unchanged and
+ * marking the node dirty otherwise.
+ * @param node - the text node to update.
+ * @param text - the new text value; non-strings are stringified.
+ */
+export const setTextNodeValue = (node, text) => {
+    if (typeof text !== 'string') {
+        text = String(text);
+    }
+    // Skip if unchanged
+    if (node.nodeValue === text) {
+        return;
+    }
+    node.nodeValue = text;
+    markDirty(node);
+};
+function isDOMElement(node) {
+    return node.nodeName !== '#text';
+}
+/**
+ * Clear yogaNode references on a node and its whole subtree before freeing.
+ * freeRecursive() frees the node and ALL its children, so every reference
+ * must be cleared to prevent dangling pointers.
+ * @param node - the node whose subtree to clear.
+ */
+export const clearYogaNodeReferences = (node) => {
+    if ('childNodes' in node) {
+        for (const child of node.childNodes) {
+            clearYogaNodeReferences(child);
+        }
+    }
+    node.yogaNode = undefined;
+};
+/**
+ * Find the React component stack responsible for content at screen row `y`.
+ *
+ * DFS the DOM tree accumulating yoga offsets. Returns the debugOwnerChain of
+ * the deepest node whose bounding box contains `y`. Called from ink.tsx when
+ * log-update triggers a full reset, to attribute the flicker to its source.
+ *
+ * Only useful when CLAUDE_CODE_DEBUG_REPAINTS is set (otherwise chains are
+ * undefined and this returns []).
+ * @param root - the ink-root element to search from.
+ * @param y - the screen row to locate.
+ * @returns the debugOwnerChain of the deepest node containing `y`, or an
+ *   empty array when none is recorded.
+ */
+export function findOwnerChainAtRow(root, y) {
+    let best = [];
+    walk(root, 0);
+    return best;
+    function walk(node, offsetY) {
+        const yoga = node.yogaNode;
+        if (!yoga || yoga.getDisplay() === LayoutDisplay.None)
+            return;
+        const top = offsetY + yoga.getComputedTop();
+        const height = yoga.getComputedHeight();
+        if (y < top || y >= top + height)
+            return;
+        if (node.debugOwnerChain)
+            best = node.debugOwnerChain;
+        for (const child of node.childNodes) {
+            if (isDOMElement(child))
+                walk(child, top);
+        }
+    }
+}

package/lib/types/ink/events/click-event.d.ts

@@ -0,0 +1,32 @@
+import { Event } from './event.js';
+/**
+ * Mouse click event. Fired on left-button release without drag, only when
+ * mouse tracking is enabled (i.e. inside <AlternateScreen>).
+ *
+ * Bubbles from the deepest hit node up through parentNode. Call
+ * stopImmediatePropagation() to prevent ancestors' onClick from firing.
+ */
+export declare class ClickEvent extends Event {
+    /** 0-indexed screen column of the click */
+    readonly col: number;
+    /** 0-indexed screen row of the click */
+    readonly row: number;
+    /**
+     * Click column relative to the current handler's Box (col - box.x).
+     * Recomputed by dispatchClick before each handler fires, so an onClick
+     * on a container sees coords relative to that container, not to any
+     * child the click landed on.
+     */
+    localCol: number;
+    /** Click row relative to the current handler's Box (row - box.y). */
+    localRow: number;
+    /**
+     * True if the clicked cell has no visible content (unwritten in the
+     * screen buffer — both packed words are 0). Handlers can check this to
+     * ignore clicks on blank space to the right of text, so accidental
+     * clicks on empty terminal space don't toggle state.
+     */
+    readonly cellIsBlank: boolean;
+    constructor(col: number, row: number, cellIsBlank: boolean);
+}
+//# sourceMappingURL=click-event.d.ts.map

package/lib/types/ink/events/click-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"click-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/click-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,2CAA2C;IAC3C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,wCAAwC;IACxC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB;;;;;OAKG;IACH,QAAQ,SAAI;IACZ,qEAAqE;IACrE,QAAQ,SAAI;IACZ;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;gBAEjB,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO;CAM3D"}

package/lib/types/ink/events/click-event.js

@@ -0,0 +1,36 @@
+import { Event } from './event.js';
+/**
+ * Mouse click event. Fired on left-button release without drag, only when
+ * mouse tracking is enabled (i.e. inside <AlternateScreen>).
+ *
+ * Bubbles from the deepest hit node up through parentNode. Call
+ * stopImmediatePropagation() to prevent ancestors' onClick from firing.
+ */
+export class ClickEvent extends Event {
+    /** 0-indexed screen column of the click */
+    col;
+    /** 0-indexed screen row of the click */
+    row;
+    /**
+     * Click column relative to the current handler's Box (col - box.x).
+     * Recomputed by dispatchClick before each handler fires, so an onClick
+     * on a container sees coords relative to that container, not to any
+     * child the click landed on.
+     */
+    localCol = 0;
+    /** Click row relative to the current handler's Box (row - box.y). */
+    localRow = 0;
+    /**
+     * True if the clicked cell has no visible content (unwritten in the
+     * screen buffer — both packed words are 0). Handlers can check this to
+     * ignore clicks on blank space to the right of text, so accidental
+     * clicks on empty terminal space don't toggle state.
+     */
+    cellIsBlank;
+    constructor(col, row, cellIsBlank) {
+        super();
+        this.col = col;
+        this.row = row;
+        this.cellIsBlank = cellIsBlank;
+    }
+}

package/lib/types/ink/events/dispatcher.d.ts

@@ -0,0 +1,63 @@
+import type { EventTarget, TerminalEvent } from './terminal-event.js';
+type DiscreteUpdates = <A, B>(fn: (a: A, b: B) => boolean, a: A, b: B, c: undefined, d: undefined) => boolean;
+/**
+ * Owns event dispatch state and the capture/bubble dispatch loop.
+ *
+ * The reconciler host config reads currentEvent and currentUpdatePriority
+ * to implement resolveUpdatePriority, resolveEventType, and
+ * resolveEventTimeStamp — mirroring how react-dom's host config reads
+ * ReactDOMSharedInternals and window.event.
+ *
+ * discreteUpdates is injected after construction (by InkReconciler)
+ * to break the import cycle.
+ */
+export declare class Dispatcher {
+    /**
+     * The terminal event currently being dispatched, or null between dispatches.
+     */
+    currentEvent: TerminalEvent | null;
+    /**
+     * The update priority currently applied to updates triggered by dispatch,
+     * or the default priority when none is set.
+     */
+    currentUpdatePriority: number;
+    /**
+     * The reconciler's `discreteUpdates` helper, injected after construction to
+     * break the import cycle, or null before injection.
+     */
+    discreteUpdates: DiscreteUpdates | null;
+    /**
+     * Infer event priority from the currently-dispatching event.
+     * Called by the reconciler host config's resolveUpdatePriority
+     * when no explicit priority has been set.
+     * @returns the current update priority, the dispatching event's mapped
+     *   priority, or the default priority.
+     */
+    resolveEventPriority(): number;
+    /**
+     * Dispatch an event through capture and bubble phases.
+     * Returns true if preventDefault() was NOT called.
+     * @param target - the node the event is dispatched to.
+     * @param event - the event to dispatch.
+     * @returns true when `preventDefault()` was not called on the event.
+     */
+    dispatch(target: EventTarget, event: TerminalEvent): boolean;
+    /**
+     * Dispatch with discrete (sync) priority.
+     * For user-initiated events: keyboard, click, focus, paste.
+     * @param target - the node the event is dispatched to.
+     * @param event - the event to dispatch.
+     * @returns true when `preventDefault()` was not called on the event.
+     */
+    dispatchDiscrete(target: EventTarget, event: TerminalEvent): boolean;
+    /**
+     * Dispatch with continuous priority.
+     * For high-frequency events: resize, scroll, mouse move.
+     * @param target - the node the event is dispatched to.
+     * @param event - the event to dispatch.
+     * @returns true when `preventDefault()` was not called on the event.
+     */
+    dispatchContinuous(target: EventTarget, event: TerminalEvent): boolean;
+}
+export {};
+//# sourceMappingURL=dispatcher.d.ts.map

package/lib/types/ink/events/dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/dispatcher.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAqIrE,KAAK,eAAe,GAAG,CAAC,CAAC,EAAE,CAAC,EAC1B,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,EAC3B,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,KACT,OAAO,CAAA;AAEZ;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IACrB;;OAEG;IACH,YAAY,EAAE,aAAa,GAAG,IAAI,CAAO;IAEzC;;;OAGG;IACH,qBAAqB,EAAE,MAAM,CAAiC;IAE9D;;;OAGG;IACH,eAAe,EAAE,eAAe,GAAG,IAAI,CAAO;IAE9C;;;;;;OAMG;IACH,oBAAoB,IAAI,MAAM;IAU9B;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO;IAkB5D;;;;;;OAMG;IACH,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO;IAapE;;;;;;OAMG;IACH,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO;CASvE"}