@expofp/debug 3.4.1 → 3.4.3

package/dist/lib/utils/add-debug-secret-listener.js

@@ -1,37 +1,69 @@
 const SECRET_PHRASE = 'dbg123';
 const callbacks = [];
 let initialized = false;
-let listenerRef = null;
+let teardown = null;
 export function addDebugSecretListener(callback) {
     callbacks.push(callback);
     if (!initialized) {
         initialized = true;
         let buffer = '';
-        function onKeyDown(e) {
-            // Ignore modifier keys
+        // A physical keypress fires both `keydown` and `input`. When `keydown`
+        // already fed a real character, this flag tells the `input` handler to skip
+        // the paired event so the character is not counted twice.
+        let consumedByKeydown = false;
+        const feed = (text) => {
+            for (const ch of text.toLowerCase()) {
+                buffer = (buffer + ch).slice(-SECRET_PHRASE.length);
+                if (buffer === SECRET_PHRASE) {
+                    buffer = '';
+                    callbacks.forEach((cb) => cb());
+                    return;
+                }
+            }
+        };
+        // Physical keyboards expose the real character here. Android soft keyboards
+        // instead report keyCode 229 / key 'Unidentified' (IME composition), so
+        // those keystrokes fall through to the `input` handler below.
+        const onKeyDown = (e) => {
             if (e.ctrlKey || e.metaKey || e.altKey)
                 return;
-            if (e.key.length !== 1)
+            if (e.isComposing || e.key.length !== 1) {
+                consumedByKeydown = false;
                 return;
-            buffer += e.key.toLowerCase();
-            // Keep buffer length sane
-            buffer = buffer.slice(-SECRET_PHRASE.length);
-            if (buffer === SECRET_PHRASE) {
-                buffer = '';
-                callbacks.forEach((cb) => cb());
             }
-        }
-        listenerRef = onKeyDown;
+            consumedByKeydown = true;
+            feed(e.key);
+        };
+        // Soft keyboards / IMEs deliver the typed text only as `InputEvent.data`.
+        // Listen in the capture phase so we still see it when an input component
+        // stops propagation. `data` is null for deletions, and we ignore in-flight
+        // composition to avoid re-counting the running composition string.
+        const onInput = (e) => {
+            if (consumedByKeydown) {
+                consumedByKeydown = false;
+                return;
+            }
+            const ie = e;
+            if (ie.isComposing)
+                return;
+            if (ie.data)
+                feed(ie.data);
+        };
         document.addEventListener('keydown', onKeyDown);
+        document.addEventListener('input', onInput, true);
+        teardown = () => {
+            document.removeEventListener('keydown', onKeyDown);
+            document.removeEventListener('input', onInput, true);
+        };
     }
     return () => {
         const index = callbacks.indexOf(callback);
         if (index !== -1) {
             callbacks.splice(index, 1);
         }
-        if (callbacks.length === 0 && listenerRef) {
-            document.removeEventListener('keydown', listenerRef);
-            listenerRef = null;
+        if (callbacks.length === 0 && teardown) {
+            teardown();
+            teardown = null;
             initialized = false;
         }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/debug",
-  "version": "3.4.1",
+  "version": "3.4.3",
   "type": "module",
   "description": "ExpoFP SDK internal: debug utilities",
   "homepage": "https://developer.expofp.com/",