gsd-pi 2.34.0 → 2.35.0-dev.34ce717

package/packages/pi-tui/dist/keys.js

@@ -185,176 +185,108 @@ const FUNCTIONAL_CODEPOINTS = {
     home: -14,
     end: -15,
 };
-const LEGACY_KEY_SEQUENCES = {
-    up: ["\x1b[A", "\x1bOA"],
-    down: ["\x1b[B", "\x1bOB"],
-    right: ["\x1b[C", "\x1bOC"],
-    left: ["\x1b[D", "\x1bOD"],
-    home: ["\x1b[H", "\x1bOH", "\x1b[1~", "\x1b[7~"],
-    end: ["\x1b[F", "\x1bOF", "\x1b[4~", "\x1b[8~"],
-    insert: ["\x1b[2~"],
-    delete: ["\x1b[3~"],
-    pageUp: ["\x1b[5~", "\x1b[[5~"],
-    pageDown: ["\x1b[6~", "\x1b[[6~"],
-    clear: ["\x1b[E", "\x1bOE"],
-    f1: ["\x1bOP", "\x1b[11~", "\x1b[[A"],
-    f2: ["\x1bOQ", "\x1b[12~", "\x1b[[B"],
-    f3: ["\x1bOR", "\x1b[13~", "\x1b[[C"],
-    f4: ["\x1bOS", "\x1b[14~", "\x1b[[D"],
-    f5: ["\x1b[15~", "\x1b[[E"],
-    f6: ["\x1b[17~"],
-    f7: ["\x1b[18~"],
-    f8: ["\x1b[19~"],
-    f9: ["\x1b[20~"],
-    f10: ["\x1b[21~"],
-    f11: ["\x1b[23~"],
-    f12: ["\x1b[24~"],
-};
-const LEGACY_SHIFT_SEQUENCES = {
-    up: ["\x1b[a"],
-    down: ["\x1b[b"],
-    right: ["\x1b[c"],
-    left: ["\x1b[d"],
-    clear: ["\x1b[e"],
-    insert: ["\x1b[2$"],
-    delete: ["\x1b[3$"],
-    pageUp: ["\x1b[5$"],
-    pageDown: ["\x1b[6$"],
-    home: ["\x1b[7$"],
-    end: ["\x1b[8$"],
-};
-const LEGACY_CTRL_SEQUENCES = {
-    up: ["\x1bOa"],
-    down: ["\x1bOb"],
-    right: ["\x1bOc"],
-    left: ["\x1bOd"],
-    clear: ["\x1bOe"],
-    insert: ["\x1b[2^"],
-    delete: ["\x1b[3^"],
-    pageUp: ["\x1b[5^"],
-    pageDown: ["\x1b[6^"],
-    home: ["\x1b[7^"],
-    end: ["\x1b[8^"],
-};
-const LEGACY_SEQUENCE_KEY_IDS = {
-    "\x1bOA": "up",
-    "\x1bOB": "down",
-    "\x1bOC": "right",
-    "\x1bOD": "left",
-    "\x1bOH": "home",
-    "\x1bOF": "end",
-    "\x1b[E": "clear",
-    "\x1bOE": "clear",
-    "\x1bOe": "ctrl+clear",
-    "\x1b[e": "shift+clear",
-    "\x1b[2~": "insert",
-    "\x1b[2$": "shift+insert",
-    "\x1b[2^": "ctrl+insert",
-    "\x1b[3$": "shift+delete",
-    "\x1b[3^": "ctrl+delete",
-    "\x1b[[5~": "pageUp",
-    "\x1b[[6~": "pageDown",
-    "\x1b[a": "shift+up",
-    "\x1b[b": "shift+down",
-    "\x1b[c": "shift+right",
-    "\x1b[d": "shift+left",
-    "\x1bOa": "ctrl+up",
-    "\x1bOb": "ctrl+down",
-    "\x1bOc": "ctrl+right",
-    "\x1bOd": "ctrl+left",
-    "\x1b[5$": "shift+pageUp",
-    "\x1b[6$": "shift+pageDown",
-    "\x1b[7$": "shift+home",
-    "\x1b[8$": "shift+end",
-    "\x1b[5^": "ctrl+pageUp",
-    "\x1b[6^": "ctrl+pageDown",
-    "\x1b[7^": "ctrl+home",
-    "\x1b[8^": "ctrl+end",
-    "\x1bOP": "f1",
-    "\x1bOQ": "f2",
-    "\x1bOR": "f3",
-    "\x1bOS": "f4",
-    "\x1b[11~": "f1",
-    "\x1b[12~": "f2",
-    "\x1b[13~": "f3",
-    "\x1b[14~": "f4",
-    "\x1b[[A": "f1",
-    "\x1b[[B": "f2",
-    "\x1b[[C": "f3",
-    "\x1b[[D": "f4",
-    "\x1b[[E": "f5",
-    "\x1b[15~": "f5",
-    "\x1b[17~": "f6",
-    "\x1b[18~": "f7",
-    "\x1b[19~": "f8",
-    "\x1b[20~": "f9",
-    "\x1b[21~": "f10",
-    "\x1b[23~": "f11",
-    "\x1b[24~": "f12",
-    "\x1bb": "alt+left",
-    "\x1bf": "alt+right",
-    "\x1bp": "alt+up",
-    "\x1bn": "alt+down",
+/**
+ * Consolidated legacy terminal key sequences.
+ * Each key maps to its sequences for unmodified, shift-modified, and ctrl-modified variants.
+ * This single structure replaces three separate maps (LEGACY_KEY_SEQUENCES,
+ * LEGACY_SHIFT_SEQUENCES, LEGACY_CTRL_SEQUENCES) that shared the same key sets.
+ */
+const LEGACY_SEQUENCES = {
+    up: { plain: ["\x1b[A", "\x1bOA"], shift: ["\x1b[a"], ctrl: ["\x1bOa"] },
+    down: { plain: ["\x1b[B", "\x1bOB"], shift: ["\x1b[b"], ctrl: ["\x1bOb"] },
+    right: { plain: ["\x1b[C", "\x1bOC"], shift: ["\x1b[c"], ctrl: ["\x1bOc"] },
+    left: { plain: ["\x1b[D", "\x1bOD"], shift: ["\x1b[d"], ctrl: ["\x1bOd"] },
+    home: { plain: ["\x1b[H", "\x1bOH", "\x1b[1~", "\x1b[7~"], shift: ["\x1b[7$"], ctrl: ["\x1b[7^"] },
+    end: { plain: ["\x1b[F", "\x1bOF", "\x1b[4~", "\x1b[8~"], shift: ["\x1b[8$"], ctrl: ["\x1b[8^"] },
+    insert: { plain: ["\x1b[2~"], shift: ["\x1b[2$"], ctrl: ["\x1b[2^"] },
+    delete: { plain: ["\x1b[3~"], shift: ["\x1b[3$"], ctrl: ["\x1b[3^"] },
+    pageUp: { plain: ["\x1b[5~", "\x1b[[5~"], shift: ["\x1b[5$"], ctrl: ["\x1b[5^"] },
+    pageDown: { plain: ["\x1b[6~", "\x1b[[6~"], shift: ["\x1b[6$"], ctrl: ["\x1b[6^"] },
+    clear: { plain: ["\x1b[E", "\x1bOE"], shift: ["\x1b[e"], ctrl: ["\x1bOe"] },
+    f1: { plain: ["\x1bOP", "\x1b[11~", "\x1b[[A"] },
+    f2: { plain: ["\x1bOQ", "\x1b[12~", "\x1b[[B"] },
+    f3: { plain: ["\x1bOR", "\x1b[13~", "\x1b[[C"] },
+    f4: { plain: ["\x1bOS", "\x1b[14~", "\x1b[[D"] },
+    f5: { plain: ["\x1b[15~", "\x1b[[E"] },
+    f6: { plain: ["\x1b[17~"] },
+    f7: { plain: ["\x1b[18~"] },
+    f8: { plain: ["\x1b[19~"] },
+    f9: { plain: ["\x1b[20~"] },
+    f10: { plain: ["\x1b[21~"] },
+    f11: { plain: ["\x1b[23~"] },
+    f12: { plain: ["\x1b[24~"] },
 };
+/**
+ * Reverse lookup from escape sequence to key identifier, auto-generated from LEGACY_SEQUENCES.
+ * Additional non-standard sequences (alt+arrow aliases) are appended after generation.
+ */
+const LEGACY_SEQUENCE_KEY_IDS = (() => {
+    const map = {};
+    for (const [key, entry] of Object.entries(LEGACY_SEQUENCES)) {
+        const keyId = key;
+        if (entry.plain) {
+            for (const seq of entry.plain)
+                map[seq] = keyId;
+        }
+        if (entry.shift) {
+            for (const seq of entry.shift)
+                map[seq] = `shift+${keyId}`;
+        }
+        if (entry.ctrl) {
+            for (const seq of entry.ctrl)
+                map[seq] = `ctrl+${keyId}`;
+        }
+    }
+    // Non-standard alt+arrow aliases not derivable from the table
+    map["\x1bb"] = "alt+left";
+    map["\x1bf"] = "alt+right";
+    map["\x1bp"] = "alt+up";
+    map["\x1bn"] = "alt+down";
+    return map;
+})();
 const matchesLegacySequence = (data, sequences) => sequences.includes(data);
 const matchesLegacyModifierSequence = (data, key, modifier) => {
-    if (modifier === MODIFIERS.shift) {
-        return matchesLegacySequence(data, LEGACY_SHIFT_SEQUENCES[key]);
+    const entry = LEGACY_SEQUENCES[key];
+    if (!entry)
+        return false;
+    if (modifier === MODIFIERS.shift && entry.shift) {
+        return matchesLegacySequence(data, entry.shift);
     }
-    if (modifier === MODIFIERS.ctrl) {
-        return matchesLegacySequence(data, LEGACY_CTRL_SEQUENCES[key]);
+    if (modifier === MODIFIERS.ctrl && entry.ctrl) {
+        return matchesLegacySequence(data, entry.ctrl);
     }
     return false;
 };
 // Store the last parsed event type for isKeyRelease() to query
 let _lastEventType = "press";
 /**
- * Check if the last parsed key event was a key release.
- * Only meaningful when Kitty keyboard protocol with flag 2 is active.
+ * Check if input data contains a Kitty event type marker.
+ * Event type markers appear as ":<eventType>" followed by a sequence terminator (u, ~, A-D, H, F).
+ * Ignores bracketed paste content which may contain similar patterns.
  */
-export function isKeyRelease(data) {
-    // Don't treat bracketed paste content as key release, even if it contains
-    // patterns like ":3F" (e.g., bluetooth MAC addresses like "90:62:3F:A5").
-    // Terminal.ts re-wraps paste content with bracketed paste markers before
-    // passing to TUI, so pasted data will always contain \x1b[200~.
+function hasKittyEventType(data, eventType) {
     if (data.includes("\x1b[200~")) {
         return false;
     }
-    // Quick check: release events with flag 2 contain ":3"
-    // Format: \x1b[<codepoint>;<modifier>:3u
-    if (data.includes(":3u") ||
-        data.includes(":3~") ||
-        data.includes(":3A") ||
-        data.includes(":3B") ||
-        data.includes(":3C") ||
-        data.includes(":3D") ||
-        data.includes(":3H") ||
-        data.includes(":3F")) {
-        return true;
-    }
-    return false;
+    const marker = `:${eventType}`;
+    return (data.includes(`${marker}u`) ||
+        data.includes(`${marker}~`) ||
+        data.includes(`${marker}A`) ||
+        data.includes(`${marker}B`) ||
+        data.includes(`${marker}C`) ||
+        data.includes(`${marker}D`) ||
+        data.includes(`${marker}H`) ||
+        data.includes(`${marker}F`));
+}
+export function isKeyRelease(data) {
+    return hasKittyEventType(data, 3);
 }
 /**
  * Check if the last parsed key event was a key repeat.
  * Only meaningful when Kitty keyboard protocol with flag 2 is active.
  */
 export function isKeyRepeat(data) {
-    // Don't treat bracketed paste content as key repeat, even if it contains
-    // patterns like ":2F". See isKeyRelease() for details.
-    if (data.includes("\x1b[200~")) {
-        return false;
-    }
-    if (data.includes(":2u") ||
-        data.includes(":2~") ||
-        data.includes(":2A") ||
-        data.includes(":2B") ||
-        data.includes(":2C") ||
-        data.includes(":2D") ||
-        data.includes(":2H") ||
-        data.includes(":2F")) {
-        return true;
-    }
-    return false;
+    return hasKittyEventType(data, 2);
 }
 function parseEventType(eventTypeStr) {
     if (!eventTypeStr)
@@ -652,7 +584,7 @@ export function matchesKey(data, keyId) {
             return matchesKittySequence(data, CODEPOINTS.backspace, modifier);
         case "insert":
             if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.insert) ||
+                return (matchesLegacySequence(data, LEGACY_SEQUENCES.insert.plain) ||
                     matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.insert, 0));
             }
             if (matchesLegacyModifierSequence(data, "insert", modifier)) {
@@ -661,7 +593,7 @@ export function matchesKey(data, keyId) {
             return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.insert, modifier);
         case "delete":
             if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.delete) ||
+                return (matchesLegacySequence(data, LEGACY_SEQUENCES.delete.plain) ||
                     matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.delete, 0));
             }
             if (matchesLegacyModifierSequence(data, "delete", modifier)) {
@@ -670,12 +602,12 @@ export function matchesKey(data, keyId) {
             return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.delete, modifier);
         case "clear":
             if (modifier === 0) {
-                return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.clear);
+                return matchesLegacySequence(data, LEGACY_SEQUENCES.clear.plain);
             }
             return matchesLegacyModifierSequence(data, "clear", modifier);
         case "home":
             if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.home) ||
+                return (matchesLegacySequence(data, LEGACY_SEQUENCES.home.plain) ||
                     matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.home, 0));
             }
             if (matchesLegacyModifierSequence(data, "home", modifier)) {
@@ -684,7 +616,7 @@ export function matchesKey(data, keyId) {
             return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.home, modifier);
         case "end":
             if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.end) ||
+                return (matchesLegacySequence(data, LEGACY_SEQUENCES.end.plain) ||
                     matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.end, 0));
             }
             if (matchesLegacyModifierSequence(data, "end", modifier)) {
@@ -693,7 +625,7 @@ export function matchesKey(data, keyId) {
             return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.end, modifier);
         case "pageup":
             if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.pageUp) ||
+                return (matchesLegacySequence(data, LEGACY_SEQUENCES.pageUp.plain) ||
                     matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.pageUp, 0));
             }
             if (matchesLegacyModifierSequence(data, "pageUp", modifier)) {
@@ -702,7 +634,7 @@ export function matchesKey(data, keyId) {
             return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.pageUp, modifier);
         case "pagedown":
             if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.pageDown) ||
+                return (matchesLegacySequence(data, LEGACY_SEQUENCES.pageDown.plain) ||
                     matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.pageDown, 0));
             }
             if (matchesLegacyModifierSequence(data, "pageDown", modifier)) {
@@ -714,7 +646,7 @@ export function matchesKey(data, keyId) {
                 return data === "\x1bp" || matchesKittySequence(data, ARROW_CODEPOINTS.up, MODIFIERS.alt);
             }
             if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.up) ||
+                return (matchesLegacySequence(data, LEGACY_SEQUENCES.up.plain) ||
                     matchesKittySequence(data, ARROW_CODEPOINTS.up, 0));
             }
             if (matchesLegacyModifierSequence(data, "up", modifier)) {
@@ -726,7 +658,7 @@ export function matchesKey(data, keyId) {
                 return data === "\x1bn" || matchesKittySequence(data, ARROW_CODEPOINTS.down, MODIFIERS.alt);
             }
             if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.down) ||
+                return (matchesLegacySequence(data, LEGACY_SEQUENCES.down.plain) ||
                     matchesKittySequence(data, ARROW_CODEPOINTS.down, 0));
             }
             if (matchesLegacyModifierSequence(data, "down", modifier)) {
@@ -746,7 +678,7 @@ export function matchesKey(data, keyId) {
                     matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.ctrl));
             }
             if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.left) ||
+                return (matchesLegacySequence(data, LEGACY_SEQUENCES.left.plain) ||
                     matchesKittySequence(data, ARROW_CODEPOINTS.left, 0));
             }
             if (matchesLegacyModifierSequence(data, "left", modifier)) {
@@ -766,7 +698,7 @@ export function matchesKey(data, keyId) {
                     matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.ctrl));
             }
             if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.right) ||
+                return (matchesLegacySequence(data, LEGACY_SEQUENCES.right.plain) ||
                     matchesKittySequence(data, ARROW_CODEPOINTS.right, 0));
             }
             if (matchesLegacyModifierSequence(data, "right", modifier)) {
@@ -789,7 +721,7 @@ export function matchesKey(data, keyId) {
                 return false;
             }
             const functionKey = key;
-            return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES[functionKey]);
+            return matchesLegacySequence(data, LEGACY_SEQUENCES[functionKey].plain);
         }
     }
     // Handle single letter/digit keys and symbols