perf: Micro-optimize hot path redundant calculations

Author: noatdk

ext/js/dictionary/dictionary-database.js

@@ -336,7 +336,14 @@ export class DictionaryDatabase {
             const indexNames = isSuffix ? ['expressionReverse', 'readingReverse'] : ['expression', 'reading'];
             const query = isSuffix ? this._createBoundQuery2(anchor) : this._createBoundQuery1(anchor);
             // Reverse-index scan needs the pattern in reversed key space; guard hits with the forward matcher.
-            const scanPattern = isSuffix ? this._reverseMaskedSubPattern(pattern, anchor) : pattern;
+            let scanPattern = pattern;
+            if (isSuffix) {
+                let lastMask = -1;
+                for (let i = 0; i < pattern.isMask.length; ++i) {
+                    if (pattern.isMask[i]) { lastMask = i; }
+                }
+                scanPattern = this._reverseMaskedSubPattern(pattern, lastMask + [...anchor].length + 1);
+            }
             /** @type {?(key: string) => boolean} */
             const recordGuard = isSuffix ? (key) => keyMatcher(stringReverse(key)) : null;
 
@@ -366,19 +373,13 @@ export class DictionaryDatabase {
     }
 
     /**
-     * Reverses the masks-plus-anchor slice (positions `0 .. lastMask + anchorLength`) of a forward pattern
-     * into reverse-index key space for a suffix scan.
+     * Reverses the masks-plus-anchor slice of a forward pattern into reverse-index key space for a suffix scan.
      * @param {import('dictionary-database').MaskedPattern} pattern Forward masked pattern.
-     * @param {string} anchor
+     * @param {number} subLength Length of the prefix to reverse.
      * @returns {import('dictionary-database').MaskedPattern}
      */
-    _reverseMaskedSubPattern(pattern, anchor) {
+    _reverseMaskedSubPattern(pattern, subLength) {
         const {chars, isMask} = pattern;
-        let lastMask = -1;
-        for (let i = 0; i < isMask.length; ++i) {
-            if (isMask[i]) { lastMask = i; }
-        }
-        const subLength = lastMask + 1 + [...anchor].length;
         return {
             chars: chars.slice(0, subLength).reverse(),
             isMask: isMask.slice(0, subLength).reverse(),
@@ -398,6 +399,10 @@ export class DictionaryDatabase {
             const isSuffix = (matchType === 'suffix');
             const indexNames = isSuffix ? ['expressionReverse', 'readingReverse'] : ['expression', 'reading'];
             const query = isSuffix ? this._createBoundQuery2(anchor) : this._createBoundQuery1(anchor);
+            /** @type {(key: IDBValidKey) => string} */
+            const keyNormalizer = isSuffix ?
+                (key) => stringReverse(/** @type {string} */ (key)) :
+                (key) => /** @type {string} */ (key);
 
             const transaction = this._db.transaction(['terms'], 'readonly');
             const objectStore = transaction.objectStore('terms');
@@ -409,7 +414,7 @@ export class DictionaryDatabase {
             for (let j = 0; j < indexNames.length; ++j) {
                 const indexIndex = j;
                 /** @type {(key: IDBValidKey) => boolean} */
-                const keyPredicate = (key) => keyMatcher(isSuffix ? stringReverse(/** @type {string} */ (key)) : /** @type {string} */ (key));
+                const keyPredicate = (key) => keyMatcher(keyNormalizer(key));
                 /** @type {(primaryKeys: IDBValidKey[]) => void} */
                 const onKeys = (primaryKeys) => {
                     for (const primaryKey of primaryKeys) {