@visulima/tui 1.0.0-alpha.6 → 1.0.0-alpha.7

package/dist/packem_shared/useInput-DKZbqMRc.js

@@ -1,594 +0,0 @@
-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-Dd7Z0A97.js';
-import { useStdinContext } from './useStdin-Rf0zPzVA.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/useInterval-CSXM8c2I.js

@@ -1,32 +0,0 @@
-import { useRef, useLayoutEffect, useEffect, useCallback } from 'react';
-
-const useInterval = (callback, interval, options) => {
-  const { isActive = true } = options ?? {};
-  const callbackRef = useRef(callback);
-  const timerRef = useRef(void 0);
-  useLayoutEffect(() => {
-    callbackRef.current = callback;
-  }, [callback]);
-  useEffect(() => {
-    if (!isActive || interval <= 0 || !Number.isFinite(interval)) {
-      return void 0;
-    }
-    const id = setInterval(() => {
-      callbackRef.current();
-    }, interval);
-    timerRef.current = id;
-    return () => {
-      clearInterval(id);
-      timerRef.current = void 0;
-    };
-  }, [interval, isActive]);
-  const clear = useCallback(() => {
-    if (timerRef.current !== void 0) {
-      clearInterval(timerRef.current);
-      timerRef.current = void 0;
-    }
-  }, []);
-  return { clear };
-};
-
-export { useInterval as default };

package/dist/packem_shared/useIsScreenReaderEnabled-BeoVqo1R.js

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

package/dist/packem_shared/useKeyBindings-S4fSIEAk.js

@@ -1,66 +0,0 @@
-import { useRef, useCallback, useMemo } from 'react';
-import useInput from './useInput-DKZbqMRc.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", "hyper", "meta", "shift", "super"]);
-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 };