fix(input): support oe and ae ligature input (@Dawn-Fighter)

frontend/__tests__/input/handlers/insert-text.spec.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import {
+  getMatchingLigatureOverride,
+  shouldIgnoreLigatureCompletion,
+} from "../../../src/ts/input/helpers/ligatures";
+
+describe("insert-text ligature input overrides", () => {
+  it.each([
+    ["o", "œ", "œ"],
+    ["O", "Œ", "Œ"],
+    ["a", "æ", "æ"],
+    ["A", "Æ", "Æ"],
+  ])(
+    "normalizes '%s' to '%s' when target is '%s'",
+    (data, target, expected) => {
+      expect(getMatchingLigatureOverride(data, target)).toBe(expected);
+    },
+  );
+
+  it.each([
+    ["e", "œ", "œuvre"],
+    ["E", "Œ", "ŒUVRE"],
+    ["e", "æ", "æther"],
+    ["E", "Æ", "ÆTHER"],
+  ])("ignores completion '%s' after '%s'", (data, input, word) => {
+    expect(shouldIgnoreLigatureCompletion(data, input, word)).toBe(true);
+  });
+
+  it("does not normalize unrelated input", () => {
+    expect(getMatchingLigatureOverride("e", "œ")).toBeNull();
+    expect(shouldIgnoreLigatureCompletion("u", "œ", "œuvre")).toBe(false);
+  });
+});

frontend/src/ts/input/handlers/insert-text.ts

@@ -37,6 +37,10 @@ import {
   isCharCorrect,
   shouldInsertSpaceCharacter,
 } from "../helpers/validation";
+import {
+  getMatchingLigatureOverride,
+  shouldIgnoreLigatureCompletion,
+} from "../helpers/ligatures";
 
 const charOverrides = new Map<string, string>([
   ["…", "..."],
@@ -82,6 +86,18 @@ export async function onInsertText(options: OnInsertTextParams): Promise<void> {
     return;
   }
 
+  if (
+    shouldIgnoreLigatureCompletion(
+      options.data,
+      TestInput.input.current,
+      TestWords.words.getCurrentText(),
+    )
+  ) {
+    setInputElementValue(inputValue.slice(0, -options.data.length));
+    TestInput.input.syncWithInputElement();
+    return;
+  }
+
   const charOverride = charOverrides.get(options.data);
   if (
     charOverride !== undefined &&
@@ -301,6 +317,12 @@ function normalizeDataAndUpdateInputIfNeeded(
   ) {
     replaceInputElementLastValueChar(targetChar);
     normalizedData = targetChar;
+  } else {
+    const ligatureOverride = getMatchingLigatureOverride(data, targetChar);
+    if (ligatureOverride !== null) {
+      replaceInputElementLastValueChar(ligatureOverride);
+      normalizedData = ligatureOverride;
+    }
   }
   return normalizedData;
 }

frontend/src/ts/input/helpers/ligatures.ts

@@ -0,0 +1,32 @@
+const ligatureInputOverrides = new Map<string, string>([
+  ["œ", "oe"],
+  ["Œ", "OE"],
+  ["æ", "ae"],
+  ["Æ", "AE"],
+]);
+
+export function getMatchingLigatureOverride(
+  data: string,
+  targetChar: string | undefined,
+): string | null {
+  if (targetChar === undefined) return null;
+
+  const override = ligatureInputOverrides.get(targetChar);
+  if (override?.[0] !== data) return null;
+
+  return targetChar;
+}
+
+export function shouldIgnoreLigatureCompletion(
+  data: string,
+  testInput: string,
+  currentWord: string,
+): boolean {
+  const previousTargetChar = currentWord[testInput.length - 1];
+  if (previousTargetChar === undefined) return false;
+
+  const override = ligatureInputOverrides.get(previousTargetChar);
+  if (override === undefined) return false;
+
+  return testInput.endsWith(previousTargetChar) && data === override.slice(1);
+}