mimo-reasonix 0.1.0 → 0.1.1

package/node_modules/ink/src/components/ScrollBox.tsx

@@ -0,0 +1,209 @@
+import React, { type PropsWithChildren, type Ref, useImperativeHandle, useRef, useState } from 'react';
+import type { Except } from 'type-fest';
+import { markScrollActivity } from '../_internal/state.js';
+import type { DOMElement } from '../dom.js';
+import { markDirty, scheduleRenderFrom } from '../dom.js';
+import { markCommitStart } from '../reconciler.js';
+import type { Styles } from '../styles.js';
+import Box from './Box.js';
+
+export type ScrollBoxHandle = {
+  /** Set absolute scrollTop in lines. Breaks stickiness. */
+  scrollTo: (y: number) => void;
+  /** Adjust scrollTop by `dy` lines. Breaks stickiness. */
+  scrollBy: (dy: number) => void;
+  scrollToElement: (el: DOMElement, offset?: number) => void;
+  scrollToBottom: () => void;
+  getScrollTop: () => number;
+  getPendingDelta: () => number;
+  getScrollHeight: () => number;
+  getFreshScrollHeight: () => number;
+  getViewportHeight: () => number;
+  getViewportTop: () => number;
+  /** `true` when scroll is pinned to the bottom. */
+  isSticky: () => boolean;
+  subscribe: (listener: () => void) => () => void;
+  /** Restrict render-time scrollTop to `[min, max]`. */
+  setClampBounds: (min: number | undefined, max: number | undefined) => void;
+};
+
+export type ScrollBoxProps = Except<Styles, 'textWrap' | 'overflow' | 'overflowX' | 'overflowY'> & {
+  ref?: Ref<ScrollBoxHandle>;
+  stickyScroll?: boolean;
+};
+
+/** A Box with `overflow: scroll` and an imperative scroll API. */
+function ScrollBox({
+  children,
+  ref,
+  stickyScroll,
+  ...style
+}: PropsWithChildren<ScrollBoxProps>): React.ReactNode {
+  const domRef = useRef<DOMElement>(null);
+  // The wheel-event hot path skips React entirely: `scrollTo`/`scrollBy`
+  // mutate `scrollTop` on the DOM node, mark it dirty, and invoke the
+  // throttled `scheduleRender` directly. The renderer reads `scrollTop`
+  // off the node at render time, so no React state and no reconciler
+  // pass is needed per wheel event. A microtask defer coalesces all
+  // `scrollBy` calls inside one input batch (discreteUpdates) into a
+  // single render — without it, `scheduleRender`'s leading edge would
+  // fire on the first event with the pre-mutation `scrollTop` and lose
+  // every subsequent delta in that batch. `scrollToBottom` still goes
+  // through a React render because stickiness is observed via attribute
+  // and there's no DOM-only sticky path.
+  const [, forceRender] = useState(0);
+  const listenersRef = useRef(new Set<() => void>());
+  const renderQueuedRef = useRef(false);
+  const notify = () => {
+    for (const l of listenersRef.current) l();
+  };
+  function scrollMutated(el: DOMElement): void {
+    // Tell background intervals (IDE poll, LSP poll, notification
+    // dampening, ...) that the user is actively driving the UI so they
+    // skip their next idle-gated tick. Without this, a long scroll
+    // drain competes with those polls for the event loop and produces
+    // visible frame gaps in the hundreds of milliseconds.
+    markScrollActivity();
+    markDirty(el);
+    markCommitStart();
+    notify();
+    if (renderQueuedRef.current) return;
+    renderQueuedRef.current = true;
+    queueMicrotask(() => {
+      renderQueuedRef.current = false;
+      scheduleRenderFrom(el);
+    });
+  }
+  useImperativeHandle(ref, (): ScrollBoxHandle => ({
+    scrollTo(y: number) {
+      const el = domRef.current;
+      if (!el) return;
+      // Explicit `false` here (rather than `undefined`) overrides the
+      // DOM attribute so manual scroll breaks stickiness. The render
+      // code reads `el.stickyScroll ?? attributes.stickyScroll`, so a
+      // missing value would still inherit the attribute.
+      el.stickyScroll = false;
+      el.pendingScrollDelta = undefined;
+      el.scrollAnchor = undefined;
+      el.scrollTop = Math.max(0, Math.floor(y));
+      scrollMutated(el);
+    },
+    scrollToElement(el: DOMElement, offset = 0) {
+      const box = domRef.current;
+      if (!box) return;
+      box.stickyScroll = false;
+      box.pendingScrollDelta = undefined;
+      box.scrollAnchor = {
+        el,
+        offset
+      };
+      scrollMutated(box);
+    },
+    scrollBy(dy: number) {
+      const el = domRef.current;
+      if (!el) return;
+      el.stickyScroll = false;
+      // User-driven wheel input takes precedence over any in-flight
+      // `scrollToElement` anchor seek — cancel it.
+      el.scrollAnchor = undefined;
+      // Accumulate into `pendingScrollDelta`; the renderer drains it at
+      // a capped rate so a fast flick yields a few intermediate frames
+      // rather than a single jump. Because this is a pure accumulator,
+      // an up-then-down nudge naturally cancels itself.
+      el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy);
+      scrollMutated(el);
+    },
+    scrollToBottom() {
+      const el = domRef.current;
+      if (!el) return;
+      el.pendingScrollDelta = undefined;
+      el.stickyScroll = true;
+      markDirty(el);
+      notify();
+      forceRender(n => n + 1);
+    },
+    getScrollTop() {
+      return domRef.current?.scrollTop ?? 0;
+    },
+    getPendingDelta() {
+      // The delta accumulated by `scrollBy` but not yet drained.
+      // `useVirtualScroll` reads this so it can mount the union of the
+      // committed range and the pending one — otherwise the drain
+      // frames in between would find no children mounted at their
+      // target offsets and render a blank slice.
+      return domRef.current?.pendingScrollDelta ?? 0;
+    },
+    getScrollHeight() {
+      return domRef.current?.scrollHeight ?? 0;
+    },
+    getFreshScrollHeight() {
+      const content = domRef.current?.childNodes[0] as DOMElement | undefined;
+      return content?.yogaNode?.getComputedHeight() ?? domRef.current?.scrollHeight ?? 0;
+    },
+    getViewportHeight() {
+      return domRef.current?.scrollViewportHeight ?? 0;
+    },
+    getViewportTop() {
+      return domRef.current?.scrollViewportTop ?? 0;
+    },
+    isSticky() {
+      const el = domRef.current;
+      if (!el) return false;
+      return el.stickyScroll ?? Boolean(el.attributes['stickyScroll']);
+    },
+    subscribe(listener: () => void) {
+      listenersRef.current.add(listener);
+      return () => listenersRef.current.delete(listener);
+    },
+    setClampBounds(min, max) {
+      const el = domRef.current;
+      if (!el) return;
+      el.scrollClampMin = min;
+      el.scrollClampMax = max;
+    }
+  }),
+  // `notify` and `scrollMutated` are inline (no `useCallback`) but only
+  // close over refs and module-level imports, so they're stable across
+  // renders. Empty deps prevents rebuilding the imperative handle on
+  // every render — re-registering would churn the parent's ref and
+  // cause subscribers to detach/reattach for no reason.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  []);
+
+  // Layout structure:
+  //   outer ink-box (overflow:scroll, constrained height)
+  //     -> inner Box (flexGrow:1, flexShrink:0)
+  //
+  // The inner box fills at least the viewport (flexGrow:1) but is free
+  // to grow taller for long content (flexShrink:0). flexGrow:1 also
+  // lets children use spacers to pin elements to the bottom of the
+  // scroll area. Yoga's Overflow.Scroll prevents the outer viewport
+  // from growing to fit the inner content, which is what makes the
+  // overflow happen in the first place. The renderer reads
+  // `scrollHeight` from the inner content box and culls its children
+  // against `scrollTop`.
+  //
+  // `stickyScroll` is set directly on `ink-box` (not via the ref) so
+  // it's available on the very first render. Ref callbacks only run
+  // after commit, which is too late for the first frame — we'd render
+  // one non-sticky frame before catching up.
+  return <ink-box ref={(el: DOMElement | null) => {
+    domRef.current = el;
+    if (el) el.scrollTop ??= 0;
+  }} style={{
+    flexWrap: 'nowrap',
+    flexDirection: style.flexDirection ?? 'row',
+    flexGrow: style.flexGrow ?? 0,
+    flexShrink: style.flexShrink ?? 1,
+    ...style,
+    overflowX: 'scroll',
+    overflowY: 'scroll'
+  }} {...stickyScroll ? {
+    stickyScroll: true
+  } : {}}>
+      <Box flexDirection="column" flexGrow={1} flexShrink={0} width="100%">
+        {children}
+      </Box>
+    </ink-box>;
+}
+export default ScrollBox;

package/node_modules/ink/src/components/Spacer.tsx

@@ -0,0 +1,6 @@
+import React from 'react';
+import Box from './Box.js';
+
+export default function Spacer() {
+  return <Box flexGrow={1} />;
+}

package/node_modules/ink/src/components/StdinContext.ts

@@ -0,0 +1,35 @@
+import { createContext } from 'react';
+import { EventEmitter } from '../events/emitter.js';
+import type { TerminalQuerier } from '../terminal-querier.js';
+
+export type Props = {
+  readonly stdin: NodeJS.ReadStream;
+
+  /** Reference-counted raw-mode toggle. */
+  readonly setRawMode: (value: boolean) => void;
+
+  /** Whether the configured stdin can enter raw mode (i.e. */
+  readonly isRawModeSupported: boolean;
+
+  readonly internal_exitOnCtrlC: boolean;
+
+  readonly internal_eventEmitter: EventEmitter;
+
+  readonly internal_querier: TerminalQuerier | null;
+};
+
+const StdinContext = createContext<Props>({
+  stdin: process.stdin,
+
+  internal_eventEmitter: new EventEmitter(),
+  setRawMode() {},
+  isRawModeSupported: false,
+
+  internal_exitOnCtrlC: true,
+  internal_querier: null,
+});
+
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+StdinContext.displayName = 'InternalStdinContext';
+
+export default StdinContext;

package/node_modules/ink/src/components/TerminalFocusContext.tsx

@@ -0,0 +1,37 @@
+import React, { createContext, type PropsWithChildren, useMemo, useSyncExternalStore } from 'react';
+import {
+  getTerminalFocused,
+  getTerminalFocusState,
+  subscribeTerminalFocus,
+  type TerminalFocusState,
+} from '../terminal-focus-state.js';
+
+export type { TerminalFocusState };
+
+export type TerminalFocusContextProps = {
+  readonly isTerminalFocused: boolean;
+  readonly terminalFocusState: TerminalFocusState;
+};
+
+/** Exposes the terminal-window focus state (DECSET 1004) to descendants. */
+const TerminalFocusContext = createContext<TerminalFocusContextProps>({
+  isTerminalFocused: true,
+  terminalFocusState: 'unknown',
+});
+
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+TerminalFocusContext.displayName = 'TerminalFocusContext';
+
+export function TerminalFocusProvider({ children }: PropsWithChildren) {
+  const isTerminalFocused = useSyncExternalStore(subscribeTerminalFocus, getTerminalFocused);
+  const terminalFocusState = useSyncExternalStore(subscribeTerminalFocus, getTerminalFocusState);
+
+  const value = useMemo(
+    () => ({ isTerminalFocused, terminalFocusState }),
+    [isTerminalFocused, terminalFocusState],
+  );
+
+  return <TerminalFocusContext.Provider value={value}>{children}</TerminalFocusContext.Provider>;
+}
+
+export default TerminalFocusContext;

package/node_modules/ink/src/components/TerminalSizeContext.tsx

@@ -0,0 +1,9 @@
+import { createContext } from 'react';
+
+export type TerminalSize = {
+  columns: number;
+  rows: number;
+};
+
+/** Live terminal viewport dimensions, updated on every SIGWINCH. */
+export const TerminalSizeContext = createContext<TerminalSize | null>(null);

package/node_modules/ink/src/components/Text.tsx

@@ -0,0 +1,85 @@
+import React, { type ReactNode } from 'react';
+import type { Color, Styles, TextStyles } from '../styles.js';
+
+type BaseProps = {
+  /** Foreground colour. */
+  readonly color?: Color;
+
+  /** Background colour. Same accepted forms as `color`. */
+  readonly backgroundColor?: Color;
+
+  /** Render italic. */
+  readonly italic?: boolean;
+
+  /** Render underlined. */
+  readonly underline?: boolean;
+
+  /** Render with a strikethrough line. */
+  readonly strikethrough?: boolean;
+
+  /** Swap foreground and background. */
+  readonly inverse?: boolean;
+
+  /** How to handle text that exceeds the parent's content width. */
+  readonly wrap?: Styles['textWrap'];
+  readonly children?: ReactNode;
+  readonly bold?: boolean;
+  readonly dim?: boolean;
+};
+
+export type Props = BaseProps;
+
+/** Pre-built `Styles` objects keyed by `textWrap` value. */
+const STYLES_BY_WRAP: Record<NonNullable<Styles['textWrap']>, Styles> = {
+  wrap: { flexGrow: 0, flexShrink: 1, flexDirection: 'row', textWrap: 'wrap' },
+  'wrap-trim': { flexGrow: 0, flexShrink: 1, flexDirection: 'row', textWrap: 'wrap-trim' },
+  end: { flexGrow: 0, flexShrink: 1, flexDirection: 'row', textWrap: 'end' },
+  middle: { flexGrow: 0, flexShrink: 1, flexDirection: 'row', textWrap: 'middle' },
+  'truncate-end': { flexGrow: 0, flexShrink: 1, flexDirection: 'row', textWrap: 'truncate-end' },
+  truncate: { flexGrow: 0, flexShrink: 1, flexDirection: 'row', textWrap: 'truncate' },
+  'truncate-middle': {
+    flexGrow: 0,
+    flexShrink: 1,
+    flexDirection: 'row',
+    textWrap: 'truncate-middle',
+  },
+  'truncate-start': {
+    flexGrow: 0,
+    flexShrink: 1,
+    flexDirection: 'row',
+    textWrap: 'truncate-start',
+  },
+};
+
+/** Renders a run of styled text. */
+export default function Text({
+  color,
+  backgroundColor,
+  bold,
+  dim,
+  italic = false,
+  underline = false,
+  strikethrough = false,
+  inverse = false,
+  wrap = 'wrap',
+  children,
+}: Props) {
+  if (children === undefined || children === null) return null;
+
+  const textStyles: TextStyles = {
+    ...(color && { color }),
+    ...(backgroundColor && { backgroundColor }),
+    ...(dim && { dim }),
+    ...(bold && { bold }),
+    ...(italic && { italic }),
+    ...(underline && { underline }),
+    ...(strikethrough && { strikethrough }),
+    ...(inverse && { inverse }),
+  };
+
+  return (
+    <ink-text style={STYLES_BY_WRAP[wrap]} textStyles={textStyles}>
+      {children}
+    </ink-text>
+  );
+}

package/node_modules/ink/src/components/TextInput.tsx

@@ -0,0 +1,140 @@
+import chalk from 'chalk';
+import React, { useEffect, useState } from 'react';
+import type { Key } from '../events/input-event.js';
+import useInput from '../hooks/use-input.js';
+import Text from './Text.js';
+
+export type TextInputProps = {
+  /** The current text. Controlled — caller owns the state. */
+  readonly value: string;
+  /** Fired with the next text on every keystroke that mutates `value`. */
+  readonly onChange: (value: string) => void;
+  /** Fired on Enter with the value at submit time. */
+  readonly onSubmit?: (value: string) => void;
+  /** Shown in place of the value while it's empty. */
+  readonly placeholder?: string;
+  /** When `true`, `useInput` is active and the cursor is drawn. */
+  readonly focus?: boolean;
+  /** Character to render in place of every value character. */
+  readonly mask?: string;
+  /** Whether to draw a visible cursor block. */
+  readonly showCursor?: boolean;
+  /** Highlight the range that the most recent input chunk inserted. */
+  readonly highlightPastedText?: boolean;
+};
+
+/** Single-line controlled text input. */
+export default function TextInput({
+  value: originalValue,
+  onChange,
+  onSubmit,
+  placeholder = '',
+  focus = true,
+  mask,
+  showCursor = true,
+  highlightPastedText = false,
+}: TextInputProps): React.ReactElement {
+  const [state, setState] = useState({
+    cursorOffset: (originalValue || '').length,
+    cursorWidth: 0,
+  });
+  const { cursorOffset, cursorWidth } = state;
+
+  useEffect(() => {
+    setState((prev) => {
+      if (!focus || !showCursor) return prev;
+      const nextValue = originalValue || '';
+      // Parent shrank `value` past where our cursor was sitting — snap
+      // the cursor to the new end so we don't render an empty inverse
+      // cell past the visible characters.
+      if (prev.cursorOffset > nextValue.length - 1) {
+        return { cursorOffset: nextValue.length, cursorWidth: 0 };
+      }
+      return prev;
+    });
+  }, [originalValue, focus, showCursor]);
+
+  const cursorActualWidth = highlightPastedText ? cursorWidth : 0;
+  const value = mask ? mask.repeat(originalValue.length) : originalValue;
+
+  let renderedValue = value;
+  let renderedPlaceholder = placeholder ? chalk.grey(placeholder) : undefined;
+
+  if (showCursor && focus) {
+    renderedPlaceholder =
+      placeholder.length > 0
+        ? chalk.inverse(placeholder[0]) + chalk.grey(placeholder.slice(1))
+        : chalk.inverse(' ');
+    renderedValue = value.length > 0 ? '' : chalk.inverse(' ');
+    let i = 0;
+    for (const char of value) {
+      renderedValue +=
+        i >= cursorOffset - cursorActualWidth && i <= cursorOffset
+          ? chalk.inverse(char)
+          : char;
+      i++;
+    }
+    if (value.length > 0 && cursorOffset === value.length) {
+      renderedValue += chalk.inverse(' ');
+    }
+  }
+
+  useInput(
+    (input: string, key: Key) => {
+      // Pass through navigation and exit keys so the surrounding app
+      // can still respond to them while a text field is focused.
+      if (
+        key.upArrow ||
+        key.downArrow ||
+        (key.ctrl && input === 'c') ||
+        key.tab ||
+        (key.shift && key.tab)
+      ) {
+        return;
+      }
+      if (key.return) {
+        onSubmit?.(originalValue);
+        return;
+      }
+
+      let nextCursorOffset = cursorOffset;
+      let nextValue = originalValue;
+      let nextCursorWidth = 0;
+
+      if (key.leftArrow) {
+        if (showCursor) nextCursorOffset--;
+      } else if (key.rightArrow) {
+        if (showCursor) nextCursorOffset++;
+      } else if (key.backspace || key.delete) {
+        if (cursorOffset > 0) {
+          nextValue =
+            originalValue.slice(0, cursorOffset - 1) +
+            originalValue.slice(cursorOffset, originalValue.length);
+          nextCursorOffset--;
+        }
+      } else {
+        nextValue =
+          originalValue.slice(0, cursorOffset) +
+          input +
+          originalValue.slice(cursorOffset, originalValue.length);
+        nextCursorOffset += input.length;
+        // Multi-character chunks are almost always pastes; remember the
+        // span so `highlightPastedText` can render the inserted range
+        // inverse on the next paint.
+        if (input.length > 1) nextCursorWidth = input.length;
+      }
+
+      if (nextCursorOffset < 0) nextCursorOffset = 0;
+      if (nextCursorOffset > nextValue.length) nextCursorOffset = nextValue.length;
+
+      setState({ cursorOffset: nextCursorOffset, cursorWidth: nextCursorWidth });
+
+      if (nextValue !== originalValue) onChange(nextValue);
+    },
+    { isActive: focus },
+  );
+
+  return (
+    <Text>{placeholder ? value.length > 0 ? renderedValue : renderedPlaceholder : renderedValue}</Text>
+  );
+}

package/node_modules/ink/src/constants.ts

@@ -0,0 +1,2 @@
+/** Frame budget in milliseconds. */
+export const FRAME_INTERVAL_MS = 16;

package/node_modules/ink/src/cursor.ts

@@ -0,0 +1,6 @@
+/** Position of the terminal hardware cursor in screen-buffer coordinates. */
+export type Cursor = {
+  readonly x: number;
+  readonly y: number;
+  readonly visible: boolean;
+};

package/node_modules/ink/src/devtools.ts

@@ -0,0 +1,2 @@
+/** Placeholder for a future React DevTools bridge. */
+export {};