mimo-reasonix 0.1.0 → 0.1.1

package/node_modules/ink/src/events/event-handlers.ts

@@ -0,0 +1,60 @@
+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 KeyboardHandler = (event: KeyboardEvent) => void
+type FocusHandler = (event: FocusEvent) => void
+type PasteHandler = (event: PasteEvent) => void
+type ResizeHandler = (event: ResizeEvent) => void
+type ClickHandler = (event: ClickEvent) => void
+type HoverHandler = () => void
+
+/** Event-handler props accepted by Box and other host components. */
+export type EventHandlerProps = {
+  onKeyDown?: KeyboardHandler
+  onKeyDownCapture?: KeyboardHandler
+
+  onFocus?: FocusHandler
+  onFocusCapture?: FocusHandler
+  onBlur?: FocusHandler
+  onBlurCapture?: FocusHandler
+
+  onPaste?: PasteHandler
+  onPasteCapture?: PasteHandler
+
+  onResize?: ResizeHandler
+
+  onClick?: ClickHandler
+  onMouseEnter?: HoverHandler
+  onMouseLeave?: HoverHandler,
+}
+
+export const HANDLER_FOR_EVENT: Record<
+  string,
+  { bubble?: keyof EventHandlerProps; capture?: keyof EventHandlerProps }
+> = {
+  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 every prop name recognised as an event handler. */
+export const EVENT_HANDLER_PROPS = new Set<string>([
+  'onKeyDown',
+  'onKeyDownCapture',
+  'onFocus',
+  'onFocusCapture',
+  'onBlur',
+  'onBlurCapture',
+  'onPaste',
+  'onPasteCapture',
+  'onResize',
+  'onClick',
+  'onMouseEnter',
+  'onMouseLeave',
+])

package/node_modules/ink/src/events/event.ts

@@ -0,0 +1,12 @@
+/** Minimal base class for every event the runtime hands to user code. */
+export class Event {
+  private didStop = false
+
+  didStopImmediatePropagation(): boolean {
+    return this.didStop
+  }
+
+  stopImmediatePropagation(): void {
+    this.didStop = true
+  }
+}

package/node_modules/ink/src/events/focus-event.ts

@@ -0,0 +1,13 @@
+import { type EventTarget, TerminalEvent } from './terminal-event.js'
+
+export class FocusEvent extends TerminalEvent {
+  readonly relatedTarget: EventTarget | null
+
+  constructor(
+    type: 'focus' | 'blur',
+    relatedTarget: EventTarget | null = null,
+  ) {
+    super(type, { bubbles: true, cancelable: false })
+    this.relatedTarget = relatedTarget
+  }
+}

package/node_modules/ink/src/events/input-event.ts

@@ -0,0 +1,212 @@
+import { nonAlphanumericKeys, type ParsedKey } from '../parse-keypress.js'
+import { Event } from './event.js'
+
+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,
+}
+
+function parseKey(keypress: ParsedKey): [Key, string] {
+  const key: Key = {
+    upArrow: keypress.name === 'up',
+    downArrow: keypress.name === 'down',
+    leftArrow: keypress.name === 'left',
+    rightArrow: keypress.name === 'right',
+    pageDown: keypress.name === 'pagedown',
+    pageUp: keypress.name === 'pageup',
+    wheelUp: keypress.name === 'wheelup',
+    wheelDown: keypress.name === 'wheeldown',
+    home: keypress.name === 'home',
+    end: keypress.name === 'end',
+    return: keypress.name === 'return',
+    escape: keypress.name === 'escape',
+    fn: keypress.fn,
+    ctrl: keypress.ctrl,
+    shift: keypress.shift,
+    tab: keypress.name === 'tab',
+    backspace: keypress.name === 'backspace',
+    delete: keypress.name === 'delete',
+    // parseKeypress reports `\u001B\u001B[A` (meta + arrow up) with meta=false
+    // and option=true. We collapse the two into the same `meta` bit so user
+    // handlers don't have to branch on which terminal sent the sequence.
+    // `escape` is folded in for the same reason: a lone ESC arrives with no
+    // meta bit set but should behave like a modifier-bearing keypress here.
+    meta: keypress.meta || keypress.name === 'escape' || keypress.option,
+    // Super (Cmd on macOS, Win key on Windows) only arrives via kitty
+    // keyboard protocol CSI u sequences. Distinct from `meta` (Alt/Option)
+    // so bindings like cmd+c can be expressed separately from opt+c.
+    super: keypress.super,
+  }
+
+  let input = keypress.ctrl ? keypress.name : keypress.sequence
+
+  if (input === undefined) {
+    input = ''
+  }
+
+  // When ctrl is held, keypress.name for the space bar is the literal
+  // word 'space'. Convert to an actual space character so the ctrl+space
+  // branch agrees with the CSI u branch below (which already maps
+  // 'space' to ' '). Without this the word "space" leaks into text input.
+  if (keypress.ctrl && input === 'space') {
+    input = ' '
+  }
+
+  // Unrecognised escape sequences that matched the function-key regex but
+  // have no entry in the key-name map (e.g. ESC[25~ = F13 / Right Alt on
+  // Windows, ESC[26~ = F14). The ESC prefix is stripped further down, so
+  // without this guard the remainder ("[25~") surfaces as literal text.
+  if (keypress.code && !keypress.name) {
+    input = ''
+  }
+
+  // Defensive sink for SGR mouse fragments arriving without their leading
+  // ESC. When a heavy React commit blocks the event loop past App's
+  // normal-flush timeout, a CSI split across stdin chunks gets its
+  // buffered ESC flushed as a lone Escape key, and the continuation
+  // arrives as a text token with name=''. It falls through every
+  // ESC-anchored regex in parseKeypress and the nonAlphanumericKeys
+  // clear below (because `name` is falsy), leaving the fragment to
+  // surface in the prompt as literal text like `[<64;74;16M`. The real
+  // fix lives in the tokenizer; this guard keeps the symptom from being
+  // user-visible.
+  if (!keypress.name && /^\[<\d+;\d+;\d+[Mm]/.test(input)) {
+    input = ''
+  }
+
+  // Strip a stray leading ESC that parseKeypress didn't consume (legacy
+  // F-keys, partial CSI fragments from a chunked read). The `meta` bit
+  // above already carries the modifier semantics, so dropping the ESC
+  // prevents the remainder from surfacing as literal text in handlers.
+  if (input.startsWith('\u001B')) {
+    input = input.slice(1)
+  }
+
+  // CSI u and application-keypad branches below rewrite `input` to the
+  // resolved character. The nonAlphanumericKeys clear at the end of the
+  // function would then wipe that work for arrow / function-key names,
+  // so the branches that succeed flip this flag to skip the final clear.
+  let processedAsSpecialSequence = false
+
+  // CSI u sequences (kitty keyboard protocol). After the leading ESC is
+  // stripped above, we're left with "[<codepoint>;<modifier>u" — for
+  // example "[98;3u" for Alt+b. The parser already resolved the keyname,
+  // so we substitute that here. The leading-digit check matters: a bare
+  // startsWith('[') false-matches X10 mouse reports at row 85 (Cy = 117 =
+  // 'u'), which would otherwise leak the literal text "mouse" into the
+  // prompt via processedAsSpecialSequence.
+  if (/^\[\d/.test(input) && input.endsWith('u')) {
+    if (!keypress.name) {
+      // Unmapped kitty functional key (Caps Lock 57358, F13-F35, KP nav,
+      // bare modifiers, ...): keycodeToName() returned undefined. Swallow
+      // so the raw "[57358u" doesn't leak into the prompt.
+      input = ''
+    } else {
+      // 'space' -> ' '; 'escape' -> '' (key.escape already carries it,
+      // and the processedAsSpecialSequence flag bypasses the
+      // nonAlphanumericKeys clear below so we must zero it explicitly);
+      // anything else uses the resolved key name.
+      input =
+        keypress.name === 'space'
+          ? ' '
+          : keypress.name === 'escape'
+            ? ''
+            : keypress.name
+    }
+    processedAsSpecialSequence = true
+  }
+
+  // xterm modifyOtherKeys sequences. After the leading ESC is stripped,
+  // we see "[27;<modifier>;<keycode>~" — for example "[27;3;98~" for
+  // Alt+b. Same shape as the CSI u path: substitute the resolved name so
+  // printable-char keycodes (single-letter names) don't skip the
+  // nonAlphanumericKeys clear and leak "[27;..." as input.
+  if (input.startsWith('[27;') && input.endsWith('~')) {
+    if (!keypress.name) {
+      // Unmapped modifyOtherKeys keycode. Practically untriggerable today
+      // (xterm modifyOtherKeys only emits ASCII keycodes, all mapped), but
+      // we mirror the CSI u behaviour as a forward-compatibility guard.
+      input = ''
+    } else {
+      input =
+        keypress.name === 'space'
+          ? ' '
+          : keypress.name === 'escape'
+            ? ''
+            : keypress.name
+    }
+    processedAsSpecialSequence = true
+  }
+
+  // Application-keypad mode. After the leading ESC is stripped we see
+  // "O<letter>" — e.g. "Op" for numpad 0, "Oy" for numpad 9. The parser
+  // resolves the digit character into `name`; use it for input.
+  if (
+    input.startsWith('O') &&
+    input.length === 2 &&
+    keypress.name &&
+    keypress.name.length === 1
+  ) {
+    input = keypress.name
+    processedAsSpecialSequence = true
+  }
+
+  // Final clear for symbolic keys (arrows, function keys, etc.). The
+  // CSI u / modifyOtherKeys / keypad branches above already replaced
+  // `input` with the right value, so we skip the clear when they fired.
+  if (
+    !processedAsSpecialSequence &&
+    keypress.name &&
+    nonAlphanumericKeys.has(keypress.name)
+  ) {
+    input = ''
+  }
+
+  // Promote uppercase ASCII letters to shift=true. The length check
+  // prevents non-letter characters that happen to be unchanged by
+  // toUpperCase (digits, punctuation) from triggering the modifier flag.
+  if (
+    input.length === 1 &&
+    typeof input[0] === 'string' &&
+    input[0] >= 'A' &&
+    input[0] <= 'Z'
+  ) {
+    key.shift = true
+  }
+
+  return [key, input]
+}
+
+/** Raw keypress event delivered by the emitter (not the DOM dispatcher). */
+export class InputEvent extends Event {
+  readonly keypress: ParsedKey
+  readonly key: Key
+  readonly input: string
+
+  constructor(keypress: ParsedKey) {
+    super()
+    const [key, input] = parseKey(keypress)
+
+    this.keypress = keypress
+    this.key = key
+    this.input = input
+  }
+}

package/node_modules/ink/src/events/keyboard-event.ts

@@ -0,0 +1,41 @@
+import type { ParsedKey } from '../parse-keypress.js'
+import { TerminalEvent } from './terminal-event.js'
+
+/** Keyboard event dispatched through the rendered tree via capture / bubble. */
+export class KeyboardEvent extends TerminalEvent {
+  readonly key: string
+  readonly ctrl: boolean
+  readonly shift: boolean
+  readonly meta: boolean
+  readonly superKey: boolean
+  readonly fn: boolean
+
+  constructor(parsedKey: ParsedKey) {
+    super('keydown', { bubbles: true, cancelable: true })
+
+    this.key = keyFromParsed(parsedKey)
+    this.ctrl = parsedKey.ctrl
+    this.shift = parsedKey.shift
+    // Meta and Option both come over the wire as ESC-prefixed sequences
+    // that parseKeypress can't always distinguish; we collapse them so
+    // user code doesn't have to branch on the source terminal.
+    this.meta = parsedKey.meta || parsedKey.option
+    this.superKey = parsedKey.super
+    this.fn = parsedKey.fn
+  }
+}
+
+/** Pick the right `key` value out of a parsed keypress. */
+function keyFromParsed(parsed: ParsedKey): string {
+  const seq = parsed.sequence ?? ''
+  const name = parsed.name ?? ''
+
+  if (parsed.ctrl) return name
+
+  if (seq.length === 1) {
+    const code = seq.charCodeAt(0)
+    if (code >= 0x20 && code !== 0x7f) return seq
+  }
+
+  return name || seq
+}

package/node_modules/ink/src/events/paste-event.ts

@@ -0,0 +1,11 @@
+import { TerminalEvent } from './terminal-event.js'
+
+/** Bracketed-paste event placeholder. */
+export class PasteEvent extends TerminalEvent {
+  readonly data: string
+
+  constructor(data: string) {
+    super('paste', { bubbles: true, cancelable: true })
+    this.data = data
+  }
+}

package/node_modules/ink/src/events/resize-event.ts

@@ -0,0 +1,13 @@
+import { TerminalEvent } from './terminal-event.js'
+
+/** Terminal resize event placeholder. */
+export class ResizeEvent extends TerminalEvent {
+  readonly columns: number
+  readonly rows: number
+
+  constructor(columns: number, rows: number) {
+    super('resize', { bubbles: false, cancelable: false })
+    this.columns = columns
+    this.rows = rows
+  }
+}

package/node_modules/ink/src/events/terminal-event.ts

@@ -0,0 +1,99 @@
+import { Event } from './event.js'
+
+type EventPhase = 'none' | 'capturing' | 'at_target' | 'bubbling'
+
+type TerminalEventInit = {
+  bubbles?: boolean
+  cancelable?: boolean
+}
+
+/** DOM-shaped base for events that traverse the rendered node tree. */
+export class TerminalEvent extends Event {
+  readonly type: string
+  readonly timeStamp: number
+  readonly bubbles: boolean
+  readonly cancelable: boolean
+
+  private currentTargetNode: EventTarget | null = null
+  private targetNode: EventTarget | null = null
+  private phase: EventPhase = 'none'
+  private propagationStopped = false
+  private prevented = false
+
+  constructor(type: string, init?: TerminalEventInit) {
+    super()
+    this.type = type
+    this.timeStamp = performance.now()
+    this.bubbles = init?.bubbles ?? true
+    this.cancelable = init?.cancelable ?? true
+  }
+
+  get target(): EventTarget | null {
+    return this.targetNode
+  }
+
+  get currentTarget(): EventTarget | null {
+    return this.currentTargetNode
+  }
+
+  get eventPhase(): EventPhase {
+    return this.phase
+  }
+
+  get defaultPrevented(): boolean {
+    return this.prevented
+  }
+
+  stopPropagation(): void {
+    this.propagationStopped = true
+  }
+
+  override stopImmediatePropagation(): void {
+    super.stopImmediatePropagation()
+    this.propagationStopped = true
+  }
+
+  preventDefault(): void {
+    // Browsers silently ignore preventDefault on non-cancelable events; we
+    // mirror that so passive listeners (focus, resize) cannot block the
+    // runtime's default handling.
+    if (this.cancelable) {
+      this.prevented = true
+    }
+  }
+
+  // Internal hooks driven by the Dispatcher. The leading underscore keeps
+  // them out of editor autocomplete on event objects exposed to user code.
+
+  /** @internal */
+  _setTarget(target: EventTarget): void {
+    this.targetNode = target
+  }
+
+  /** @internal */
+  _setCurrentTarget(target: EventTarget | null): void {
+    this.currentTargetNode = target
+  }
+
+  /** @internal */
+  _setEventPhase(phase: EventPhase): void {
+    this.phase = phase
+  }
+
+  /** @internal */
+  _isPropagationStopped(): boolean {
+    return this.propagationStopped
+  }
+
+  /** @internal */
+  _isImmediatePropagationStopped(): boolean {
+    return this.didStopImmediatePropagation()
+  }
+
+  _prepareForTarget(_target: EventTarget): void {}
+}
+
+export type EventTarget = {
+  parentNode: EventTarget | undefined
+  _eventHandlers?: Record<string, unknown>
+}

package/node_modules/ink/src/events/terminal-focus-event.ts

@@ -0,0 +1,13 @@
+import { Event } from './event.js'
+
+export type TerminalFocusEventType = 'terminalfocus' | 'terminalblur'
+
+/** Window-level focus change for the host terminal emulator itself. */
+export class TerminalFocusEvent extends Event {
+  readonly type: TerminalFocusEventType
+
+  constructor(type: TerminalFocusEventType) {
+    super()
+    this.type = type
+  }
+}

package/node_modules/ink/src/focus.ts

@@ -0,0 +1,159 @@
+import type { DOMElement } from './dom.js';
+import { FocusEvent } from './events/focus-event.js';
+
+/** Upper bound on the size of the focus restoration stack. */
+const MAX_FOCUS_STACK = 32;
+
+/** DOM-like focus manager. */
+export class FocusManager {
+  activeElement: DOMElement | null = null;
+
+  private readonly dispatch: (target: DOMElement, event: FocusEvent) => boolean;
+  private enabled = true;
+  private focusStack: DOMElement[] = [];
+
+  constructor(dispatch: (target: DOMElement, event: FocusEvent) => boolean) {
+    this.dispatch = dispatch;
+  }
+
+  focus(node: DOMElement): void {
+    if (node === this.activeElement) return;
+    if (!this.enabled) return;
+
+    const previous = this.activeElement;
+    if (previous) {
+      // Deduplicate before pushing: tab-cycling between a small set of
+      // nodes would otherwise pin the stack at MAX_FOCUS_STACK forever
+      // and silently drop earlier entries from real navigation history.
+      const existing = this.focusStack.indexOf(previous);
+      if (existing !== -1) this.focusStack.splice(existing, 1);
+      this.focusStack.push(previous);
+      if (this.focusStack.length > MAX_FOCUS_STACK) this.focusStack.shift();
+      this.dispatch(previous, new FocusEvent('blur', node));
+    }
+
+    this.activeElement = node;
+    this.dispatch(node, new FocusEvent('focus', previous));
+  }
+
+  blur(): void {
+    if (!this.activeElement) return;
+
+    const previous = this.activeElement;
+    this.activeElement = null;
+    this.dispatch(previous, new FocusEvent('blur', null));
+  }
+
+  /** Called from the reconciler when a node leaves the tree. */
+  handleNodeRemoved(node: DOMElement, root: DOMElement): void {
+    this.focusStack = this.focusStack.filter(
+      (entry) => entry !== node && isInTree(entry, root),
+    );
+
+    if (!this.activeElement) return;
+    if (this.activeElement !== node && isInTree(this.activeElement, root)) {
+      return;
+    }
+
+    const removed = this.activeElement;
+    this.activeElement = null;
+    this.dispatch(removed, new FocusEvent('blur', null));
+
+    while (this.focusStack.length > 0) {
+      const candidate = this.focusStack.pop()!;
+      if (isInTree(candidate, root)) {
+        this.activeElement = candidate;
+        this.dispatch(candidate, new FocusEvent('focus', removed));
+        return;
+      }
+    }
+  }
+
+  handleAutoFocus(node: DOMElement): void {
+    this.focus(node);
+  }
+
+  /** Click-to-focus. */
+  handleClickFocus(node: DOMElement): void {
+    const tabIndex = node.attributes['tabIndex'];
+    if (typeof tabIndex !== 'number') return;
+    this.focus(node);
+  }
+
+  enable(): void {
+    this.enabled = true;
+  }
+
+  disable(): void {
+    this.enabled = false;
+  }
+
+  focusNext(root: DOMElement): void {
+    this.moveFocus(1, root);
+  }
+
+  focusPrevious(root: DOMElement): void {
+    this.moveFocus(-1, root);
+  }
+
+  private moveFocus(direction: 1 | -1, root: DOMElement): void {
+    if (!this.enabled) return;
+
+    const tabbable = collectTabbable(root);
+    if (tabbable.length === 0) return;
+
+    const currentIndex = this.activeElement ? tabbable.indexOf(this.activeElement) : -1;
+
+    const nextIndex =
+      currentIndex === -1
+        ? direction === 1
+          ? 0
+          : tabbable.length - 1
+        : (currentIndex + direction + tabbable.length) % tabbable.length;
+
+    const next = tabbable[nextIndex];
+    if (next) this.focus(next);
+  }
+}
+
+function collectTabbable(root: DOMElement): DOMElement[] {
+  const collected: DOMElement[] = [];
+  walkTree(root, collected);
+  return collected;
+}
+
+function walkTree(node: DOMElement, collected: DOMElement[]): void {
+  const tabIndex = node.attributes['tabIndex'];
+  if (typeof tabIndex === 'number' && tabIndex >= 0) {
+    collected.push(node);
+  }
+
+  for (const child of node.childNodes) {
+    if (child.nodeName !== '#text') {
+      walkTree(child, collected);
+    }
+  }
+}
+
+function isInTree(node: DOMElement, root: DOMElement): boolean {
+  let current: DOMElement | undefined = node;
+  while (current) {
+    if (current === root) return true;
+    current = current.parentNode;
+  }
+  return false;
+}
+
+/** Walk up to the root DOMElement and return it. */
+export function getRootNode(node: DOMElement): DOMElement {
+  let current: DOMElement | undefined = node;
+  while (current) {
+    if (current.focusManager) return current;
+    current = current.parentNode;
+  }
+  throw new Error('Node is not attached to a tree that owns a FocusManager');
+}
+
+export function getFocusManager(node: DOMElement): FocusManager {
+  return getRootNode(node).focusManager!;
+}