@writegeez/ime 0.0.2 → 0.1.0

package/dist/index.d.cts

@@ -10,8 +10,7 @@ type InputMethodSpec = {
 };
 
 declare class WebGeezIME {
-    private inputMap;
-    private geezToLatinMap;
+    private transliterator;
     private activeElement;
     private elementType;
     private isContentEditable;
@@ -32,8 +31,20 @@ declare class WebGeezIME {
         output: string;
         modifiesPrev: boolean;
     };
+    /** The word before the caret, e.g. `"ሰላ"` while typing `ሰላም`. */
+    currentWord(): string;
+    /**
+     * Write `text` at the caret, as if typed. With `replaceWord`, the word
+     * before the caret is replaced (accepting a suggestion). Returns false
+     * while an OS IME composition is in progress, so it cannot be corrupted.
+     */
+    insertText(text: string, options?: {
+        replaceWord?: boolean;
+    }): boolean;
+    private textBeforeCaret;
     private handleBeforeInput;
     private insertGeezChar;
+    /** Replace `length` UTF-16 units before the caret; defaults to the previous grapheme. */
     private replaceGeezChar;
     private dispatchSyntheticInput;
     private getPreviousCharByTargetRanges;
@@ -50,6 +61,31 @@ declare namespace core {
 
 declare const inputMethod: InputMethodSpec;
 
+/** Every input method bundled with the package, in menu order. */
+declare const inputMethods: InputMethodSpec[];
+/** Look one up by its `code`, e.g. `"ti-ER"`. */
+declare function getInputMethod(code: string): InputMethodSpec | undefined;
+
+/**
+ * DOM-free transliteration engine. Feed it the character before the caret
+ * and the key just typed; it says what to write and whether that replaces
+ * the previous character.
+ */
+declare class Transliterator {
+    private inputMap;
+    private geezToLatinMap;
+    constructor(spec: InputMethodSpec);
+    feed(prevChar: string, key: string): {
+        replace: boolean;
+        text: string;
+    };
+    /** Run a whole key sequence, e.g. `"selam"` → `"ሰላም"`. */
+    transliterate(keys: string): string;
+}
+
+/** The word at the end of `text`: everything after the last space or punctuation mark. */
+declare function trailingWord(text: string): string;
+
 declare const ime: typeof core;
 
-export { WebGeezIME as GeezIME, type InputMethod, type InputMethodSpec, type SymbolMap, inputMethod as TigrinyaEritrean, ime };
+export { WebGeezIME as GeezIME, type InputMethod, type InputMethodSpec, type SymbolMap, inputMethod as TigrinyaEritrean, Transliterator, getInputMethod, ime, inputMethods, trailingWord };

package/dist/index.d.ts

@@ -10,8 +10,7 @@ type InputMethodSpec = {
 };
 
 declare class WebGeezIME {
-    private inputMap;
-    private geezToLatinMap;
+    private transliterator;
     private activeElement;
     private elementType;
     private isContentEditable;
@@ -32,8 +31,20 @@ declare class WebGeezIME {
         output: string;
         modifiesPrev: boolean;
     };
+    /** The word before the caret, e.g. `"ሰላ"` while typing `ሰላም`. */
+    currentWord(): string;
+    /**
+     * Write `text` at the caret, as if typed. With `replaceWord`, the word
+     * before the caret is replaced (accepting a suggestion). Returns false
+     * while an OS IME composition is in progress, so it cannot be corrupted.
+     */
+    insertText(text: string, options?: {
+        replaceWord?: boolean;
+    }): boolean;
+    private textBeforeCaret;
     private handleBeforeInput;
     private insertGeezChar;
+    /** Replace `length` UTF-16 units before the caret; defaults to the previous grapheme. */
     private replaceGeezChar;
     private dispatchSyntheticInput;
     private getPreviousCharByTargetRanges;
@@ -50,6 +61,31 @@ declare namespace core {
 
 declare const inputMethod: InputMethodSpec;
 
+/** Every input method bundled with the package, in menu order. */
+declare const inputMethods: InputMethodSpec[];
+/** Look one up by its `code`, e.g. `"ti-ER"`. */
+declare function getInputMethod(code: string): InputMethodSpec | undefined;
+
+/**
+ * DOM-free transliteration engine. Feed it the character before the caret
+ * and the key just typed; it says what to write and whether that replaces
+ * the previous character.
+ */
+declare class Transliterator {
+    private inputMap;
+    private geezToLatinMap;
+    constructor(spec: InputMethodSpec);
+    feed(prevChar: string, key: string): {
+        replace: boolean;
+        text: string;
+    };
+    /** Run a whole key sequence, e.g. `"selam"` → `"ሰላም"`. */
+    transliterate(keys: string): string;
+}
+
+/** The word at the end of `text`: everything after the last space or punctuation mark. */
+declare function trailingWord(text: string): string;
+
 declare const ime: typeof core;
 
-export { WebGeezIME as GeezIME, type InputMethod, type InputMethodSpec, type SymbolMap, inputMethod as TigrinyaEritrean, ime };
+export { WebGeezIME as GeezIME, type InputMethod, type InputMethodSpec, type SymbolMap, inputMethod as TigrinyaEritrean, Transliterator, getInputMethod, ime, inputMethods, trailingWord };

package/dist/index.mjs

@@ -28,6 +28,48 @@ function buildReverseMap(inputMethod2, prefix = "") {
 function isLatinChar(char) {
   return char >= "a" && char <= "z" || char >= "A" && char <= "Z";
 }
+function trailingWord(text) {
+  return /[^\s\p{P}]*$/u.exec(text)[0];
+}
+
+// src/transliterator.ts
+var Transliterator = class {
+  constructor(spec) {
+    this.inputMap = spec.map;
+    this.geezToLatinMap = buildReverseMap(this.inputMap);
+  }
+  feed(prevChar, key) {
+    let prevLatinChar = prevChar;
+    if (!isLatinChar(prevChar))
+      prevLatinChar = this.geezToLatinMap[prevChar] || prevChar;
+    let currentNode = null;
+    let tempNode = this.inputMap;
+    for (const char of prevLatinChar) {
+      if (tempNode[char]) {
+        currentNode = tempNode[char];
+        tempNode = currentNode.next || {};
+      } else {
+        currentNode = null;
+        break;
+      }
+    }
+    if (currentNode?.next && currentNode.next[key])
+      return { replace: true, text: currentNode.next[key].value || key };
+    const newNode = this.inputMap[key];
+    if (newNode) return { replace: false, text: newNode.value || key };
+    return { replace: false, text: key };
+  }
+  /** Run a whole key sequence, e.g. `"selam"` → `"ሰላም"`. */
+  transliterate(keys) {
+    const out = [];
+    for (const key of keys) {
+      const { replace, text } = this.feed(out[out.length - 1] ?? "", key);
+      if (replace) out.pop();
+      out.push(text);
+    }
+    return out.join("");
+  }
+};
 
 // src/webGeezIme.ts
 var WebGeezIME = class {
@@ -44,8 +86,7 @@ var WebGeezIME = class {
     this.boundCompositionEnd = () => {
       this.composing = false;
     };
-    this.inputMap = inputMethodSpec.map;
-    this.geezToLatinMap = buildReverseMap(this.inputMap);
+    this.transliterator = new Transliterator(inputMethodSpec);
     if (typeof options?.enabled === "boolean")
       this.enabled = options.enabled;
     this.attachToElement(element);
@@ -101,30 +142,46 @@ var WebGeezIME = class {
     );
   }
   processInput(prevChar, newChar) {
-    let prevLatinChar = prevChar;
-    if (!isLatinChar(prevChar))
-      prevLatinChar = this.geezToLatinMap[prevChar] || prevChar;
-    let currentNode = null;
-    let tempNode = this.inputMap;
-    for (const char of prevLatinChar) {
-      if (tempNode[char]) {
-        currentNode = tempNode[char];
-        tempNode = currentNode.next || {};
-      } else {
-        currentNode = null;
-        break;
-      }
+    const { replace, text } = this.transliterator.feed(prevChar, newChar);
+    return { output: text, modifiesPrev: replace };
+  }
+  /** The word before the caret, e.g. `"ሰላ"` while typing `ሰላም`. */
+  currentWord() {
+    return trailingWord(this.textBeforeCaret());
+  }
+  /**
+   * Write `text` at the caret, as if typed. With `replaceWord`, the word
+   * before the caret is replaced (accepting a suggestion). Returns false
+   * while an OS IME composition is in progress, so it cannot be corrupted.
+   */
+  insertText(text, options) {
+    if (!this.activeElement || this.composing) return false;
+    const length = options?.replaceWord ? this.currentWord().length : 0;
+    if (length) this.replaceGeezChar(text, length);
+    else this.insertGeezChar(text);
+    this.dispatchSyntheticInput(length ? "insertReplacementText" : "insertText");
+    return true;
+  }
+  textBeforeCaret() {
+    if (!this.activeElement) return "";
+    if (this.elementType === "input") {
+      const el = this.activeElement;
+      return el.value.slice(0, el.selectionStart ?? el.value.length);
     }
-    if (currentNode?.next && currentNode.next[newChar]) {
-      return {
-        output: currentNode.next[newChar].value || newChar,
-        modifiesPrev: true
-      };
+    if (!this.isContentEditable) return "";
+    this.activeElement.normalize();
+    const sel = window.getSelection();
+    if (!sel) return "";
+    if (!sel.rangeCount || !this.activeElement.contains(sel.getRangeAt(0).startContainer)) {
+      const range2 = document.createRange();
+      range2.selectNodeContents(this.activeElement);
+      range2.collapse(false);
+      sel.removeAllRanges();
+      sel.addRange(range2);
     }
-    const newNode = this.inputMap[newChar];
-    if (newNode)
-      return { output: newNode.value || newChar, modifiesPrev: false };
-    return { output: newChar, modifiesPrev: false };
+    const range = sel.getRangeAt(0);
+    const { node, offset } = this.resolveTextPosition(range.startContainer, range.startOffset);
+    return node ? (node.textContent ?? "").slice(0, offset) : "";
   }
   handleBeforeInput(event) {
     if (!this.activeElement) return;
@@ -176,12 +233,13 @@ var WebGeezIME = class {
       sel.addRange(range);
     }
   }
-  replaceGeezChar(char) {
+  /** Replace `length` UTF-16 units before the caret; defaults to the previous grapheme. */
+  replaceGeezChar(char, length) {
     if (!this.activeElement) return;
     if (this.elementType === "input") {
       const target = this.activeElement;
       const caret = target.selectionStart ?? 0;
-      const start = this.findPrevGraphemeStart(target.value, caret);
+      const start = length === void 0 ? this.findPrevGraphemeStart(target.value, caret) : Math.max(0, caret - length);
       target.setRangeText(char, start, caret, "end");
     } else if (this.isContentEditable) {
       const sel = window.getSelection();
@@ -193,7 +251,7 @@ var WebGeezIME = class {
       );
       if (node) {
         const text = node.textContent ?? "";
-        const start = this.findPrevGraphemeStart(text, offset);
+        const start = length === void 0 ? this.findPrevGraphemeStart(text, offset) : Math.max(0, offset - length);
         const r = document.createRange();
         r.setStart(node, start);
         r.setEnd(node, offset);
@@ -2215,12 +2273,14 @@ var inputMethod = {
 var ti_ER_default = inputMethod;
 
 // src/input-methods/index.ts
-var inputMethods = {};
-inputMethods[ti_ER_default.name] = ti_ER_default.map;
+var inputMethods = [ti_ER_default];
+function getInputMethod(code) {
+  return inputMethods.find((method) => method.code === code);
+}
 
 // src/index.ts
 var ime = webGeezIme_exports;
 
-export { WebGeezIME as GeezIME, ti_ER_default as TigrinyaEritrean, ime };
+export { WebGeezIME as GeezIME, ti_ER_default as TigrinyaEritrean, Transliterator, getInputMethod, ime, inputMethods, trailingWord };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map