@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/ink/events/dispatcher.js

@@ -0,0 +1,194 @@
+import { ContinuousEventPriority, DefaultEventPriority, DiscreteEventPriority, NoEventPriority, } from 'react-reconciler/constants.js';
+import { logError } from '../../utils/log.js';
+import { HANDLER_FOR_EVENT } from './event-handlers.js';
+function getHandler(node, eventType, capture) {
+    const handlers = node._eventHandlers;
+    if (!handlers)
+        return undefined;
+    const mapping = HANDLER_FOR_EVENT[eventType];
+    if (!mapping)
+        return undefined;
+    const propName = capture ? mapping.capture : mapping.bubble;
+    if (!propName)
+        return undefined;
+    return handlers[propName];
+}
+/**
+ * Collect all listeners for an event in dispatch order.
+ *
+ * Uses react-dom's two-phase accumulation pattern:
+ * - Walk from target to root
+ * - Capture handlers are prepended (unshift) → root-first
+ * - Bubble handlers are appended (push) → target-first
+ *
+ * Result: [root-cap, ..., parent-cap, target-cap, target-bub, parent-bub, ..., root-bub]
+ */
+function collectListeners(target, event) {
+    const listeners = [];
+    let node = target;
+    while (node) {
+        const isTarget = node === target;
+        const captureHandler = getHandler(node, event.type, true);
+        const bubbleHandler = getHandler(node, event.type, false);
+        if (captureHandler) {
+            listeners.unshift({
+                node,
+                handler: captureHandler,
+                phase: isTarget ? 'at_target' : 'capturing',
+            });
+        }
+        if (bubbleHandler && (event.bubbles || isTarget)) {
+            listeners.push({
+                node,
+                handler: bubbleHandler,
+                phase: isTarget ? 'at_target' : 'bubbling',
+            });
+        }
+        node = node.parentNode;
+    }
+    return listeners;
+}
+/**
+ * Execute collected listeners with propagation control.
+ *
+ * Before each handler, calls event._prepareForTarget(node) so event
+ * subclasses can do per-node setup.
+ */
+function processDispatchQueue(listeners, event) {
+    let previousNode;
+    for (const { node, handler, phase } of listeners) {
+        if (event._isImmediatePropagationStopped()) {
+            break;
+        }
+        if (event._isPropagationStopped() && node !== previousNode) {
+            break;
+        }
+        event._setEventPhase(phase);
+        event._setCurrentTarget(node);
+        event._prepareForTarget(node);
+        try {
+            handler(event);
+        }
+        catch (error) {
+            logError(error);
+        }
+        previousNode = node;
+    }
+}
+// --
+/**
+ * Map terminal event types to React scheduling priorities.
+ * Mirrors react-dom's getEventPriority() switch.
+ */
+function getEventPriority(eventType) {
+    switch (eventType) {
+        case 'keydown':
+        case 'keyup':
+        case 'click':
+        case 'focus':
+        case 'blur':
+        case 'paste':
+            return DiscreteEventPriority;
+        case 'resize':
+        case 'scroll':
+        case 'mousemove':
+            return ContinuousEventPriority;
+        default:
+            return DefaultEventPriority;
+    }
+}
+/**
+ * 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 class Dispatcher {
+    /**
+     * The terminal event currently being dispatched, or null between dispatches.
+     */
+    currentEvent = null;
+    /**
+     * The update priority currently applied to updates triggered by dispatch,
+     * or the default priority when none is set.
+     */
+    currentUpdatePriority = DefaultEventPriority;
+    /**
+     * The reconciler's `discreteUpdates` helper, injected after construction to
+     * break the import cycle, or null before injection.
+     */
+    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() {
+        if (this.currentUpdatePriority !== NoEventPriority) {
+            return this.currentUpdatePriority;
+        }
+        if (this.currentEvent) {
+            return getEventPriority(this.currentEvent.type);
+        }
+        return DefaultEventPriority;
+    }
+    /**
+     * 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, event) {
+        const previousEvent = this.currentEvent;
+        this.currentEvent = event;
+        try {
+            event._setTarget(target);
+            const listeners = collectListeners(target, event);
+            processDispatchQueue(listeners, event);
+            event._setEventPhase('none');
+            event._setCurrentTarget(null);
+            return !event.defaultPrevented;
+        }
+        finally {
+            this.currentEvent = previousEvent;
+        }
+    }
+    /**
+     * 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, event) {
+        if (!this.discreteUpdates) {
+            return this.dispatch(target, event);
+        }
+        return this.discreteUpdates((t, e) => this.dispatch(t, e), target, event, undefined, undefined);
+    }
+    /**
+     * 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, event) {
+        const previousPriority = this.currentUpdatePriority;
+        try {
+            this.currentUpdatePriority = ContinuousEventPriority;
+            return this.dispatch(target, event);
+        }
+        finally {
+            this.currentUpdatePriority = previousPriority;
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import { EventEmitter as NodeEventEmitter } from 'events';
+/**
+ * Node-compatible event emitter that is aware of the `Event` class, so
+ * `emit` respects `stopImmediatePropagation()` on dispatched events.
+ */
+export declare class EventEmitter extends NodeEventEmitter {
+    constructor();
+    /**
+     * Emit an event to all registered listeners.
+     * `error` events delegate to Node's implementation; other events stop at the
+     * first listener that calls `stopImmediatePropagation()` on an `Event` first
+     * argument.
+     * @param type - the event name.
+     * @param args - arguments passed to each listener.
+     * @returns true when at least one listener received the event; false when
+     *   no listeners were registered, or Node's result for `error` events.
+     */
+    emit(type: string | symbol, ...args: unknown[]): boolean;
+}
+//# sourceMappingURL=emitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/emitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,QAAQ,CAAA;AAGzD;;;GAGG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;;IAShD;;;;;;;;;OASG;IACM,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO;CAwBlE"}

package/lib/types/ink/events/emitter.js

@@ -0,0 +1,43 @@
+import { EventEmitter as NodeEventEmitter } from 'events';
+import { Event } from './event.js';
+/**
+ * Node-compatible event emitter that is aware of the `Event` class, so
+ * `emit` respects `stopImmediatePropagation()` on dispatched events.
+ */
+export class EventEmitter extends NodeEventEmitter {
+    constructor() {
+        super();
+        // Disable the default maxListeners warning. In React, many components
+        // can legitimately listen to the same event (e.g., useInput hooks).
+        // The default limit of 10 causes spurious warnings.
+        this.setMaxListeners(0);
+    }
+    /**
+     * Emit an event to all registered listeners.
+     * `error` events delegate to Node's implementation; other events stop at the
+     * first listener that calls `stopImmediatePropagation()` on an `Event` first
+     * argument.
+     * @param type - the event name.
+     * @param args - arguments passed to each listener.
+     * @returns true when at least one listener received the event; false when
+     *   no listeners were registered, or Node's result for `error` events.
+     */
+    emit(type, ...args) {
+        // Delegate to node for `error`, since it's not treated like a normal event
+        if (type === 'error') {
+            return super.emit(type, ...args);
+        }
+        const listeners = this.rawListeners(type);
+        if (listeners.length === 0) {
+            return false;
+        }
+        const ccEvent = args[0] instanceof Event ? args[0] : null;
+        for (const listener of listeners) {
+            listener.apply(this, args);
+            if (ccEvent?.didStopImmediatePropagation()) {
+                break;
+            }
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,47 @@
+import type { ClickEvent } from './click-event.js';
+import type { FocusEvent } from './focus-event.js';
+import type { KeyboardEvent } from './keyboard-event.js';
+import type { PasteEvent } from './paste-event.js';
+import type { ResizeEvent } from './resize-event.js';
+type KeyboardEventHandler = (event: KeyboardEvent) => void;
+type FocusEventHandler = (event: FocusEvent) => void;
+type PasteEventHandler = (event: PasteEvent) => void;
+type ResizeEventHandler = (event: ResizeEvent) => void;
+type ClickEventHandler = (event: ClickEvent) => void;
+type HoverEventHandler = () => void;
+/**
+ * Props for event handlers on Box and other host components.
+ *
+ * Follows the React/DOM naming convention:
+ * - onEventName: handler for bubble phase
+ * - onEventNameCapture: handler for capture phase
+ */
+export type EventHandlerProps = {
+    onKeyDown?: KeyboardEventHandler;
+    onKeyDownCapture?: KeyboardEventHandler;
+    onFocus?: FocusEventHandler;
+    onFocusCapture?: FocusEventHandler;
+    onBlur?: FocusEventHandler;
+    onBlurCapture?: FocusEventHandler;
+    onPaste?: PasteEventHandler;
+    onPasteCapture?: PasteEventHandler;
+    onResize?: ResizeEventHandler;
+    onClick?: ClickEventHandler;
+    onMouseEnter?: HoverEventHandler;
+    onMouseLeave?: HoverEventHandler;
+};
+/**
+ * Reverse lookup: event type string → handler prop names.
+ * Used by the dispatcher for O(1) handler lookup per node.
+ */
+export declare const HANDLER_FOR_EVENT: Record<string, {
+    bubble?: keyof EventHandlerProps;
+    capture?: keyof EventHandlerProps;
+}>;
+/**
+ * Set of all event handler prop names, for the reconciler to detect
+ * event props and store them in _eventHandlers instead of attributes.
+ */
+export declare const EVENT_HANDLER_PROPS: Set<string>;
+export {};
+//# sourceMappingURL=event-handlers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event-handlers.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/event-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD,KAAK,oBAAoB,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;AAC1D,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;AACpD,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;AACpD,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAA;AACtD,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;AACpD,KAAK,iBAAiB,GAAG,MAAM,IAAI,CAAA;AAEnC;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,CAAC,EAAE,oBAAoB,CAAA;IAChC,gBAAgB,CAAC,EAAE,oBAAoB,CAAA;IAEvC,OAAO,CAAC,EAAE,iBAAiB,CAAA;IAC3B,cAAc,CAAC,EAAE,iBAAiB,CAAA;IAClC,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,aAAa,CAAC,EAAE,iBAAiB,CAAA;IAEjC,OAAO,CAAC,EAAE,iBAAiB,CAAA;IAC3B,cAAc,CAAC,EAAE,iBAAiB,CAAA;IAElC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAE7B,OAAO,CAAC,EAAE,iBAAiB,CAAA;IAC3B,YAAY,CAAC,EAAE,iBAAiB,CAAA;IAChC,YAAY,CAAC,EAAE,iBAAiB,CAAA;CACjC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CACpC,MAAM,EACN;IAAE,MAAM,CAAC,EAAE,MAAM,iBAAiB,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,iBAAiB,CAAA;CAAE,CAQxE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,aAa9B,CAAA"}

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

@@ -0,0 +1,30 @@
+/**
+ * Reverse lookup: event type string → handler prop names.
+ * Used by the dispatcher for O(1) handler lookup per node.
+ */
+export const HANDLER_FOR_EVENT = {
+    keydown: { bubble: 'onKeyDown', capture: 'onKeyDownCapture' },
+    focus: { bubble: 'onFocus', capture: 'onFocusCapture' },
+    blur: { bubble: 'onBlur', capture: 'onBlurCapture' },
+    paste: { bubble: 'onPaste', capture: 'onPasteCapture' },
+    resize: { bubble: 'onResize' },
+    click: { bubble: 'onClick' },
+};
+/**
+ * Set of all event handler prop names, for the reconciler to detect
+ * event props and store them in _eventHandlers instead of attributes.
+ */
+export const EVENT_HANDLER_PROPS = new Set([
+    'onKeyDown',
+    'onKeyDownCapture',
+    'onFocus',
+    'onFocusCapture',
+    'onBlur',
+    'onBlurCapture',
+    'onPaste',
+    'onPasteCapture',
+    'onResize',
+    'onClick',
+    'onMouseEnter',
+    'onMouseLeave',
+]);

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

@@ -0,0 +1,19 @@
+/**
+ * Base class for events with immediate-propagation control.
+ *
+ * `stopImmediatePropagation()` marks the event so the emitter stops invoking
+ * any further listeners for it.
+ */
+export declare class Event {
+    private _didStopImmediatePropagation;
+    /**
+     * Whether `stopImmediatePropagation()` was called on this event.
+     * @returns true when immediate propagation has been stopped.
+     */
+    didStopImmediatePropagation(): boolean;
+    /**
+     * Stop the emitter from invoking any further listeners for this event.
+     */
+    stopImmediatePropagation(): void;
+}
+//# sourceMappingURL=event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/event.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,4BAA4B,CAAQ;IAE5C;;;OAGG;IACH,2BAA2B,IAAI,OAAO;IAItC;;OAEG;IACH,wBAAwB,IAAI,IAAI;CAGjC"}

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

@@ -0,0 +1,22 @@
+/**
+ * Base class for events with immediate-propagation control.
+ *
+ * `stopImmediatePropagation()` marks the event so the emitter stops invoking
+ * any further listeners for it.
+ */
+export class Event {
+    _didStopImmediatePropagation = false;
+    /**
+     * Whether `stopImmediatePropagation()` was called on this event.
+     * @returns true when immediate propagation has been stopped.
+     */
+    didStopImmediatePropagation() {
+        return this._didStopImmediatePropagation;
+    }
+    /**
+     * Stop the emitter from invoking any further listeners for this event.
+     */
+    stopImmediatePropagation() {
+        this._didStopImmediatePropagation = true;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { type EventTarget, TerminalEvent } from './terminal-event.js';
+/**
+ * Focus event for component focus changes.
+ *
+ * Dispatched when focus moves between elements. 'focus' fires on the
+ * newly focused element, 'blur' fires on the previously focused one.
+ * Both bubble, matching react-dom's use of focusin/focusout semantics
+ * so parent components can observe descendant focus changes.
+ */
+export declare class FocusEvent extends TerminalEvent {
+    /**
+     * The other element involved in the focus change: the previously focused
+     * element for 'focus' events, the newly focused element for 'blur' events,
+     * or null when there is none.
+     */
+    readonly relatedTarget: EventTarget | null;
+    constructor(type: 'focus' | 'blur', relatedTarget?: EventTarget | null);
+}
+//# sourceMappingURL=focus-event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"focus-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/focus-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAErE;;;;;;;GAOG;AACH,qBAAa,UAAW,SAAQ,aAAa;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,WAAW,GAAG,IAAI,CAAA;gBAGxC,IAAI,EAAE,OAAO,GAAG,MAAM,EACtB,aAAa,GAAE,WAAW,GAAG,IAAW;CAK3C"}

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

@@ -0,0 +1,21 @@
+import { TerminalEvent } from './terminal-event.js';
+/**
+ * Focus event for component focus changes.
+ *
+ * Dispatched when focus moves between elements. 'focus' fires on the
+ * newly focused element, 'blur' fires on the previously focused one.
+ * Both bubble, matching react-dom's use of focusin/focusout semantics
+ * so parent components can observe descendant focus changes.
+ */
+export class FocusEvent extends TerminalEvent {
+    /**
+     * The other element involved in the focus change: the previously focused
+     * element for 'focus' events, the newly focused element for 'blur' events,
+     * or null when there is none.
+     */
+    relatedTarget;
+    constructor(type, relatedTarget = null) {
+        super(type, { bubbles: true, cancelable: false });
+        this.relatedTarget = relatedTarget;
+    }
+}

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

@@ -0,0 +1,53 @@
+import { type ParsedKey } from '../parse-keypress.js';
+import { Event } from './event.js';
+/**
+ * Boolean flags describing which named keys (arrows, modifiers, home/end,
+ * etc.) a parsed keypress reports as pressed.
+ */
+export type Key = {
+    upArrow: boolean;
+    downArrow: boolean;
+    leftArrow: boolean;
+    rightArrow: boolean;
+    pageDown: boolean;
+    pageUp: boolean;
+    wheelUp: boolean;
+    wheelDown: boolean;
+    home: boolean;
+    end: boolean;
+    return: boolean;
+    escape: boolean;
+    ctrl: boolean;
+    shift: boolean;
+    fn: boolean;
+    tab: boolean;
+    backspace: boolean;
+    delete: boolean;
+    meta: boolean;
+    super: boolean;
+};
+/**
+ * Event fired for each input chunk received from stdin (a typed character or
+ * a paste), carrying the parsed key flags and the text it produced.
+ */
+export declare class InputEvent extends Event {
+    /**
+     * The raw parsed keypress this event was built from.
+     */
+    readonly keypress: ParsedKey;
+    /**
+     * Named-key flags describing which keys the keypress reports as pressed.
+     */
+    readonly key: Key;
+    /**
+     * The text input produced by this keypress ('' for non-printing keys).
+     */
+    readonly input: string;
+    /** True when this input arrived as a bracketed paste (terminal paste —
+     *  Ctrl+Shift+V / right-click) rather than typed characters. Handlers use
+     *  this to insert paste content verbatim instead of treating newlines as
+     *  Enter/submit. */
+    readonly isPasted: boolean;
+    constructor(keypress: ParsedKey);
+}
+//# sourceMappingURL=input-event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/input-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAC1E,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC;;;GAGG;AACH,MAAM,MAAM,GAAG,GAAG;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,OAAO,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,OAAO,CAAA;IAClB,IAAI,EAAE,OAAO,CAAA;IACb,GAAG,EAAE,OAAO,CAAA;IACZ,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,EAAE,EAAE,OAAO,CAAA;IACX,GAAG,EAAE,OAAO,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;IAClB,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAuKD;;;GAGG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAA;IAE5B;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IAEjB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB;;;wBAGoB;IACpB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;gBAEd,QAAQ,EAAE,SAAS;CAShC"}