mimo-reasonix 0.1.0 → 0.1.1

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

@@ -0,0 +1,17 @@
+import { createContext } from 'react';
+
+export type Props = {
+  /** Tear down the root and unmount the whole app. */
+  readonly exit: (error?: Error) => void;
+};
+
+/** Provides the imperative `exit()` handle to descendants. */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const AppContext = createContext<Props>({
+  exit() {},
+});
+
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+AppContext.displayName = 'InternalAppContext';
+
+export default AppContext;

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

@@ -0,0 +1,105 @@
+import React, { type PropsWithChildren, type Ref } from 'react';
+import type { Except } from 'type-fest';
+import type { DOMElement } from '../dom.js';
+import type { ClickEvent } from '../events/click-event.js';
+import type { FocusEvent } from '../events/focus-event.js';
+import type { KeyboardEvent } from '../events/keyboard-event.js';
+import type { Styles } from '../styles.js';
+import * as warn from '../warn.js';
+
+export type Props = Except<Styles, 'textWrap'> & {
+  ref?: Ref<DOMElement>;
+  /** Position in the Tab/Shift+Tab cycle. */
+  tabIndex?: number;
+  /** Receive focus at mount, like the HTML `autofocus` attribute. */
+  autoFocus?: boolean;
+  onClick?: (event: ClickEvent) => void;
+  onFocus?: (event: FocusEvent) => void;
+  onFocusCapture?: (event: FocusEvent) => void;
+  onBlur?: (event: FocusEvent) => void;
+  onBlurCapture?: (event: FocusEvent) => void;
+  onKeyDown?: (event: KeyboardEvent) => void;
+  onKeyDownCapture?: (event: KeyboardEvent) => void;
+  /** Fired when the pointer enters this Box's rendered rect. */
+  onMouseEnter?: () => void;
+  /** Fired when the pointer leaves this Box's rendered rect. */
+  onMouseLeave?: () => void;
+};
+
+const INTEGER_SPACING_KEYS = [
+  'margin',
+  'marginX',
+  'marginY',
+  'marginTop',
+  'marginBottom',
+  'marginLeft',
+  'marginRight',
+  'padding',
+  'paddingX',
+  'paddingY',
+  'paddingTop',
+  'paddingBottom',
+  'paddingLeft',
+  'paddingRight',
+  'gap',
+  'columnGap',
+  'rowGap',
+] as const;
+
+/** The fundamental flexbox primitive. */
+function Box({
+  children,
+  flexWrap = 'nowrap',
+  flexDirection = 'row',
+  flexGrow = 0,
+  flexShrink = 1,
+  ref,
+  tabIndex,
+  autoFocus,
+  onClick,
+  onFocus,
+  onFocusCapture,
+  onBlur,
+  onBlurCapture,
+  onMouseEnter,
+  onMouseLeave,
+  onKeyDown,
+  onKeyDownCapture,
+  ...style
+}: PropsWithChildren<Props>) {
+  for (const key of INTEGER_SPACING_KEYS) {
+    warn.ifNotInteger((style as Styles)[key] as number | undefined, key);
+  }
+
+  const resolvedStyle: Styles = {
+    flexWrap,
+    flexDirection,
+    flexGrow,
+    flexShrink,
+    ...style,
+    overflowX: style.overflowX ?? style.overflow ?? 'visible',
+    overflowY: style.overflowY ?? style.overflow ?? 'visible',
+  };
+
+  return (
+    <ink-box
+      ref={ref}
+      tabIndex={tabIndex}
+      autoFocus={autoFocus}
+      onClick={onClick}
+      onFocus={onFocus}
+      onFocusCapture={onFocusCapture}
+      onBlur={onBlur}
+      onBlurCapture={onBlurCapture}
+      onMouseEnter={onMouseEnter}
+      onMouseLeave={onMouseLeave}
+      onKeyDown={onKeyDown}
+      onKeyDownCapture={onKeyDownCapture}
+      style={resolvedStyle}
+    >
+      {children}
+    </ink-box>
+  );
+}
+
+export default Box;

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

@@ -0,0 +1,96 @@
+import React, { type Ref, useCallback, useEffect, useRef, useState } from 'react';
+import type { Except } from 'type-fest';
+import type { DOMElement } from '../dom.js';
+import type { ClickEvent } from '../events/click-event.js';
+import type { FocusEvent } from '../events/focus-event.js';
+import type { KeyboardEvent } from '../events/keyboard-event.js';
+import type { Styles } from '../styles.js';
+import Box from './Box.js';
+
+/** How long the visual `active` flag stays true after a press. */
+const ACTIVE_FLASH_MS = 100;
+
+type ButtonState = {
+  focused: boolean;
+  hovered: boolean;
+  active: boolean;
+};
+
+export type Props = Except<Styles, 'textWrap'> & {
+  ref?: Ref<DOMElement>;
+  onAction: () => void;
+  /** Tab order index. */
+  tabIndex?: number;
+  /** Focus the button at mount. */
+  autoFocus?: boolean;
+  children: ((state: ButtonState) => React.ReactNode) | React.ReactNode;
+};
+
+function Button({
+  onAction,
+  tabIndex = 0,
+  autoFocus,
+  children,
+  ref,
+  ...style
+}: Props) {
+  const [isFocused, setIsFocused] = useState(false);
+  const [isHovered, setIsHovered] = useState(false);
+  const [isActive, setIsActive] = useState(false);
+  const activeTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  useEffect(
+    () => () => {
+      if (activeTimer.current) clearTimeout(activeTimer.current);
+    },
+    [],
+  );
+
+  const handleKeyDown = useCallback(
+    (e: KeyboardEvent) => {
+      if (e.key === 'return' || e.key === ' ') {
+        e.preventDefault();
+        setIsActive(true);
+        onAction();
+        if (activeTimer.current) clearTimeout(activeTimer.current);
+        activeTimer.current = setTimeout(() => setIsActive(false), ACTIVE_FLASH_MS);
+      }
+    },
+    [onAction],
+  );
+
+  const handleClick = useCallback(
+    (_e: ClickEvent) => {
+      onAction();
+    },
+    [onAction],
+  );
+
+  const handleFocus = useCallback((_e: FocusEvent) => setIsFocused(true), []);
+  const handleBlur = useCallback((_e: FocusEvent) => setIsFocused(false), []);
+  const handleMouseEnter = useCallback(() => setIsHovered(true), []);
+  const handleMouseLeave = useCallback(() => setIsHovered(false), []);
+
+  const state: ButtonState = { focused: isFocused, hovered: isHovered, active: isActive };
+  const content = typeof children === 'function' ? children(state) : children;
+
+  return (
+    <Box
+      ref={ref}
+      tabIndex={tabIndex}
+      autoFocus={autoFocus}
+      onKeyDown={handleKeyDown}
+      onClick={handleClick}
+      onFocus={handleFocus}
+      onBlur={handleBlur}
+      onMouseEnter={handleMouseEnter}
+      onMouseLeave={handleMouseLeave}
+      {...style}
+    >
+      {content}
+    </Box>
+  );
+}
+
+export default Button;
+export type { ButtonState };

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

@@ -0,0 +1,94 @@
+import React, { createContext, type PropsWithChildren, useEffect, useState } from 'react';
+import { FRAME_INTERVAL_MS } from '../constants.js';
+import { useTerminalFocus } from '../hooks/use-terminal-focus.js';
+
+export type Clock = {
+  subscribe: (onChange: () => void, keepAlive: boolean) => () => void;
+  now: () => number;
+  setTickInterval: (ms: number) => void;
+};
+
+/** Build a shared animation clock. */
+export function createClock(tickIntervalMs: number): Clock {
+  const subscribers = new Map<() => void, boolean>();
+  let interval: ReturnType<typeof setInterval> | null = null;
+  let currentTickIntervalMs = tickIntervalMs;
+  let startTime = 0;
+  // Snapshot of the current tick time. All subscribers run with the same
+  // value, so two animations that started in the same frame stay in sync
+  // even if one of them takes longer to react.
+  let tickTime = 0;
+
+  function tick(): void {
+    tickTime = Date.now() - startTime;
+    for (const onChange of subscribers.keys()) {
+      onChange();
+    }
+  }
+
+  function updateInterval(): void {
+    let anyKeepAlive = false;
+    for (const keepAlive of subscribers.values()) {
+      if (keepAlive) {
+        anyKeepAlive = true;
+        break;
+      }
+    }
+
+    if (anyKeepAlive) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      if (startTime === 0) startTime = Date.now();
+      interval = setInterval(tick, currentTickIntervalMs);
+    } else if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+  }
+
+  return {
+    subscribe(onChange, keepAlive) {
+      subscribers.set(onChange, keepAlive);
+      updateInterval();
+      return () => {
+        subscribers.delete(onChange);
+        updateInterval();
+      };
+    },
+    now() {
+      if (startTime === 0) startTime = Date.now();
+      // Live interval → return the per-tick snapshot so concurrent
+      // subscribers stay coherent. Paused → return real time, because
+      // `tickTime` is stuck at whatever the last burst left it at.
+      if (interval && tickTime) return tickTime;
+      return Date.now() - startTime;
+    },
+    setTickInterval(ms) {
+      if (ms === currentTickIntervalMs) return;
+      currentTickIntervalMs = ms;
+      updateInterval();
+    },
+  };
+}
+
+/** Carries the active `Clock` instance to descendants. */
+export const ClockContext = createContext<Clock | null>(null);
+
+/** While the terminal window is unfocused, drop the tick rate in half. */
+const BLURRED_TICK_INTERVAL_MS = FRAME_INTERVAL_MS * 2;
+
+const initialClock = () => createClock(FRAME_INTERVAL_MS);
+
+/** Owns one `Clock` for the whole app and re-rates it on focus changes. */
+export function ClockProvider({ children }: PropsWithChildren) {
+  const [clock] = useState(initialClock);
+  const focused = useTerminalFocus();
+
+  useEffect(() => {
+    clock.setTickInterval(focused ? FRAME_INTERVAL_MS : BLURRED_TICK_INTERVAL_MS);
+  }, [clock, focused]);
+
+  return <ClockContext.Provider value={clock}>{children}</ClockContext.Provider>;
+}

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

@@ -0,0 +1,23 @@
+import { createContext } from 'react';
+import type { DOMElement } from '../dom.js';
+
+export type CursorDeclaration = {
+  /** Column offset (in terminal cells) relative to `node`'s top-left. */
+  readonly relativeX: number;
+  /** Row offset (in lines) relative to `node`'s top-left. */
+  readonly relativeY: number;
+  /** The owning `ink-box` element. */
+  readonly node: DOMElement;
+};
+
+/** Setter for the declared native-cursor position. */
+export type CursorDeclarationSetter = (
+  declaration: CursorDeclaration | null,
+  clearIfNode?: DOMElement | null,
+) => void;
+
+const CursorDeclarationContext = createContext<CursorDeclarationSetter>(
+  () => {},
+);
+
+export default CursorDeclarationContext;

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

@@ -0,0 +1,116 @@
+import codeExcerpt, { type CodeExcerpt } from 'code-excerpt';
+import { readFileSync } from 'fs';
+import React from 'react';
+import StackUtils from 'stack-utils';
+import Box from './Box.js';
+import Text from './Text.js';
+
+/* eslint-disable custom-rules/no-process-cwd -- stack trace file:// paths are relative to the real OS cwd, not the virtual cwd */
+
+// V8 reports frames as `file:///abs/path/to/file.js`. Strip the
+// `file://<cwd>/` prefix so the rendered path is relative to the
+// project root — keeps the overlay readable on deep checkouts.
+const stripFilePrefix = (path: string | undefined): string | undefined => {
+  return path?.replace(`file://${process.cwd()}/`, '');
+};
+
+let stackUtilsInstance: StackUtils | undefined;
+
+// Lazy-initialise StackUtils. Building it eagerly at module load would
+// snapshot `process.cwd()` before the host has had a chance to chdir,
+// producing wrong relative paths when the renderer is consumed as a
+// library.
+function getStackUtils(): StackUtils {
+  return stackUtilsInstance ??= new StackUtils({
+    cwd: process.cwd(),
+    internals: StackUtils.nodeInternals(),
+  });
+}
+
+/* eslint-enable custom-rules/no-process-cwd */
+
+type Props = {
+  readonly error: Error;
+};
+
+export default function ErrorOverview({
+  error,
+}: Props) {
+  const stack = error.stack ? error.stack.split('\n').slice(1) : undefined;
+  const origin = stack ? getStackUtils().parseLine(stack[0]!) : undefined;
+  const filePath = stripFilePrefix(origin?.file);
+  let excerpt: CodeExcerpt[] | undefined;
+  let lineWidth = 0;
+  if (filePath && origin?.line) {
+    try {
+      // eslint-disable-next-line custom-rules/no-sync-fs -- sync render path; error overlay can't go async without suspense restructuring
+      const sourceCode = readFileSync(filePath, 'utf8');
+      excerpt = codeExcerpt(sourceCode, origin.line);
+      if (excerpt) {
+        for (const {
+          line
+        } of excerpt) {
+          lineWidth = Math.max(lineWidth, String(line).length);
+        }
+      }
+    } catch {
+      // file not readable — skip source context
+    }
+  }
+  return <Box flexDirection="column" padding={1}>
+      <Box>
+        <Text backgroundColor="ansi:red" color="ansi:white">
+          {' '}
+          ERROR{' '}
+        </Text>
+
+        <Text> {error.message}</Text>
+      </Box>
+
+      {origin && filePath && <Box marginTop={1}>
+          <Text dim>
+            {filePath}:{origin.line}:{origin.column}
+          </Text>
+        </Box>}
+
+      {origin && excerpt && <Box marginTop={1} flexDirection="column">
+          {excerpt.map(({
+        line: line_0,
+        value
+      }) => <Box key={line_0}>
+              <Box width={lineWidth + 1}>
+                <Text dim={line_0 !== origin.line} backgroundColor={line_0 === origin.line ? 'ansi:red' : undefined} color={line_0 === origin.line ? 'ansi:white' : undefined}>
+                  {String(line_0).padStart(lineWidth, ' ')}:
+                </Text>
+              </Box>
+
+              <Text key={line_0} backgroundColor={line_0 === origin.line ? 'ansi:red' : undefined} color={line_0 === origin.line ? 'ansi:white' : undefined}>
+                {' ' + value}
+              </Text>
+            </Box>)}
+        </Box>}
+
+      {error.stack && <Box marginTop={1} flexDirection="column">
+          {error.stack.split('\n').slice(1).map(line_1 => {
+        const parsedLine = getStackUtils().parseLine(line_1);
+
+        // If the line from the stack cannot be parsed, we print out the unparsed line.
+        if (!parsedLine) {
+          return <Box key={line_1}>
+                    <Text dim>- </Text>
+                    <Text bold>{line_1}</Text>
+                  </Box>;
+        }
+        return <Box key={line_1}>
+                  <Text dim>- </Text>
+                  <Text bold>{parsedLine.function}</Text>
+                  <Text dim>
+                    {' '}
+                    ({stripFilePrefix(parsedLine.file) ?? ''}:{parsedLine.line}:
+                    {parsedLine.column})
+                  </Text>
+                </Box>;
+      })}
+        </Box>}
+    </Box>;
+}

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

@@ -0,0 +1,27 @@
+import React, { type ReactNode } from 'react';
+import { supportsHyperlinks } from '../supports-hyperlinks.js';
+import Text from './Text.js';
+
+export type Props = {
+  /** Visible link text. Defaults to `url` when omitted. */
+  readonly children?: ReactNode;
+  /** Target URL. Emitted verbatim into the OSC 8 escape. */
+  readonly url: string;
+  /** What to render when the terminal does not advertise OSC 8 support. */
+  readonly fallback?: ReactNode;
+};
+
+/** Renders a clickable hyperlink using OSC 8 escapes. */
+export default function Link({ children, url, fallback }: Props) {
+  const content = children ?? url;
+
+  if (supportsHyperlinks()) {
+    return (
+      <Text>
+        <ink-link href={url}>{content}</ink-link>
+      </Text>
+    );
+  }
+
+  return <Text>{fallback ?? content}</Text>;
+}

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

@@ -0,0 +1,11 @@
+import React from 'react';
+
+export type Props = {
+  /** How many `\n` characters to emit. */
+  readonly count?: number;
+};
+
+/** Emits one or more newline characters inside a `<Text>` block. */
+export default function Newline({ count = 1 }: Props) {
+  return <ink-text>{'\n'.repeat(count)}</ink-text>;
+}

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

@@ -0,0 +1,16 @@
+import React, { type PropsWithChildren } from 'react';
+import Box, { type Props as BoxProps } from './Box.js';
+
+type Props = Omit<BoxProps, 'noSelect'> & {
+  fromLeftEdge?: boolean;
+};
+
+/** Marks a sub-tree as non-selectable in fullscreen text selection. */
+export function NoSelect({ children, fromLeftEdge, ...boxProps }: PropsWithChildren<Props>) {
+  const noSelect = fromLeftEdge ? 'from-left-edge' : true;
+  return (
+    <Box {...boxProps} noSelect={noSelect}>
+      {children}
+    </Box>
+  );
+}

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

@@ -0,0 +1,18 @@
+import React from 'react';
+
+type Props = {
+  /** Pre-rendered ANSI rows. */
+  lines: string[];
+  /** Column width the producer wrapped `lines` to. */
+  width: number;
+};
+
+export function RawAnsi({ lines, width }: Props) {
+  if (lines.length === 0) return null;
+
+  // `ink-raw-ansi` is a renderer-recognised host element; the reconciler
+  // routes it through the dedicated raw-ANSI measure path.
+  return (
+    <ink-raw-ansi rawText={lines.join('\n')} rawWidth={width} rawHeight={lines.length} />
+  );
+}