@adnsistemas/pdf-lib 2.6.4 → 2.7.0

package/dist/pdf-lib.js

@@ -8341,9 +8341,11 @@
             return this.array.length;
         }
         push(object) {
+            this.registerChange();
             this.array.push(object);
         }
         insert(index, object) {
+            this.registerChange();
             this.array.splice(index, 0, object);
         }
         indexOf(object) {
@@ -8351,9 +8353,11 @@
             return index === -1 ? undefined : index;
         }
         remove(index) {
+            this.registerChange();
             this.array.splice(index, 1);
         }
         set(idx, object) {
+            this.registerChange();
             this.array[idx] = object;
         }
         get(index) {
@@ -8428,6 +8432,9 @@
                 }
             }
         }
+        registerChange() {
+            this.context.registerObjectChange(this);
+        }
     }
     PDFArray.withContext = (context) => new PDFArray(context);
 
@@ -8917,6 +8924,7 @@
             return this.contents.length;
         }
         updateContents(contents) {
+            this.dict.registerChange();
             this.contents = contents;
         }
     }
@@ -9533,8 +9541,49 @@
             return `${prefix}-${Math.floor(this.rng.nextInt() * Math.pow(10, suffixLength))}`;
         }
         registerObjectChange(obj) {
-            if (this.snapshot)
-                this.snapshot.markObjForSave(obj);
+            if (!this.snapshot)
+                return;
+            const ref = this.getObjectRef(obj);
+            if (ref) {
+                this.snapshot.markRefForSave(ref);
+                return;
+            }
+            const containingRef = this.findContainingIndirectObject(obj);
+            if (containingRef) {
+                this.snapshot.markRefForSave(containingRef);
+            }
+        }
+        findContainingIndirectObject(target) {
+            const entries = Array.from(this.indirectObjects.entries());
+            for (let idx = 0, len = entries.length; idx < len; idx++) {
+                const [ref, object] = entries[idx];
+                if (this.objectContains(object, target)) {
+                    return ref;
+                }
+            }
+            return undefined;
+        }
+        objectContains(container, target) {
+            if (container === target)
+                return true;
+            if (container instanceof PDFDict) {
+                const values = container.values();
+                for (let i = 0, len = values.length; i < len; i++) {
+                    if (this.objectContains(values[i], target))
+                        return true;
+                }
+            }
+            else if (container instanceof PDFArray) {
+                for (let i = 0, len = container.size(); i < len; i++) {
+                    if (this.objectContains(container.get(i), target))
+                        return true;
+                }
+            }
+            else if (container instanceof PDFStream) {
+                if (this.objectContains(container.dict, target))
+                    return true;
+            }
+            return false;
         }
         getObjectVersions(ref) {
             if (!this.preserveObjectsVersions)
@@ -30170,7 +30219,7 @@ end\
      */
     class PDFFont {
         constructor(ref, doc, embedder) {
-            this.modified = true;
+            this.alreadyEmbedded = false;
             assertIs(ref, 'ref', [[PDFRef, 'PDFRef']]);
             assertIs(doc, 'doc', [[PDFDocument, 'PDFDocument']]);
             assertIs(embedder, 'embedder', [
@@ -30194,7 +30243,6 @@ end\
          */
         encodeText(text) {
             assertIs(text, 'text', ['string']);
-            this.modified = true;
             return this.embedder.encodeText(text);
         }
         /**
@@ -30269,10 +30317,9 @@ end\
          */
         embed() {
             return __awaiter(this, void 0, void 0, function* () {
-                // TODO: Cleanup orphan embedded objects if a font is embedded multiple times...
-                if (this.modified) {
+                if (!this.alreadyEmbedded) {
                     yield this.embedder.embedIntoContext(this.doc.context, this.ref);
-                    this.modified = false;
+                    this.alreadyEmbedded = true;
                 }
             });
         }
@@ -37194,6 +37241,51 @@ end\
                 .map((value) => value[1])
                 .filter((ov) => ov.actual || ov.previous.length);
         }
+        /**
+         * Saves the current changes to the document as an incremental update, returns the full document,
+         * like save method, and modifies the internal state to be able to continue editing the document
+         * for another incremental update.
+         * This allows you to save multiple incremental updates without reloading the PDF.
+         *
+         * For example:
+         * ```js
+         * const pdfDoc = await PDFDocument.load(pdfBytes, { forIncrementalUpdate: true })
+         *
+         * const page = pdfDoc.getPage(0)
+         * page.drawText('First update')
+         * const firstsave = await pdfDoc.saveAndContinue()
+         *
+         * page.drawText('Second update', { y: 100 })
+         * const secondsave = await pdfDoc.saveAndContinue()
+         * ```
+         *
+         * @param options The options to be used when saving changes.
+         * @returns Resolves with the complete PDF bytes including all updates.
+         */
+        saveAndContinue(options = {}) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.context.pdfFileDetails.originalBytes || !this.context.snapshot) {
+                    throw new Error('saveAndContinue() requires the document to be loaded with forIncrementalUpdate: true');
+                }
+                const originalBytes = this.context.pdfFileDetails.originalBytes;
+                const incrementalBytes = yield this.saveIncremental(this.context.snapshot, options);
+                const newPdfBytes = new Uint8Array(originalBytes.byteLength + incrementalBytes.byteLength);
+                newPdfBytes.set(originalBytes);
+                newPdfBytes.set(incrementalBytes, originalBytes.byteLength);
+                this.context.pdfFileDetails.originalBytes = newPdfBytes;
+                this.context.pdfFileDetails.pdfSize = newPdfBytes.byteLength;
+                const incrementalStr = new TextDecoder('latin1').decode(incrementalBytes);
+                const startxrefMatch = incrementalStr.match(/startxref\s+(\d+)/);
+                if (startxrefMatch) {
+                    this.context.pdfFileDetails.prevStartXRef = parseInt(startxrefMatch[1], 10);
+                }
+                else {
+                    this.context.pdfFileDetails.prevStartXRef = originalBytes.byteLength;
+                }
+                this.context.snapshot = this.takeSnapshot();
+                return newPdfBytes;
+            });
+        }
         prepareForSave(options) {
             return __awaiter(this, void 0, void 0, function* () {
                 const { addDefaultPage = true, updateFieldAppearances = true } = options;