plusui-native-core 0.1.102 → 0.1.104

package/Core/Features/Keyboard/keyboard.cpp

@@ -1,189 +1,218 @@
-#include <iostream>
-#include <plusui/keyboard.hpp>
-#include <unordered_map>
-
-namespace plusui {
-
-struct Keyboard::Impl {
-  std::unordered_map<int, bool> pressedKeys;
-  std::vector<std::function<void(const KeyEvent &)>> keyDownCallbacks;
-  std::vector<std::function<void(const KeyEvent &)>> keyUpCallbacks;
-  bool autoRepeat = true;
-
-  static const std::unordered_map<KeyCode, std::string> &keyNames() {
-    static std::unordered_map<KeyCode, std::string> names = {
-        {KeyCode::Space, "Space"},
-        {KeyCode::Escape, "Escape"},
-        {KeyCode::Enter, "Enter"},
-        {KeyCode::Tab, "Tab"},
-        {KeyCode::Backspace, "Backspace"},
-        {KeyCode::Delete, "Delete"},
-        {KeyCode::Right, "Right"},
-        {KeyCode::Left, "Left"},
-        {KeyCode::Down, "Down"},
-        {KeyCode::Up, "Up"},
-        {KeyCode::A, "A"},
-        {KeyCode::B, "B"},
-        {KeyCode::C, "C"},
-        {KeyCode::D, "D"},
-        {KeyCode::E, "E"},
-        {KeyCode::F, "F"},
-        {KeyCode::G, "G"},
-        {KeyCode::H, "H"},
-        {KeyCode::I, "I"},
-        {KeyCode::J, "J"},
-        {KeyCode::K, "K"},
-        {KeyCode::L, "L"},
-        {KeyCode::M, "M"},
-        {KeyCode::N, "N"},
-        {KeyCode::O, "O"},
-        {KeyCode::P, "P"},
-        {KeyCode::Q, "Q"},
-        {KeyCode::R, "R"},
-        {KeyCode::S, "S"},
-        {KeyCode::T, "T"},
-        {KeyCode::U, "U"},
-        {KeyCode::V, "V"},
-        {KeyCode::W, "W"},
-        {KeyCode::X, "X"},
-        {KeyCode::Y, "Y"},
-        {KeyCode::Z, "Z"},
-        {KeyCode::F1, "F1"},
-        {KeyCode::F2, "F2"},
-        {KeyCode::F3, "F3"},
-        {KeyCode::F4, "F4"},
-        {KeyCode::F5, "F5"},
-        {KeyCode::F6, "F6"},
-        {KeyCode::F7, "F7"},
-        {KeyCode::F8, "F8"},
-        {KeyCode::F9, "F9"},
-        {KeyCode::F10, "F10"},
-        {KeyCode::F11, "F11"},
-        {KeyCode::F12, "F12"},
-    };
-    return names;
-  }
-};
-
-Keyboard::Keyboard() : pImpl(std::make_unique<Impl>()) {}
-Keyboard::~Keyboard() = default;
-
-Keyboard &Keyboard::instance() {
-  static Keyboard instance;
-  return instance;
-}
-
-void Keyboard::onKeyDown(std::function<void(const KeyEvent &)> callback) {
-  pImpl->keyDownCallbacks.push_back(callback);
-}
-
-void Keyboard::onKeyUp(std::function<void(const KeyEvent &)> callback) {
-  pImpl->keyUpCallbacks.push_back(callback);
-}
-
-bool Keyboard::isKeyPressed(KeyCode key) const {
-  return pImpl->pressedKeys.count(static_cast<int>(key)) &&
-         pImpl->pressedKeys.at(static_cast<int>(key));
-}
-
-bool Keyboard::areModsActive(KeyMod mods) const { 
-  (void)mods; // Suppress unused warning - placeholder implementation
-  return false;
-}
-
-std::string Keyboard::getKeyName(KeyCode key) const {
-  auto it = Impl::keyNames().find(key);
-  return it != Impl::keyNames().end() ? it->second : "Unknown";
-}
-
-KeyCode Keyboard::getKeyFromName(const std::string &name) const {
-  for (const auto &[key, keyName] : Impl::keyNames()) {
-    if (keyName == name)
-      return key;
-  }
-  return KeyCode::Unknown;
-}
-
-void Keyboard::setAutoRepeat(bool enabled) { pImpl->autoRepeat = enabled; }
-
-bool Keyboard::getAutoRepeat() const { return pImpl->autoRepeat; }
-
-struct ShortcutManager::Impl {
-  std::map<std::string, std::pair<Shortcut, std::function<void()>>> shortcuts;
-  std::function<void(const std::string &id)> triggerCallback;
-};
-
-ShortcutManager::ShortcutManager() : pImpl(std::make_unique<Impl>()) {}
-ShortcutManager::~ShortcutManager() = default;
-
-ShortcutManager &ShortcutManager::instance() {
-  static ShortcutManager instance;
-  return instance;
-}
-
-bool ShortcutManager::registerShortcut(const std::string &id,
-                                       const Shortcut &shortcut,
-                                       std::function<void()> callback) {
-  pImpl->shortcuts[id] = {shortcut, callback};
-  return true;
-}
-
-bool ShortcutManager::unregisterShortcut(const std::string &id) {
-  return pImpl->shortcuts.erase(id) > 0;
-}
-
-void ShortcutManager::clearShortcuts() { pImpl->shortcuts.clear(); }
-
-bool ShortcutManager::isRegistered(const std::string &id) const {
-  return pImpl->shortcuts.count(id) > 0;
-}
-
-Shortcut ShortcutManager::getShortcut(const std::string &id) const {
-  auto it = pImpl->shortcuts.find(id);
-  return it != pImpl->shortcuts.end() ? it->second.first : Shortcut();
-}
-
-void ShortcutManager::onShortcutTriggered(
-    std::function<void(const std::string &id)> callback) {
-  pImpl->triggerCallback = callback;
-}
-
-std::string Shortcut::toString() const {
-  std::string s;
-  if (mods & KeyMod::Control)
-    s += "Ctrl+";
-  if (mods & KeyMod::Alt)
-    s += "Alt+";
-  if (mods & KeyMod::Shift)
-    s += "Shift+";
-  if (mods & KeyMod::Super)
-    s += "Super+";
-  return s + std::to_string(static_cast<int>(key));
-}
-
-Shortcut Shortcut::parse(const std::string &str) {
-  Shortcut shortcut;
-  KeyMod mods = KeyMod::None;
-  std::string key;
-
-  for (size_t i = 0; i < str.size(); ++i) {
-    if (str[i] == '+') {
-      if (key == "Ctrl" || key == "Control")
-        mods = mods | KeyMod::Control;
-      else if (key == "Alt")
-        mods = mods | KeyMod::Alt;
-      else if (key == "Shift")
-        mods = mods | KeyMod::Shift;
-      else if (key == "Super" || key == "Win")
-        mods = mods | KeyMod::Super;
-      key.clear();
-    } else {
-      key += str[i];
-    }
-  }
-
-  shortcut.mods = mods;
-  return shortcut;
-}
-
-} // namespace plusui
+/**
+ * keyboard.cpp — Platform-unified keyboard implementation
+ *
+ * Platform-specific code lives in:
+ *   keyboard_windows.cpp  — Windows (Win32 / WebView2)
+ *   keyboard_macos.cpp    — macOS  (Carbon / CGEvent)
+ *   keyboard_linux.cpp    — Linux  (X11 / XGrabKey)
+ *
+ * Each platform file defines (inside namespace plusui):
+ *   static bool areModsActiveImpl(int flags)
+ *   static bool isKeyPressedImpl(int keyCode)
+ *   static bool registerGlobalShortcutImpl(id, keyCode, mods, callback)  [macOS/Linux]
+ *   static bool unregisterGlobalShortcutImpl(id)                          [macOS/Linux]
+ *   static void clearGlobalShortcutsImpl()                                [macOS/Linux]
+ *
+ * Windows global shortcuts are handled in window.cpp/webview.cpp via
+ * RegisterHotKey/WM_HOTKEY (requires the HWND which lives on Window::Impl).
+ */
+
+#include <iostream>
+#include <plusui/keyboard.hpp>
+#include <unordered_map>
+
+// Pull in platform-specific helpers
+#ifdef _WIN32
+#  include "keyboard_windows.cpp"
+#elif defined(__APPLE__)
+#  include "keyboard_macos.cpp"
+#else
+#  include "keyboard_linux.cpp"
+#endif
+
+namespace plusui {
+
+// ── Keyboard::Impl ────────────────────────────────────────────────────────────
+
+struct Keyboard::Impl {
+    std::unordered_map<int, bool> pressedKeys;
+    std::vector<std::function<void(const KeyEvent&)>> keyDownCallbacks;
+    std::vector<std::function<void(const KeyEvent&)>> keyUpCallbacks;
+    bool autoRepeat = true;
+
+    static const std::unordered_map<KeyCode, std::string>& keyNames() {
+        static std::unordered_map<KeyCode, std::string> names = {
+            {KeyCode::Space,     "Space"},
+            {KeyCode::Escape,    "Escape"},
+            {KeyCode::Enter,     "Enter"},
+            {KeyCode::Tab,       "Tab"},
+            {KeyCode::Backspace, "Backspace"},
+            {KeyCode::Delete,    "Delete"},
+            {KeyCode::Right,     "Right"},
+            {KeyCode::Left,      "Left"},
+            {KeyCode::Down,      "Down"},
+            {KeyCode::Up,        "Up"},
+            {KeyCode::A,  "A"}, {KeyCode::B,  "B"}, {KeyCode::C,  "C"},
+            {KeyCode::D,  "D"}, {KeyCode::E,  "E"}, {KeyCode::F,  "F"},
+            {KeyCode::G,  "G"}, {KeyCode::H,  "H"}, {KeyCode::I,  "I"},
+            {KeyCode::J,  "J"}, {KeyCode::K,  "K"}, {KeyCode::L,  "L"},
+            {KeyCode::M,  "M"}, {KeyCode::N,  "N"}, {KeyCode::O,  "O"},
+            {KeyCode::P,  "P"}, {KeyCode::Q,  "Q"}, {KeyCode::R,  "R"},
+            {KeyCode::S,  "S"}, {KeyCode::T,  "T"}, {KeyCode::U,  "U"},
+            {KeyCode::V,  "V"}, {KeyCode::W,  "W"}, {KeyCode::X,  "X"},
+            {KeyCode::Y,  "Y"}, {KeyCode::Z,  "Z"},
+            {KeyCode::F1,  "F1"},  {KeyCode::F2,  "F2"},  {KeyCode::F3,  "F3"},
+            {KeyCode::F4,  "F4"},  {KeyCode::F5,  "F5"},  {KeyCode::F6,  "F6"},
+            {KeyCode::F7,  "F7"},  {KeyCode::F8,  "F8"},  {KeyCode::F9,  "F9"},
+            {KeyCode::F10, "F10"}, {KeyCode::F11, "F11"}, {KeyCode::F12, "F12"},
+        };
+        return names;
+    }
+};
+
+// ── Keyboard ──────────────────────────────────────────────────────────────────
+
+Keyboard::Keyboard() : pImpl(std::make_unique<Impl>()) {}
+Keyboard::~Keyboard() = default;
+
+Keyboard& Keyboard::instance() {
+    static Keyboard instance;
+    return instance;
+}
+
+void Keyboard::onKeyDown(std::function<void(const KeyEvent&)> callback) {
+    pImpl->keyDownCallbacks.push_back(callback);
+}
+
+void Keyboard::onKeyUp(std::function<void(const KeyEvent&)> callback) {
+    pImpl->keyUpCallbacks.push_back(callback);
+}
+
+bool Keyboard::isKeyPressed(KeyCode key) const {
+    // Prefer live query via platform helper over the cached map
+    return isKeyPressedImpl(static_cast<int>(key));
+}
+
+bool Keyboard::areModsActive(KeyMod mods) const {
+    return areModsActiveImpl(static_cast<int>(mods));
+}
+
+std::string Keyboard::getKeyName(KeyCode key) const {
+    auto it = Impl::keyNames().find(key);
+    return it != Impl::keyNames().end() ? it->second : "Unknown";
+}
+
+KeyCode Keyboard::getKeyFromName(const std::string& name) const {
+    for (const auto& [key, keyName] : Impl::keyNames()) {
+        if (keyName == name) return key;
+    }
+    return KeyCode::Unknown;
+}
+
+void Keyboard::setAutoRepeat(bool enabled) { pImpl->autoRepeat = enabled; }
+bool Keyboard::getAutoRepeat() const       { return pImpl->autoRepeat; }
+
+// ── ShortcutManager ───────────────────────────────────────────────────────────
+
+struct ShortcutManager::Impl {
+    std::map<std::string, std::pair<Shortcut, std::function<void()>>> shortcuts;
+    std::function<void(const std::string&)> triggerCallback;
+    // callback to execute JS in the webview when a global shortcut fires
+    std::function<void(const std::string&)> shortcutFiredFn;
+};
+
+ShortcutManager::ShortcutManager() : pImpl(std::make_unique<Impl>()) {}
+ShortcutManager::~ShortcutManager() = default;
+
+ShortcutManager& ShortcutManager::instance() {
+    static ShortcutManager instance;
+    return instance;
+}
+
+bool ShortcutManager::registerShortcut(const std::string& id,
+                                        const Shortcut& shortcut,
+                                        std::function<void()> callback) {
+    pImpl->shortcuts[id] = {shortcut, callback};
+
+#if defined(__APPLE__) || (!defined(_WIN32) && !defined(__APPLE__))
+    // On non-Windows platforms, register the hotkey natively here.
+    // The callback fires the JS shortcut event via shortcutFiredFn.
+    auto fired = pImpl->shortcutFiredFn;
+    return registerGlobalShortcutImpl(
+        id,
+        static_cast<int>(shortcut.key),
+        static_cast<int>(shortcut.mods),
+        [id, callback, fired]() {
+            if (callback) callback();
+            if (fired) fired(id);
+        });
+#else
+    // Windows: hotkey registration is done in webview.cpp via RegisterHotKey
+    // (requires the HWND which is only available there).  ShortcutManager
+    // just stores the callback so it can be invoked from the JS bridge.
+    return true;
+#endif
+}
+
+bool ShortcutManager::unregisterShortcut(const std::string& id) {
+    bool removed = pImpl->shortcuts.erase(id) > 0;
+#if defined(__APPLE__) || (!defined(_WIN32) && !defined(__APPLE__))
+    unregisterGlobalShortcutImpl(id);
+#endif
+    return removed;
+}
+
+void ShortcutManager::clearShortcuts() {
+    pImpl->shortcuts.clear();
+#if defined(__APPLE__) || (!defined(_WIN32) && !defined(__APPLE__))
+    clearGlobalShortcutsImpl();
+#endif
+}
+
+bool ShortcutManager::isRegistered(const std::string& id) const {
+    return pImpl->shortcuts.count(id) > 0;
+}
+
+Shortcut ShortcutManager::getShortcut(const std::string& id) const {
+    auto it = pImpl->shortcuts.find(id);
+    return it != pImpl->shortcuts.end() ? it->second.first : Shortcut();
+}
+
+void ShortcutManager::onShortcutTriggered(
+    std::function<void(const std::string&)> callback) {
+    pImpl->triggerCallback = callback;
+}
+
+// ── Shortcut helpers ──────────────────────────────────────────────────────────
+
+std::string Shortcut::toString() const {
+    std::string s;
+    if (mods & KeyMod::Control) s += "Ctrl+";
+    if (mods & KeyMod::Alt)     s += "Alt+";
+    if (mods & KeyMod::Shift)   s += "Shift+";
+    if (mods & KeyMod::Super)   s += "Super+";
+    return s + std::to_string(static_cast<int>(key));
+}
+
+Shortcut Shortcut::parse(const std::string& str) {
+    Shortcut shortcut;
+    KeyMod mods = KeyMod::None;
+    std::string key;
+
+    for (size_t i = 0; i < str.size(); ++i) {
+        if (str[i] == '+') {
+            if      (key == "Ctrl"  || key == "Control") mods = mods | KeyMod::Control;
+            else if (key == "Alt")                        mods = mods | KeyMod::Alt;
+            else if (key == "Shift")                      mods = mods | KeyMod::Shift;
+            else if (key == "Super" || key == "Win")      mods = mods | KeyMod::Super;
+            key.clear();
+        } else {
+            key += str[i];
+        }
+    }
+
+    shortcut.mods = mods;
+    return shortcut;
+}
+
+} // namespace plusui

package/Core/Features/Keyboard/keyboard.ts

@@ -14,6 +14,15 @@
 export enum KeyCode {
   Unknown = 0,
   Space = 32,
+  // Digits 0–9
+  D0 = 48, D1 = 49, D2 = 50, D3 = 51, D4 = 52,
+  D5 = 53, D6 = 54, D7 = 55, D8 = 56, D9 = 57,
+  // Letters A–Z (GLFW convention: same as ASCII upper-case)
+  A = 65, B = 66, C = 67, D = 68, E = 69, F = 70,
+  G = 71, H = 72, I = 73, J = 74, K = 75, L = 76,
+  M = 77, N = 78, O = 79, P = 80, Q = 81, R = 82,
+  S = 83, T = 84, U = 85, V = 86, W = 87, X = 88,
+  Y = 89, Z = 90,
   Escape = 256,
   Enter = 257,
   Tab = 258,
@@ -65,40 +74,79 @@ export interface Shortcut {
 export type KeyEventCallback = (event: KeyEvent) => void;
 export type ShortcutCallback = () => void;
 
-let _invoke: ((name: string, args?: unknown[]) => Promise<unknown>) | null = null;
-let _event: ((event: string, callback: (...args: unknown[]) => void) => () => void) | null = null;
-const shortcutHandlers: Map<string, ShortcutCallback> = new Map();
+// ── Bridge (matches window.ts exactly) ───────────────────────────────────────
 
-export function setInvokeFn(fn: (name: string, args?: unknown[]) => Promise<unknown>) {
-  _invoke = fn;
-}
+let callId = 0;
+const pending = new Map<string, { resolve: (v: any) => void; reject: (e: any) => void }>();
 
-export function setEventFn(fn: (event: string, callback: (...args: unknown[]) => void) => () => void) {
-  _event = fn;
+function getGlobal(): any {
+  if (typeof window !== 'undefined') return window;
+  if (typeof globalThis !== 'undefined') return globalThis as any;
+  return {} as any;
 }
 
-async function invoke<T = unknown>(name: string, args?: unknown[]): Promise<T> {
-  if (!_invoke) {
-    if (typeof window !== 'undefined' && (window as any).__invoke__) {
-      _invoke = (window as any).__invoke__;
-    } else {
-      throw new Error('Keyboard API not initialized');
+const g = getGlobal();
+
+// Merge __response__ handler — multiple modules may define it; guard so we
+// don't overwrite a version already installed by window.ts.
+if (!g.__response__) {
+  g.__response__ = function(id: string, result: any, error?: any) {
+    const p = pending.get(id);
+    if (p) {
+      pending.delete(id);
+      error ? p.reject(new Error(error)) : p.resolve(result);
+    }
+  };
+} else {
+  // Wrap the existing handler so both pending maps are served.
+  const existing = g.__response__;
+  g.__response__ = function(id: string, result: any, error?: any) {
+    existing(id, result, error);
+    const p = pending.get(id);
+    if (p) {
+      pending.delete(id);
+      error ? p.reject(new Error(error)) : p.resolve(result);
     }
-  }
-  return _invoke!(name, args) as Promise<T>;
+  };
 }
 
-function eventHandler(event: string, callback: (...args: unknown[]) => void): () => void {
-  if (!_event) {
-    if (typeof window !== 'undefined' && (window as any).__on__) {
-      _event = (window as any).__on__;
+async function invoke<T>(method: string, params: any[] = []): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const id = String(++callId) + '-kb';
+    pending.set(id, { resolve, reject });
+
+    const payload = JSON.stringify({ id, method, params });
+
+    if (g.__native_invoke__) {
+      g.__native_invoke__(payload);
+    } else if (g.chrome && g.chrome.webview && g.chrome.webview.postMessage) {
+      g.chrome.webview.postMessage(payload);
     } else {
-      return () => {};
+      pending.delete(id);
+      console.warn('[PlusUI] ' + method + ' - native bridge not ready');
+      resolve(null as T);
     }
-  }
-  return _event!(event, callback);
+  });
 }
 
+// ── onKeyDown / onKeyUp / onShortcut ─────────────────────────────────────────
+// C++ fires these as CustomEvents on `window` via ExecuteScript:
+//   plusui:keyboard:keydown   { detail: KeyEvent }
+//   plusui:keyboard:keyup     { detail: KeyEvent }
+//   plusui:keyboard:shortcut  { detail: { id: string } }
+
+function onDomEvent<T>(
+  eventName: string,
+  callback: (data: T) => void
+): () => void {
+  if (typeof window === 'undefined') return () => {};
+  const handler = (e: Event) => callback((e as CustomEvent<T>).detail);
+  window.addEventListener(eventName, handler as EventListener);
+  return () => window.removeEventListener(eventName, handler as EventListener);
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
 export const keyboard = {
   async isKeyPressed(key: KeyCode): Promise<boolean> {
     return invoke<boolean>('keyboard.isKeyPressed', [key]);
@@ -113,30 +161,40 @@ export const keyboard = {
   },
 
   async registerShortcut(id: string, shortcut: Shortcut, callback: ShortcutCallback): Promise<boolean> {
-    shortcutHandlers.set(id, callback);
+    // Store the callback under the global handler table that WM_HOTKEY fires.
+    if (typeof window !== 'undefined') {
+      const w = window as any;
+      if (!w.__plusui_shortcut_handlers__) w.__plusui_shortcut_handlers__ = {};
+      w.__plusui_shortcut_handlers__[id] = callback;
+    }
     return invoke<boolean>('keyboard.registerShortcut', [id, shortcut]);
   },
 
   async unregisterShortcut(id: string): Promise<boolean> {
-    shortcutHandlers.delete(id);
+    if (typeof window !== 'undefined') {
+      const w = window as any;
+      if (w.__plusui_shortcut_handlers__) delete w.__plusui_shortcut_handlers__[id];
+    }
     return invoke<boolean>('keyboard.unregisterShortcut', [id]);
   },
 
   async clearShortcuts(): Promise<void> {
-    shortcutHandlers.clear();
+    if (typeof window !== 'undefined') {
+      (window as any).__plusui_shortcut_handlers__ = {};
+    }
     await invoke('keyboard.clearShortcuts');
   },
 
   onKeyDown(callback: KeyEventCallback): () => void {
-    return eventHandler('keyboard:keydown', callback as (...args: unknown[]) => void);
+    return onDomEvent<KeyEvent>('plusui:keyboard:keydown', callback);
   },
 
   onKeyUp(callback: KeyEventCallback): () => void {
-    return eventHandler('keyboard:keyup', callback as (...args: unknown[]) => void);
+    return onDomEvent<KeyEvent>('plusui:keyboard:keyup', callback);
   },
 
   onShortcut(callback: (id: string) => void): () => void {
-    return eventHandler('keyboard:shortcut', callback as (...args: unknown[]) => void);
+    return onDomEvent<{ id: string }>('plusui:keyboard:shortcut', (d) => callback(d.id));
   },
 
   parseShortcut(str: string): Shortcut {
@@ -155,7 +213,7 @@ export const keyboard = {
       } else if (trimmed === 'super' || trimmed === 'win' || trimmed === 'cmd') {
         mods |= KeyMod.Super;
       } else {
-        key = this.keyNameToCode(trimmed);
+        key = keyboard.keyNameToCode(trimmed);
       }
     }
 
@@ -166,10 +224,13 @@ export const keyboard = {
     const map: Record<string, KeyCode> = {
       'space': KeyCode.Space,
       'escape': KeyCode.Escape,
+      'esc': KeyCode.Escape,
       'enter': KeyCode.Enter,
+      'return': KeyCode.Enter,
       'tab': KeyCode.Tab,
       'backspace': KeyCode.Backspace,
       'delete': KeyCode.Delete,
+      'del': KeyCode.Delete,
       'right': KeyCode.Right,
       'left': KeyCode.Left,
       'down': KeyCode.Down,
@@ -186,8 +247,16 @@ export const keyboard = {
       'f10': KeyCode.F10,
       'f11': KeyCode.F11,
       'f12': KeyCode.F12,
+      // A–Z single letters (GLFW convention: A=65 … Z=90)
+      'a': KeyCode.A, 'b': KeyCode.B, 'c': KeyCode.C, 'd': KeyCode.D,
+      'e': KeyCode.E, 'f': KeyCode.F, 'g': KeyCode.G, 'h': KeyCode.H,
+      'i': KeyCode.I, 'j': KeyCode.J, 'k': KeyCode.K, 'l': KeyCode.L,
+      'm': KeyCode.M, 'n': KeyCode.N, 'o': KeyCode.O, 'p': KeyCode.P,
+      'q': KeyCode.Q, 'r': KeyCode.R, 's': KeyCode.S, 't': KeyCode.T,
+      'u': KeyCode.U, 'v': KeyCode.V, 'w': KeyCode.W, 'x': KeyCode.X,
+      'y': KeyCode.Y, 'z': KeyCode.Z,
     };
-    return map[name] || KeyCode.Unknown;
+    return map[name] ?? KeyCode.Unknown;
   },
 };