@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/ink/styles.js

@@ -0,0 +1,307 @@
+import { LayoutAlign, LayoutDisplay, LayoutEdge, LayoutFlexDirection, LayoutGutter, LayoutJustify, LayoutOverflow, LayoutPositionType, LayoutWrap, } from './layout/node.js';
+const applyPositionStyles = (node, style) => {
+    if ('position' in style) {
+        node.setPositionType(style.position === 'absolute'
+            ? LayoutPositionType.Absolute
+            : LayoutPositionType.Relative);
+    }
+    if ('top' in style)
+        applyPositionEdge(node, 'top', style.top);
+    if ('bottom' in style)
+        applyPositionEdge(node, 'bottom', style.bottom);
+    if ('left' in style)
+        applyPositionEdge(node, 'left', style.left);
+    if ('right' in style)
+        applyPositionEdge(node, 'right', style.right);
+};
+function applyPositionEdge(node, edge, v) {
+    if (typeof v === 'string') {
+        node.setPositionPercent(edge, Number.parseInt(v, 10));
+    }
+    else if (typeof v === 'number') {
+        node.setPosition(edge, v);
+    }
+    else {
+        node.setPosition(edge, Number.NaN);
+    }
+}
+const applyOverflowStyles = (node, style) => {
+    // Yoga's Overflow controls whether children expand the container.
+    // 'hidden' and 'scroll' both prevent expansion; 'scroll' additionally
+    // signals that the renderer should apply scrollTop translation.
+    // overflowX/Y are render-time concerns; for layout we use the union.
+    const y = style.overflowY ?? style.overflow;
+    const x = style.overflowX ?? style.overflow;
+    if (y === 'scroll' || x === 'scroll') {
+        node.setOverflow(LayoutOverflow.Scroll);
+    }
+    else if (y === 'hidden' || x === 'hidden') {
+        node.setOverflow(LayoutOverflow.Hidden);
+    }
+    else if ('overflow' in style ||
+        'overflowX' in style ||
+        'overflowY' in style) {
+        node.setOverflow(LayoutOverflow.Visible);
+    }
+};
+const applyMarginStyles = (node, style) => {
+    if ('margin' in style) {
+        node.setMargin(LayoutEdge.All, style.margin ?? 0);
+    }
+    if ('marginX' in style) {
+        node.setMargin(LayoutEdge.Horizontal, style.marginX ?? 0);
+    }
+    if ('marginY' in style) {
+        node.setMargin(LayoutEdge.Vertical, style.marginY ?? 0);
+    }
+    if ('marginLeft' in style) {
+        node.setMargin(LayoutEdge.Start, style.marginLeft || 0);
+    }
+    if ('marginRight' in style) {
+        node.setMargin(LayoutEdge.End, style.marginRight || 0);
+    }
+    if ('marginTop' in style) {
+        node.setMargin(LayoutEdge.Top, style.marginTop || 0);
+    }
+    if ('marginBottom' in style) {
+        node.setMargin(LayoutEdge.Bottom, style.marginBottom || 0);
+    }
+};
+const applyPaddingStyles = (node, style) => {
+    if ('padding' in style) {
+        node.setPadding(LayoutEdge.All, style.padding ?? 0);
+    }
+    if ('paddingX' in style) {
+        node.setPadding(LayoutEdge.Horizontal, style.paddingX ?? 0);
+    }
+    if ('paddingY' in style) {
+        node.setPadding(LayoutEdge.Vertical, style.paddingY ?? 0);
+    }
+    if ('paddingLeft' in style) {
+        node.setPadding(LayoutEdge.Left, style.paddingLeft || 0);
+    }
+    if ('paddingRight' in style) {
+        node.setPadding(LayoutEdge.Right, style.paddingRight || 0);
+    }
+    if ('paddingTop' in style) {
+        node.setPadding(LayoutEdge.Top, style.paddingTop || 0);
+    }
+    if ('paddingBottom' in style) {
+        node.setPadding(LayoutEdge.Bottom, style.paddingBottom || 0);
+    }
+};
+const applyFlexStyles = (node, style) => {
+    if ('flexGrow' in style) {
+        node.setFlexGrow(style.flexGrow ?? 0);
+    }
+    if ('flexShrink' in style) {
+        node.setFlexShrink(typeof style.flexShrink === 'number' ? style.flexShrink : 1);
+    }
+    if ('flexWrap' in style) {
+        if (style.flexWrap === 'nowrap') {
+            node.setFlexWrap(LayoutWrap.NoWrap);
+        }
+        if (style.flexWrap === 'wrap') {
+            node.setFlexWrap(LayoutWrap.Wrap);
+        }
+        if (style.flexWrap === 'wrap-reverse') {
+            node.setFlexWrap(LayoutWrap.WrapReverse);
+        }
+    }
+    if ('flexDirection' in style) {
+        if (style.flexDirection === 'row') {
+            node.setFlexDirection(LayoutFlexDirection.Row);
+        }
+        if (style.flexDirection === 'row-reverse') {
+            node.setFlexDirection(LayoutFlexDirection.RowReverse);
+        }
+        if (style.flexDirection === 'column') {
+            node.setFlexDirection(LayoutFlexDirection.Column);
+        }
+        if (style.flexDirection === 'column-reverse') {
+            node.setFlexDirection(LayoutFlexDirection.ColumnReverse);
+        }
+    }
+    if ('flexBasis' in style) {
+        if (typeof style.flexBasis === 'number') {
+            node.setFlexBasis(style.flexBasis);
+        }
+        else if (typeof style.flexBasis === 'string') {
+            node.setFlexBasisPercent(Number.parseInt(style.flexBasis, 10));
+        }
+        else {
+            node.setFlexBasis(Number.NaN);
+        }
+    }
+    if ('alignItems' in style) {
+        if (style.alignItems === 'stretch' || !style.alignItems) {
+            node.setAlignItems(LayoutAlign.Stretch);
+        }
+        if (style.alignItems === 'flex-start') {
+            node.setAlignItems(LayoutAlign.FlexStart);
+        }
+        if (style.alignItems === 'center') {
+            node.setAlignItems(LayoutAlign.Center);
+        }
+        if (style.alignItems === 'flex-end') {
+            node.setAlignItems(LayoutAlign.FlexEnd);
+        }
+    }
+    if ('alignSelf' in style) {
+        if (style.alignSelf === 'auto' || !style.alignSelf) {
+            node.setAlignSelf(LayoutAlign.Auto);
+        }
+        if (style.alignSelf === 'flex-start') {
+            node.setAlignSelf(LayoutAlign.FlexStart);
+        }
+        if (style.alignSelf === 'center') {
+            node.setAlignSelf(LayoutAlign.Center);
+        }
+        if (style.alignSelf === 'flex-end') {
+            node.setAlignSelf(LayoutAlign.FlexEnd);
+        }
+    }
+    if ('justifyContent' in style) {
+        if (style.justifyContent === 'flex-start' || !style.justifyContent) {
+            node.setJustifyContent(LayoutJustify.FlexStart);
+        }
+        if (style.justifyContent === 'center') {
+            node.setJustifyContent(LayoutJustify.Center);
+        }
+        if (style.justifyContent === 'flex-end') {
+            node.setJustifyContent(LayoutJustify.FlexEnd);
+        }
+        if (style.justifyContent === 'space-between') {
+            node.setJustifyContent(LayoutJustify.SpaceBetween);
+        }
+        if (style.justifyContent === 'space-around') {
+            node.setJustifyContent(LayoutJustify.SpaceAround);
+        }
+        if (style.justifyContent === 'space-evenly') {
+            node.setJustifyContent(LayoutJustify.SpaceEvenly);
+        }
+    }
+};
+const applyDimensionStyles = (node, style) => {
+    if ('width' in style) {
+        if (typeof style.width === 'number') {
+            node.setWidth(style.width);
+        }
+        else if (typeof style.width === 'string') {
+            node.setWidthPercent(Number.parseInt(style.width, 10));
+        }
+        else {
+            node.setWidthAuto();
+        }
+    }
+    if ('height' in style) {
+        if (typeof style.height === 'number') {
+            node.setHeight(style.height);
+        }
+        else if (typeof style.height === 'string') {
+            node.setHeightPercent(Number.parseInt(style.height, 10));
+        }
+        else {
+            node.setHeightAuto();
+        }
+    }
+    if ('minWidth' in style) {
+        if (typeof style.minWidth === 'string') {
+            node.setMinWidthPercent(Number.parseInt(style.minWidth, 10));
+        }
+        else {
+            node.setMinWidth(style.minWidth ?? 0);
+        }
+    }
+    if ('minHeight' in style) {
+        if (typeof style.minHeight === 'string') {
+            node.setMinHeightPercent(Number.parseInt(style.minHeight, 10));
+        }
+        else {
+            node.setMinHeight(style.minHeight ?? 0);
+        }
+    }
+    if ('maxWidth' in style) {
+        if (typeof style.maxWidth === 'string') {
+            node.setMaxWidthPercent(Number.parseInt(style.maxWidth, 10));
+        }
+        else {
+            node.setMaxWidth(style.maxWidth ?? 0);
+        }
+    }
+    if ('maxHeight' in style) {
+        if (typeof style.maxHeight === 'string') {
+            node.setMaxHeightPercent(Number.parseInt(style.maxHeight, 10));
+        }
+        else {
+            node.setMaxHeight(style.maxHeight ?? 0);
+        }
+    }
+};
+const applyDisplayStyles = (node, style) => {
+    if ('display' in style) {
+        node.setDisplay(style.display === 'flex' ? LayoutDisplay.Flex : LayoutDisplay.None);
+    }
+};
+const applyBorderStyles = (node, style, resolvedStyle) => {
+    // resolvedStyle is the full current style (already set on the DOM node).
+    // style may be a diff with only changed properties. For border side props,
+    // we need the resolved value because `borderStyle` in a diff may not include
+    // unchanged border side values (e.g. borderTop stays false but isn't in the diff).
+    const resolved = resolvedStyle ?? style;
+    if ('borderStyle' in style) {
+        const borderWidth = style.borderStyle ? 1 : 0;
+        node.setBorder(LayoutEdge.Top, resolved.borderTop !== false ? borderWidth : 0);
+        node.setBorder(LayoutEdge.Bottom, resolved.borderBottom !== false ? borderWidth : 0);
+        node.setBorder(LayoutEdge.Left, resolved.borderLeft !== false ? borderWidth : 0);
+        node.setBorder(LayoutEdge.Right, resolved.borderRight !== false ? borderWidth : 0);
+    }
+    else {
+        // Handle individual border property changes (when only borderX changes without borderStyle).
+        // Skip undefined values — they mean the prop was removed or never set,
+        // not that a border should be enabled.
+        if ('borderTop' in style && style.borderTop !== undefined) {
+            node.setBorder(LayoutEdge.Top, style.borderTop === false ? 0 : 1);
+        }
+        if ('borderBottom' in style && style.borderBottom !== undefined) {
+            node.setBorder(LayoutEdge.Bottom, style.borderBottom === false ? 0 : 1);
+        }
+        if ('borderLeft' in style && style.borderLeft !== undefined) {
+            node.setBorder(LayoutEdge.Left, style.borderLeft === false ? 0 : 1);
+        }
+        if ('borderRight' in style && style.borderRight !== undefined) {
+            node.setBorder(LayoutEdge.Right, style.borderRight === false ? 0 : 1);
+        }
+    }
+};
+const applyGapStyles = (node, style) => {
+    if ('gap' in style) {
+        node.setGap(LayoutGutter.All, style.gap ?? 0);
+    }
+    if ('columnGap' in style) {
+        node.setGap(LayoutGutter.Column, style.columnGap ?? 0);
+    }
+    if ('rowGap' in style) {
+        node.setGap(LayoutGutter.Row, style.rowGap ?? 0);
+    }
+};
+/**
+ * Apply a style diff to a layout node, delegating each property group to its
+ * Yoga setter. The node's styles must already be applied elsewhere; `style`
+ * may be a diff containing only changed properties.
+ * @param node - the layout node to style.
+ * @param style - the styles to apply; defaults to an empty object.
+ * @param resolvedStyle - the node's full current styles, used to resolve border side values.
+ */
+const styles = (node, style = {}, resolvedStyle) => {
+    applyPositionStyles(node, style);
+    applyOverflowStyles(node, style);
+    applyMarginStyles(node, style);
+    applyPaddingStyles(node, style);
+    applyFlexStyles(node, style);
+    applyDimensionStyles(node, style);
+    applyDisplayStyles(node, style);
+    applyBorderStyles(node, style, resolvedStyle);
+    applyGapStyles(node, style);
+};
+export default styles;

package/lib/types/ink/supports-hyperlinks.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Terminals that support OSC 8 hyperlinks but are not detected by the
+ * supports-hyperlinks library. Checked against both TERM_PROGRAM and
+ * LC_TERMINAL (the latter is preserved inside tmux).
+ */
+export declare const ADDITIONAL_HYPERLINK_TERMINALS: string[];
+type EnvLike = Record<string, string | undefined>;
+type SupportsHyperlinksOptions = {
+    env?: EnvLike;
+    stdoutSupported?: boolean;
+};
+/**
+ * Returns whether stdout supports OSC 8 hyperlinks.
+ * Extends the supports-hyperlinks library with additional terminal detection.
+ * @param options Optional overrides for testing (env, stdoutSupported)
+ * @returns true when stdout or the detected terminal supports hyperlinks.
+ */
+export declare function supportsHyperlinks(options?: SupportsHyperlinksOptions): boolean;
+export {};
+//# sourceMappingURL=supports-hyperlinks.d.ts.map

package/lib/types/ink/supports-hyperlinks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supports-hyperlinks.d.ts","sourceRoot":"","sources":["../../../src/ink/supports-hyperlinks.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,UAO1C,CAAA;AAED,KAAK,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;AAEjD,KAAK,yBAAyB,GAAG;IAC/B,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CA6BT"}

package/lib/types/ink/supports-hyperlinks.js

@@ -0,0 +1,44 @@
+import supportsHyperlinksLib from 'supports-hyperlinks';
+/**
+ * Terminals that support OSC 8 hyperlinks but are not detected by the
+ * supports-hyperlinks library. Checked against both TERM_PROGRAM and
+ * LC_TERMINAL (the latter is preserved inside tmux).
+ */
+export const ADDITIONAL_HYPERLINK_TERMINALS = [
+    'ghostty',
+    'Hyper',
+    'kitty',
+    'alacritty',
+    'iTerm.app',
+    'iTerm2',
+];
+/**
+ * Returns whether stdout supports OSC 8 hyperlinks.
+ * Extends the supports-hyperlinks library with additional terminal detection.
+ * @param options Optional overrides for testing (env, stdoutSupported)
+ * @returns true when stdout or the detected terminal supports hyperlinks.
+ */
+export function supportsHyperlinks(options) {
+    const stdoutSupported = options?.stdoutSupported ?? supportsHyperlinksLib.stdout;
+    if (stdoutSupported) {
+        return true;
+    }
+    const env = options?.env ?? process.env;
+    // Check for additional terminals not detected by supports-hyperlinks
+    const termProgram = env['TERM_PROGRAM'];
+    if (termProgram && ADDITIONAL_HYPERLINK_TERMINALS.includes(termProgram)) {
+        return true;
+    }
+    // LC_TERMINAL is set by some terminals (e.g. iTerm2) and preserved inside tmux,
+    // where TERM_PROGRAM is overwritten to 'tmux'.
+    const lcTerminal = env['LC_TERMINAL'];
+    if (lcTerminal && ADDITIONAL_HYPERLINK_TERMINALS.includes(lcTerminal)) {
+        return true;
+    }
+    // Kitty sets TERM=xterm-kitty
+    const term = env['TERM'];
+    if (term?.includes('kitty')) {
+        return true;
+    }
+    return false;
+}

package/lib/types/ink/tabstops.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Expand tab characters to spaces at fixed column intervals, preserving
+ * escape sequences and resetting the column on newlines.
+ * @param text - the text to expand.
+ * @param interval - the tab stop interval in columns; defaults to 8.
+ * @returns `text` with every tab replaced by the spaces needed to reach the next stop.
+ */
+export declare function expandTabs(text: string, interval?: number): string;
+//# sourceMappingURL=tabstops.d.ts.map

package/lib/types/ink/tabstops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabstops.d.ts","sourceRoot":"","sources":["../../../src/ink/tabstops.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,QAAQ,SAAuB,GAC9B,MAAM,CAkCR"}

package/lib/types/ink/tabstops.js

@@ -0,0 +1,46 @@
+// Tab expansion, inspired by Ghostty's Tabstops.zig
+// Uses 8-column intervals (POSIX default, hardcoded in terminals like Ghostty)
+import { stringWidth } from './stringWidth.js';
+import { createTokenizer } from './termio/tokenize.js';
+const DEFAULT_TAB_INTERVAL = 8;
+/**
+ * Expand tab characters to spaces at fixed column intervals, preserving
+ * escape sequences and resetting the column on newlines.
+ * @param text - the text to expand.
+ * @param interval - the tab stop interval in columns; defaults to 8.
+ * @returns `text` with every tab replaced by the spaces needed to reach the next stop.
+ */
+export function expandTabs(text, interval = DEFAULT_TAB_INTERVAL) {
+    if (!text.includes('\t')) {
+        return text;
+    }
+    const tokenizer = createTokenizer();
+    const tokens = tokenizer.feed(text);
+    tokens.push(...tokenizer.flush());
+    let result = '';
+    let column = 0;
+    for (const token of tokens) {
+        if (token.type === 'sequence') {
+            result += token.value;
+        }
+        else {
+            const parts = token.value.split(/(\t|\n)/);
+            for (const part of parts) {
+                if (part === '\t') {
+                    const spaces = interval - (column % interval);
+                    result += ' '.repeat(spaces);
+                    column += spaces;
+                }
+                else if (part === '\n') {
+                    result += part;
+                    column = 0;
+                }
+                else {
+                    result += part;
+                    column += stringWidth(part);
+                }
+            }
+        }
+    }
+    return result;
+}

package/lib/types/ink/terminal-focus-state.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Terminal focus state, driven by DECSET 1004 focus events. 'unknown' is
+ * the default for terminals that don't support focus reporting; consumers
+ * treat 'unknown' identically to 'focused' (no throttling).
+ */
+export type TerminalFocusState = 'focused' | 'blurred' | 'unknown';
+/**
+ * Record a terminal focus change and notify subscribers synchronously.
+ * A blur also resolves pending focus waiters.
+ * @param v - true when the terminal gained focus, false when it blurred.
+ */
+export declare function setTerminalFocused(v: boolean): void;
+/**
+ * Whether the terminal is currently considered focused. 'unknown' counts
+ * as focused so terminals without focus reporting never appear blurred.
+ * @returns true unless the terminal is known to be blurred.
+ */
+export declare function getTerminalFocused(): boolean;
+/**
+ * The current terminal focus state ('focused' | 'blurred' | 'unknown').
+ * @returns the current focus state.
+ */
+export declare function getTerminalFocusState(): TerminalFocusState;
+/**
+ * Subscribe to focus-change notifications, for useSyncExternalStore.
+ * @param cb - callback invoked synchronously on every focus change.
+ * @returns a function that unsubscribes the callback.
+ */
+export declare function subscribeTerminalFocus(cb: () => void): () => void;
+/**
+ * Reset the focus state to 'unknown' and notify subscribers. Used when
+ * focus reporting is (re)initialized.
+ */
+export declare function resetTerminalFocusState(): void;
+//# sourceMappingURL=terminal-focus-state.d.ts.map

package/lib/types/ink/terminal-focus-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-focus-state.d.ts","sourceRoot":"","sources":["../../../src/ink/terminal-focus-state.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;AAMlE;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI,CAYnD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,kBAAkB,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKjE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAK9C"}

package/lib/types/ink/terminal-focus-state.js

@@ -0,0 +1,57 @@
+let focusState = 'unknown';
+const resolvers = new Set();
+const subscribers = new Set();
+/**
+ * Record a terminal focus change and notify subscribers synchronously.
+ * A blur also resolves pending focus waiters.
+ * @param v - true when the terminal gained focus, false when it blurred.
+ */
+export function setTerminalFocused(v) {
+    focusState = v ? 'focused' : 'blurred';
+    // Notify useSyncExternalStore subscribers
+    for (const cb of subscribers) {
+        cb();
+    }
+    if (!v) {
+        for (const resolve of resolvers) {
+            resolve();
+        }
+        resolvers.clear();
+    }
+}
+/**
+ * Whether the terminal is currently considered focused. 'unknown' counts
+ * as focused so terminals without focus reporting never appear blurred.
+ * @returns true unless the terminal is known to be blurred.
+ */
+export function getTerminalFocused() {
+    return focusState !== 'blurred';
+}
+/**
+ * The current terminal focus state ('focused' | 'blurred' | 'unknown').
+ * @returns the current focus state.
+ */
+export function getTerminalFocusState() {
+    return focusState;
+}
+/**
+ * Subscribe to focus-change notifications, for useSyncExternalStore.
+ * @param cb - callback invoked synchronously on every focus change.
+ * @returns a function that unsubscribes the callback.
+ */
+export function subscribeTerminalFocus(cb) {
+    subscribers.add(cb);
+    return () => {
+        subscribers.delete(cb);
+    };
+}
+/**
+ * Reset the focus state to 'unknown' and notify subscribers. Used when
+ * focus reporting is (re)initialized.
+ */
+export function resetTerminalFocusState() {
+    focusState = 'unknown';
+    for (const cb of subscribers) {
+        cb();
+    }
+}