web-doc 0.6.2 → 0.8.0

package/dist/pdf-edit-worker.js

@@ -0,0 +1,35 @@
+import { createPdfEditHandler } from "./edit/pdf/engine/handler.js";
+import { Pdfium } from "./edit/pdf/engine/pdfium.js";
+import { attachWorkerEndpoint } from "./worker-endpoint.js";
+/*
+ * Module worker that owns a PDFium instance for one edit session. The WASM is
+ * fetched from the URL the main thread resolved, so hosting the assets
+ * elsewhere (assetBaseUrl) needs no change here.
+ */
+async function fetchBytes(url) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`Fetching ${url} failed with HTTP ${response.status}`);
+    return new Uint8Array(await response.arrayBuffer());
+}
+attachWorkerEndpoint(self, createPdfEditHandler({
+    loadPdfium: async (wasmUrl) => Pdfium.load(await fetchBytes(wasmUrl)),
+    fetchBytes,
+    decodeImage: async (bytes, mimeType) => {
+        const bitmap = await createImageBitmap(new Blob([new Uint8Array(bytes)], { type: mimeType }));
+        try {
+            const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+            const context = canvas.getContext("2d");
+            context.drawImage(bitmap, 0, 0);
+            const { data } = context.getImageData(0, 0, bitmap.width, bitmap.height);
+            return {
+                width: bitmap.width,
+                height: bitmap.height,
+                rgba: new Uint8Array(data.buffer),
+            };
+        }
+        finally {
+            bitmap.close();
+        }
+    },
+}));

package/dist/spreadsheet-viewport.d.ts

@@ -22,6 +22,11 @@ export declare class SpreadsheetViewport {
     #private;
     constructor(container: HTMLElement, host: ViewportHost);
     setDocument(info: DocumentInfo | undefined): void;
+    /** Sheets are not editable yet, so new content is treated as a new document. */
+    replaceDocument(info: DocumentInfo, _changedPages?: readonly number[], _revision?: number): void;
+    /** Sheet geometry is cell-addressed; page-space helpers do not apply. */
+    pageToClient(): undefined;
+    clientToPage(): undefined;
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     /** Sheet matches are cell-addressed; the sheet viewport scrolls per cell already. */

package/dist/spreadsheet-viewport.js

@@ -203,6 +203,17 @@ export class SpreadsheetViewport {
         this.#root.scrollTo({ left: 0, top: 0 });
         this.schedule();
     }
+    /** Sheets are not editable yet, so new content is treated as a new document. */
+    replaceDocument(info, _changedPages, _revision) {
+        this.setDocument(info);
+    }
+    /** Sheet geometry is cell-addressed; page-space helpers do not apply. */
+    pageToClient() {
+        return undefined;
+    }
+    clientToPage() {
+        return undefined;
+    }
     update() {
         if (!this.#info)
             return;

package/dist/ui.js

@@ -120,6 +120,13 @@ export class BasicViewerUi {
             if (!this.#thumbnailPanel.hidden)
                 void this.#renderThumbnails();
             this.#renderSheetTabs();
+        }), viewer.on("documentchange", () => {
+            // Edited content: counters, tabs and thumbnails follow the new document.
+            this.#info = viewer.getDocumentInfo();
+            this.#renderSheetTabs();
+            this.#syncState(viewer.state);
+            if (!this.#thumbnailPanel.hidden)
+                void this.#renderThumbnails();
         }));
         this.root.addEventListener("keydown", this.#onKeyDown);
         document.addEventListener("fullscreenchange", this.#onFullscreenChange);

package/dist/viewer.d.ts

@@ -1,4 +1,6 @@
 import type { CellRange, CellSelection, DocumentInfo, DocumentSource, FitMode, HeadlessRenderOptions, OpenDocumentOptions, ResourceLimits, SearchOptions, SearchResult, SpreadsheetViewportRange, TextSelection, TextSelectionRange, ThumbnailRenderOptions, ViewerApi, ViewerEventListener, ViewerEventMap, ViewerFetch, ViewerLogger, ViewerOptions, ViewerState } from "./contracts.js";
+import type { EditOptions, PageHit, PageRect, ViewportRect } from "./edit/types.js";
+import type { EditSession } from "./edit/sessions.js";
 import type { AdapterRegistry } from "./registry.js";
 import type { FontManager } from "./fonts.js";
 import { RenderScheduler } from "./render-scheduler.js";
@@ -47,6 +49,10 @@ export declare class DocumentViewer implements ViewerApi {
     copySelection(): Promise<string>;
     getOriginalBytes(): Uint8Array | undefined;
     downloadOriginal(fileName?: string): Blob;
+    edit(options?: EditOptions): Promise<EditSession>;
+    getEditSession(): EditSession | undefined;
+    pageToClient(pageIndex: number, rect: PageRect): ViewportRect | undefined;
+    clientToPage(clientX: number, clientY: number): PageHit | undefined;
     on<K extends keyof ViewerEventMap>(type: K, listener: ViewerEventListener<K>): () => void;
     destroy(): Promise<void>;
 }

package/dist/viewer.js

@@ -1,3 +1,4 @@
+import { EditSessionController, } from "./edit/session.js";
 import { linkedAbortController } from "./abort.js";
 import { detectFormat } from "./detect.js";
 import { abortError, normalizeError, ViewerError } from "./errors.js";
@@ -28,6 +29,12 @@ export class DocumentViewer {
     #info;
     #original;
     #originalFileName;
+    #originalContentType;
+    /** Limits the current document was opened with; reused when it is reopened. */
+    #limits;
+    #session;
+    /** Shared by concurrent `edit()` calls while the engine starts. */
+    #sessionStart;
     #activeLoad;
     #activeSearch;
     #selection = null;
@@ -45,6 +52,7 @@ export class DocumentViewer {
     constructor(options, runtime) {
         this.#options = options;
         this.#runtime = runtime;
+        this.#limits = runtime.limits;
         this.#state = freezeState({
             status: "idle",
             pageIndex: 0,
@@ -77,6 +85,7 @@ export class DocumentViewer {
                 onTextSelection: (range) => void this.selectText(range),
                 onCellSelection: (selection) => this.#applyInteractiveCellSelection(selection),
                 getSelectionText: () => this.#getCachedSelectionText(),
+                onPainted: (pages, revision) => this.#onPainted(pages, revision),
             }, options);
         }
     }
@@ -151,31 +160,21 @@ export class DocumentViewer {
                 await adapter.close(handle);
                 throw abortError();
             }
-            if (!Number.isInteger(backendInfo.pageCount) ||
-                backendInfo.pageCount < 1 ||
-                backendInfo.pageCount > limits.maxDocumentUnits) {
+            let info;
+            try {
+                info = describeDocument(adapter, backendInfo, detection.format, limits);
+            }
+            catch (error) {
                 await adapter.close(handle);
-                throw new ViewerError("resource-limit", "Document unit count exceeds the configured limit", {
-                    details: {
-                        pageCount: backendInfo.pageCount,
-                        limit: limits.maxDocumentUnits,
-                    },
-                });
+                throw error;
             }
-            const info = immutableInfo({
-                ...backendInfo,
-                capabilities: {
-                    textSelection: Boolean(adapter.getTextMap),
-                    cellSelection: backendInfo.unit === "sheet",
-                    search: Boolean(adapter.getTextMap),
-                    thumbnails: backendInfo.unit !== "sheet",
-                },
-            });
             this.#adapter = adapter;
             this.#handle = handle;
             this.#info = info;
             this.#original = loaded.bytes;
             this.#originalFileName = fileName;
+            this.#originalContentType = contentType;
+            this.#limits = limits;
             this.#update({
                 status: "ready",
                 format: detection.format,
@@ -671,6 +670,45 @@ export class DocumentViewer {
         }
         return blob;
     }
+    async edit(options = {}) {
+        const { adapter, info } = this.#assertReady();
+        if (this.#session?.core.usable)
+            return this.#session.session;
+        if (this.#sessionStart)
+            return this.#sessionStart;
+        const format = editableFormat(adapter, info.format);
+        if (!format || !adapter.edit)
+            throw new ViewerError("edit-unsupported", "Editing is not available for this document", { details: { format: info.format, reason: "no-engine" } });
+        const start = this.#startSession(adapter.edit, format, options);
+        this.#sessionStart = start;
+        try {
+            return await start;
+        }
+        finally {
+            if (this.#sessionStart === start)
+                this.#sessionStart = undefined;
+        }
+    }
+    getEditSession() {
+        this.#assertAlive();
+        return this.#session?.session;
+    }
+    pageToClient(pageIndex, rect) {
+        this.#assertAlive();
+        if (this.#state.status !== "ready" ||
+            !Number.isInteger(pageIndex) ||
+            ![rect.x, rect.y, rect.width, rect.height].every(Number.isFinite))
+            return undefined;
+        return this.#viewport?.pageToClient(pageIndex, rect);
+    }
+    clientToPage(clientX, clientY) {
+        this.#assertAlive();
+        if (this.#state.status !== "ready" ||
+            !Number.isFinite(clientX) ||
+            !Number.isFinite(clientY))
+            return undefined;
+        return this.#viewport?.clientToPage(clientX, clientY);
+    }
     on(type, listener) {
         this.#assertAlive();
         const listeners = this.#listeners.get(type) ?? new Set();
@@ -700,6 +738,194 @@ export class DocumentViewer {
         this.#listeners.clear();
         this.#runtime.release(this);
     }
+    async #startSession(provider, format, options) {
+        const generation = this.#generation;
+        const operation = this.#startOperation(options.signal);
+        // A session that broke (failed recovery) makes way for a fresh engine.
+        const stale = this.#session;
+        this.#session = undefined;
+        if (stale)
+            await stale.core.end();
+        try {
+            const engine = await provider.load(this.#original.slice(), {
+                format,
+                limits: this.#limits,
+                fonts: this.#runtime.fonts.registered,
+                signal: operation.signal,
+                ...(this.#originalFileName ? { fileName: this.#originalFileName } : {}),
+                ...(this.#runtime.assetBaseUrl
+                    ? { assetBaseUrl: this.#runtime.assetBaseUrl }
+                    : {}),
+            });
+            if (generation !== this.#generation || operation.signal.aborted) {
+                await engine.dispose().catch(() => undefined);
+                throw abortError();
+            }
+            const host = {
+                format,
+                limits: this.#limits,
+                prepareDocument: (bytes, signal) => this.#prepareDocument(bytes, signal),
+                commitDocument: (prepared, changedPages) => this.#commitDocument(prepared, changedPages),
+                discardDocument: (prepared) => this.#discardDocument(prepared),
+                emit: (type, event) => this.#emit(type, event),
+                pageOf: (paragraphId) => {
+                    let first;
+                    for (const [pageIndex, runs] of this.#textMaps)
+                        if ((first === undefined || pageIndex < first) &&
+                            runs.some((run) => run.paragraphId === paragraphId))
+                            first = pageIndex;
+                    return first;
+                },
+            };
+            const core = new EditSessionController(engine, host, this.#original, this.#info.pageCount);
+            const session = provider.createSession(core, {
+                getTextRuns: (pageIndex, signal) => this.#getTextRuns(pageIndex, signal),
+                cachedPages: () => [...this.#textMaps.keys()],
+            });
+            this.#session = { core, session };
+            this.#emit("editstatechange", {
+                ...core.state,
+                active: true,
+                format,
+            });
+            return session;
+        }
+        catch (error) {
+            const normalized = normalizeError(error, "edit-failed");
+            throw normalized.code === "edit-failed" && !normalized.details
+                ? new ViewerError("edit-failed", normalized.message, {
+                    cause: error,
+                    details: { stage: "load" },
+                })
+                : normalized;
+        }
+        finally {
+            this.#finishOperation(operation);
+        }
+    }
+    /**
+     * Shows edited bytes as the current document: opens them through the
+     * adapter, swaps the handle, drops every cache derived from the old content
+     * and keeps the view where it was. Returns the new page count.
+     */
+    /**
+     * Phase one of showing edited bytes: opens them next to the current
+     * document. Everything that can fail or be aborted happens here.
+     */
+    async #prepareDocument(bytes, signal) {
+        const { adapter, handle, info } = this.#assertReady();
+        const generation = this.#generation;
+        enforceContainerLimits(bytes, info.format, this.#limits);
+        const context = {
+            format: info.format,
+            signal,
+            limits: this.#limits,
+            reportProgress: (progress) => this.#emit("progress", progress),
+            reportWarning: (warning) => this.#emit("warning", warning),
+            ...(this.#originalFileName ? { fileName: this.#originalFileName } : {}),
+            ...(this.#originalContentType
+                ? { contentType: this.#originalContentType }
+                : {}),
+            ...(this.#runtime.assetBaseUrl
+                ? { assetBaseUrl: this.#runtime.assetBaseUrl }
+                : {}),
+        };
+        const next = adapter.reopen
+            ? await adapter.reopen(handle, bytes, context)
+            : await adapter.open(bytes, context);
+        let nextInfo;
+        try {
+            if (generation !== this.#generation || signal.aborted)
+                throw abortError();
+            const backendInfo = await adapter.getInfo(next);
+            if (generation !== this.#generation || signal.aborted)
+                throw abortError();
+            nextInfo = describeDocument(adapter, backendInfo, info.format, this.#limits);
+        }
+        catch (error) {
+            await adapter.close(next);
+            throw error;
+        }
+        return {
+            pageCount: nextInfo.pageCount,
+            handle: next,
+            info: nextInfo,
+            generation,
+        };
+    }
+    /**
+     * Phase two: swaps the prepared document in. Synchronous and never throws
+     * for a preparation of the current document, so a session that reached
+     * this point always completes; the old handle is closed in the background.
+     */
+    #commitDocument(prepared, changedPages) {
+        if (prepared.generation !== this.#generation || !this.#handle) {
+            this.#discardDocument(prepared);
+            throw new ViewerError("lifecycle-error", "The document was replaced while an edit was being shown");
+        }
+        const { adapter, handle: previous } = this.#assertReady();
+        this.#handle = prepared.handle;
+        this.#info = prepared.info;
+        this.#invalidateContentCaches();
+        this.#update({
+            pageCount: prepared.info.pageCount,
+            pageIndex: Math.min(this.#state.pageIndex, prepared.info.pageCount - 1),
+        });
+        for (const warning of prepared.info.warnings ?? [])
+            this.#emit("warning", warning);
+        const revision = (this.#session?.core.state.revision ?? 0) + 1;
+        if (this.#viewport)
+            this.#viewport.replaceDocument(prepared.info, changedPages, revision);
+        else
+            // Headless: nothing paints, so geometry is "current" as soon as the
+            // session has emitted documentchange, which happens before the next
+            // macrotask.
+            setTimeout(() => this.#onPainted([...changedPages], revision), 0);
+        void Promise.resolve(adapter.close(previous)).catch((error) => this.#reportError(error));
+        return prepared.info.pageCount;
+    }
+    #discardDocument(prepared) {
+        void Promise.resolve(this.#adapter?.close(prepared.handle)).catch((error) => this.#reportError(error));
+    }
+    /** Painted pages of a content revision become a `layoutchange` while a session is active. */
+    #onPainted(pages, revision) {
+        const session = this.#session;
+        // The viewport reports only paints of its current content, so a revision
+        // the session has not committed yet is the only thing to drop.
+        if (!session || revision > session.core.state.revision)
+            return;
+        this.#emit("layoutchange", {
+            sessionId: session.core.sessionId,
+            revision,
+            pages: Object.freeze([...pages]),
+        });
+    }
+    #reportError(error) {
+        const report = globalThis
+            .reportError;
+        if (report)
+            report(error);
+        else
+            console.error(error);
+    }
+    /** Forgets everything derived from the document's content, not from its view. */
+    #invalidateContentCaches() {
+        this.#textMaps.clear();
+        this.#textMapBytes = 0;
+        // The worker keeps its index; a stale key makes the next search rebuild it.
+        this.#fuzzyIndexKey = undefined;
+        this.#activeSearch?.abort();
+        this.#activeSearch = undefined;
+        this.#searchGeneration += 1;
+        if (this.#searchResult) {
+            this.#searchResult = null;
+            this.#emit("searchchange", null);
+        }
+        if (this.#selection) {
+            this.#selection = null;
+            this.#emit("selectionchange", null);
+        }
+    }
     async #getTextRuns(pageIndex, signal) {
         const { adapter, handle, info } = this.#assertReady();
         assertPageIndex(pageIndex, info.pageCount);
@@ -779,6 +1005,11 @@ export class DocumentViewer {
         this.#update({ panX: x, panY: y });
     }
     async #closeDocument() {
+        const session = this.#session;
+        this.#session = undefined;
+        this.#sessionStart = undefined;
+        if (session)
+            await session.core.end();
         const adapter = this.#adapter;
         const handle = this.#handle;
         this.#adapter = undefined;
@@ -786,6 +1017,7 @@ export class DocumentViewer {
         this.#info = undefined;
         this.#original = undefined;
         this.#originalFileName = undefined;
+        this.#originalContentType = undefined;
         this.#activeSearch?.abort();
         this.#activeSearch = undefined;
         this.#searchResult = null;
@@ -856,9 +1088,51 @@ export class DocumentViewer {
     }
     #emit(type, event) {
         for (const listener of this.#listeners.get(type) ?? [])
-            listener(event);
+            try {
+                listener(event);
+            }
+            catch (error) {
+                // A listener's bug is its own; it never fails the call that emitted.
+                this.#reportError(error);
+            }
     }
 }
+/** The edit format of `format` when `adapter` can edit it. */
+/** The session format of a document format the adapter's provider edits. */
+function editableFormat(adapter, format) {
+    const formats = adapter.edit?.formats ?? [];
+    return formats.includes(format) ? SESSION_FORMATS[format] : undefined;
+}
+const SESSION_FORMATS = {
+    pdf: "pdf",
+    pptx: "pptx",
+    pptm: "pptx",
+    ppsx: "pptx",
+    docx: "docx",
+    docm: "docx",
+};
+/** Validates backend info and freezes it with the viewer's capability flags. */
+function describeDocument(adapter, backendInfo, format, limits) {
+    if (!Number.isInteger(backendInfo.pageCount) ||
+        backendInfo.pageCount < 1 ||
+        backendInfo.pageCount > limits.maxDocumentUnits)
+        throw new ViewerError("resource-limit", "Document unit count exceeds the configured limit", {
+            details: {
+                pageCount: backendInfo.pageCount,
+                limit: limits.maxDocumentUnits,
+            },
+        });
+    return immutableInfo({
+        ...backendInfo,
+        capabilities: {
+            textSelection: Boolean(adapter.getTextMap),
+            cellSelection: backendInfo.unit === "sheet",
+            search: Boolean(adapter.getTextMap),
+            thumbnails: backendInfo.unit !== "sheet",
+            editing: editableFormat(adapter, format) !== undefined,
+        },
+    });
+}
 function clampZoom(value) {
     if (!Number.isFinite(value))
         return 1;

package/dist/viewport.d.ts

@@ -1,4 +1,5 @@
 import type { CellRange, CellSelection, DocumentInfo, HeadlessRenderOptions, SearchMatch, TextRun, TextSelectionRange, ViewerState, SpreadsheetViewportRange } from "./contracts.js";
+import type { PageHit, PageRect, ViewportRect } from "./edit/types.js";
 export interface ViewportHost {
     readonly state: ViewerState;
     renderPage(pageIndex: number, target: HTMLCanvasElement, options: HeadlessRenderOptions): Promise<void>;
@@ -12,9 +13,15 @@ export interface ViewportHost {
     onTextSelection(range: TextSelectionRange): void;
     onCellSelection(selection: CellRange | CellSelection | null): void;
     getSelectionText(): string | undefined;
+    /** Pages whose paint for content revision `revision` just finished. */
+    onPainted(pages: readonly number[], revision: number): void;
 }
 interface ViewportStrategy {
     setDocument(info: DocumentInfo | undefined): void;
+    /** New content of the same document: keeps zoom and scroll, re-renders. */
+    replaceDocument(info: DocumentInfo, changedPages?: readonly number[], revision?: number): void;
+    pageToClient(pageIndex: number, rect: PageRect): ViewportRect | undefined;
+    clientToPage(clientX: number, clientY: number): PageHit | undefined;
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     goToPage(pageIndex: number): void;
@@ -30,6 +37,9 @@ export declare class AdaptiveViewport implements ViewportStrategy {
         readonly layout?: "continuous" | "single";
     });
     setDocument(info: DocumentInfo | undefined): void;
+    replaceDocument(info: DocumentInfo, changedPages?: readonly number[], revision?: number): void;
+    pageToClient(pageIndex: number, rect: PageRect): ViewportRect | undefined;
+    clientToPage(clientX: number, clientY: number): PageHit | undefined;
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     goToPage(pageIndex: number): void;
@@ -45,6 +55,9 @@ export declare class ViewerViewport {
         readonly layout?: "continuous" | "single";
     });
     setDocument(info: DocumentInfo | undefined): void;
+    replaceDocument(info: DocumentInfo, changedPages?: readonly number[], revision?: number): void;
+    pageToClient(pageIndex: number, rect: PageRect): ViewportRect | undefined;
+    clientToPage(clientX: number, clientY: number): PageHit | undefined;
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     goToPage(pageIndex: number): void;