[Init] Initial commit - NetMesh terminal manager

domain/imeControlledInput.test.ts

@@ -0,0 +1,184 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  resolveSupersededImeInputEvent,
+  shouldAdoptExternalImeControlledValue,
+  shouldCommitImeControlledChange,
+} from "./imeControlledInput.ts";
+
+test("does not commit controlled changes while an IME composition session is open", () => {
+  assert.equal(
+    shouldCommitImeControlledChange({
+      isComposingSession: true,
+      nativeEventIsComposing: true,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldCommitImeControlledChange({
+      isComposingSession: true,
+      nativeEventIsComposing: false,
+    }),
+    false,
+  );
+});
+
+test("does not commit when the native event still reports composing", () => {
+  assert.equal(
+    shouldCommitImeControlledChange({
+      isComposingSession: false,
+      nativeEventIsComposing: true,
+    }),
+    false,
+  );
+});
+
+test("commits ordinary keystrokes outside composition", () => {
+  assert.equal(
+    shouldCommitImeControlledChange({
+      isComposingSession: false,
+      nativeEventIsComposing: false,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldCommitImeControlledChange({
+      isComposingSession: false,
+    }),
+    true,
+  );
+});
+
+test("does not commit when composition was externally superseded", () => {
+  assert.equal(
+    shouldCommitImeControlledChange({
+      isComposingSession: false,
+      nativeEventIsComposing: false,
+      compositionExternallySuperseded: true,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldCommitImeControlledChange({
+      isComposingSession: true,
+      nativeEventIsComposing: false,
+      compositionExternallySuperseded: true,
+    }),
+    false,
+  );
+});
+
+test("adopts external value into draft only when not composing and values differ", () => {
+  assert.equal(
+    shouldAdoptExternalImeControlledValue({
+      isComposingSession: false,
+      draftValue: "sou",
+      externalValue: "",
+    }),
+    true,
+  );
+  assert.equal(
+    shouldAdoptExternalImeControlledValue({
+      isComposingSession: true,
+      draftValue: "sou",
+      externalValue: "",
+    }),
+    false,
+  );
+  assert.equal(
+    shouldAdoptExternalImeControlledValue({
+      isComposingSession: false,
+      draftValue: "搜",
+      externalValue: "搜",
+    }),
+    false,
+  );
+});
+
+test("adopts external navigation-clear mid-composition when compose-start baseline is provided", () => {
+  // Parent cleared filter for different-directory navigation while IME was open.
+  assert.equal(
+    shouldAdoptExternalImeControlledValue({
+      isComposingSession: true,
+      draftValue: "sou",
+      externalValue: "",
+      valueAtComposeStart: "old",
+    }),
+    true,
+  );
+  // External value still matches the compose-start baseline - keep draft for IME.
+  assert.equal(
+    shouldAdoptExternalImeControlledValue({
+      isComposingSession: true,
+      draftValue: "sou",
+      externalValue: "old",
+      valueAtComposeStart: "old",
+    }),
+    false,
+  );
+  // Draft already matches external after a prior adopt - no-op.
+  assert.equal(
+    shouldAdoptExternalImeControlledValue({
+      isComposingSession: true,
+      draftValue: "",
+      externalValue: "",
+      valueAtComposeStart: "old",
+    }),
+    false,
+  );
+});
+
+test("suppresses post-composition onChange after external supersede and clears the latch once ended", () => {
+  // Mid-composition after navigation clear: ignore event, keep latch armed.
+  assert.deepEqual(
+    resolveSupersededImeInputEvent({
+      compositionExternallySuperseded: true,
+      isComposingSession: true,
+      nativeEventIsComposing: true,
+    }),
+    { ignoreEventValue: true, clearSupersedeLatch: false },
+  );
+
+  // Post-compositionend follow-up change (composing=false): ignore once and clear.
+  assert.deepEqual(
+    resolveSupersededImeInputEvent({
+      compositionExternallySuperseded: true,
+      isComposingSession: false,
+      nativeEventIsComposing: false,
+    }),
+    { ignoreEventValue: true, clearSupersedeLatch: true },
+  );
+
+  // No supersede: ordinary path.
+  assert.deepEqual(
+    resolveSupersededImeInputEvent({
+      compositionExternallySuperseded: false,
+      isComposingSession: false,
+      nativeEventIsComposing: false,
+    }),
+    { ignoreEventValue: false, clearSupersedeLatch: false },
+  );
+});
+
+test("ordinary commits remain blocked only while the supersede latch is armed", () => {
+  // Documents the stuck-latch failure mode: if compositionend arms the latch and
+  // no post-composition onChange clears it, shouldCommitImeControlledChange stays
+  // false for ordinary keystrokes. UI must clear via onChange or a deferred fallback.
+  assert.equal(
+    shouldCommitImeControlledChange({
+      isComposingSession: false,
+      nativeEventIsComposing: false,
+      compositionExternallySuperseded: true,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldCommitImeControlledChange({
+      isComposingSession: false,
+      nativeEventIsComposing: false,
+      compositionExternallySuperseded: false,
+    }),
+    true,
+  );
+});