web-doc 0.12.0 → 0.13.0

package/dist/edit/pdf/engine/document.d.ts

@@ -36,9 +36,9 @@ export declare class PdfEditDocument {
     get pageCount(): number;
     get pdfium(): Pdfium;
     /**
-     * Checks a batch against the current document. Operations are checked one
-     * after another against the state before the batch, which is exact for
-     * everything but a page count another operation of the batch changes.
+     * Preflights a batch against its starting document. Applying revalidates
+     * each operation against earlier changes in the batch; created-element
+     * references are checked once their targets exist.
      */
     validate(operations: readonly PdfOrUnknownOperation[]): OperationIssue[];
     /**

package/dist/edit/pdf/engine/document.js

@@ -167,9 +167,9 @@ export class PdfEditDocument {
         return this.#pdfium;
     }
     /**
-     * Checks a batch against the current document. Operations are checked one
-     * after another against the state before the batch, which is exact for
-     * everything but a page count another operation of the batch changes.
+     * Preflights a batch against its starting document. Applying revalidates
+     * each operation against earlier changes in the batch; created-element
+     * references are checked once their targets exist.
      */
     validate(operations) {
         const issues = [];
@@ -229,7 +229,7 @@ export class PdfEditDocument {
             if (!handler)
                 throw new ViewerError("internal", `Unknown pdf operation ${raw.op}`);
             const context = this.#context(stateId, operationIndex);
-            const operation = this.#resolveReference(raw, operationIndex, createdByOperation, handler, context);
+            const operation = this.#resolveAndValidate(raw, operationIndex, createdByOperation, handler, context);
             const result = handler.apply(operation, context);
             createdIds.push(...result.createdIds);
             createdByOperation[operationIndex] = [...result.createdIds];
@@ -251,23 +251,23 @@ export class PdfEditDocument {
         };
     }
     /**
-     * Turns a `"$<n>"` target into the id operation `n` created, then runs the
-     * handler's own checks on the resolved operation: a reference that lands
-     * on an element the operation cannot act on fails the batch the same way
-     * validation would have.
+     * Resolves a `"$<n>"` target, then checks every operation against the
+     * current document. Earlier operations may have moved, resized or removed
+     * an ordinary target since the batch's initial preflight.
      */
-    #resolveReference(operation, operationIndex, createdByOperation, handler, context) {
+    #resolveAndValidate(operation, operationIndex, createdByOperation, handler, context) {
         const reference = referenceOf(operation);
-        if (reference === undefined)
-            return operation;
         const issues = [];
         const issue = issueCollector(operationIndex, issues);
-        const id = createdByOperation[reference]?.[0];
-        if (id === undefined) {
-            issue("/target", "unknown-target", `Operation ${reference} created no element for "$${reference}"`);
-            throw invalidOperationError(issues);
+        let resolved = operation;
+        if (reference !== undefined && "target" in operation) {
+            const id = createdByOperation[reference]?.[0];
+            if (id === undefined) {
+                issue("/target", "unknown-target", `Operation ${reference} created no element for "$${reference}"`);
+                throw invalidOperationError(issues);
+            }
+            resolved = { ...operation, target: id };
         }
-        const resolved = { ...operation, target: id };
         handler.validate(resolved, context, issue);
         if (issues.length > 0)
             throw invalidOperationError(issues);
@@ -888,7 +888,21 @@ export class PdfEditDocument {
             const records = this.#objectsOf(pageIndex, page);
             const { byObject, elements } = scanPage(this.#pdfium, page, textPage, pageIndex, geometry, records);
             const offsets = this.#charOffsets(page, textPage, byObject, new Map(elements.map((element) => [element.id, element.text ?? ""])));
-            return use({ page, textPage, geometry, byObject, elements, offsets });
+            // A text box lays its lines out in the rect its mark keeps; only
+            // fresh marks are still on the records.
+            const frames = new Map();
+            for (const record of records)
+                if (record.mark?.kind === "textBox" && !frames.has(record.id))
+                    frames.set(record.id, roundRect(record.mark.rect));
+            return use({
+                page,
+                textPage,
+                geometry,
+                byObject,
+                elements,
+                offsets,
+                frames,
+            });
         });
     }
     #withPage(pageIndex, use) {

package/dist/edit/pdf/engine/existing-text.js

@@ -169,16 +169,30 @@ function replaceInPlace(context, target, text) {
     context.withPage(target.location.pageIndex, (page) => {
         setText(pdfium, lib.FPDFPage_GetObject(page, index), text);
     });
-    const readBack = context.withPage(target.location.pageIndex, (page) => {
+    const faithful = context.withPage(target.location.pageIndex, (page) => {
         const textPage = lib.FPDFText_LoadPage(page);
         try {
-            return pdfium.readWideString((buffer, bytes) => lib.FPDFTextObj_GetText(lib.FPDFPage_GetObject(page, index), textPage, buffer, bytes));
+            const object = lib.FPDFPage_GetObject(page, index);
+            const readBack = pdfium.readWideString((buffer, bytes) => lib.FPDFTextObj_GetText(object, textPage, buffer, bytes));
+            if (readBack === text)
+                return true;
+            // Reading-order extraction can append a generated gap before the next
+            // object. Verify the object's own characters instead, retaining every
+            // authored space: trimming would also hide a lost deliberate space.
+            let authored = "";
+            const count = lib.FPDFText_CountChars(textPage);
+            for (let at = 0; at < count; at += 1) {
+                if (lib.FPDFText_GetTextObject(textPage, at) === object &&
+                    lib.FPDFText_IsGenerated(textPage, at) === 0)
+                    authored += String.fromCodePoint(lib.FPDFText_GetUnicode(textPage, at));
+            }
+            return authored === text;
         }
         finally {
             lib.FPDFText_ClosePage(textPage);
         }
     });
-    if (readBack === text)
+    if (faithful)
         return true;
     // Put the old text back so the fallback path starts from a known state.
     context.withPage(target.location.pageIndex, (page) => {

package/dist/edit/pdf/engine/layout.d.ts

@@ -12,6 +12,8 @@ export interface TextPageScan {
     readonly elements: readonly PdfElement[];
     /** Per character of the text page: its element and offset, when an object draws it. */
     readonly offsets: readonly (TextPosition | undefined)[];
+    /** Element id → the rectangle its text is laid out in, for text boxes. */
+    readonly frames?: ReadonlyMap<string, PageRect>;
 }
 /** The layout of one element, or `undefined` when it draws no text. */
 export declare function layoutOf(pdfium: Pdfium, scan: TextPageScan, element: PdfElement): TextLayout | undefined;

package/dist/edit/pdf/engine/layout.js

@@ -8,10 +8,12 @@ export function layoutOf(pdfium, scan, element) {
     if (!TEXT_KINDS.has(element.kind))
         return undefined;
     const glyphs = glyphsOf(pdfium, scan, (position) => position.elementId === element.id);
+    const lines = linesOf(pdfium, scan, glyphs);
     return {
         elementId: element.id,
         pageIndex: element.pageIndex,
-        lines: linesOf(pdfium, scan, glyphs),
+        frame: frameOf(scan, element, lines),
+        lines,
     };
 }
 /** The layouts of every text element of the page, in reading order, from one pass. */
@@ -30,14 +32,30 @@ export function layoutsOf(pdfium, scan) {
         const own = byElement.get(element.id);
         if (!own || !TEXT_KINDS.has(element.kind))
             continue;
+        const lines = linesOf(pdfium, scan, own);
         layouts.push({
             elementId: element.id,
             pageIndex: element.pageIndex,
-            lines: linesOf(pdfium, scan, own),
+            frame: frameOf(scan, element, lines),
+            lines,
         });
     }
     return layouts;
 }
+/**
+ * The box an element's text is laid out in: a paragraph's frame (its bounds
+ * already start at the pen and span its widest advance), a text box's own
+ * rect, else the union of the lines' advance boxes.
+ */
+function frameOf(scan, element, lines) {
+    if (element.kind === "paragraph")
+        return element.bounds;
+    const own = scan.frames?.get(element.id);
+    if (own)
+        return own;
+    const boxes = lines.flatMap((line) => line.advanceBounds ? [line.advanceBounds] : []);
+    return boxes.length > 0 ? roundRect(unionRects(boxes)) : element.bounds;
+}
 /** The caret position nearest to a page-space point, or none without text. */
 export function positionIn(pdfium, scan, point) {
     const glyphs = glyphsOf(pdfium, scan, () => true);
@@ -105,6 +123,7 @@ function glyphsOf(pdfium, scan, keep) {
             position,
             char: String.fromCodePoint(lib.FPDFText_GetUnicode(textPage, index)),
             box: roundRect(userRectToPage(geometry, left, bottom, right, top)),
+            loose: roundRect(userRectToPage(geometry, looseLeft, looseBottom, looseRight, looseTop)),
             advance: round(Math.abs(looseRight - looseLeft)),
             origin: roundPoint(userToPage(geometry, origin[0], origin[1])),
         });
@@ -136,11 +155,15 @@ function linesOf(pdfium, scan, glyphs) {
             },
             text: members.map((glyph) => glyph.char).join(""),
             bounds: roundRect(unionRects(members.map((glyph) => glyph.box))),
+            // PDFium's loose boxes run from each origin to origin plus advance,
+            // ascent to descent: their union is the line a text field must hold.
+            advanceBounds: roundRect(unionRects(members.map((glyph) => glyph.loose))),
             baseline: members[0].origin,
-            glyphs: members.map(({ position, box, advance }) => ({
+            glyphs: members.map(({ position, box, advance, origin }) => ({
                 offset: position.offset,
                 box,
                 advance,
+                origin,
             })),
             fontFamily: style.fontFamily,
             fontSize: style.fontSize,

package/dist/edit/pdf/engine/pdfium.d.ts

@@ -75,6 +75,7 @@ export interface PdfiumFunctions {
     FPDFText_GetCharBox(textPage: number, index: number, left: number, right: number, bottom: number, top: number): boolean;
     FPDFText_GetTextObject(textPage: number, index: number): number;
     FPDFText_GetUnicode(textPage: number, index: number): number;
+    FPDFText_IsGenerated(textPage: number, index: number): number;
     FPDFText_GetCharIndexFromTextIndex(textPage: number, textIndex: number): number;
     /** Advance box of a character as an FS_RECTF {left, top, right, bottom} of floats. */
     FPDFText_GetLooseCharBox(textPage: number, index: number, rect: number): boolean;

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

@@ -255,6 +255,12 @@ export interface TextLayoutGlyph {
     readonly box: PageRect;
     /** Advance width along the baseline, in points. */
     readonly advance: number;
+    /**
+     * Pen position on the baseline where the glyph starts, in page space. The
+     * steps between neighbours are the advances the file draws with, character
+     * and word spacing and TJ kerning included.
+     */
+    readonly origin?: PagePoint;
 }
 /** One line of a text element: one PDFium text object, as the file stores it. */
 export interface TextLayoutLine {
@@ -263,6 +269,15 @@ export interface TextLayoutLine {
     readonly text: string;
     /** Union of the glyph boxes, in page space. */
     readonly bounds: PageRect;
+    /**
+     * The box the line's advances fill, the size a text field needs to hold the
+     * line unwrapped: from the first glyph's origin to the last glyph's origin
+     * plus its advance, and from the font's ascent to its descent at the line's
+     * size. It differs from `bounds` by the glyphs' side bearings, usually
+     * wider; in page space and axis-aligned like `bounds`, so it turns with the
+     * text.
+     */
+    readonly advanceBounds?: PageRect;
     /** Start of the baseline, in page space. */
     readonly baseline: PagePoint;
     readonly glyphs: readonly TextLayoutGlyph[];
@@ -305,10 +320,17 @@ export interface TextFont {
      */
     readonly missing?: "not-embedded" | "cid-keyed" | "type1" | "no-unicode" | "unreadable";
 }
-/** The drawn geometry of a `text`, `textBox` or `table` element. */
+/** The drawn geometry of a `text`, `textBox`, `paragraph` or `table` element. */
 export interface TextLayout {
     readonly elementId: string;
     readonly pageIndex: number;
+    /**
+     * The box the element's text is laid out in, in page space: a text box's or
+     * a paragraph's own rectangle, otherwise the union of its lines'
+     * `advanceBounds`. Place an inline text field here rather than on the ink
+     * `bounds`, which a browser's advance-based layout outgrows.
+     */
+    readonly frame?: PageRect;
     /** Lines in reading order: a text box's lines, a table's cells. */
     readonly lines: readonly TextLayoutLine[];
 }

package/dist/workers/pdf-edit-worker.js

@@ -6759,10 +6759,12 @@ function layoutOf(pdfium, scan, element) {
     scan,
     (position) => position.elementId === element.id
   );
+  const lines = linesOf(pdfium, scan, glyphs);
   return {
     elementId: element.id,
     pageIndex: element.pageIndex,
-    lines: linesOf(pdfium, scan, glyphs)
+    frame: frameOf(scan, element, lines),
+    lines
   };
 }
 function layoutsOf(pdfium, scan) {
@@ -6777,14 +6779,25 @@ function layoutsOf(pdfium, scan) {
   for (const element of scan.elements) {
     const own = byElement.get(element.id);
     if (!own || !TEXT_KINDS.has(element.kind)) continue;
+    const lines = linesOf(pdfium, scan, own);
     layouts.push({
       elementId: element.id,
       pageIndex: element.pageIndex,
-      lines: linesOf(pdfium, scan, own)
+      frame: frameOf(scan, element, lines),
+      lines
     });
   }
   return layouts;
 }
+function frameOf(scan, element, lines) {
+  if (element.kind === "paragraph") return element.bounds;
+  const own = scan.frames?.get(element.id);
+  if (own) return own;
+  const boxes = lines.flatMap(
+    (line) => line.advanceBounds ? [line.advanceBounds] : []
+  );
+  return boxes.length > 0 ? roundRect(unionRects(boxes)) : element.bounds;
+}
 function positionIn(pdfium, scan, point) {
   const glyphs = glyphsOf(pdfium, scan, () => true);
   if (glyphs.length === 0) return void 0;
@@ -6859,6 +6872,9 @@ function glyphsOf(pdfium, scan, keep) {
       position,
       char: String.fromCodePoint(lib.FPDFText_GetUnicode(textPage, index)),
       box: roundRect(userRectToPage(geometry, left, bottom, right, top)),
+      loose: roundRect(
+        userRectToPage(geometry, looseLeft, looseBottom, looseRight, looseTop)
+      ),
       advance: round(Math.abs(looseRight - looseLeft)),
       origin: roundPoint(userToPage(geometry, origin[0], origin[1]))
     });
@@ -6886,11 +6902,15 @@ function linesOf(pdfium, scan, glyphs) {
       },
       text: members.map((glyph) => glyph.char).join(""),
       bounds: roundRect(unionRects(members.map((glyph) => glyph.box))),
+      // PDFium's loose boxes run from each origin to origin plus advance,
+      // ascent to descent: their union is the line a text field must hold.
+      advanceBounds: roundRect(unionRects(members.map((glyph) => glyph.loose))),
       baseline: members[0].origin,
-      glyphs: members.map(({ position, box, advance: advance2 }) => ({
+      glyphs: members.map(({ position, box, advance: advance2, origin }) => ({
         offset: position.offset,
         box,
-        advance: advance2
+        advance: advance2,
+        origin
       })),
       fontFamily: style.fontFamily,
       fontSize: style.fontSize,
@@ -9997,22 +10017,28 @@ function replaceInPlace(context, target, text) {
   context.withPage(target.location.pageIndex, (page) => {
     setText(pdfium, lib.FPDFPage_GetObject(page, index), text);
   });
-  const readBack = context.withPage(target.location.pageIndex, (page) => {
+  const faithful = context.withPage(target.location.pageIndex, (page) => {
     const textPage = lib.FPDFText_LoadPage(page);
     try {
-      return pdfium.readWideString(
-        (buffer, bytes2) => lib.FPDFTextObj_GetText(
-          lib.FPDFPage_GetObject(page, index),
-          textPage,
-          buffer,
-          bytes2
-        )
+      const object = lib.FPDFPage_GetObject(page, index);
+      const readBack = pdfium.readWideString(
+        (buffer, bytes2) => lib.FPDFTextObj_GetText(object, textPage, buffer, bytes2)
       );
+      if (readBack === text) return true;
+      let authored = "";
+      const count = lib.FPDFText_CountChars(textPage);
+      for (let at = 0; at < count; at += 1) {
+        if (lib.FPDFText_GetTextObject(textPage, at) === object && lib.FPDFText_IsGenerated(textPage, at) === 0)
+          authored += String.fromCodePoint(
+            lib.FPDFText_GetUnicode(textPage, at)
+          );
+      }
+      return authored === text;
     } finally {
       lib.FPDFText_ClosePage(textPage);
     }
   });
-  if (readBack === text) return true;
+  if (faithful) return true;
   context.withPage(target.location.pageIndex, (page) => {
     setText(pdfium, lib.FPDFPage_GetObject(page, index), previous);
   });
@@ -11500,9 +11526,9 @@ var PdfEditDocument = class {
     return this.#pdfium;
   }
   /**
-   * Checks a batch against the current document. Operations are checked one
-   * after another against the state before the batch, which is exact for
-   * everything but a page count another operation of the batch changes.
+   * Preflights a batch against its starting document. Applying revalidates
+   * each operation against earlier changes in the batch; created-element
+   * references are checked once their targets exist.
    */
   validate(operations) {
     const issues = [];
@@ -11558,7 +11584,7 @@ var PdfEditDocument = class {
       if (!handler)
         throw new ViewerError("internal", `Unknown pdf operation ${raw.op}`);
       const context = this.#context(stateId, operationIndex);
-      const operation2 = this.#resolveReference(
+      const operation2 = this.#resolveAndValidate(
         raw,
         operationIndex,
         createdByOperation,
@@ -11585,26 +11611,27 @@ var PdfEditDocument = class {
     };
   }
   /**
-   * Turns a `"$<n>"` target into the id operation `n` created, then runs the
-   * handler's own checks on the resolved operation: a reference that lands
-   * on an element the operation cannot act on fails the batch the same way
-   * validation would have.
+   * Resolves a `"$<n>"` target, then checks every operation against the
+   * current document. Earlier operations may have moved, resized or removed
+   * an ordinary target since the batch's initial preflight.
    */
-  #resolveReference(operation2, operationIndex, createdByOperation, handler, context) {
+  #resolveAndValidate(operation2, operationIndex, createdByOperation, handler, context) {
     const reference = referenceOf(operation2);
-    if (reference === void 0) return operation2;
     const issues = [];
     const issue = issueCollector(operationIndex, issues);
-    const id = createdByOperation[reference]?.[0];
-    if (id === void 0) {
-      issue(
-        "/target",
-        "unknown-target",
-        `Operation ${reference} created no element for "$${reference}"`
-      );
-      throw invalidOperationError(issues);
+    let resolved = operation2;
+    if (reference !== void 0 && "target" in operation2) {
+      const id = createdByOperation[reference]?.[0];
+      if (id === void 0) {
+        issue(
+          "/target",
+          "unknown-target",
+          `Operation ${reference} created no element for "$${reference}"`
+        );
+        throw invalidOperationError(issues);
+      }
+      resolved = { ...operation2, target: id };
     }
-    const resolved = { ...operation2, target: id };
     handler.validate(resolved, context, issue);
     if (issues.length > 0) throw invalidOperationError(issues);
     return resolved;
@@ -12238,7 +12265,19 @@ var PdfEditDocument = class {
         byObject,
         new Map(elements.map((element) => [element.id, element.text ?? ""]))
       );
-      return use({ page, textPage, geometry, byObject, elements, offsets });
+      const frames = /* @__PURE__ */ new Map();
+      for (const record of records)
+        if (record.mark?.kind === "textBox" && !frames.has(record.id))
+          frames.set(record.id, roundRect(record.mark.rect));
+      return use({
+        page,
+        textPage,
+        geometry,
+        byObject,
+        elements,
+        offsets,
+        frames
+      });
     });
   }
   #withPage(pageIndex, use) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-doc",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "web-doc — embeddable browser-only document viewer with Rust/WASM adapters (a fork of Zrimo)",
   "keywords": [
     "document-viewer",