@inshapardaz/likhari-react 0.1.25-dev.226 → 0.1.25-dev.230

package/dist/autocomplete/AutocompletePlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AutocompletePlugin.d.ts","sourceRoot":"","sources":["../../src/autocomplete/AutocompletePlugin.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAGrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAmB1D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,KAAK,EACL,MAAM,EACN,QAAQ,EAAE,cAAc,GACzB,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,8EAA8E;IAC9E,QAAQ,EAAE,aAAa,GAAG,MAAM,CAAC;CAClC,sCA6KA"}
+{"version":3,"file":"AutocompletePlugin.d.ts","sourceRoot":"","sources":["../../src/autocomplete/AutocompletePlugin.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAGrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAsB1D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,KAAK,EACL,MAAM,EACN,QAAQ,EAAE,cAAc,GACzB,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,8EAA8E;IAC9E,QAAQ,EAAE,aAAa,GAAG,MAAM,CAAC;CAClC,sCAgNA"}

package/dist/autocomplete/AutocompletePlugin.js

@@ -33,11 +33,35 @@ export function AutocompletePlugin({ label, stores, language: chosenLanguage, })
         popupRef.current = next;
         setPopup(next);
     };
+    /** Counts an accepted completion in every store that keeps counts, then drops the cached lists. */
+    const recordAcceptance = (language, word) => {
+        for (const store of storesRef.current) {
+            store.recordAccept?.(language, word).catch(() => undefined);
+        }
+        indexes.current.clear();
+    };
     useEffect(() => {
         const indexFor = (language) => {
             let index = indexes.current.get(language);
             if (!index) {
-                index = Promise.all(storesRef.current.map((store) => store.load(language).catch(() => []))).then((lists) => new WordIndex(lists.flat()));
+                index = Promise.all(storesRef.current.map(async (store) => {
+                    try {
+                        const [words, counts] = await Promise.all([
+                            store.load(language),
+                            store.loadCounts ? store.loadCounts(language) : Promise.resolve({}),
+                        ]);
+                        return { words, counts };
+                    }
+                    catch {
+                        return { words: [], counts: {} };
+                    }
+                })).then((parts) => {
+                    const counts = {};
+                    for (const part of parts)
+                        for (const [word, count] of Object.entries(part.counts))
+                            counts[word] = (counts[word] ?? 0) + count;
+                    return new WordIndex(parts.flatMap((part) => part.words), counts);
+                });
                 indexes.current.set(language, index);
             }
             return index;
@@ -67,26 +91,37 @@ export function AutocompletePlugin({ label, stores, language: chosenLanguage, })
             const { prefix, rtl } = target;
             const language = languageRef.current === 'auto' ? (rtl ? 'ur' : 'en') : languageRef.current;
             void indexFor(language).then((loaded) => {
+                // Same word as the open list: keep the user's highlight rather than resetting it.
+                const open = popupRef.current;
+                if (open && open.prefix === prefix && open.dir === (rtl ? 'rtl' : 'ltr'))
+                    return;
                 const items = loaded.complete(prefix);
                 if (items.length === 0)
                     return hide();
                 const rect = caretRect(editor);
-                show({ items, index: 0, selected: false, x: rect.left, y: rect.bottom, dir: rtl ? 'rtl' : 'ltr' });
+                show({ prefix, language, items, index: 0, selected: false, x: rect.left, y: rect.bottom, dir: rtl ? 'rtl' : 'ltr' });
             });
         };
-        const move = (delta) => {
+        // Handles an arrow key for the list, and cancels the browser's own caret movement.
+        const move = (delta, event) => {
             const current = popupRef.current;
-            if (!current)
+            // Still loading the list for the word being typed: the arrow is for the list, not the caret.
+            if (!current && prefixAtCaret(editor) === null)
                 return false;
-            const count = current.items.length;
-            show({ ...current, index: (current.index + delta + count) % count, selected: true });
+            event?.preventDefault();
+            if (current) {
+                const count = current.items.length;
+                show({ ...current, index: (current.index + delta + count) % count, selected: true });
+            }
             return true;
         };
         const onKeyDown = (event) => {
             // Up, Down, Tab and Enter act on the list through their editor commands, which
             // run after this listener, so the list must stay open for them.
             const current = popupRef.current;
-            if (current && (event.key === 'ArrowUp' || event.key === 'ArrowDown' || event.key === 'Tab' || (event.key === 'Enter' && current.selected)))
+            if (current && (event.key === 'Tab' || (event.key === 'Enter' && current.selected)))
+                return;
+            if ((event.key === 'ArrowUp' || event.key === 'ArrowDown') && (current || prefixAtCaret(editor) !== null))
                 return;
             if (event.key === 'Escape' && popupRef.current) {
                 event.preventDefault();
@@ -129,8 +164,8 @@ export function AutocompletePlugin({ label, stores, language: chosenLanguage, })
                 setTimeout(refresh, 0);
         });
         const unregisterCommands = [
-            editor.registerCommand(KEY_ARROW_DOWN_COMMAND, () => move(1), COMMAND_PRIORITY_HIGH),
-            editor.registerCommand(KEY_ARROW_UP_COMMAND, () => move(-1), COMMAND_PRIORITY_HIGH),
+            editor.registerCommand(KEY_ARROW_DOWN_COMMAND, (event) => move(1, event), COMMAND_PRIORITY_HIGH),
+            editor.registerCommand(KEY_ARROW_UP_COMMAND, (event) => move(-1, event), COMMAND_PRIORITY_HIGH),
             editor.registerCommand(KEY_TAB_COMMAND, (event) => acceptHighlighted(event), COMMAND_PRIORITY_HIGH),
             editor.registerCommand(KEY_ENTER_COMMAND, (event) => (popupRef.current?.selected ? acceptHighlighted(event) : false), COMMAND_PRIORITY_HIGH),
         ];
@@ -139,7 +174,9 @@ export function AutocompletePlugin({ label, stores, language: chosenLanguage, })
             if (!current)
                 return false;
             event?.preventDefault();
-            acceptItem(editor, current.items[current.index]);
+            const word = current.items[current.index];
+            acceptItem(editor, word);
+            recordAcceptance(current.language, word);
             show(null);
             return true;
         }
@@ -161,8 +198,29 @@ export function AutocompletePlugin({ label, stores, language: chosenLanguage, })
     return (_jsx("div", { className: "likhari-autocomplete", role: "listbox", "aria-label": label, dir: popup.dir, style: { position: 'fixed', left: popup.x, top: popup.y + 4 }, children: popup.items.map((item, i) => (_jsx("div", { role: "option", "aria-selected": i === popup.index, className: i === popup.index ? 'likhari-autocomplete-item likhari-autocomplete-item--active' : 'likhari-autocomplete-item', onMouseDown: (event) => {
                 event.preventDefault();
                 acceptItem(editor, item);
+                recordAcceptance(popup.language, item);
+                show(null);
             }, children: item }, item))) }));
 }
+/** The typed part of the word at the caret, when the caret is at its end and the word is long enough to complete. */
+function prefixAtCaret(editor) {
+    let prefix = null;
+    editor.getEditorState().read(() => {
+        const selection = $getSelection();
+        if (!$isRangeSelection(selection) || !selection.isCollapsed())
+            return;
+        const node = selection.anchor.getNode();
+        if (!$isTextNode(node))
+            return;
+        const text = node.getTextContent();
+        const before = text.slice(0, selection.anchor.offset);
+        const word = WORD_END.exec(before)?.[0];
+        const after = text.charAt(selection.anchor.offset);
+        if (word && word.length >= MIN_PREFIX && !(after !== '' && LETTER.test(after)))
+            prefix = word;
+    });
+    return prefix;
+}
 /** Where to put the popup: under the caret, or the editor's top-left if the caret has no position yet. */
 function caretRect(editor) {
     const selection = window.getSelection();

package/dist/autocomplete/completionStores.d.ts

@@ -1,20 +1,29 @@
 import { type SpellLanguage } from '../spellcheck/spellDictionaries.js';
 /**
- * Where autocomplete words come from. The host can pass several; their words
- * are combined per language. Like the other stores, a failing store is skipped.
+ * Where autocomplete words come from, and how often each was accepted. The host
+ * can pass several; words are combined per language and their counts summed.
+ * A failing store is skipped.
  */
 export interface CompletionStore {
     readonly id: string;
     load(language: SpellLanguage): Promise<string[]>;
+    /** How many times each word was accepted as a completion. */
+    loadCounts?(language: SpellLanguage): Promise<Record<string, number>>;
+    /** Records one accepted completion, so the word is suggested sooner next time. */
+    recordAccept?(language: SpellLanguage, word: string): Promise<void>;
 }
 /**
- * The default: the dictionary's words plus the words the user has added. Nothing
- * to configure; it follows whichever spelling dictionaries are registered.
+ * The default: the dictionary's words plus the words the user has added. Accepted
+ * completions are counted in this browser's localStorage, and the most accepted
+ * words are suggested first.
  */
-export declare function dictionaryCompletionStore(): CompletionStore;
+export declare function dictionaryCompletionStore(options?: {
+    countsKey?: string;
+}): CompletionStore;
 /**
- * Words served by an API. `load` calls `GET {url}?language=xx` and expects a JSON
- * array of strings.
+ * Words and counts served by an API. `load` calls `GET {url}?language=xx` for a JSON
+ * array of strings; `loadCounts` calls `GET {url}/counts?language=xx` for a JSON
+ * object of counts; `recordAccept` calls `POST {url}/accept` with `{ language, word }`.
  */
 export declare function apiCompletionStore(options: {
     id?: string;

package/dist/autocomplete/completionStores.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"completionStores.d.ts","sourceRoot":"","sources":["../../src/autocomplete/completionStores.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAGzF;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CAClD;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,eAAe,CAS3D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB,GAAG,eAAe,CAWlB"}
+{"version":3,"file":"completionStores.d.ts","sourceRoot":"","sources":["../../src/autocomplete/completionStores.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAGzF;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACjD,6DAA6D;IAC7D,UAAU,CAAC,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtE,kFAAkF;IAClF,YAAY,CAAC,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrE;AAiBD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,eAAe,CAwB/F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB,GAAG,eAAe,CA0BlB"}

package/dist/autocomplete/completionStores.js

@@ -1,10 +1,22 @@
 import { getDictionaryWords } from '../spellcheck/spellDictionaries.js';
 import { acceptedWords } from '../spellcheck/userWords.js';
+const COUNTS_KEY = 'likhari-completion-counts';
+function readCounts(key) {
+    try {
+        const parsed = JSON.parse(localStorage.getItem(key) ?? '{}');
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
 /**
- * The default: the dictionary's words plus the words the user has added. Nothing
- * to configure; it follows whichever spelling dictionaries are registered.
+ * The default: the dictionary's words plus the words the user has added. Accepted
+ * completions are counted in this browser's localStorage, and the most accepted
+ * words are suggested first.
  */
-export function dictionaryCompletionStore() {
+export function dictionaryCompletionStore(options = {}) {
+    const key = options.countsKey ?? COUNTS_KEY;
     return {
         id: 'dictionary',
         async load(language) {
@@ -12,22 +24,55 @@ export function dictionaryCompletionStore() {
             const dictionary = words ? await words : [];
             return [...dictionary, ...acceptedWords(language)];
         },
+        async loadCounts(language) {
+            return readCounts(key)[language] ?? {};
+        },
+        async recordAccept(language, word) {
+            const all = readCounts(key);
+            const counts = all[language] ?? {};
+            counts[word] = (counts[word] ?? 0) + 1;
+            all[language] = counts;
+            try {
+                localStorage.setItem(key, JSON.stringify(all));
+            }
+            catch {
+                // Storage full or disabled: the count is kept for this session only.
+            }
+        },
     };
 }
 /**
- * Words served by an API. `load` calls `GET {url}?language=xx` and expects a JSON
- * array of strings.
+ * Words and counts served by an API. `load` calls `GET {url}?language=xx` for a JSON
+ * array of strings; `loadCounts` calls `GET {url}/counts?language=xx` for a JSON
+ * object of counts; `recordAccept` calls `POST {url}/accept` with `{ language, word }`.
  */
 export function apiCompletionStore(options) {
     const doFetch = options.fetch ?? fetch;
+    const query = (language) => `?language=${encodeURIComponent(language)}`;
     return {
         id: options.id ?? 'api',
         async load(language) {
-            const response = await doFetch(`${options.url}?language=${encodeURIComponent(language)}`, { headers: options.headers });
+            const response = await doFetch(`${options.url}${query(language)}`, { headers: options.headers });
             if (!response.ok)
                 throw new Error(`Completion API failed: ${response.status}`);
             const data = await response.json();
             return Array.isArray(data) ? data.filter((w) => typeof w === 'string') : [];
         },
+        async loadCounts(language) {
+            const response = await doFetch(`${options.url}/counts${query(language)}`, { headers: options.headers });
+            if (!response.ok)
+                throw new Error(`Completion counts failed: ${response.status}`);
+            const data = await response.json();
+            return data && typeof data === 'object' ? data : {};
+        },
+        async recordAccept(language, word) {
+            const response = await doFetch(`${options.url}/accept`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...options.headers },
+                body: JSON.stringify({ language, word }),
+            });
+            if (!response.ok)
+                throw new Error(`Completion API rejected the count: ${response.status}`);
+        },
     };
 }

package/dist/autocomplete/wordIndex.d.ts

@@ -1,13 +1,20 @@
-/** Words sorted once, so every prefix lookup is a binary search rather than a scan. */
+/**
+ * Completion words, sorted once so every prefix lookup is a binary search. Each
+ * word has a count of how often it was accepted as a completion; more used words
+ * are suggested first.
+ */
 export declare class WordIndex {
     private readonly words;
-    constructor(words: Iterable<string>);
+    private readonly counts;
+    constructor(words: Iterable<string>, counts?: Record<string, number>);
     /**
      * Completions for a prefix: words that start with it (other than the prefix
-     * itself), shortest first, then alphabetical. Only the first `scanLimit`
-     * matches are considered, so a one-letter prefix stays quick.
+     * itself), most accepted first, then shortest, then alphabetical. Only the first
+     * `scanLimit` matches of the sorted words are scanned, so a one-letter prefix stays
+     * quick; words with a count are always considered.
      */
     complete(prefix: string, limit?: number, scanLimit?: number): string[];
+    private countOf;
     private lowerBound;
 }
 //# sourceMappingURL=wordIndex.d.ts.map

package/dist/autocomplete/wordIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wordIndex.d.ts","sourceRoot":"","sources":["../../src/autocomplete/wordIndex.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;gBAErB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC;IAInC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,SAAI,EAAE,SAAS,SAAM,GAAG,MAAM,EAAE;IAY9D,OAAO,CAAC,UAAU;CAUnB"}
+{"version":3,"file":"wordIndex.d.ts","sourceRoot":"","sources":["../../src/autocomplete/wordIndex.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;gBAEjC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM;IAKxE;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,SAAI,EAAE,SAAS,SAAM,GAAG,MAAM,EAAE;IAgB9D,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,UAAU;CAUnB"}

package/dist/autocomplete/wordIndex.js

@@ -1,26 +1,40 @@
-/** Words sorted once, so every prefix lookup is a binary search rather than a scan. */
+/**
+ * Completion words, sorted once so every prefix lookup is a binary search. Each
+ * word has a count of how often it was accepted as a completion; more used words
+ * are suggested first.
+ */
 export class WordIndex {
-    constructor(words) {
-        this.words = [...new Set(words)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    constructor(words, counts = {}) {
+        this.counts = new Map(Object.entries(counts));
+        this.words = [...new Set([...words, ...this.counts.keys()])].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
     }
     /**
      * Completions for a prefix: words that start with it (other than the prefix
-     * itself), shortest first, then alphabetical. Only the first `scanLimit`
-     * matches are considered, so a one-letter prefix stays quick.
+     * itself), most accepted first, then shortest, then alphabetical. Only the first
+     * `scanLimit` matches of the sorted words are scanned, so a one-letter prefix stays
+     * quick; words with a count are always considered.
      */
     complete(prefix, limit = 5, scanLimit = 500) {
         if (prefix === '')
             return [];
-        const matches = [];
-        for (let i = this.lowerBound(prefix); i < this.words.length && matches.length < scanLimit; i++) {
+        const candidates = new Set();
+        for (let i = this.lowerBound(prefix), scanned = 0; i < this.words.length && scanned < scanLimit; i++) {
             const word = this.words[i];
             if (!word.startsWith(prefix))
                 break;
             if (word !== prefix)
-                matches.push(word);
+                candidates.add(word);
+            scanned += 1;
         }
-        matches.sort((a, b) => a.length - b.length || (a < b ? -1 : a > b ? 1 : 0));
-        return matches.slice(0, limit);
+        for (const word of this.counts.keys())
+            if (word !== prefix && word.startsWith(prefix))
+                candidates.add(word);
+        return [...candidates]
+            .sort((a, b) => (this.countOf(b) - this.countOf(a)) || a.length - b.length || (a < b ? -1 : a > b ? 1 : 0))
+            .slice(0, limit);
+    }
+    countOf(word) {
+        return this.counts.get(word) ?? 0;
     }
     lowerBound(prefix) {
         let low = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inshapardaz/likhari-react",
-  "version": "0.1.25-dev.226",
+  "version": "0.1.25-dev.230",
   "description": "React implementation of the Likhari editor, built on @lexical/react.",
   "license": "MIT",
   "repository": {