@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/useInput-Cfp5zB2s.js

@@ -0,0 +1,594 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+import { useRef, useEffectEvent, useEffect } from 'react';
+import { IMECompositionBuffer, isIMEInput } from './IMECompositionBuffer-Dl3S0KnF.js';
+const {
+  Buffer
+} = __cjs_getBuiltinModule("node:buffer");
+import { kittyModifiers } from './kittyFlags-bNNf_9kX.js';
+import { r as reconcilerInstance } from './reconciler-gfmqURLy.js';
+import { useStdinContext } from './useStdin-X-O0kd-n.js';
+
+const metaKeyCodeRe = /^\u001B([a-z0-9])$/i;
+const functionKeyRe = /^\u001B+([ON[]|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
+const keyName = {
+  /* xterm/rxvt ESC [ number ~ */
+  "[1~": "home",
+  "[2$": "insert",
+  "[2^": "insert",
+  "[2~": "insert",
+  "[3$": "delete",
+  "[3^": "delete",
+  "[3~": "delete",
+  "[4~": "end",
+  "[5$": "pageup",
+  "[5^": "pageup",
+  "[5~": "pageup",
+  "[6$": "pagedown",
+  "[6^": "pagedown",
+  "[6~": "pagedown",
+  "[7$": "home",
+  "[7^": "home",
+  /* rxvt */
+  "[7~": "home",
+  "[8$": "end",
+  "[8^": "end",
+  "[8~": "end",
+  /* xterm/rxvt ESC [ number ~ */
+  "[11~": "f1",
+  "[12~": "f2",
+  "[13~": "f3",
+  "[14~": "f4",
+  /* common */
+  "[15~": "f5",
+  "[17~": "f6",
+  "[18~": "f7",
+  "[19~": "f8",
+  "[20~": "f9",
+  "[21~": "f10",
+  "[23~": "f11",
+  "[24~": "f12",
+  /* putty */
+  "[[5~": "pageup",
+  "[[6~": "pagedown",
+  /* from Cygwin and used in libuv */
+  "[[A": "f1",
+  "[[B": "f2",
+  "[[C": "f3",
+  "[[D": "f4",
+  "[[E": "f5",
+  /* xterm ESC [ letter */
+  "[A": "up",
+  /* rxvt keys with modifiers */
+  "[a": "up",
+  "[B": "down",
+  "[b": "down",
+  "[C": "right",
+  "[c": "right",
+  "[D": "left",
+  "[d": "left",
+  "[E": "clear",
+  "[e": "clear",
+  "[F": "end",
+  "[H": "home",
+  /* VT220-style modifier sequences: ESC [ 1 ; mod P/Q/R/S */
+  "[P": "f1",
+  "[Q": "f2",
+  "[R": "f3",
+  "[S": "f4",
+  /* misc. */
+  "[Z": "tab",
+  /* xterm/gnome ESC O letter */
+  OA: "up",
+  Oa: "up",
+  OB: "down",
+  Ob: "down",
+  OC: "right",
+  Oc: "right",
+  OD: "left",
+  Od: "left",
+  OE: "clear",
+  Oe: "clear",
+  OF: "end",
+  OH: "home",
+  /* xterm/gnome ESC O letter */
+  OP: "f1",
+  OQ: "f2",
+  OR: "f3",
+  OS: "f4"
+};
+const nonAlphanumericKeys = [...Object.values(keyName), "backspace"];
+const isShiftKey = (code) => ["[2$", "[3$", "[5$", "[6$", "[7$", "[8$", "[a", "[b", "[c", "[d", "[e", "[Z"].includes(code);
+const isCtrlKey = (code) => ["[2^", "[3^", "[5^", "[6^", "[7^", "[8^", "Oa", "Ob", "Oc", "Od", "Oe"].includes(code);
+const kittyKeyRe = /^\u001B\[(\d+)(?:;(\d+)(?::(\d+))?(?:;([\d:]+))?)?u$/;
+const kittySpecialKeyRe = /^\u001B\[(\d+);(\d+):(\d+)([A-Z~])$/i;
+const kittySpecialLetterKeys = {
+  A: "up",
+  B: "down",
+  C: "right",
+  D: "left",
+  E: "clear",
+  F: "end",
+  H: "home",
+  P: "f1",
+  Q: "f2",
+  R: "f3",
+  S: "f4"
+};
+const kittySpecialNumberKeys = {
+  2: "insert",
+  3: "delete",
+  5: "pageup",
+  6: "pagedown",
+  7: "home",
+  8: "end",
+  11: "f1",
+  12: "f2",
+  13: "f3",
+  14: "f4",
+  15: "f5",
+  17: "f6",
+  18: "f7",
+  19: "f8",
+  20: "f9",
+  21: "f10",
+  23: "f11",
+  24: "f12"
+};
+const kittyCodepointNames = {
+  8: "backspace",
+  // 13 (return) and 32 (space) are handled before this lookup
+  // in parseKittyKeypress so they can be marked as printable.
+  9: "tab",
+  27: "escape",
+  127: "backspace",
+  57358: "capslock",
+  57359: "scrolllock",
+  57360: "numlock",
+  57361: "printscreen",
+  57362: "pause",
+  57363: "menu",
+  57376: "f13",
+  57377: "f14",
+  57378: "f15",
+  57379: "f16",
+  57380: "f17",
+  57381: "f18",
+  57382: "f19",
+  57383: "f20",
+  57384: "f21",
+  57385: "f22",
+  57386: "f23",
+  57387: "f24",
+  57388: "f25",
+  57389: "f26",
+  57390: "f27",
+  57391: "f28",
+  57392: "f29",
+  57393: "f30",
+  57394: "f31",
+  57395: "f32",
+  57396: "f33",
+  57397: "f34",
+  57398: "f35",
+  57399: "kp0",
+  57400: "kp1",
+  57401: "kp2",
+  57402: "kp3",
+  57403: "kp4",
+  57404: "kp5",
+  57405: "kp6",
+  57406: "kp7",
+  57407: "kp8",
+  57408: "kp9",
+  57409: "kpdecimal",
+  57410: "kpdivide",
+  57411: "kpmultiply",
+  57412: "kpsubtract",
+  57413: "kpadd",
+  57414: "kpenter",
+  57415: "kpequal",
+  57416: "kpseparator",
+  57417: "kpleft",
+  57418: "kpright",
+  57419: "kpup",
+  57420: "kpdown",
+  57421: "kppageup",
+  57422: "kppagedown",
+  57423: "kphome",
+  57424: "kpend",
+  57425: "kpinsert",
+  57426: "kpdelete",
+  57427: "kpbegin",
+  57428: "mediaplay",
+  57429: "mediapause",
+  57430: "mediaplaypause",
+  57431: "mediareverse",
+  57432: "mediastop",
+  57433: "mediafastforward",
+  57434: "mediarewind",
+  57435: "mediatracknext",
+  57436: "mediatrackprevious",
+  57437: "mediarecord",
+  57438: "lowervolume",
+  57439: "raisevolume",
+  57440: "mutevolume",
+  57441: "leftshift",
+  57442: "leftcontrol",
+  57443: "leftalt",
+  57444: "leftsuper",
+  57445: "lefthyper",
+  57446: "leftmeta",
+  57447: "rightshift",
+  57448: "rightcontrol",
+  57449: "rightalt",
+  57450: "rightsuper",
+  57451: "righthyper",
+  57452: "rightmeta",
+  57453: "isoLevel3Shift",
+  57454: "isoLevel5Shift"
+};
+const isValidCodepoint = (cp) => cp >= 0 && cp <= 1114111 && !(cp >= 55296 && cp <= 57343);
+const safeFromCodePoint = (cp) => isValidCodepoint(cp) ? String.fromCodePoint(cp) : "?";
+function resolveEventType(value) {
+  if (value === 3) {
+    return "release";
+  }
+  if (value === 2) {
+    return "repeat";
+  }
+  return "press";
+}
+function parseKittyModifiers(modifiers) {
+  return {
+    capsLock: !!(modifiers & kittyModifiers.capsLock),
+    ctrl: !!(modifiers & kittyModifiers.ctrl),
+    hyper: !!(modifiers & kittyModifiers.hyper),
+    meta: !!(modifiers & kittyModifiers.meta),
+    numLock: !!(modifiers & kittyModifiers.numLock),
+    option: !!(modifiers & kittyModifiers.alt),
+    shift: !!(modifiers & kittyModifiers.shift),
+    super: !!(modifiers & kittyModifiers.super)
+  };
+}
+const parseKittyKeypress = (s) => {
+  const match = kittyKeyRe.exec(s);
+  if (!match) {
+    return null;
+  }
+  const codepoint = Number.parseInt(match[1], 10);
+  const modifiers = match[2] ? Math.max(0, Number.parseInt(match[2], 10) - 1) : 0;
+  const eventType = match[3] ? Number.parseInt(match[3], 10) : 1;
+  const textField = match[4];
+  if (!isValidCodepoint(codepoint)) {
+    return null;
+  }
+  let text;
+  if (textField) {
+    text = textField.split(":").map((cp) => safeFromCodePoint(Number.parseInt(cp, 10))).join("");
+  }
+  let name;
+  let isPrintable;
+  if (codepoint === 32) {
+    name = "space";
+    isPrintable = true;
+  } else if (codepoint === 13) {
+    name = "return";
+    isPrintable = true;
+  } else if (kittyCodepointNames[codepoint]) {
+    name = kittyCodepointNames[codepoint];
+    isPrintable = false;
+  } else if (codepoint >= 1 && codepoint <= 26) {
+    name = String.fromCodePoint(codepoint + 96);
+    isPrintable = false;
+  } else {
+    name = safeFromCodePoint(codepoint).toLowerCase();
+    isPrintable = true;
+  }
+  if (isPrintable && !text) {
+    text = safeFromCodePoint(codepoint);
+  }
+  return {
+    name,
+    ...parseKittyModifiers(modifiers),
+    eventType: resolveEventType(eventType),
+    isKittyProtocol: true,
+    isPrintable,
+    raw: s,
+    sequence: s,
+    text
+  };
+};
+const parseKittySpecialKey = (s) => {
+  const match = kittySpecialKeyRe.exec(s);
+  if (!match) {
+    return null;
+  }
+  const number = Number.parseInt(match[1], 10);
+  const modifiers = Math.max(0, Number.parseInt(match[2], 10) - 1);
+  const eventType = Number.parseInt(match[3], 10);
+  const terminator = match[4];
+  const name = terminator === "~" ? kittySpecialNumberKeys[number] : kittySpecialLetterKeys[terminator];
+  if (!name) {
+    return null;
+  }
+  return {
+    name,
+    ...parseKittyModifiers(modifiers),
+    eventType: resolveEventType(eventType),
+    isKittyProtocol: true,
+    isPrintable: false,
+    raw: s,
+    sequence: s
+  };
+};
+const parseKeypress = (s = "") => {
+  let parts;
+  if (Buffer.isBuffer(s)) {
+    if (s[0] > 127 && s[1] === void 0) {
+      s[0] -= 128;
+      s = `\x1B${String(s)}`;
+    } else {
+      s = String(s);
+    }
+  } else if (s !== void 0 && typeof s !== "string") {
+    s = String(s);
+  } else if (!s) {
+    s = "";
+  }
+  const kittyResult = parseKittyKeypress(s);
+  if (kittyResult) {
+    return kittyResult;
+  }
+  const kittySpecialResult = parseKittySpecialKey(s);
+  if (kittySpecialResult) {
+    return kittySpecialResult;
+  }
+  if (kittyKeyRe.test(s)) {
+    return {
+      ctrl: false,
+      isKittyProtocol: true,
+      isPrintable: false,
+      meta: false,
+      name: "",
+      option: false,
+      raw: s,
+      sequence: s,
+      shift: false
+    };
+  }
+  const key = {
+    ctrl: false,
+    meta: false,
+    name: "",
+    option: false,
+    raw: s,
+    sequence: s,
+    shift: false
+  };
+  key.sequence = key.sequence || s || key.name;
+  switch (s) {
+    case "\r":
+    case "\x1B\r": {
+      key.raw = void 0;
+      key.name = "return";
+      key.option = s.length === 2;
+      break;
+    }
+    case "\n": {
+      key.name = "enter";
+      break;
+    }
+    case "	": {
+      key.name = "tab";
+      break;
+    }
+    case " ":
+    case "\x1B ": {
+      key.name = "space";
+      key.meta = s.length === 2;
+      break;
+    }
+    case "\b":
+    case "\x1B\b": {
+      key.name = "backspace";
+      key.meta = s.charAt(0) === "\x1B";
+      break;
+    }
+    case "\x1B":
+    case "\x1B\x1B": {
+      key.name = "escape";
+      key.meta = s.length === 2;
+      break;
+    }
+    case "\x1B":
+    case "": {
+      key.name = "backspace";
+      key.meta = s.charAt(0) === "\x1B";
+      break;
+    }
+    default: {
+      if (s.length === 1 && s <= "") {
+        key.name = String.fromCharCode(s.charCodeAt(0) + "a".charCodeAt(0) - 1);
+        key.ctrl = true;
+      } else if (s.length === 1 && s >= "0" && s <= "9") {
+        key.name = "number";
+      } else if (s.length === 1 && s >= "a" && s <= "z") {
+        key.name = s;
+      } else if (s.length === 1 && s >= "A" && s <= "Z") {
+        key.name = s.toLowerCase();
+        key.shift = true;
+      } else if (parts = metaKeyCodeRe.exec(s)) {
+        key.meta = true;
+        key.shift = /^[A-Z]$/.test(parts[1]);
+      } else if (parts = functionKeyRe.exec(s)) {
+        const segs = [...s];
+        if (segs[0] === "\x1B" && segs[1] === "\x1B") {
+          key.option = true;
+        }
+        const code = [parts[1], parts[2], parts[4], parts[6]].filter(Boolean).join("");
+        const modifier = (parts[3] || parts[5] || 1) - 1;
+        key.ctrl = !!(modifier & 4);
+        key.meta = !!(modifier & 10);
+        key.shift = !!(modifier & 1);
+        key.code = code;
+        key.name = keyName[code] ?? "";
+        key.shift = isShiftKey(code) || key.shift;
+        key.ctrl = isCtrlKey(code) || key.ctrl;
+      }
+    }
+  }
+  return key;
+};
+
+const useInput = (inputHandler, options = {}) => {
+  const { internal_eventEmitter, internal_exitOnCtrlC, setRawMode, stdin } = useStdinContext();
+  const imeEnabled = options.imeEnabled ?? true;
+  const imeTimeout = options.imeTimeout ?? 50;
+  const imeBufferRef = useRef(void 0);
+  const stableInputHandler = useEffectEvent(inputHandler);
+  useEffect(() => {
+    if (!imeEnabled) {
+      return;
+    }
+    imeBufferRef.current = new IMECompositionBuffer({
+      onFlush: (text) => {
+        const key = {
+          backspace: false,
+          capsLock: false,
+          ctrl: false,
+          delete: false,
+          downArrow: false,
+          end: false,
+          escape: false,
+          home: false,
+          hyper: false,
+          leftArrow: false,
+          meta: false,
+          numLock: false,
+          pageDown: false,
+          pageUp: false,
+          return: false,
+          rightArrow: false,
+          shift: false,
+          super: false,
+          tab: false,
+          upArrow: false
+        };
+        reconcilerInstance.discreteUpdates(() => {
+          stableInputHandler(text, key);
+        });
+      },
+      timeout: imeTimeout
+    });
+    return () => {
+      imeBufferRef.current?.destroy();
+      imeBufferRef.current = void 0;
+    };
+  }, [imeEnabled, imeTimeout]);
+  useEffect(() => {
+    if (options.isActive === false) {
+      return;
+    }
+    setRawMode(true);
+    return () => {
+      setRawMode(false);
+    };
+  }, [options.isActive, setRawMode]);
+  useEffect(() => {
+    if (options.isActive === false) {
+      return;
+    }
+    const handleData = (data) => {
+      if (imeEnabled && isIMEInput(data)) {
+        imeBufferRef.current?.add(data);
+        return;
+      }
+      imeBufferRef.current?.flush();
+      const keypress = parseKeypress(data);
+      const key = {
+        backspace: keypress.name === "backspace",
+        capsLock: keypress.capsLock ?? false,
+        ctrl: keypress.ctrl,
+        delete: keypress.name === "delete",
+        downArrow: keypress.name === "down",
+        end: keypress.name === "end",
+        escape: keypress.name === "escape",
+        eventType: keypress.eventType,
+        home: keypress.name === "home",
+        hyper: keypress.hyper ?? false,
+        leftArrow: keypress.name === "left",
+        // `parseKeypress` parses \u001B\u001B[A (meta + up arrow) as meta = false
+        // but with option = true, so we need to take this into account here.
+        // Plain Escape no longer sets meta — only actual Alt/Meta modifier
+        // combinations do.
+        meta: keypress.meta || keypress.option,
+        numLock: keypress.numLock ?? false,
+        pageDown: keypress.name === "pagedown",
+        pageUp: keypress.name === "pageup",
+        return: keypress.name === "return",
+        rightArrow: keypress.name === "right",
+        shift: keypress.shift,
+        // Kitty keyboard protocol modifiers
+        super: keypress.super ?? false,
+        tab: keypress.name === "tab",
+        upArrow: keypress.name === "up"
+      };
+      let input;
+      if (keypress.isKittyProtocol) {
+        if (keypress.isPrintable) {
+          input = keypress.text ?? keypress.name;
+        } else if (keypress.ctrl && keypress.name.length === 1) {
+          input = keypress.name;
+        } else {
+          input = "";
+        }
+      } else if (keypress.ctrl) {
+        input = keypress.name;
+      } else {
+        input = keypress.sequence;
+      }
+      if (!keypress.isKittyProtocol && nonAlphanumericKeys.includes(keypress.name)) {
+        input = "";
+      }
+      if (input.startsWith("\x1B")) {
+        input = input.slice(1);
+      }
+      if (input.length === 1 && typeof input[0] === "string" && /[A-Z]/.test(input[0])) {
+        key.shift = true;
+      }
+      if (input === "c" && key.ctrl && internal_exitOnCtrlC) {
+        return;
+      }
+      if (!keypress.name && input === "") {
+        return;
+      }
+      reconcilerInstance.discreteUpdates(() => {
+        stableInputHandler(input, key);
+      });
+    };
+    internal_eventEmitter.on("input", handleData);
+    return () => {
+      internal_eventEmitter.removeListener("input", handleData);
+    };
+  }, [options.isActive, stdin, internal_exitOnCtrlC, imeEnabled]);
+};
+
+export { useInput as default };

package/dist/packem_shared/useIsScreenReaderEnabled-CnGKCe0f.js

@@ -0,0 +1,9 @@
+import { useContext } from 'react';
+import { a as accessibilityContext } from './AccessibilityContext-BLelHhNU.js';
+
+const useIsScreenReaderEnabled = () => {
+  const { isScreenReaderEnabled } = useContext(accessibilityContext);
+  return isScreenReaderEnabled;
+};
+
+export { useIsScreenReaderEnabled as default };

package/dist/packem_shared/useKeyBindings-B78l1E1n.js

@@ -0,0 +1,66 @@
+import { useRef, useCallback, useMemo } from 'react';
+import useInput from './useInput-Cfp5zB2s.js';
+
+const specialKeyFields = /* @__PURE__ */ new Set([
+  "backspace",
+  "delete",
+  "downArrow",
+  "end",
+  "escape",
+  "home",
+  "leftArrow",
+  "pageDown",
+  "pageUp",
+  "return",
+  "rightArrow",
+  "tab",
+  "upArrow"
+]);
+const modifierFields = /* @__PURE__ */ new Set(["ctrl", "meta", "shift", "super", "hyper"]);
+function matchesKey(spec, input, key) {
+  const plusIndex = spec.indexOf("+");
+  if (plusIndex !== -1) {
+    const modifier = spec.slice(0, plusIndex);
+    const rest = spec.slice(plusIndex + 1);
+    if (!modifierFields.has(modifier)) {
+      return false;
+    }
+    if (!key[modifier]) {
+      return false;
+    }
+    if (specialKeyFields.has(rest)) {
+      return key[rest] === true;
+    }
+    return input === rest;
+  }
+  if (specialKeyFields.has(spec)) {
+    return key[spec] === true;
+  }
+  return input === spec;
+}
+function useKeyBindings(handlers, options) {
+  const { isActive = true } = options ?? {};
+  const handlersRef = useRef(handlers);
+  handlersRef.current = handlers;
+  useInput(
+    useCallback((input, key) => {
+      for (const { binding, handler } of handlersRef.current) {
+        if (binding.enabled === false) {
+          continue;
+        }
+        const keys = typeof binding.key === "string" ? [binding.key] : binding.key;
+        for (const k of keys) {
+          if (matchesKey(k, input, key)) {
+            handler();
+            return;
+          }
+        }
+      }
+    }, []),
+    { isActive }
+  );
+  const bindings = useMemo(() => handlers.filter((h) => h.binding.enabled !== false).map((h) => h.binding), [handlers]);
+  return { bindings };
+}
+
+export { useKeyBindings as default };

package/dist/packem_shared/useMouseAction-C5gZ2nj7.js

@@ -0,0 +1,29 @@
+import { useState, useEffect } from 'react';
+import useMouseContext from './useMouseContext-D-rFy60Q.js';
+
+const useMouseAction = () => {
+  const mouse = useMouseContext();
+  const [action, setAction] = useState(null);
+  useEffect(() => {
+    const onClickHandler = (_position, clickAction) => {
+      setAction(clickAction);
+    };
+    const onScrollHandler = (_position, scrollAction) => {
+      setAction(scrollAction);
+    };
+    const onDragHandler = (_position, dragAction) => {
+      setAction(dragAction);
+    };
+    mouse.events.on("click", onClickHandler);
+    mouse.events.on("scroll", onScrollHandler);
+    mouse.events.on("drag", onDragHandler);
+    return () => {
+      mouse.events.off("click", onClickHandler);
+      mouse.events.off("scroll", onScrollHandler);
+      mouse.events.off("drag", onDragHandler);
+    };
+  }, [mouse.events]);
+  return action;
+};
+
+export { useMouseAction as default };

package/dist/packem_shared/useMouseContext-D-rFy60Q.js

@@ -0,0 +1,12 @@
+import { useContext } from 'react';
+import { M as MouseContext } from './mouse-context-BUHWKEIe.js';
+
+const useMouseContext = () => {
+  const context = useContext(MouseContext);
+  if (!context) {
+    throw new Error("useMouseContext must only be used within children of <MouseProvider/>");
+  }
+  return context;
+};
+
+export { useMouseContext as default };