Search improvements. Code refactoring so its easier to maintain. Experimental features for speed dial: connect/disconnect from printer.

resources/web/js/fuzzy-search.js

@@ -34,24 +34,44 @@ function NormText(text, caseSensitive) {
 // Match a PRE-normalized haystack against a PRE-normalized needle (both produced by NormText with the
 // same caseSensitive flag). Skipping the per-character fold makes repeated matching (per keystroke over a
 // cached pool) cheap. Returns ranges in original coordinates, or null on no match.
+// Prefers the most-contiguous (smallest-span) occurrence over greedy-leftmost: a scattered match that
+// spans a stray earlier character is worse than a tight run later, so "orient" against a normalized
+// "auto-orient" returns [[5,11]] (the word) not [[3,4],[6,11]]. A fully contiguous run is the optimum
+// and short-circuits early.
 function FuzzyRangesNorm(haystackNorm, needleNorm) {
   const t = haystackNorm || "";
   const needle = needleNorm || "";
   if (!needle)
     return null;
-  const ranges = [];
-  let qi = 0;
-  for (let i = 0; i < t.length && qi < needle.length; i++) {
-    if (t[i] === needle[qi]) {
-      const last = ranges[ranges.length - 1];
-      if (last && last[1] === i)
-        last[1] = i + 1;
-      else
-        ranges.push([i, i + 1]);
-      qi++;
+  const n = t.length, nl = needle.length;
+  let best = null; // {ranges, span, start}
+  for (let start = 0; start < n; start++) {
+    if (t[start] !== needle[0])
+      continue;
+    let qi = 0;
+    const ranges = [];
+    let lastEnd = start;
+    for (let i = start; i < n && qi < nl; i++) {
+      if (t[i] === needle[qi]) {
+        const last = ranges[ranges.length - 1];
+        if (last && last[1] === i)
+          last[1] = i + 1;
+        else
+          ranges.push([i, i + 1]);
+        lastEnd = i + 1;
+        qi++;
+      }
+    }
+    if (qi !== nl)
+      continue;
+    const span = lastEnd - start;
+    if (!best || span < best.span || (span === best.span && start < best.start)) {
+      best = { ranges, span, start };
+      if (span === nl)
+        return ranges; // can't beat a fully contiguous run
     }
   }
-  return qi === needle.length ? ranges : null;
+  return best ? best.ranges : null;
 }
 
 function EscapeRegExp(value) {
@@ -95,3 +115,18 @@ function WholeWordRanges(text, query, caseSensitive) {
     ranges.push([match.index, match.index + match[0].length]);
   return ranges.length > 0 ? ranges : null;
 }
+
+// Same whole-word (\b-bounded) match as WholeWordRanges, but against PRE-normalized haystack/needle
+// (NormText output, so offsets stay length-aligned to the original text). Returns the first match as
+// [[i, i+len]] in original coordinates, or null. Non-global so the caller can reuse one compiled regex
+// across many fields without re-setting lastIndex. Skipping the per-char fold keeps the Speed Dial's
+// per-keystroke scan over thousands of cached settings cheap.
+function WholeWordRangesNorm(haystackNorm, needleNorm) {
+  const t = haystackNorm || "";
+  const needle = needleNorm || "";
+  if (!needle)
+    return null;
+  const re = new RegExp(`\\b${EscapeRegExp(needle)}\\b`);
+  const match = re.exec(t);
+  return match ? [[match.index, match.index + match[0].length]] : null;
+}

resources/web/js/fuzzy-search.test.js

@@ -5,7 +5,7 @@ const vm = require("vm"), assert = require("assert"), fs = require("fs");
 const ctx = {};
 vm.createContext(ctx);
 vm.runInContext(fs.readFileSync(__dirname + "/fuzzy-search.js", "utf8"), ctx);
-const { FoldChar, Norm, EscapeRegExp, FuzzyRanges, WholeWordRanges } = ctx;
+const { FoldChar, Norm, NormText, EscapeRegExp, FuzzyRanges, WholeWordRanges, FuzzyRangesNorm, WholeWordRangesNorm } = ctx;
 
 // FoldChar / Norm: accents fold, case only folds when case-insensitive.
 assert.equal(FoldChar("é"), "e");
@@ -34,4 +34,15 @@ assert.deepEqual(WholeWordRanges("a.b", "a", false), [[0, 1]]);      // '.' is a
 assert.equal(EscapeRegExp("a.b*"), "a\\.b\\*");
 assert.deepEqual(WholeWordRanges("c++ tool", "c", false), [[0, 1]]); // '+' would be a regex error unescaped
 
+// FuzzyRangesNorm: prefers the most-contiguous (smallest-span) occurrence over greedy-leftmost, so a
+// stray earlier character does not steal the highlight from a later tight word.
+assert.deepEqual(FuzzyRangesNorm(NormText("Auto-Orient", false), NormText("orient", false)), [[5, 11]]);
+// A contiguous run inside a larger word is also preferred over a scattered greedy pick.
+assert.deepEqual(FuzzyRangesNorm(NormText("AutoOriented", false), NormText("orient", false)), [[4, 10]]);
+assert.equal(FuzzyRangesNorm(NormText("Measure", false), NormText("xyz", false)), null); // no subsequence
+
+// WholeWordRangesNorm: \b-bounded literal against a pre-normalized haystack, offsets in original coords.
+assert.deepEqual(WholeWordRangesNorm(NormText("Auto-Orient", false), NormText("orient", false)), [[5, 11]]);
+assert.equal(WholeWordRangesNorm(NormText("AutoOriented", false), NormText("orient", false)), null); // inside a word
+
 console.log("ok");