@cplieger/web-terminal-ui 7.0.4 → 7.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/web-terminal-ui",
-  "version": "7.0.4",
+  "version": "7.0.5",
   "type": "module",
   "description": "Reference touch-first browser UI for @cplieger/web-terminal-engine: a composable kernel + feature modules (tabs, activity monitor, mobile toolbar, context menu, IME, predictive echo, viewport handling) and CSS. One createTerminal() call.",
   "license": "MPL-2.0",
@@ -50,21 +50,21 @@
     "@stryker-mutator/core": "10.0.0",
     "@stryker-mutator/typescript-checker": "10.0.0",
     "@stryker-mutator/vitest-runner": "10.0.0",
-    "@types/node": "26.4.0",
+    "@types/node": "26.4.1",
     "@typescript/native": "npm:typescript@7.0.2",
     "@vitest/browser": "4.1.11",
     "@vitest/browser-playwright": "4.1.11",
     "@vitest/coverage-v8": "4.1.11",
     "eslint": "10.9.1",
     "fast-check": "4.9.0",
-    "html-validate": "11.10.0",
-    "knip": "6.33.0",
+    "html-validate": "11.12.0",
+    "knip": "6.34.0",
     "playwright": "1.62.1",
     "prettier": "3.9.6",
     "stylelint": "17.14.1",
     "stylelint-config-standard": "40.0.0",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "typescript-eslint": "8.68.0",
+    "typescript-eslint": "8.69.0",
     "vitest": "4.1.11"
   },
   "publishConfig": {

package/src/composition.ts

@@ -39,6 +39,31 @@ let sendingComposition = false;
 let compositionStart = 0;
 let compositionSuffix = "";
 
+// A soft keyboard may announce its composition only at COMMIT time: the
+// per-character `input` events arrive with no composition in progress, the
+// kernel sends each keystroke as typed, and then the keyboard fires
+// compositionstart + compositionend back-to-back on the committing key while
+// writing the WHOLE accumulated word into the textarea. The deferred read below
+// then sends that word a second time — reported on Android Chrome with
+// SwiftKey, where typing "hello" and pressing space produced "hellohello  ".
+//
+// The terminal has already been given the literal keystrokes and cannot be
+// asked to retract them, so a commit that only repeats them is a no-op.
+// `noteDirectSend` records what the kernel sent with no composition running;
+// the finaliser drops a commit that matches it.
+//
+// Unreachable on a keyboard that announces its composition BEFORE the
+// keystrokes (every desktop IME, iOS, Android's own keyboard): there the
+// kernel's `input` listener returns early while composing, so nothing is
+// recorded and there is nothing for a commit to match.
+const ECHO_TAIL_MAX = 64;
+const ECHO_WINDOW_MS = 1500;
+const ECHO_MAX_COMPOSE_MS = 60;
+
+let directTail = "";
+let directTailAt = 0;
+let compositionStartedAt: number | null = null;
+
 export function init(opts: {
   textarea: HTMLTextAreaElement;
   compositionView: HTMLElement;
@@ -67,6 +92,42 @@ export function isComposing(): boolean {
   return composing || sendingComposition;
 }
 
+/** Record text the kernel put on the wire with no composition running, so a
+ *  keyboard that announces its composition only at commit time cannot have the
+ *  same keystrokes delivered twice (see the ECHO_* note above). Typed text
+ *  only — a paste is never re-committed by a keyboard. */
+export function noteDirectSend(text: string): void {
+  if (text === "") {
+    return;
+  }
+  const now = Date.now();
+  if (now - directTailAt > ECHO_WINDOW_MS) {
+    directTail = "";
+  }
+  directTail = (directTail + text).slice(-ECHO_TAIL_MAX);
+  directTailAt = now;
+}
+
+/** Whether this commit merely repeats keystrokes already delivered literally. */
+function repeatsDirectSends(composed: string, startedAt: number | null, endedAt: number): boolean {
+  if (directTail === "") {
+    return false;
+  }
+  // A composition the user typed INTO spans human time; a commit-time
+  // announcement starts and ends inside one keystroke.
+  if (startedAt !== null && endedAt - startedAt > ECHO_MAX_COMPOSE_MS) {
+    return false;
+  }
+  // Only the burst still being typed can be a re-commit of itself.
+  if (endedAt - directTailAt > ECHO_WINDOW_MS) {
+    return false;
+  }
+  // The committing key (space, tab) is delivered as its own `input` event, so
+  // what has to match is the WORD the keyboard is re-committing.
+  const word = composed.replace(/[ \t]+$/u, "");
+  return word !== "" && directTail.endsWith(word);
+}
+
 /** Abort any in-flight composition without sending, and clear the textarea.
  *  The kernel calls this on a tab switch (detach): committing half-composed IME
  *  text to either the outgoing or the incoming session is wrong, so we discard
@@ -77,6 +138,8 @@ export function isComposing(): boolean {
 export function cancelComposition(): void {
   composing = false;
   sendingComposition = false;
+  compositionStartedAt = null;
+  directTail = "";
   compositionView.textContent = "";
   compositionView.classList.remove("active");
   resetToPlaceholder(textarea);
@@ -104,6 +167,7 @@ export function teardown(): void {
 
 function onStart(): void {
   composing = true;
+  compositionStartedAt = Date.now();
   const start = textarea.selectionStart;
   const end = textarea.selectionEnd;
   compositionStart = Math.min(start, end);
@@ -131,6 +195,9 @@ function onEnd(): void {
   sendingComposition = true;
   const startSnapshot = compositionStart;
   const suffixSnapshot = compositionSuffix;
+  const startedAt = compositionStartedAt;
+  const endedAt = Date.now();
+  compositionStartedAt = null;
   setTimeout(() => {
     if (!sendingComposition) {
       return;
@@ -144,9 +211,10 @@ function onEnd(): void {
     const composed = value
       .substring(startSnapshot, Math.max(startSnapshot, valueEnd))
       .replace(/\u00A0/g, " ");
-    if (composed.length > 0) {
+    if (composed.length > 0 && !repeatsDirectSends(composed, startedAt, endedAt)) {
       send(composed);
     }
+    directTail = "";
     resetToPlaceholder(textarea);
   }, 0);
 }

package/src/kernel/kernel.ts

@@ -390,6 +390,14 @@ function buildTerminal(
   function sendText(text: string): void {
     sendBytes(encoder.encode(text));
   }
+  /** A keystroke the user typed with no composition running. Recorded so a
+   *  keyboard that announces its composition only at commit time cannot have
+   *  the same characters delivered twice (composition.ts, the ECHO_* note). */
+  function sendTyped(text: string): void {
+    const out = normalizeTypedText(text);
+    sendText(out);
+    composition.noteDirectSend(out);
+  }
   function paste(text: string): void {
     // The one bracketed-paste + newline-normalize funnel; every feature and the
     // kernel's own paste paths route through here (paste-jacking defense).
@@ -763,14 +771,14 @@ function buildTerminal(
           paste(ev.data);
         } else {
           // Normalize iOS's NBSP-for-space quirk, then send through the funnel.
-          sendText(normalizeTypedText(ev.data));
+          sendTyped(ev.data);
         }
       } else {
         const v = input.value;
         if (v.length > INPUT_PLACEHOLDER.length && v.startsWith(INPUT_PLACEHOLDER)) {
-          sendText(normalizeTypedText(v.slice(INPUT_PLACEHOLDER.length)));
+          sendTyped(v.slice(INPUT_PLACEHOLDER.length));
         } else if (v !== INPUT_PLACEHOLDER && v.length > 0) {
-          sendText(normalizeTypedText(v));
+          sendTyped(v);
         }
       }
       resetToPlaceholder(input);
@@ -1171,7 +1179,7 @@ function buildTerminal(
         // an uncanceled keydown's insertion target after a listener moved focus
         // mid-dispatch. Chromium does; no specification requires it.
         ev.preventDefault();
-        sendText(normalizeTypedText(char));
+        sendTyped(char);
         return;
       }
       applyMappedKey(ev, result);