Fix IME composition Enter key handling on Windows (#20)

Stop swallowing the IME confirm Enter so Windows Zhuyin no longer dumps the raw phonetic buffer; scope the guard to a short post-compositionend window with a -Infinity no-composition sentinel.

Author: PttCodingMan

frontend/src/components/Editor/Editor.jsx

@@ -16,6 +16,7 @@ import { mention } from './mention'
 import { math, mathBlockSchema } from './math'
 import { tableTooltip } from './tableTooltip'
 import { tablePasteExpand } from './tablePasteExpand'
+import { isStrayPostCompositionEnter, NO_COMPOSITION } from './imeGuard'
 
 const SLASH_ITEM_DEFS = [
   { id: 'h1', icon: 'H1' },
@@ -801,32 +802,24 @@ const Editor = forwardRef(function Editor({ defaultValue = '', onChange, onDrawi
       })
     })
 
-    // On Windows, compositionend fires before the keydown for the Enter that
-    // confirmed the IME selection. By the time handleKeyDown runs, both
-    // event.isComposing and view.composing are false, so ProseMirror's default
-    // Enter handler creates a spurious newline (causing the "line shifts down"
-    // symptom). Track composition state via DOM events and clear the flag one
-    // microtask later so that post-composition Enter keydown is suppressed.
+    // On Windows, the Enter that confirms an IME selection can surface as a
+    // stray keydown fired right after compositionend (isComposing already
+    // false), which ProseMirror's default Enter handler would turn into a
+    // spurious block split. Suppress only that stray Enter — scoped to a
+    // short window after compositionend — and never an Enter that is still
+    // part of an active composition (see imeGuard.js for the rationale).
     const compositionGuardPlugin = $prose(() => {
-      let _imeComposing = false
+      let lastCompositionEndAt = NO_COMPOSITION
       return new Plugin({
         props: {
           handleDOMEvents: {
-            compositionstart(_view, _event) {
-              _imeComposing = true
-              return false
-            },
             compositionend(_view, _event) {
-              // setTimeout(0) rather than Promise microtask — on Windows the
-              // post-composition Enter keydown may arrive in the same task after
-              // compositionend, and microtasks run within that same task before
-              // the next macrotask, making the delay insufficient.
-              setTimeout(() => { _imeComposing = false }, 0)
+              lastCompositionEndAt = performance.now()
               return false
             },
           },
           handleKeyDown(_view, event) {
-            if (_imeComposing && event.key === 'Enter') {
+            if (isStrayPostCompositionEnter(event, lastCompositionEndAt, performance.now())) {
               event.preventDefault()
               return true
             }

frontend/src/components/Editor/imeGuard.js

@@ -0,0 +1,29 @@
+// Window (ms) after `compositionend` during which a *stray* Enter keydown
+// is suppressed. On Windows, the Enter that confirms an IME selection can
+// surface as an extra keydown fired right after `compositionend` (with
+// `isComposing` already false); ProseMirror's default Enter handler would
+// turn that into a spurious block split ("the line shifts down"). That
+// stray Enter is part of the same physical keypress as the IME confirm, so
+// it lands within a few ms — a deliberate newline is a separate, much
+// later keypress, so a short window cleanly separates the two.
+export const POST_COMPOSITION_ENTER_MS = 50
+
+// Sentinel for "no compositionend has happened yet". Must be -Infinity, not
+// 0: timestamps are `performance.now()` (ms since page load), so a 0
+// sentinel would falsely fall inside the window during the first
+// POST_COMPOSITION_ENTER_MS after load and swallow a plain Enter.
+export const NO_COMPOSITION = Number.NEGATIVE_INFINITY
+
+// Pure decision: should this keydown be swallowed as a post-composition
+// stray Enter? `lastCompositionEndAt` is the timestamp of the most recent
+// `compositionend` (NO_COMPOSITION if none yet); `now` is the current
+// timestamp (same clock as `lastCompositionEndAt`).
+export function isStrayPostCompositionEnter(event, lastCompositionEndAt, now) {
+  // An Enter that is still part of an active composition (e.g. Zhuyin
+  // pressing Enter to commit bopomofo into Han characters) MUST reach the
+  // IME. Never preventDefault it, or the IME can't finalize the conversion
+  // and commits the raw phonetic buffer instead of the converted text.
+  if (event.isComposing || event.keyCode === 229) return false
+  if (event.key !== 'Enter') return false
+  return now - lastCompositionEndAt <= POST_COMPOSITION_ENTER_MS
+}

frontend/src/components/Editor/imeGuard.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest'
+import { isStrayPostCompositionEnter, POST_COMPOSITION_ENTER_MS, NO_COMPOSITION } from './imeGuard'
+
+const enter = (overrides = {}) => ({ key: 'Enter', keyCode: 13, isComposing: false, ...overrides })
+
+describe('isStrayPostCompositionEnter', () => {
+  it('suppresses a stray Enter fired right after compositionend', () => {
+    expect(isStrayPostCompositionEnter(enter(), 1000, 1001)).toBe(true)
+  })
+
+  it('suppresses at the exact end of the window (inclusive)', () => {
+    expect(
+      isStrayPostCompositionEnter(enter(), 1000, 1000 + POST_COMPOSITION_ENTER_MS),
+    ).toBe(true)
+  })
+
+  it('does NOT suppress an Enter that is still part of composition (isComposing)', () => {
+    // Zhuyin pressing Enter to commit bopomofo->Han: must reach the IME or
+    // the raw phonetic buffer gets dumped instead of the converted text.
+    expect(isStrayPostCompositionEnter(enter({ isComposing: true }), 1000, 1001)).toBe(false)
+  })
+
+  it('does NOT suppress an Enter delivered to the IME (keyCode 229)', () => {
+    expect(isStrayPostCompositionEnter(enter({ keyCode: 229 }), 1000, 1001)).toBe(false)
+  })
+
+  it('does NOT suppress a deliberate Enter long after compositionend', () => {
+    expect(
+      isStrayPostCompositionEnter(enter(), 1000, 1000 + POST_COMPOSITION_ENTER_MS + 1),
+    ).toBe(false)
+  })
+
+  it('does NOT suppress Enter when no composition has happened yet', () => {
+    expect(isStrayPostCompositionEnter(enter(), NO_COMPOSITION, 999999)).toBe(false)
+  })
+
+  it('does NOT suppress a plain Enter pressed within 50ms of page load', () => {
+    // Regression: a 0 sentinel + performance.now()-based `now` would make
+    // `now - 0 <= 50` true during the first 50ms after the time origin.
+    expect(isStrayPostCompositionEnter(enter(), NO_COMPOSITION, 12)).toBe(false)
+  })
+
+  it('ignores non-Enter keys even right after compositionend', () => {
+    expect(isStrayPostCompositionEnter({ key: 'a', keyCode: 65, isComposing: false }, 1000, 1001)).toBe(false)
+  })
+})