web-doc 0.13.0 → 0.13.1

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

@@ -87,6 +87,12 @@ const CREATING_OPERATIONS = new Set([
     "insertImage",
     "insertTable",
 ]);
+/** Operations that change page order, and with it the index a loaded page is kept by. */
+const PAGE_ORDER_OPERATIONS = new Set([
+    "insertPage",
+    "deletePage",
+    "movePage",
+]);
 function referenceOf(operation) {
     const target = operation.target;
     return typeof target === "string" ? parseReference(target) : undefined;
@@ -129,6 +135,8 @@ export class PdfEditDocument {
     #batches = 0;
     /** Browser faces of the document's fonts, by font program; see `textFont`. */
     #faces = new Map();
+    /** Pages the running batch changed, by index; see `#batch`. */
+    #written;
     constructor(pdfium, original, fonts = new FontLibrary(async () => {
         throw new Error("No font source is configured");
     }), limits = defaultResourceLimits, assets = new AssetStore(), compact = compactPdf) {
@@ -205,6 +213,9 @@ export class PdfEditDocument {
      * the next batch number as their state id.
      */
     apply(input) {
+        return this.#batch(() => this.#apply(input));
+    }
+    #apply(input) {
         const batch = Array.isArray(input)
             ? { stateId: this.#batches + 1, operations: input }
             : input;
@@ -225,6 +236,8 @@ export class PdfEditDocument {
                 details: { signatures: this.#signatures, features: this.#features },
             });
         operations.forEach((raw, operationIndex) => {
+            if (PAGE_ORDER_OPERATIONS.has(raw.op))
+                this.#writeBack();
             const handler = handlers[raw.op];
             if (!handler)
                 throw new ViewerError("internal", `Unknown pdf operation ${raw.op}`);
@@ -693,28 +706,71 @@ export class PdfEditDocument {
             }
             : undefined;
     }
-    /** Loads a page, lets `use` change it, regenerates its content stream. */
+    /**
+     * Loads a page and lets `use` change it. The page stays loaded until the
+     * batch ends, so what the batch reads next sees the change; see `#batch`.
+     */
     #writePage(pageIndex, use) {
-        const { lib } = this.#pdfium;
-        const page = lib.FPDF_LoadPage(this.#document.handle, pageIndex);
-        if (!page)
-            throw new ViewerError("render-failed", "PDFium could not load the page", {
-                details: { pageIndex },
-            });
+        if (!this.#written)
+            return this.#batch(() => this.#writePage(pageIndex, use));
+        let page = this.#written.get(pageIndex);
+        if (page === undefined) {
+            page = this.#pdfium.lib.FPDF_LoadPage(this.#document.handle, pageIndex);
+            if (!page)
+                throw new ViewerError("render-failed", "PDFium could not load the page", { details: { pageIndex } });
+            this.#written.set(pageIndex, page);
+        }
+        // Objects are assigned before the change so appended ones follow them.
+        this.#objectsOf(pageIndex, page);
+        const result = use(page);
+        delete this.#pages[pageIndex].elements;
+        delete this.#pages[pageIndex].paragraphs;
+        return result;
+    }
+    /**
+     * Runs `run` with the pages it changes kept loaded, then regenerates each
+     * page's content stream once. PDFium rewrites a whole stream however
+     * little changed, which takes seconds on a page of thousands of objects,
+     * and object reads (text, bounds) need no regenerated content. A failing
+     * batch closes its pages unwritten: the caller restores the working copy.
+     */
+    #batch(run) {
+        if (this.#written)
+            return run();
+        const written = new Map();
+        this.#written = written;
         try {
-            // Objects are assigned before the change so appended ones follow them.
-            this.#objectsOf(pageIndex, page);
-            const result = use(page);
-            if (!lib.FPDFPage_GenerateContent(page))
-                throw new ViewerError("edit-failed", "PDFium could not rewrite the page", {
-                    details: { stage: "apply", pageIndex },
-                });
-            delete this.#pages[pageIndex].elements;
-            delete this.#pages[pageIndex].paragraphs;
+            const result = run();
+            this.#writeBack();
             return result;
         }
         finally {
-            lib.FPDF_ClosePage(page);
+            this.#written = undefined;
+            for (const [pageIndex, page] of written) {
+                this.#pdfium.lib.FPDF_ClosePage(page);
+                delete this.#pages[pageIndex]?.elements;
+                delete this.#pages[pageIndex]?.paragraphs;
+            }
+        }
+    }
+    /** Regenerates and closes the pages the running batch changed. */
+    #writeBack() {
+        const written = this.#written;
+        if (!written)
+            return;
+        const { lib } = this.#pdfium;
+        for (const [pageIndex, page] of written) {
+            written.delete(pageIndex);
+            try {
+                if (!lib.FPDFPage_GenerateContent(page))
+                    throw new ViewerError("edit-failed", "PDFium could not rewrite the page", { details: { stage: "apply", pageIndex } });
+            }
+            finally {
+                lib.FPDF_ClosePage(page);
+            }
+            // Elements are read again from the regenerated content.
+            delete this.#pages[pageIndex].elements;
+            delete this.#pages[pageIndex].paragraphs;
         }
     }
     #originalPages() {
@@ -907,7 +963,9 @@ export class PdfEditDocument {
     }
     #withPage(pageIndex, use) {
         const { lib } = this.#pdfium;
-        const page = lib.FPDF_LoadPage(this.#document.handle, pageIndex);
+        // A page the running batch changed is read as it stands in memory.
+        const written = this.#written?.get(pageIndex);
+        const page = written ?? lib.FPDF_LoadPage(this.#document.handle, pageIndex);
         if (!page)
             throw new ViewerError("render-failed", "PDFium could not load the page", {
                 details: { pageIndex },
@@ -922,7 +980,8 @@ export class PdfEditDocument {
             }
         }
         finally {
-            lib.FPDF_ClosePage(page);
+            if (written === undefined)
+                lib.FPDF_ClosePage(page);
         }
     }
     *#matches(textPage, query, options) {

package/dist/edit/pdf/engine/text-box.d.ts

@@ -68,4 +68,4 @@ export declare function placeUpright(pdfium: Pdfium, object: number, geometry: P
 export declare function setText(pdfium: Pdfium, object: number, text: string): void;
 export declare function parseColor(color: string): [number, number, number];
 export declare function resolveStyle(style: PdfTextBoxStyle): TextBoxSpec["style"];
-export declare function validateRect(rect: PageRect, geometry: PageGeometry, issue: Issue, path?: string): void;
+export declare function validateRect(rect: PageRect, geometry: PageGeometry, issue: Issue, path?: string, current?: PageRect): void;

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

@@ -319,12 +319,27 @@ export function resolveStyle(style) {
 function definedFields(style) {
     return Object.fromEntries(Object.entries(style).filter(([, value]) => value !== undefined));
 }
-export function validateRect(rect, geometry, issue, path = "/rect") {
+export function validateRect(rect, geometry, issue, path = "/rect", current) {
     const size = displayedSize(geometry);
     const tolerance = 0.01;
-    if (rect.x < -tolerance ||
-        rect.y < -tolerance ||
-        rect.x + rect.width > size.width + tolerance ||
-        rect.y + rect.height > size.height + tolerance)
-        issue(path, "range", `The rectangle must lie within the ${size.width}×${size.height} pt page`);
+    // Imported objects may already bleed outside the visible crop. Transforms
+    // can keep or reduce that overflow; the page tolerance must not accumulate
+    // on their current edges and permit repeated small outward steps.
+    const left = Math.min(-tolerance, current?.x ?? 0);
+    const top = Math.min(-tolerance, current?.y ?? 0);
+    const right = Math.max(size.width + tolerance, current ? current.x + current.width : 0);
+    const bottom = Math.max(size.height + tolerance, current ? current.y + current.height : 0);
+    const missesPage = current !== undefined &&
+        (rect.x >= size.width ||
+            rect.y >= size.height ||
+            rect.x + rect.width <= 0 ||
+            rect.y + rect.height <= 0);
+    if (rect.x < left ||
+        rect.y < top ||
+        rect.x + rect.width > right ||
+        rect.y + rect.height > bottom ||
+        missesPage)
+        issue(path, "range", current
+            ? `The rectangle must preserve or reduce existing overflow and remain partly visible within the ${size.width}×${size.height} pt page`
+            : `The rectangle must lie within the ${size.width}×${size.height} pt page`);
 }

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

@@ -20,7 +20,7 @@ export const moveElement = {
             return;
         }
         const delta = moveDelta(operation, target.element.bounds);
-        validateRect(shifted(target.element.bounds, delta.dx, delta.dy), context.geometry(target.location.pageIndex), issue, operation.to ? "/to" : "/by");
+        validateRect(shifted(target.element.bounds, delta.dx, delta.dy), context.geometry(target.location.pageIndex), issue, operation.to ? "/to" : "/by", target.element.bounds);
     },
     apply(operation, context) {
         const { location, element } = anyTarget(operation.target, context);
@@ -61,7 +61,7 @@ export const resizeElement = {
             issue("/target", "unsupported-target", "Tables and imported paragraphs cannot be resized");
             return;
         }
-        validateRect(operation.rect, context.geometry(target.location.pageIndex), issue);
+        validateRect(operation.rect, context.geometry(target.location.pageIndex), issue, "/rect", target.element.bounds);
     },
     apply(operation, context) {
         const { location, element } = anyTarget(operation.target, context);

package/dist/edit/session.js

@@ -6,6 +6,11 @@ import { buildToolSet, callTool as runTool } from "./ai/tools.js";
 import { assetIdOf, AssetStore, binaryFields, isAssetReference, } from "./assets.js";
 import { batchOf, EditHistory, modeOf } from "./history.js";
 import { assertBatchSize, checkOperations, freezeOperations, invalidOperationError, parseReference, } from "./operations.js";
+/**
+ * A state the engine would take at least this long to rebuild by replaying
+ * batches keeps its bytes, so undo, redo and recovery reopen it instead.
+ */
+const SLOW_REPLAY_MS = 1000;
 /**
  * The format-independent editing session: validation, history, revisions,
  * saving and the viewer refresh. Format modules wrap it to add typed methods.
@@ -26,6 +31,8 @@ export class EditSessionController {
     /** Materialized bytes of some committed states, by state id, so restores replay less. */
     #checkpoints = new Map();
     #checkpointBytes = 0;
+    /** Engine time each reachable state took to build from the state before it. */
+    #buildMs = new Map();
     /** Named checkpoints by id, in creation order. */
     #named = new Map();
     /** State ids named checkpoints pin, with how many name each; never evicted. */
@@ -106,10 +113,12 @@ export class EditSessionController {
                 });
             }
             const before = this.#history.pageCount;
-            const { change, shown } = await this.#transaction(signal, "apply", async () => {
+            const { change, shown, buildMs } = await this.#transaction(signal, "apply", async () => {
+                const started = performance.now();
                 const result = await this.#engine.apply(engineBatch, signal);
                 return {
                     change: result,
+                    buildMs: performance.now() - started,
                     shown: await this.#show(signal, this.#pagesOf(result.changedPages, result.reflowFrom)),
                 };
             });
@@ -126,7 +135,7 @@ export class EditSessionController {
                 pageCountBefore: before,
                 pageCountAfter: shown.pageCount,
             });
-            this.#commit("apply", shown.changedPages, shown);
+            this.#commit("apply", shown.changedPages, shown, buildMs);
             return this.#receipt(false, batch.length, change.createdIds, {
                 ...change,
                 changedPages: shown.changedPages,
@@ -293,8 +302,11 @@ export class EditSessionController {
                 return this.#noop();
             const before = this.#history.pageCount;
             const changedPages = allPages(Math.max(before, named.pageCount));
+            let buildMs = 0;
             const shown = await this.#transaction(signal, "apply", async () => {
+                const started = performance.now();
                 await this.#engine.restore(this.#targetFor(named.entries), signal);
+                buildMs = performance.now() - started;
                 return this.#show(signal, changedPages);
             });
             const diff = entryDiff(this.#history.entriesAt(this.#history.position), named.entries);
@@ -307,7 +319,7 @@ export class EditSessionController {
                 pageCountAfter: shown.pageCount,
                 base: { stateId: named.stateId, batches: named.batches },
             }, named.stateId);
-            this.#commit("restore", shown.changedPages, shown);
+            this.#commit("restore", shown.changedPages, shown, buildMs);
             return this.#receipt(false, 0, diff.created, {
                 removedIds: diff.removed,
                 changedPages: shown.changedPages,
@@ -509,10 +521,11 @@ export class EditSessionController {
             clearTimeout(timer);
         }
     }
-    #commit(reason, changedPages, shown) {
+    /** `buildMs`: the engine time the new state took, for an apply or a restore. */
+    #commit(reason, changedPages, shown, buildMs = 0) {
         this.#committedBytes = shown.bytes;
         if (reason === "apply" || reason === "restore")
-            this.#keepCheckpoint(shown.bytes);
+            this.#keepCheckpoint(shown.bytes, buildMs);
         else if (reason === "reset")
             this.#dropCheckpoints();
         this.#revision += 1;
@@ -595,8 +608,11 @@ export class EditSessionController {
             throw invalidOperationError(issues);
         return Object.freeze(result);
     }
-    /** Keeps every stride-th committed state's bytes within the memory budget. */
-    #keepCheckpoint(bytes) {
+    /**
+     * Keeps a committed state's bytes, within the memory budget, every
+     * stride-th state and whenever replaying to it would take SLOW_REPLAY_MS.
+     */
+    #keepCheckpoint(bytes, buildMs) {
         const stride = Math.max(1, Math.floor(this.#host.limits.maxEditHistory / 4));
         const stateId = this.#history.stateId;
         // Entries dropped by a new change after an undo can never be restored;
@@ -605,11 +621,32 @@ export class EditSessionController {
         for (const [id, kept] of this.#checkpoints)
             if (!reachable.has(id) && !this.#pinned.has(id))
                 this.#forgetCheckpoint(id, kept);
-        if (stateId === 0 ||
-            this.#checkpoints.has(stateId) ||
-            stateId % stride !== 0)
+        for (const id of this.#buildMs.keys())
+            if (!reachable.has(id))
+                this.#buildMs.delete(id);
+        if (stateId === 0 || this.#checkpoints.has(stateId))
             return;
-        this.#retain(stateId, bytes);
+        this.#buildMs.set(stateId, buildMs);
+        if (stateId % stride === 0 || this.#replayMs() >= SLOW_REPLAY_MS)
+            this.#retain(stateId, bytes);
+    }
+    /**
+     * The engine time a restore of the current state would spend replaying:
+     * what its entries took since the newest retained bytes, or since the
+     * original or a restore entry's rebuild.
+     */
+    #replayMs() {
+        const entries = this.#history.entriesAt(this.#history.position);
+        let total = 0;
+        for (let index = entries.length - 1; index >= 0; index -= 1) {
+            const entry = entries[index];
+            if (this.#checkpoints.has(entry.stateId))
+                break;
+            total += this.#buildMs.get(entry.stateId) ?? 0;
+            if (entry.base)
+                break;
+        }
+        return total;
     }
     /** Stores a state's bytes when the budget, less the pinned states, can hold them. */
     #retain(stateId, bytes) {

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

@@ -9089,14 +9089,25 @@ function definedFields(style) {
     Object.entries(style).filter(([, value]) => value !== void 0)
   );
 }
-function validateRect(rect, geometry, issue, path = "/rect") {
+function validateRect(rect, geometry, issue, path = "/rect", current) {
   const size = displayedSize(geometry);
   const tolerance = 0.01;
-  if (rect.x < -tolerance || rect.y < -tolerance || rect.x + rect.width > size.width + tolerance || rect.y + rect.height > size.height + tolerance)
+  const left = Math.min(-tolerance, current?.x ?? 0);
+  const top = Math.min(-tolerance, current?.y ?? 0);
+  const right = Math.max(
+    size.width + tolerance,
+    current ? current.x + current.width : 0
+  );
+  const bottom = Math.max(
+    size.height + tolerance,
+    current ? current.y + current.height : 0
+  );
+  const missesPage = current !== void 0 && (rect.x >= size.width || rect.y >= size.height || rect.x + rect.width <= 0 || rect.y + rect.height <= 0);
+  if (rect.x < left || rect.y < top || rect.x + rect.width > right || rect.y + rect.height > bottom || missesPage)
     issue(
       path,
       "range",
-      `The rectangle must lie within the ${size.width}\xD7${size.height} pt page`
+      current ? `The rectangle must preserve or reduce existing overflow and remain partly visible within the ${size.width}\xD7${size.height} pt page` : `The rectangle must lie within the ${size.width}\xD7${size.height} pt page`
     );
 }
 
@@ -10297,7 +10308,8 @@ var moveElement = {
       shifted(target.element.bounds, delta.dx, delta.dy),
       context.geometry(target.location.pageIndex),
       issue,
-      operation2.to ? "/to" : "/by"
+      operation2.to ? "/to" : "/by",
+      target.element.bounds
     );
   },
   apply(operation2, context) {
@@ -10350,7 +10362,9 @@ var resizeElement = {
     validateRect(
       operation2.rect,
       context.geometry(target.location.pageIndex),
-      issue
+      issue,
+      "/rect",
+      target.element.bounds
     );
   },
   apply(operation2, context) {
@@ -11442,6 +11456,11 @@ var CREATING_OPERATIONS = /* @__PURE__ */ new Set([
   "insertImage",
   "insertTable"
 ]);
+var PAGE_ORDER_OPERATIONS = /* @__PURE__ */ new Set([
+  "insertPage",
+  "deletePage",
+  "movePage"
+]);
 function referenceOf(operation2) {
   const target = operation2.target;
   return typeof target === "string" ? parseReference(target) : void 0;
@@ -11484,6 +11503,8 @@ var PdfEditDocument = class {
   #batches = 0;
   /** Browser faces of the document's fonts, by font program; see `textFont`. */
   #faces = /* @__PURE__ */ new Map();
+  /** Pages the running batch changed, by index; see `#batch`. */
+  #written;
   constructor(pdfium, original, fonts = new FontLibrary(async () => {
     throw new Error("No font source is configured");
   }), limits = defaultResourceLimits, assets = new AssetStore(), compact = compactPdf) {
@@ -11565,6 +11586,9 @@ var PdfEditDocument = class {
    * the next batch number as their state id.
    */
   apply(input) {
+    return this.#batch(() => this.#apply(input));
+  }
+  #apply(input) {
     const batch = Array.isArray(input) ? { stateId: this.#batches + 1, operations: input } : input;
     const { stateId, operations } = batch;
     const createdIds = [];
@@ -11580,6 +11604,7 @@ var PdfEditDocument = class {
         details: { signatures: this.#signatures, features: this.#features }
       });
     operations.forEach((raw, operationIndex) => {
+      if (PAGE_ORDER_OPERATIONS.has(raw.op)) this.#writeBack();
       const handler = handlers[raw.op];
       if (!handler)
         throw new ViewerError("internal", `Unknown pdf operation ${raw.op}`);
@@ -12051,30 +12076,73 @@ var PdfEditDocument = class {
       record: { ...first, id, mark: paragraph.spec }
     } : void 0;
   }
-  /** Loads a page, lets `use` change it, regenerates its content stream. */
+  /**
+   * Loads a page and lets `use` change it. The page stays loaded until the
+   * batch ends, so what the batch reads next sees the change; see `#batch`.
+   */
   #writePage(pageIndex, use) {
-    const { lib } = this.#pdfium;
-    const page = lib.FPDF_LoadPage(this.#document.handle, pageIndex);
-    if (!page)
-      throw new ViewerError("render-failed", "PDFium could not load the page", {
-        details: { pageIndex }
-      });
-    try {
-      this.#objectsOf(pageIndex, page);
-      const result3 = use(page);
-      if (!lib.FPDFPage_GenerateContent(page))
+    if (!this.#written)
+      return this.#batch(() => this.#writePage(pageIndex, use));
+    let page = this.#written.get(pageIndex);
+    if (page === void 0) {
+      page = this.#pdfium.lib.FPDF_LoadPage(this.#document.handle, pageIndex);
+      if (!page)
         throw new ViewerError(
-          "edit-failed",
-          "PDFium could not rewrite the page",
-          {
-            details: { stage: "apply", pageIndex }
-          }
+          "render-failed",
+          "PDFium could not load the page",
+          { details: { pageIndex } }
         );
-      delete this.#pages[pageIndex].elements;
-      delete this.#pages[pageIndex].paragraphs;
+      this.#written.set(pageIndex, page);
+    }
+    this.#objectsOf(pageIndex, page);
+    const result3 = use(page);
+    delete this.#pages[pageIndex].elements;
+    delete this.#pages[pageIndex].paragraphs;
+    return result3;
+  }
+  /**
+   * Runs `run` with the pages it changes kept loaded, then regenerates each
+   * page's content stream once. PDFium rewrites a whole stream however
+   * little changed, which takes seconds on a page of thousands of objects,
+   * and object reads (text, bounds) need no regenerated content. A failing
+   * batch closes its pages unwritten: the caller restores the working copy.
+   */
+  #batch(run2) {
+    if (this.#written) return run2();
+    const written = /* @__PURE__ */ new Map();
+    this.#written = written;
+    try {
+      const result3 = run2();
+      this.#writeBack();
       return result3;
     } finally {
-      lib.FPDF_ClosePage(page);
+      this.#written = void 0;
+      for (const [pageIndex, page] of written) {
+        this.#pdfium.lib.FPDF_ClosePage(page);
+        delete this.#pages[pageIndex]?.elements;
+        delete this.#pages[pageIndex]?.paragraphs;
+      }
+    }
+  }
+  /** Regenerates and closes the pages the running batch changed. */
+  #writeBack() {
+    const written = this.#written;
+    if (!written) return;
+    const { lib } = this.#pdfium;
+    for (const [pageIndex, page] of written) {
+      written.delete(pageIndex);
+      try {
+        if (!lib.FPDFPage_GenerateContent(page))
+          throw new ViewerError(
+            "edit-failed",
+            "PDFium could not rewrite the page",
+            { details: { stage: "apply", pageIndex } }
+          );
+      } finally {
+        lib.FPDF_ClosePage(page);
+      }
+      delete this.#pages[pageIndex].elements;
+      delete this.#pages[pageIndex].paragraphs;
     }
   }
   #originalPages() {
@@ -12282,7 +12350,8 @@ var PdfEditDocument = class {
   }
   #withPage(pageIndex, use) {
     const { lib } = this.#pdfium;
-    const page = lib.FPDF_LoadPage(this.#document.handle, pageIndex);
+    const written = this.#written?.get(pageIndex);
+    const page = written ?? lib.FPDF_LoadPage(this.#document.handle, pageIndex);
     if (!page)
       throw new ViewerError("render-failed", "PDFium could not load the page", {
         details: { pageIndex }
@@ -12295,7 +12364,7 @@ var PdfEditDocument = class {
         lib.FPDFText_ClosePage(textPage);
       }
     } finally {
-      lib.FPDF_ClosePage(page);
+      if (written === void 0) lib.FPDF_ClosePage(page);
     }
   }
   *#matches(textPage, query, options) {

package/package.json

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