@mdxui/terminal 2.0.0

package/dist/chunk-GBQ6UD6I.js

@@ -0,0 +1,655 @@
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/keyboard/manager.ts
+var KEY = {
+  ENTER: "enter",
+  ESCAPE: "escape",
+  UP: "up",
+  DOWN: "down",
+  LEFT: "left",
+  RIGHT: "right",
+  TAB: "tab",
+  SPACE: "space",
+  BACKSPACE: "backspace",
+  DELETE: "delete"
+};
+function matchKey(key, expected) {
+  return key === expected;
+}
+function createKeyboardManager(options) {
+  let bindings = { ...options.bindings };
+  let enabled = options.enabled !== false;
+  let context = options.context ?? null;
+  const onAction = options.onAction;
+  const sequenceTimeout = options.sequenceTimeout ?? 1e3;
+  let pendingSequence = "";
+  let sequenceTimer = null;
+  function getSequenceBindings() {
+    return Object.keys(bindings).filter((key) => key.length > 1 && !key.includes("+"));
+  }
+  function startsSequence(key) {
+    const sequences = getSequenceBindings();
+    return sequences.some((seq) => seq.startsWith(key));
+  }
+  function continuesSequence(key) {
+    if (!pendingSequence) return false;
+    const potential = pendingSequence + key;
+    const sequences = getSequenceBindings();
+    return sequences.some((seq) => seq.startsWith(potential));
+  }
+  function clearSequence() {
+    pendingSequence = "";
+    if (sequenceTimer) {
+      clearTimeout(sequenceTimer);
+      sequenceTimer = null;
+    }
+  }
+  function buildActionContext(key) {
+    const actionContext = { key };
+    if (context !== null) {
+      actionContext.context = context;
+    }
+    return actionContext;
+  }
+  function handleSequenceTimeout() {
+    if (pendingSequence && bindings[pendingSequence]) {
+      const action = bindings[pendingSequence];
+      if (typeof action === "function") {
+        action();
+      } else if (onAction) {
+        onAction(action, buildActionContext(pendingSequence));
+      }
+    }
+    clearSequence();
+  }
+  const manager = {
+    getAction(key) {
+      return bindings[key];
+    },
+    handleKey(key, handler) {
+      if (!enabled) return false;
+      if (key === "escape") {
+        if (pendingSequence) {
+          clearSequence();
+          return true;
+        }
+      }
+      const potentialSequence = pendingSequence + key;
+      if (bindings[potentialSequence]) {
+        clearSequence();
+        const action2 = bindings[potentialSequence];
+        if (typeof action2 === "function") {
+          action2();
+        } else {
+          const effectiveHandler = handler || onAction;
+          if (effectiveHandler) {
+            effectiveHandler(action2, buildActionContext(potentialSequence));
+          }
+        }
+        return true;
+      }
+      if (continuesSequence(key) || !pendingSequence && startsSequence(key)) {
+        pendingSequence = potentialSequence;
+        if (sequenceTimer) clearTimeout(sequenceTimer);
+        sequenceTimer = setTimeout(handleSequenceTimeout, sequenceTimeout);
+        return true;
+      }
+      if (pendingSequence) {
+        clearSequence();
+      }
+      const action = bindings[key];
+      if (action === void 0) {
+        return false;
+      }
+      if (typeof action === "function") {
+        action();
+      } else {
+        const effectiveHandler = handler || onAction;
+        if (effectiveHandler) {
+          effectiveHandler(action, buildActionContext(key));
+        }
+      }
+      return true;
+    },
+    addBinding(key, action) {
+      bindings[key] = action;
+    },
+    removeBinding(key) {
+      delete bindings[key];
+    },
+    setBindings(newBindings) {
+      bindings = { ...newBindings };
+    },
+    getBindings() {
+      const result = {};
+      for (const [key, action] of Object.entries(bindings)) {
+        if (typeof action === "string") {
+          result[key] = action;
+        }
+      }
+      return result;
+    },
+    disable() {
+      enabled = false;
+    },
+    enable() {
+      enabled = true;
+    },
+    toggle() {
+      enabled = !enabled;
+    },
+    isEnabled() {
+      return enabled;
+    },
+    getPendingSequence() {
+      return pendingSequence;
+    },
+    setContext(newContext) {
+      context = newContext;
+    },
+    destroy() {
+      if (sequenceTimer) {
+        clearTimeout(sequenceTimer);
+        sequenceTimer = null;
+      }
+      pendingSequence = "";
+    }
+  };
+  return manager;
+}
+
+// src/keyboard/presets.ts
+var VIM_BINDINGS = {
+  h: "move-left",
+  j: "move-down",
+  k: "move-up",
+  l: "move-right",
+  gg: "move-first",
+  G: "move-last",
+  "/": "search",
+  ":": "command",
+  i: "insert",
+  enter: "select",
+  escape: "back",
+  q: "quit"
+};
+var ARROW_BINDINGS = {
+  up: "move-up",
+  down: "move-down",
+  left: "move-left",
+  right: "move-right"
+};
+var COMMON_BINDINGS = {
+  enter: "select",
+  escape: "back",
+  tab: "focus-next",
+  "shift+tab": "focus-prev",
+  space: "toggle"
+};
+var EMACS_BINDINGS = {
+  "ctrl+f": "move-right",
+  "ctrl+b": "move-left",
+  "ctrl+n": "move-down",
+  "ctrl+p": "move-up",
+  "ctrl+a": "move-first",
+  "ctrl+e": "move-last",
+  "ctrl+g": "back"
+};
+
+// src/keyboard/focus.ts
+import React, { useState, useCallback, useRef, useEffect, useContext, createContext } from "react";
+
+// src/types.ts
+var focusIdCounter = 0;
+function createFocusId(id) {
+  return id ?? `focus-${++focusIdCounter}`;
+}
+function isFocusId(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function __resetFocusIdCounter() {
+  focusIdCounter = 0;
+}
+
+// src/keyboard/focus.ts
+function useKeyboard(handler, options) {
+  const [enabled, setEnabled] = useState(options?.enabled !== false);
+  const priority = options?.priority ?? 0;
+  const handlerRef = useRef(handler);
+  handlerRef.current = handler;
+  const cleanup = useCallback(() => {
+  }, []);
+  useEffect(() => {
+    return cleanup;
+  }, [cleanup]);
+  return {
+    enabled,
+    priority,
+    enable: () => setEnabled(true),
+    disable: () => setEnabled(false),
+    cleanup
+  };
+}
+function useFocus(options) {
+  const idRef = useRef(createFocusId(options?.id));
+  const [localFocused, setLocalFocused] = useState(options?.autoFocus ?? false);
+  const tabIndex = options?.tabIndex ?? 0;
+  const context = useContext(FocusContext);
+  const id = idRef.current;
+  useEffect(() => {
+    if (context?.registerFocusable) {
+      context.registerFocusable(id, tabIndex);
+      return () => context.unregisterFocusable?.(id);
+    }
+  }, [id, tabIndex, context]);
+  const focused = context ? context.focusedId === id : localFocused;
+  const focus = useCallback(() => {
+    if (context) {
+      context.focusById(id);
+    } else {
+      setLocalFocused(true);
+    }
+    options?.onFocus?.();
+  }, [context, id, options]);
+  const blur = useCallback(() => {
+    if (!context) {
+      setLocalFocused(false);
+    }
+    options?.onBlur?.();
+  }, [context, options]);
+  const focusNext = useCallback(() => {
+    context?.focusNext();
+  }, [context]);
+  const focusPrev = useCallback(() => {
+    context?.focusPrev();
+  }, [context]);
+  const focusFirst = useCallback(() => {
+    context?.focusFirst();
+  }, [context]);
+  const focusLast = useCallback(() => {
+    context?.focusLast();
+  }, [context]);
+  return {
+    id,
+    focused,
+    tabIndex,
+    focus,
+    blur,
+    focusNext,
+    focusPrev,
+    focusFirst,
+    focusLast
+  };
+}
+var FocusContext = createContext(null);
+function useFocusManager() {
+  const context = useContext(FocusContext);
+  if (context) {
+    return context;
+  }
+  return {
+    focusableIds: [],
+    focusedId: null,
+    isTrapped: false,
+    focusById: () => {
+    },
+    focusNext: () => {
+    },
+    focusPrev: () => {
+    },
+    focusFirst: () => {
+    },
+    focusLast: () => {
+    },
+    registerFocusable: () => {
+    },
+    unregisterFocusable: () => {
+    }
+  };
+}
+function useNavigableList(options) {
+  const { items, initialIndex = 0, wrap = false, useKeyboard: keyboardEnabled = false } = options;
+  const [currentIndex, setCurrentIndex] = useState(initialIndex);
+  const moveUp = useCallback(() => {
+    setCurrentIndex((prev) => {
+      if (prev <= 0) {
+        return wrap ? items.length - 1 : 0;
+      }
+      return prev - 1;
+    });
+  }, [items.length, wrap]);
+  const moveDown = useCallback(() => {
+    setCurrentIndex((prev) => {
+      if (prev >= items.length - 1) {
+        return wrap ? 0 : items.length - 1;
+      }
+      return prev + 1;
+    });
+  }, [items.length, wrap]);
+  const moveToFirst = useCallback(() => {
+    setCurrentIndex(0);
+  }, []);
+  const moveToLast = useCallback(() => {
+    setCurrentIndex(items.length - 1);
+  }, [items.length]);
+  const setIndex = useCallback(
+    (index) => {
+      if (index >= 0 && index < items.length) {
+        setCurrentIndex(index);
+      }
+    },
+    [items.length]
+  );
+  return {
+    currentIndex,
+    currentItem: items[currentIndex],
+    wrap,
+    keyboardEnabled,
+    moveUp,
+    moveDown,
+    moveToFirst,
+    moveToLast,
+    setIndex
+  };
+}
+function useNavigableGrid(options) {
+  const {
+    rows,
+    cols,
+    initialRow = 0,
+    initialCol = 0,
+    wrapHorizontal = false,
+    wrapVertical = false,
+    useKeyboard: keyboardEnabled = false
+  } = options;
+  const [row, setRow] = useState(initialRow);
+  const [col, setCol] = useState(initialCol);
+  const moveUp = useCallback(() => {
+    setRow((prev) => {
+      if (prev <= 0) {
+        return wrapVertical ? rows - 1 : 0;
+      }
+      return prev - 1;
+    });
+  }, [rows, wrapVertical]);
+  const moveDown = useCallback(() => {
+    setRow((prev) => {
+      if (prev >= rows - 1) {
+        return wrapVertical ? 0 : rows - 1;
+      }
+      return prev + 1;
+    });
+  }, [rows, wrapVertical]);
+  const moveLeft = useCallback(() => {
+    setCol((prev) => {
+      if (prev <= 0) {
+        return wrapHorizontal ? cols - 1 : 0;
+      }
+      return prev - 1;
+    });
+  }, [cols, wrapHorizontal]);
+  const moveRight = useCallback(() => {
+    setCol((prev) => {
+      if (prev >= cols - 1) {
+        return wrapHorizontal ? 0 : cols - 1;
+      }
+      return prev + 1;
+    });
+  }, [cols, wrapHorizontal]);
+  const moveToCell = useCallback(
+    (newRow, newCol) => {
+      if (newRow >= 0 && newRow < rows) {
+        setRow(newRow);
+      }
+      if (newCol >= 0 && newCol < cols) {
+        setCol(newCol);
+      }
+    },
+    [rows, cols]
+  );
+  return {
+    row,
+    col,
+    wrapHorizontal,
+    wrapVertical,
+    keyboardEnabled,
+    moveUp,
+    moveDown,
+    moveLeft,
+    moveRight,
+    moveToCell
+  };
+}
+function FocusProvider(props) {
+  const { children, trap = false, wrapFocus = false, initialFocus, focusFirstOnMount = false, restoreFocus = false, group } = props;
+  const [focusableIds, setFocusableIds] = useState([]);
+  const [focusedId, setFocusedId] = useState(initialFocus ?? null);
+  const previousFocusRef = useRef(null);
+  const tabIndexMapRef = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    if (focusFirstOnMount && focusableIds.length > 0 && !focusedId) {
+      setFocusedId(focusableIds[0]);
+    }
+  }, [focusFirstOnMount, focusableIds, focusedId]);
+  useEffect(() => {
+    if (restoreFocus) {
+      previousFocusRef.current = focusedId;
+    }
+    return () => {
+      if (restoreFocus && previousFocusRef.current) {
+      }
+    };
+  }, [restoreFocus, focusedId]);
+  const focusById = useCallback((id) => {
+    if (focusableIds.includes(id)) {
+      setFocusedId(id);
+    }
+  }, [focusableIds]);
+  const focusNext = useCallback(() => {
+    if (focusableIds.length === 0) return;
+    const currentIndex = focusedId ? focusableIds.indexOf(focusedId) : -1;
+    let nextIndex = currentIndex + 1;
+    if (nextIndex >= focusableIds.length) {
+      nextIndex = wrapFocus ? 0 : focusableIds.length - 1;
+    }
+    setFocusedId(focusableIds[nextIndex]);
+  }, [focusableIds, focusedId, wrapFocus]);
+  const focusPrev = useCallback(() => {
+    if (focusableIds.length === 0) return;
+    const currentIndex = focusedId ? focusableIds.indexOf(focusedId) : focusableIds.length;
+    let prevIndex = currentIndex - 1;
+    if (prevIndex < 0) {
+      prevIndex = wrapFocus ? focusableIds.length - 1 : 0;
+    }
+    setFocusedId(focusableIds[prevIndex]);
+  }, [focusableIds, focusedId, wrapFocus]);
+  const focusFirst = useCallback(() => {
+    if (focusableIds.length > 0) {
+      setFocusedId(focusableIds[0]);
+    }
+  }, [focusableIds]);
+  const focusLast = useCallback(() => {
+    if (focusableIds.length > 0) {
+      setFocusedId(focusableIds[focusableIds.length - 1]);
+    }
+  }, [focusableIds]);
+  const registerFocusable = useCallback((id, tabIndex) => {
+    tabIndexMapRef.current.set(id, tabIndex);
+    setFocusableIds((prev) => {
+      if (prev.includes(id)) return prev;
+      const newIds = [...prev, id];
+      newIds.sort((a, b) => {
+        const tabA = tabIndexMapRef.current.get(a) ?? 0;
+        const tabB = tabIndexMapRef.current.get(b) ?? 0;
+        return tabA - tabB;
+      });
+      return newIds;
+    });
+  }, []);
+  const unregisterFocusable = useCallback((id) => {
+    tabIndexMapRef.current.delete(id);
+    setFocusableIds((prev) => prev.filter((fid) => fid !== id));
+  }, []);
+  const contextValue = {
+    focusableIds,
+    focusedId,
+    isTrapped: trap,
+    focusById,
+    focusNext,
+    focusPrev,
+    focusFirst,
+    focusLast,
+    registerFocusable,
+    unregisterFocusable
+  };
+  return React.createElement(
+    FocusContext.Provider,
+    { value: contextValue },
+    React.createElement(
+      "div",
+      {
+        "data-focus-provider": true,
+        "data-focus-group": group,
+        "data-focus-trap": trap,
+        ...props,
+        children: void 0
+        // Remove children from div props to avoid duplication
+      },
+      children
+    )
+  );
+}
+
+// src/keyboard/integration.ts
+function normalizeReadlineKey(str, key) {
+  if (!key && str) {
+    return {
+      name: str,
+      ctrl: false,
+      alt: false,
+      shift: str !== str.toLowerCase() && str === str.toUpperCase(),
+      meta: false,
+      sequence: str
+    };
+  }
+  const nameMap = {
+    return: "enter",
+    escape: "escape",
+    up: "up",
+    down: "down",
+    left: "left",
+    right: "right",
+    tab: "tab",
+    backspace: "backspace",
+    delete: "delete",
+    space: "space"
+  };
+  const keyName = key?.name ?? str ?? "";
+  const normalizedName = nameMap[keyName.toLowerCase()] ?? keyName.toLowerCase();
+  return {
+    name: normalizedName,
+    ctrl: key?.ctrl ?? false,
+    alt: false,
+    // readline doesn't distinguish alt reliably
+    shift: key?.shift ?? false,
+    meta: key?.meta ?? false,
+    sequence: key?.sequence ?? str
+  };
+}
+function keyToBindingString(key) {
+  const modifiers = [];
+  if (key.ctrl) modifiers.push("ctrl");
+  if (key.alt) modifiers.push("alt");
+  if (key.shift) modifiers.push("shift");
+  if (key.meta) modifiers.push("meta");
+  if (modifiers.length > 0) {
+    return `${modifiers.join("+")}+${key.name}`;
+  }
+  return key.name;
+}
+function attachKeyboardManager(manager, options = {}) {
+  const { input = process.stdin, exitOnCtrlC = true } = options;
+  if (!input.isTTY) {
+    throw new Error("attachKeyboardManager requires a TTY stdin. Cannot attach to non-TTY input.");
+  }
+  const readline = __require("readline");
+  readline.emitKeypressEvents(input);
+  const wasRaw = input.isRaw;
+  input.setRawMode(true);
+  const handleKeypress = (str, key) => {
+    if (exitOnCtrlC && key?.ctrl && key?.name === "c") {
+      input.setRawMode(wasRaw ?? false);
+      process.exit(0);
+    }
+    const normalized = normalizeReadlineKey(str, key);
+    const bindingKey = keyToBindingString(normalized);
+    manager.handleKey(bindingKey);
+  };
+  input.on("keypress", handleKeypress);
+  input.resume();
+  return () => {
+    input.off("keypress", handleKeypress);
+    input.setRawMode(wasRaw ?? false);
+  };
+}
+function normalizeOpenTUIKey(event) {
+  const nameMap = {
+    return: "enter",
+    escape: "escape",
+    up: "up",
+    down: "down",
+    left: "left",
+    right: "right",
+    tab: "tab",
+    backspace: "backspace",
+    delete: "delete",
+    space: "space"
+  };
+  const normalizedName = nameMap[event.name.toLowerCase()] ?? event.name.toLowerCase();
+  return {
+    name: normalizedName,
+    ctrl: event.ctrl,
+    alt: event.option,
+    // OpenTUI uses 'option' for Alt
+    shift: event.shift,
+    meta: event.meta,
+    sequence: event.sequence
+  };
+}
+function createOpenTUIKeyHandler(manager) {
+  return (event) => {
+    if (event.eventType === "release") {
+      return;
+    }
+    const normalized = normalizeOpenTUIKey(event);
+    const bindingKey = keyToBindingString(normalized);
+    manager.handleKey(bindingKey);
+  };
+}
+
+export {
+  KEY,
+  matchKey,
+  createKeyboardManager,
+  VIM_BINDINGS,
+  ARROW_BINDINGS,
+  COMMON_BINDINGS,
+  EMACS_BINDINGS,
+  createFocusId,
+  isFocusId,
+  __resetFocusIdCounter,
+  useKeyboard,
+  useFocus,
+  FocusContext,
+  useFocusManager,
+  useNavigableList,
+  useNavigableGrid,
+  FocusProvider,
+  normalizeReadlineKey,
+  keyToBindingString,
+  attachKeyboardManager,
+  normalizeOpenTUIKey,
+  createOpenTUIKeyHandler
+};