web-doc 0.5.0 → 0.6.1

package/dist/search-text.js

@@ -0,0 +1,44 @@
+export function normalizeSearchText(text, caseSensitive = false) {
+    const normalized = text.normalize("NFKC");
+    return caseSensitive ? normalized : unicodeCaseFold(normalized);
+}
+export function normalizeWithMap(text, caseSensitive) {
+    const output = [];
+    const starts = [];
+    const ends = [];
+    const segments = graphemeSegments(text);
+    for (const segment of segments) {
+        const normalized = normalizeSearchText(segment.value, caseSensitive);
+        output.push(normalized);
+        for (let index = 0; index < normalized.length; index += 1) {
+            starts.push(segment.start);
+            ends.push(segment.end);
+        }
+    }
+    return { text: output.join(""), starts, ends };
+}
+export function graphemeSegments(text) {
+    if (typeof Intl.Segmenter === "function") {
+        const segmenter = new Intl.Segmenter(undefined, {
+            granularity: "grapheme",
+        });
+        return [...segmenter.segment(text)].map((segment) => ({
+            value: segment.segment,
+            start: segment.index,
+            end: segment.index + segment.segment.length,
+        }));
+    }
+    const result = [];
+    let offset = 0;
+    for (const value of text) {
+        result.push({ value, start: offset, end: offset + value.length });
+        offset += value.length;
+    }
+    return result;
+}
+function unicodeCaseFold(text) {
+    return text
+        .toLocaleLowerCase("und")
+        .replaceAll("ß", "ss")
+        .replaceAll("ς", "σ");
+}

package/dist/viewer.js

@@ -3,6 +3,7 @@ import { detectFormat } from "./detect.js";
 import { abortError, normalizeError, ViewerError } from "./errors.js";
 import { cellRangeToTsv, cellRangesToTsv, findNormalizedMatches, normalizeCellRange, } from "./interaction.js";
 import { findFuzzyPageMatches, nearestMatchIndex, pagesNearestFirst, resolveFuzzySearchOptions, } from "./fuzzy-search.js";
+import { FuzzyWorkerClient } from "./fuzzy-worker-client.js";
 import { enforceContainerLimits, resolveLimits } from "./limits.js";
 import { loadDocumentSource } from "./source.js";
 import { AdaptiveViewport } from "./viewport.js";
@@ -31,6 +32,12 @@ export class DocumentViewer {
     #activeSearch;
     #selection = null;
     #searchResult = null;
+    /** Off-thread fuzzy matcher holding the current document's index. */
+    #fuzzyWorker;
+    /** Which pages/options the worker's index was built from; rebuilt on change. */
+    #fuzzyIndexKey;
+    /** Set once the worker failed to start, so the main thread takes over for good. */
+    #fuzzyWorkerUnavailable = false;
     #generation = 0;
     #searchGeneration = 0;
     #viewEventScheduled = false;
@@ -411,26 +418,37 @@ export class DocumentViewer {
                 matches.push(...findNormalizedMatches(text, cleanQuery, pageIndex, caseSensitive));
             }
             if (matches.length === 0 && fuzzy) {
-                // The page texts are already in memory, so the fallback is CPU only.
-                // Pages are compared nearest to the hint first, a batch at a time,
-                // and the scan stops at the first batch that holds the passage; a
-                // yield between batches keeps a long document from freezing the UI.
                 // With a hint the passage sits near it, so only that neighbourhood is
                 // worth the fuzzy cost; without one every page is a candidate.
                 const order = pagesNearestFirst(firstPage, lastPage, nearPage).slice(0, nearPage === undefined ? undefined : fuzzy.pageWindow);
-                for (let offset = 0; offset < order.length && matches.length === 0; offset += fuzzy.pagesPerBatch) {
-                    if (offset > 0)
-                        await yieldToEventLoop();
-                    if (controller.signal.aborted)
-                        throw abortError();
-                    const batch = order
-                        .slice(offset, offset + fuzzy.pagesPerBatch)
-                        .map((pageIndex) => ({
-                        pageIndex,
-                        text: texts.get(pageIndex) ?? "",
-                    }));
-                    matches.push(...findFuzzyPageMatches(batch, cleanQuery, fuzzy, caseSensitive));
-                }
+                const pattern = cleanQuery.slice(0, fuzzy.maxQueryLength);
+                const pages = [];
+                for (const [pageIndex, text] of texts)
+                    pages.push({ pageIndex, text });
+                const offThread = fuzzy.worker
+                    ? await this.#searchFuzzyInWorker(pages, pattern, order, fuzzy, caseSensitive, controller.signal)
+                    : undefined;
+                if (offThread)
+                    matches.push(...offThread);
+                else
+                    for (let offset = 0; offset < order.length && matches.length === 0; offset += fuzzy.pagesPerBatch) {
+                        // The page texts are already in memory, so the fallback is CPU
+                        // only. Pages are compared nearest to the hint first, a batch at
+                        // a time, and the scan stops at the first batch that holds the
+                        // passage; a yield between batches keeps a long document from
+                        // freezing the UI.
+                        if (offset > 0)
+                            await yieldToEventLoop();
+                        if (controller.signal.aborted)
+                            throw abortError();
+                        const batch = order
+                            .slice(offset, offset + fuzzy.pagesPerBatch)
+                            .map((pageIndex) => ({
+                            pageIndex,
+                            text: texts.get(pageIndex) ?? "",
+                        }));
+                        matches.push(...findFuzzyPageMatches(batch, pattern, fuzzy, caseSensitive));
+                    }
                 if (matches.length > 0)
                     strategy = "fuzzy";
             }
@@ -454,6 +472,56 @@ export class DocumentViewer {
                 this.#activeSearch = undefined;
         }
     }
+    /**
+     * Fuzzy scan in the worker. The document's pages are indexed once per
+     * (range, options) and reused by every search until the document closes;
+     * `undefined` hands the scan back to the main thread when the worker is
+     * unavailable or failed, so a missing worker asset degrades to slowness,
+     * never to a lost match.
+     */
+    async #searchFuzzyInWorker(pages, pattern, pageIndices, fuzzy, caseSensitive, signal) {
+        if (this.#fuzzyWorkerUnavailable)
+            return undefined;
+        try {
+            this.#fuzzyWorker ??= FuzzyWorkerClient.create(this.#fuzzyWorkerUrl());
+            if (!this.#fuzzyWorker) {
+                this.#fuzzyWorkerUnavailable = true;
+                return undefined;
+            }
+            const key = `${pages.map((page) => page.pageIndex).join(",")}|${fuzzy.threshold}|${fuzzy.maxPageTextLength}|${caseSensitive}`;
+            if (this.#fuzzyIndexKey !== key) {
+                this.#fuzzyIndexKey = undefined;
+                await this.#fuzzyWorker.index(pages, {
+                    threshold: fuzzy.threshold,
+                    maxPageTextLength: fuzzy.maxPageTextLength,
+                    caseSensitive,
+                });
+                this.#fuzzyIndexKey = key;
+            }
+            const matches = await this.#fuzzyWorker.search(pattern, fuzzy.maxScore, pageIndices);
+            if (signal.aborted)
+                throw abortError();
+            return matches;
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            this.#runtime.logger?.warn?.("Fuzzy search worker unavailable; matching on the main thread", { message: error instanceof Error ? error.message : String(error) });
+            this.#dropFuzzyWorker();
+            this.#fuzzyWorkerUnavailable = true;
+            return undefined;
+        }
+    }
+    #fuzzyWorkerUrl() {
+        return this.#runtime.assetBaseUrl
+            ? new URL("workers/fuzzy-search-worker.js", this.#runtime.assetBaseUrl)
+            : new URL("./workers/fuzzy-search-worker.js", import.meta.url);
+    }
+    #dropFuzzyWorker() {
+        this.#fuzzyWorker?.terminate();
+        this.#fuzzyWorker = undefined;
+        this.#fuzzyIndexKey = undefined;
+    }
     searchNext() {
         return this.#moveSearch(1);
     }
@@ -721,6 +789,7 @@ export class DocumentViewer {
         this.#activeSearch?.abort();
         this.#activeSearch = undefined;
         this.#searchResult = null;
+        this.#dropFuzzyWorker();
         this.#selection = null;
         this.#textMaps.clear();
         this.#textMapBytes = 0;