web-doc 0.4.0 → 0.6.0

package/dist/spreadsheet-viewport.d.ts

@@ -24,6 +24,8 @@ export declare class SpreadsheetViewport {
     setDocument(info: DocumentInfo | undefined): void;
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
+    /** Sheet matches are cell-addressed; the sheet viewport scrolls per cell already. */
+    revealMatch(): Promise<void>;
     goToPage(pageIndex: number): void;
     fitWidth(): number;
     fitPage(): number;

package/dist/spreadsheet-viewport.js

@@ -241,6 +241,8 @@ export class SpreadsheetViewport {
         this.#reportPan();
         this.schedule();
     }
+    /** Sheet matches are cell-addressed; the sheet viewport scrolls per cell already. */
+    async revealMatch() { }
     goToPage(pageIndex) {
         if (pageIndex === this.#sheetIndex)
             return;

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,24 +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.
-                const order = pagesNearestFirst(firstPage, lastPage, nearPage);
-                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));
-                }
+                // 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);
+                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";
             }
@@ -442,7 +462,7 @@ export class DocumentViewer {
             });
             this.#searchResult = result;
             if (result.activeIndex >= 0)
-                this.#goToPage(result.matches[result.activeIndex].pageIndex, true);
+                this.#revealSearchMatch(result.matches[result.activeIndex]);
             this.#emit("searchchange", result);
             this.#viewport?.update();
             return result;
@@ -452,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);
     }
@@ -683,11 +753,16 @@ export class DocumentViewer {
             current.matches.length;
         const result = immutableSearchResult({ ...current, activeIndex });
         this.#searchResult = result;
-        this.#goToPage(result.matches[activeIndex].pageIndex, true);
+        this.#revealSearchMatch(result.matches[activeIndex]);
         this.#emit("searchchange", result);
         this.#viewport?.update();
         return result;
     }
+    /** Land on the match's page, then bring the match itself into view. */
+    #revealSearchMatch(match) {
+        this.#goToPage(match.pageIndex, true);
+        void this.#viewport?.revealMatch(match);
+    }
     #goToPage(pageIndex, scrollViewport) {
         this.#assertAlive();
         const upperBound = Math.max(0, this.#state.pageCount - 1);
@@ -714,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;

package/dist/viewport.d.ts

@@ -18,6 +18,7 @@ interface ViewportStrategy {
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     goToPage(pageIndex: number): void;
+    revealMatch(match: SearchMatch): Promise<void>;
     fitWidth(): number;
     fitPage(): number;
     destroy(): void;
@@ -32,6 +33,7 @@ export declare class AdaptiveViewport implements ViewportStrategy {
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     goToPage(pageIndex: number): void;
+    revealMatch(match: SearchMatch): Promise<void>;
     fitWidth(): number;
     fitPage(): number;
     destroy(): void;
@@ -46,6 +48,13 @@ export declare class ViewerViewport {
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     goToPage(pageIndex: number): void;
+    /**
+     * Scroll so the match itself is in view, not just its page: a page can be
+     * taller than the viewport, and a search that only lands on the page top
+     * leaves a match further down invisible until the reader scrolls. Resolves
+     * once the text runs are known; a navigation that happened meanwhile wins.
+     */
+    revealMatch(match: SearchMatch): Promise<void>;
     fitWidth(): number;
     fitPage(): number;
     schedule(): void;

package/dist/viewport.js

@@ -1,8 +1,11 @@
+import { matchTopInPage, revealScrollTop } from "./search-reveal.js";
 import { snapGraphemeOffset } from "./interaction.js";
 import { SpreadsheetViewport } from "./spreadsheet-viewport.js";
 const BASE_WIDTH = 816;
 const BASE_HEIGHT = 1056;
 const PAGE_GAP = 24;
+/** Page slots sit this far inside the spacer (top and left). */
+const SLOT_INSET = 12;
 export class AdaptiveViewport {
     #container;
     #host;
@@ -36,6 +39,9 @@ export class AdaptiveViewport {
     goToPage(pageIndex) {
         this.#strategy.goToPage(pageIndex);
     }
+    revealMatch(match) {
+        return this.#strategy.revealMatch(match);
+    }
     fitWidth() {
         return this.#strategy.fitWidth();
     }
@@ -154,6 +160,36 @@ export class ViewerViewport {
         }
         this.schedule();
     }
+    /**
+     * Scroll so the match itself is in view, not just its page: a page can be
+     * taller than the viewport, and a search that only lands on the page top
+     * leaves a match further down invisible until the reader scrolls. Resolves
+     * once the text runs are known; a navigation that happened meanwhile wins.
+     */
+    async revealMatch(match) {
+        if (this.#layout !== "continuous" || !this.#info)
+            return;
+        let runs;
+        try {
+            runs = await this.#host.getTextRuns(match.pageIndex);
+        }
+        catch {
+            return;
+        }
+        if (this.#destroyed || this.#host.state.pageIndex !== match.pageIndex)
+            return;
+        const top = matchTopInPage(runs, match);
+        if (top === undefined)
+            return;
+        const zoom = this.#host.state.zoom;
+        const metrics = pageMetrics(this.#info, zoom);
+        this.#root.scrollTop = revealScrollTop({
+            pageTop: metrics.offsets[match.pageIndex] ?? 0,
+            matchTop: SLOT_INSET + top * zoom,
+            viewportHeight: this.#root.clientHeight,
+        });
+        this.schedule();
+    }
     fitWidth() {
         const size = naturalPageSize(this.#info, this.#host.state.pageIndex);
         return Math.max(0.1, Math.min(8, (this.#root.clientWidth - 24) / size.width));
@@ -217,7 +253,9 @@ export class ViewerViewport {
             const slot = this.#slots.get(pageIndex) ?? this.#createSlot(pageIndex);
             const width = metrics.widths[pageIndex] ?? BASE_WIDTH * state.zoom;
             const height = metrics.heights[pageIndex] ?? BASE_HEIGHT * state.zoom;
-            const top = this.#layout === "single" ? 12 : (metrics.offsets[pageIndex] ?? 0) + 12;
+            const top = this.#layout === "single"
+                ? SLOT_INSET
+                : (metrics.offsets[pageIndex] ?? 0) + SLOT_INSET;
             const contentWidth = Math.max(this.#root.clientWidth, metrics.maxWidth + 24);
             slot.root.style.top = `${top}px`;
             slot.root.style.left = `${Math.max(12, (contentWidth - width) / 2)}px`;