web-doc 0.6.2 → 0.8.0

package/dist/viewport.js

@@ -30,6 +30,19 @@ export class AdaptiveViewport {
         }
         this.#strategy.setDocument(info);
     }
+    replaceDocument(info, changedPages, revision) {
+        const nextKind = info.unit === "sheet" ? "sheet" : "page";
+        if (nextKind !== this.#kind)
+            this.setDocument(info);
+        else
+            this.#strategy.replaceDocument(info, changedPages, revision);
+    }
+    pageToClient(pageIndex, rect) {
+        return this.#strategy.pageToClient(pageIndex, rect);
+    }
+    clientToPage(clientX, clientY) {
+        return this.#strategy.clientToPage(clientX, clientY);
+    }
     update() {
         this.#strategy.update();
     }
@@ -70,6 +83,13 @@ export class ViewerViewport {
     #onSelectionChange = () => this.#handleSelectionChange();
     #pointers = new Map();
     #info;
+    /** Per page: grows when that page's content changed, so only it re-renders. */
+    #pageRevisions = [];
+    /** The session revision the shown content belongs to; 0 before any edit. */
+    #contentRevision = 0;
+    /** Pages painted since the last `onPainted`, keyed by content revision. */
+    #painted = new Map();
+    #paintedFlush = 0;
     #frame = 0;
     #resizeObserver;
     #destroyed = false;
@@ -126,11 +146,90 @@ export class ViewerViewport {
     }
     setDocument(info) {
         this.#info = info;
+        this.#pageRevisions = [];
+        this.#contentRevision = 0;
+        this.#painted.clear();
         this.#appliedZoom = this.#host.state.zoom;
         this.#root.scrollTo({ left: 0, top: 0 });
         this.#clearSlots();
         this.schedule();
     }
+    replaceDocument(info, changedPages, revision) {
+        const previous = this.#info;
+        this.#info = info;
+        this.#contentRevision = revision ?? this.#contentRevision + 1;
+        // Only pages whose content or size changed get a new render key; the
+        // others keep their bitmaps. A changed page count shifts everything
+        // from the first changed page on.
+        const countChanged = previous?.pageCount !== info.pageCount;
+        const from = changedPages === undefined
+            ? 0
+            : countChanged
+                ? Math.min(...changedPages, info.pageCount)
+                : Number.POSITIVE_INFINITY;
+        const changed = new Set(changedPages ?? []);
+        for (let pageIndex = 0; pageIndex < info.pageCount; pageIndex += 1) {
+            const size = info.pageSizes?.[pageIndex];
+            const before = previous?.pageSizes?.[pageIndex];
+            const resized = size?.width !== before?.width || size?.height !== before?.height;
+            if (pageIndex >= from || changed.has(pageIndex) || resized)
+                this.#pageRevisions[pageIndex] =
+                    (this.#pageRevisions[pageIndex] ?? 0) + 1;
+        }
+        // Slots stay mounted and repaint in place; the browser clamps the scroll
+        // position itself once the spacer takes the new document's height.
+        this.schedule();
+    }
+    pageToClient(pageIndex, rect) {
+        const page = this.#mountedPage(pageIndex);
+        if (!page)
+            return undefined;
+        return {
+            left: page.left + rect.x * page.scale,
+            top: page.top + rect.y * page.scale,
+            width: rect.width * page.scale,
+            height: rect.height * page.scale,
+        };
+    }
+    clientToPage(clientX, clientY) {
+        for (const pageIndex of this.#slots.keys()) {
+            const page = this.#mountedPage(pageIndex);
+            if (!page ||
+                clientX < page.left ||
+                clientX >= page.left + page.width ||
+                clientY < page.top ||
+                clientY >= page.top + page.height)
+                continue;
+            return {
+                pageIndex,
+                point: {
+                    x: (clientX - page.left) / page.scale,
+                    y: (clientY - page.top) / page.scale,
+                },
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Client-space box of a mounted page and its page-space scale, read from
+     * the DOM so it matches what is painted rather than what is scheduled.
+     */
+    #mountedPage(pageIndex) {
+        const slot = this.#slots.get(pageIndex);
+        if (!slot || !this.#info)
+            return undefined;
+        const box = slot.root.getBoundingClientRect();
+        const natural = naturalPageSize(this.#info, pageIndex);
+        if (box.width <= 0 || box.height <= 0)
+            return undefined;
+        return {
+            left: box.left,
+            top: box.top,
+            width: box.width,
+            height: box.height,
+            scale: box.width / natural.width,
+        };
+    }
     update() {
         const zoom = this.#host.state.zoom;
         if (this.#info &&
@@ -198,6 +297,28 @@ export class ViewerViewport {
         const size = naturalPageSize(this.#info, this.#host.state.pageIndex);
         return Math.max(0.1, Math.min(8, (this.#root.clientWidth - 24) / size.width, (this.#root.clientHeight - 24) / size.height));
     }
+    /** Collects finished paints and reports them once per frame, newest content only. */
+    #markPainted(pageIndex, contentRevision) {
+        if (contentRevision !== this.#contentRevision)
+            return;
+        let pages = this.#painted.get(contentRevision);
+        if (!pages) {
+            pages = new Set();
+            this.#painted.clear();
+            this.#painted.set(contentRevision, pages);
+        }
+        pages.add(pageIndex);
+        if (this.#paintedFlush)
+            return;
+        this.#paintedFlush = requestAnimationFrame(() => {
+            this.#paintedFlush = 0;
+            const current = this.#painted.get(this.#contentRevision);
+            this.#painted.clear();
+            if (!current || current.size === 0 || this.#destroyed)
+                return;
+            this.#host.onPainted([...current].sort((a, b) => a - b), this.#contentRevision);
+        });
+    }
     schedule() {
         if (this.#destroyed || this.#frame)
             return;
@@ -212,6 +333,8 @@ export class ViewerViewport {
         this.#destroyed = true;
         if (this.#frame)
             cancelAnimationFrame(this.#frame);
+        if (this.#paintedFlush)
+            cancelAnimationFrame(this.#paintedFlush);
         if (this.#zoomSettleTimer)
             clearTimeout(this.#zoomSettleTimer);
         this.#resizeObserver?.disconnect();
@@ -266,7 +389,7 @@ export class ViewerViewport {
                 .getSearchMatches(pageIndex)
                 .map((match) => `${match.start}:${match.end}`)
                 .join(",");
-            const renderKey = `${state.zoom}:${window.devicePixelRatio || 1}:${highlights}`;
+            const renderKey = `${this.#pageRevisions[pageIndex] ?? 0}:${state.zoom}:${window.devicePixelRatio || 1}:${highlights}`;
             if (slot.renderKey === undefined ||
                 (!this.#zoomGestureActive && slot.renderKey !== renderKey)) {
                 slot.renderKey = renderKey;
@@ -320,6 +443,7 @@ export class ViewerViewport {
         slot.controller = controller;
         const generation = ++slot.generation;
         const zoom = this.#host.state.zoom;
+        const contentRevision = this.#contentRevision;
         try {
             let renderError;
             const rendering = this.#host
@@ -347,6 +471,7 @@ export class ViewerViewport {
             const cssHeight = slot.canvas.height / (window.devicePixelRatio || 1);
             slot.root.style.width = `${cssWidth}px`;
             slot.root.style.height = `${cssHeight}px`;
+            this.#markPainted(pageIndex, contentRevision);
         }
         catch (error) {
             if (!controller.signal.aborted) {

package/dist/worker-protocol.d.ts

@@ -1,5 +1,9 @@
 import type { DocumentFormat, DocumentInfo, ResourceLimits, TextRun, ViewerErrorData, ViewerProgress, ViewerWarning } from "./contracts.js";
-export type WorkerOperation = "init" | "open" | "get-info" | "render" | "get-text-map" | "close" | "destroy";
+import type { EditableFormat } from "./edit/types.js";
+export type DocumentWorkerOperation = "init" | "open" | "get-info" | "render" | "get-text-map" | "close" | "destroy";
+/** Operations of an edit engine worker; payloads mirror the engine interface. */
+export type EditWorkerOperation = "edit-init" | "edit-open" | "edit-validate" | "edit-apply" | "edit-materialize" | "edit-restore" | "edit-put-asset" | "edit-elements" | "edit-element" | "edit-elements-at" | "edit-find-text" | "edit-text-layout" | "edit-position-at" | "edit-range-rects" | "edit-render-without" | "edit-page-layout" | "edit-pptx-slides" | "edit-pptx-layouts" | "edit-docx-revisions" | "edit-dispose";
+export type WorkerOperation = DocumentWorkerOperation | EditWorkerOperation;
 export interface WorkerRequest {
     readonly kind: "request";
     readonly id: number;
@@ -44,5 +48,38 @@ export interface WorkerRenderPayload {
     readonly zoom: number;
     readonly devicePixelRatio: number;
 }
-export type WorkerOperationResult = DocumentInfo | readonly TextRun[] | ImageBitmap | ArrayBuffer | undefined;
+export interface EditWorkerInitPayload {
+    /** Where the worker fetches the engine's WebAssembly from. */
+    readonly wasmUrl: string;
+    /** TrueType font for text the standard PDF fonts cannot encode. */
+    readonly fallbackFontUrl?: string;
+}
+/** A host-registered font as the edit worker receives it. */
+export interface EditWorkerFont {
+    readonly family: string;
+    readonly weight: number;
+    readonly style: "normal" | "italic" | "oblique";
+    /** Font bytes, or an absolute URL the worker fetches on first use. */
+    readonly source: ArrayBuffer | string;
+}
+export interface EditWorkerOpenPayload {
+    readonly data: ArrayBuffer;
+    readonly limits: ResourceLimits;
+    /** The session format; a worker that serves several formats picks its engine by it. */
+    readonly format?: EditableFormat;
+    readonly fileName?: string;
+    readonly fonts?: readonly EditWorkerFont[];
+}
+/** A rendered page as the worker returns it; `data` is transferred, not copied. */
+export interface EditWorkerBitmap {
+    readonly pageIndex: number;
+    readonly scale: number;
+    readonly width: number;
+    readonly height: number;
+    readonly data: ArrayBuffer;
+}
+export interface EditWorkerOpenResult {
+    readonly pageCount: number;
+}
+export type WorkerOperationResult = DocumentInfo | readonly TextRun[] | ImageBitmap | ArrayBuffer | EditWorkerOpenResult | undefined;
 export declare function transferablesFor(value: unknown): Transferable[];

package/dist/workers/fuzzy-search-worker.js

@@ -1634,7 +1634,7 @@ function alignFuzzyPassage(text, query, caseSensitive, maxScore) {
   if (bestEnd <= bestStart || bestCost / length > maxScore) return void 0;
   const start = source.starts[bestStart];
   const end = source.ends[bestEnd - 1];
-  return start === void 0 || end === void 0 ? void 0 : { start, end };
+  return start === void 0 || end === void 0 ? void 0 : { start, end, cost: bestCost, length };
 }
 
 // src/fuzzy-search.ts