web-doc 0.9.0 → 0.10.0

package/dist/edit/pdf/types.d.ts

@@ -244,6 +244,41 @@ export interface TextLayoutLine {
     readonly fontSize: number;
     readonly color: string;
 }
+/**
+ * The font a PDF text element is drawn in, as a browser can load it: a host
+ * typing over the element shows the text in the document's own glyphs and
+ * metrics. Exactly one of `face` and `missing` is set.
+ */
+export interface TextFont {
+    readonly elementId: string;
+    /** The same for every element drawn in this font, so a host loads each face once. */
+    readonly key: string;
+    /** The family the file declares, as `textStyle.fontFamily` reports it. */
+    readonly family: string;
+    /**
+     * An OpenType or TrueType file for `FontFace`: a TrueType program with
+     * the OS/2, name and post tables a subset left out added, or a CFF program
+     * wrapped as OpenType with a Unicode cmap built from its glyph names (Adobe
+     * Glyph List names, `uniXXXX` and `uXXXX`). The program's own glyphs and
+     * widths are kept. Subset fonts hold only the glyphs the file uses, often
+     * not even a space, which the file places by positioning instead; a browser
+     * draws other characters in a fallback face. The file declares a
+     * regular face: its glyphs already carry the weight and slant, so load it
+     * with the default descriptors and do not ask the browser for bold or
+     * italic on top.
+     */
+    readonly face?: {
+        readonly data: Uint8Array;
+        readonly format: "opentype" | "truetype";
+    };
+    /**
+     * Why there is no face: the font is not embedded (a host shows it by name,
+     * as PDF readers do), or it is embedded in a form no browser loads: a
+     * CID-keyed CFF font, a Type 1 or Type 3 font, a font whose glyphs have no
+     * code points, or a program this reader cannot read.
+     */
+    readonly missing?: "not-embedded" | "cid-keyed" | "type1" | "no-unicode" | "unreadable";
+}
 /** The drawn geometry of a `text`, `textBox` or `table` element. */
 export interface TextLayout {
     readonly elementId: string;
@@ -282,6 +317,11 @@ export interface PdfEditSession extends EditSessionBase<PdfOperation, PdfElement
     save(options?: PdfSaveOptions): Promise<SavedDocument>;
     /** Lines, glyph boxes and styles of a `text`, `textBox` or `table` element. */
     getTextLayout(elementId: string, options?: ReadOptions): Promise<ReadItem<TextLayout>>;
+    /**
+     * The font a `text` or `textBox` element is drawn in, as a browser loads it,
+     * or why it cannot be loaded; see `TextFont`.
+     */
+    getTextFont(elementId: string, options?: ReadOptions): Promise<ReadItem<TextFont>>;
     /** The text position nearest to a page-space point; none on a page without text. */
     positionAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadItem<TextPosition>>;
     /** The rectangles a range covers, one per line fragment, in reading order. */

package/dist/edit/pptx/session.d.ts

@@ -1,5 +1,5 @@
 import type { DescribeOptions, DocumentDescription, EditCheckpoint, OutlineOptions, OutlineResult, TargetCandidate, TargetQuery, ToolCall, ToolCallOptions, ToolResult, ToolSet } from "../ai/types.js";
-import type { EditSessionCore } from "../engine.js";
+import type { EditSessionAccess, EditSessionCore } from "../engine.js";
 import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, ReadItem, ReadOptions, ReadResult, SavedDocument, TextTarget } from "../types.js";
 import type { PptxDeleteElementOperation, PptxDeleteSlideOperation, PptxDuplicateSlideOperation, PptxEditSession, PptxElement, PptxFields, PptxInsertImageOperation, PptxInsertSlideOperation, PptxInsertTableOperation, PptxInsertTextBoxOperation, PptxLayoutInfo, PptxMoveElementOperation, PptxMoveSlideOperation, PptxOperation, PptxReplaceTextOperation, PptxResizeElementOperation, PptxSaveOptions, PptxSetShapeStyleOperation, PptxSetTableCellOperation, PptxSetTextStyleOperation, PptxSlideInfo } from "./types.js";
 /**
@@ -10,7 +10,7 @@ import type { PptxDeleteElementOperation, PptxDeleteSlideOperation, PptxDuplicat
 export declare class PptxSession implements PptxEditSession {
     #private;
     readonly format: "pptx";
-    constructor(core: EditSessionCore);
+    constructor(core: EditSessionCore, access?: EditSessionAccess);
     get sessionId(): string;
     get state(): EditState;
     get schemas(): OperationSchemaSet;
@@ -24,6 +24,11 @@ export declare class PptxSession implements PptxEditSession {
     addAsset(data: Uint8Array, options?: AssetOptions): Promise<string>;
     getElements(query?: ElementQuery, options?: ReadOptions): Promise<ReadResult<PptxElement>>;
     getElement(id: string, options?: ReadOptions): Promise<ReadItem<PptxElement>>;
+    /**
+     * The elements under a point, top-most first: those whose frame holds it,
+     * and before them a shape whose text is painted there past its frame, as
+     * text wrapped below a short box is.
+     */
     elementsAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadResult<PptxElement>>;
     findText(query: string, options?: EditFindOptions): Promise<ReadResult<TextTarget>>;
     getOutline(options?: OutlineOptions): Promise<OutlineResult>;

package/dist/edit/pptx/session.js

@@ -11,8 +11,11 @@ export class PptxSession {
     format = "pptx";
     #core;
     #tools;
-    constructor(core) {
+    /** The shown deck's text runs; absent in a headless session, which hits frames only. */
+    #access;
+    constructor(core, access) {
         this.#core = core;
+        this.#access = access;
     }
     get sessionId() {
         return this.#core.sessionId;
@@ -53,8 +56,31 @@ export class PptxSession {
     getElement(id, options) {
         return this.#core.getElement(id, options);
     }
-    elementsAt(pageIndex, point, options) {
-        return this.#core.elementsAt(pageIndex, point, options);
+    /**
+     * The elements under a point, top-most first: those whose frame holds it,
+     * and before them a shape whose text is painted there past its frame, as
+     * text wrapped below a short box is.
+     */
+    async elementsAt(pageIndex, point, options) {
+        const framed = (await this.#core.elementsAt(pageIndex, point, options));
+        const access = this.#access;
+        if (!access)
+            return framed;
+        const origins = (await access.getTextRuns(pageIndex, options?.signal))
+            .filter((run) => run.shapeOrigin && runHolds(run, point))
+            .map((run) => run.shapeOrigin);
+        if (origins.length === 0)
+            return framed;
+        const all = (await this.getElements({ pageIndex }, options)).items;
+        const painted = all.filter((element) => element.text !== undefined &&
+            !framed.items.some((hit) => hit.id === element.id) &&
+            origins.some((origin) => originOf(element, origin)));
+        if (painted.length === 0)
+            return framed;
+        return Object.freeze({
+            ...framed,
+            items: Object.freeze([...painted, ...framed.items]),
+        });
     }
     findText(query, options) {
         return this.#core.findText(query, options);
@@ -143,3 +169,15 @@ function pptxReads(engine) {
         throw new ViewerError("edit-unsupported", "The engine does not provide the PPTX reads", { details: { format: "pptx", reason: "no-reads" } });
     return candidate;
 }
+/** Whether a run's box holds a point. */
+function runHolds(run, point) {
+    return (point.x >= run.x &&
+        point.x <= run.x + run.width &&
+        point.y >= run.y &&
+        point.y <= run.y + run.height);
+}
+/** Whether a shape's frame starts where a run says its shape does, to half a pixel. */
+function originOf(element, origin) {
+    const frame = element.frame ?? element.bounds;
+    return (Math.abs(frame.x - origin.x) <= 0.5 && Math.abs(frame.y - origin.y) <= 0.5);
+}

package/dist/viewport.js

@@ -156,6 +156,8 @@ export class ViewerViewport {
     }
     replaceDocument(info, changedPages, revision) {
         const previous = this.#info;
+        const painted = this.#painted.get(this.#contentRevision);
+        this.#painted.clear();
         this.#info = info;
         this.#contentRevision = revision ?? this.#contentRevision + 1;
         // Only pages whose content or size changed get a new render key; the
@@ -172,9 +174,15 @@ export class ViewerViewport {
             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)
+            if (pageIndex >= from || changed.has(pageIndex) || resized) {
                 this.#pageRevisions[pageIndex] =
                     (this.#pageRevisions[pageIndex] ?? 0) + 1;
+            }
+            else if (painted?.has(pageIndex) && this.#slots.has(pageIndex)) {
+                // A completed, retained page is still current. Carry its queued
+                // notification forward instead of losing it at the next frame.
+                this.#markPainted(pageIndex, this.#contentRevision);
+            }
         }
         // Slots stay mounted and repaint in place; the browser clamps the scroll
         // position itself once the spacer takes the new document's height.
@@ -371,6 +379,8 @@ export class ViewerViewport {
                 slot.controller?.abort();
                 slot.root.remove();
                 this.#slots.delete(pageIndex);
+                for (const pages of this.#painted.values())
+                    pages.delete(pageIndex);
             }
         for (let pageIndex = range.start; pageIndex < range.end; pageIndex += 1) {
             const slot = this.#slots.get(pageIndex) ?? this.#createSlot(pageIndex);
@@ -443,41 +453,86 @@ export class ViewerViewport {
         slot.controller = controller;
         const generation = ++slot.generation;
         const zoom = this.#host.state.zoom;
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const pageRevision = this.#pageRevisions[pageIndex] ?? 0;
         const contentRevision = this.#contentRevision;
+        // Adapters resize and paint their target asynchronously. Never give them
+        // the visible canvas: resizing clears it before the next frame is ready.
+        const canvas = document.createElement("canvas");
+        const textLayer = document.createElement("div");
+        const highlightLayer = document.createElement("div");
+        textLayer.style.cssText = slot.textLayer.style.cssText;
+        highlightLayer.style.cssText = slot.highlightLayer.style.cssText;
+        const isCurrent = () => !this.#destroyed &&
+            !controller.signal.aborted &&
+            this.#slots.get(pageIndex) === slot &&
+            slot.controller === controller &&
+            slot.generation === generation &&
+            (this.#pageRevisions[pageIndex] ?? 0) === pageRevision &&
+            this.#host.state.zoom === zoom &&
+            (window.devicePixelRatio || 1) === devicePixelRatio;
+        let rendering;
         try {
-            let renderError;
-            const rendering = this.#host
-                .renderPage(pageIndex, slot.canvas, {
+            rendering = this.#host.renderPage(pageIndex, canvas, {
                 zoom,
-                devicePixelRatio: window.devicePixelRatio || 1,
+                devicePixelRatio,
                 priority: pageIndex === this.#host.state.pageIndex ? "visible" : "adjacent",
                 signal: controller.signal,
+            });
+            const preparingText = this.#host
+                .getTextRuns(pageIndex, controller.signal)
+                .then(async (runs) => {
+                await rendering;
+                if (!isCurrent())
+                    return;
+                await this.#buildTextLayers(textLayer, highlightLayer, pageIndex, runs, zoom, controller.signal);
             })
-                .catch((error) => {
-                renderError = error;
+                .then(() => true, (error) => {
+                if (isCurrent())
+                    slot.root.dataset.renderError =
+                        error instanceof Error ? error.message : String(error);
+                // A valid raster still publishes without unavailable geometry.
+                // Never retain partial or previous text/highlight hit targets.
+                for (const layer of [textLayer, highlightLayer]) {
+                    layer.replaceChildren();
+                    resetOverlay(layer);
+                }
+                return false;
             });
-            const runs = await this.#host.getTextRuns(pageIndex, controller.signal);
-            if (controller.signal.aborted || slot.generation !== generation)
-                return;
-            await this.#buildTextLayers(slot.textLayer, slot.highlightLayer, pageIndex, runs, zoom, controller.signal);
-            if (controller.signal.aborted || slot.generation !== generation)
-                return;
-            await rendering;
-            if (renderError)
-                throw renderError;
-            if (controller.signal.aborted || slot.generation !== generation)
+            const [, textReady] = await Promise.all([rendering, preparingText]);
+            if (!isCurrent())
                 return;
-            const cssWidth = slot.canvas.width / (window.devicePixelRatio || 1);
-            const cssHeight = slot.canvas.height / (window.devicePixelRatio || 1);
+            const context = slot.canvas.getContext("2d");
+            if (!context)
+                throw new Error("Canvas 2D context is unavailable");
+            // Publish the completed raster and its matching text geometry in one
+            // synchronous commit, keeping the mounted page and layer identities.
+            slot.canvas.width = canvas.width;
+            slot.canvas.height = canvas.height;
+            context.drawImage(canvas, 0, 0);
+            replaceTextLayer(slot.textLayer, textLayer);
+            replaceTextLayer(slot.highlightLayer, highlightLayer);
+            const cssWidth = canvas.width / devicePixelRatio;
+            const cssHeight = canvas.height / devicePixelRatio;
             slot.root.style.width = `${cssWidth}px`;
             slot.root.style.height = `${cssHeight}px`;
+            if (textReady)
+                delete slot.root.dataset.renderError;
             this.#markPainted(pageIndex, contentRevision);
         }
         catch (error) {
-            if (!controller.signal.aborted) {
+            if (isCurrent()) {
                 slot.root.dataset.renderError =
                     error instanceof Error ? error.message : String(error);
             }
+            controller.abort();
+        }
+        finally {
+            // A cancelled adapter may still be writing. Release its backing store
+            // only once it has stopped, without affecting the committed page.
+            await rendering?.catch(() => undefined);
+            canvas.width = 0;
+            canvas.height = 0;
         }
     }
     async #buildTextLayers(textLayer, highlightLayer, pageIndex, runs, zoom, signal) {
@@ -817,6 +872,7 @@ export class ViewerViewport {
         });
     }
     #clearSlots() {
+        this.#painted.clear();
         for (const slot of this.#slots.values()) {
             slot.controller?.abort();
             slot.root.remove();
@@ -824,6 +880,13 @@ export class ViewerViewport {
         this.#slots.clear();
     }
 }
+function replaceTextLayer(target, source) {
+    const children = document.createDocumentFragment();
+    while (source.firstChild)
+        children.append(source.firstChild);
+    target.style.cssText = source.style.cssText;
+    target.replaceChildren(children);
+}
 function naturalPageSize(info, pageIndex) {
     const candidate = info?.pageSizes?.[pageIndex];
     return candidate &&

package/dist/worker-protocol.d.ts

@@ -2,7 +2,7 @@ import type { DocumentFormat, DocumentInfo, ResourceLimits, TextRun, ViewerError
 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 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-text-font" | "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";