[WIP] Update the named page destinations when some pdf are combined (bug 1997379)

and remove link annotations pointing on a deleted page.

Author: calixteman

src/core/editor/pdf_editor.js

@@ -32,6 +32,8 @@ class PageData {
     this.page = page;
     this.documentData = documentData;
     this.annotations = null;
+    // Named destinations which points to this page.
+    this.pointingNamedDestinations = null;
 
     documentData.pagesMap.put(page.ref, this);
   }
@@ -40,9 +42,13 @@ class PageData {
 class DocumentData {
   constructor(document) {
     this.document = document;
+    this.destinations = null;
     this.pageLabels = null;
     this.pagesMap = new RefSetCache();
     this.oldRefMapping = new RefSetCache();
+    this.dedupNamedDestinations = new Map();
+    this.usedNamedDestinations = new Set();
+    this.postponedRefCopies = new RefSetCache();
   }
 }
 
@@ -64,6 +70,7 @@ class PDFEditor {
     this.title = title;
     this.author = author;
     this.pageLabels = null;
+    this.namedDestinations = new Map();
   }
 
   /**
@@ -134,11 +141,20 @@ class PDFEditor {
       return newRef;
     }
     const promises = [];
+    const {
+      currentDocument: { postponedRefCopies },
+    } = this;
     if (Array.isArray(obj)) {
       if (mustClone) {
         obj = obj.slice();
       }
       for (let i = 0, ii = obj.length; i < ii; i++) {
+        const postponedActions = postponedRefCopies.get(obj[i]);
+        if (postponedActions) {
+          // The object is a reference that needs to be copied later.
+          postponedActions.push(ref => (obj[i] = ref));
+          continue;
+        }
         promises.push(
           this.#collectDependencies(obj[i], true, xref).then(
             newObj => (obj[i] = newObj)
@@ -159,6 +175,12 @@ class PDFEditor {
     }
     if (dict) {
       for (const [key, rawObj] of dict.getRawEntries()) {
+        const postponedActions = postponedRefCopies.get(rawObj);
+        if (postponedActions) {
+          // The object is a reference that needs to be copied later.
+          postponedActions.push(ref => dict.set(key, ref));
+          continue;
+        }
         promises.push(
           this.#collectDependencies(rawObj, true, xref).then(newObj =>
             dict.set(key, newObj)
@@ -189,11 +211,13 @@ class PDFEditor {
     const promises = [];
     let newIndex = 0;
     this.hasSingleFile = pageInfos.length === 1;
+    const allDocumentData = [];
     for (const { document, includePages, excludePages } of pageInfos) {
       if (!document) {
         continue;
       }
       const documentData = new DocumentData(document);
+      allDocumentData.push(documentData);
       promises.push(this.#collectDocumentData(documentData));
       let keptIndices, keptRanges, deletedIndices, deletedRanges;
       for (const page of includePages || []) {
@@ -256,17 +280,23 @@ class PDFEditor {
     await Promise.all(promises);
     promises.length = 0;
 
+    this.#collectValidDestinations(allDocumentData);
     this.#collectPageLabels();
 
     for (const page of this.oldPages) {
       promises.push(this.#postCollectPageData(page));
     }
     await Promise.all(promises);
 
+    this.#findDuplicateNamedDestinations();
+    this.#setPostponedRefCopies(allDocumentData);
+
     for (let i = 0, ii = this.oldPages.length; i < ii; i++) {
       this.newPages[i] = await this.#makePageCopy(i, null);
     }
 
+    this.#fixPostponedRefCopies(allDocumentData);
+
     return this.writePDF();
   }
 
@@ -277,9 +307,14 @@ class PDFEditor {
    */
   async #collectDocumentData(documentData) {
     const { document } = documentData;
-    await document.pdfManager
-      .ensureCatalog("rawPageLabels")
-      .then(pageLabels => (documentData.pageLabels = pageLabels));
+    await Promise.all([
+      document.pdfManager
+        .ensureCatalog("destinations")
+        .then(destinations => (documentData.destinations = destinations)),
+      document.pdfManager
+        .ensureCatalog("rawPageLabels")
+        .then(pageLabels => (documentData.pageLabels = pageLabels)),
+    ]);
   }
 
   /**
@@ -290,6 +325,7 @@ class PDFEditor {
   async #postCollectPageData(pageData) {
     const {
       page: { xref, annotations },
+      documentData: { pagesMap, destinations, usedNamedDestinations },
     } = pageData;
 
     if (!annotations) {
@@ -300,22 +336,166 @@ class PDFEditor {
     let newAnnotations = [];
     let newIndex = 0;
 
-    // TODO: remove only links to deleted pages.
     for (const annotationRef of annotations) {
       const newAnnotationIndex = newIndex++;
       promises.push(
         xref.fetchIfRefAsync(annotationRef).then(async annotationDict => {
           if (!isName(annotationDict.get("Subtype"), "Link")) {
             newAnnotations[newAnnotationIndex] = annotationRef;
+            return;
+          }
+          const action = annotationDict.get("A");
+          const dest =
+            action instanceof Dict
+              ? action.get("D")
+              : annotationDict.get("Dest");
+
+          if (Array.isArray(dest) && pagesMap.has(dest[0])) {
+            newAnnotations[newAnnotationIndex] = annotationRef;
+          } else if (typeof dest === "string") {
+            const destString = stringToPDFString(
+              dest,
+              /* keepEscapeSequence = */ true
+            );
+            if (destinations.has(destString)) {
+              newAnnotations[newAnnotationIndex] = annotationRef;
+              usedNamedDestinations.add(destString);
+            }
           }
         })
       );
     }
+
     await Promise.all(promises);
     newAnnotations = newAnnotations.filter(annot => !!annot);
     pageData.annotations = newAnnotations.length > 0 ? newAnnotations : null;
   }
 
+  /**
+   * Some references cannot be copied right away since they correspond to some
+   * pages that haven't been processed yet. Postpone the copy of those
+   * references.
+   * @param {Array<DocumentData>} allDocumentData
+   */
+  #setPostponedRefCopies(allDocumentData) {
+    for (const { postponedRefCopies, pagesMap } of allDocumentData) {
+      for (const oldPageRef of pagesMap.keys()) {
+        postponedRefCopies.put(oldPageRef, []);
+      }
+    }
+  }
+
+  /**
+   * Fix all postponed reference copies.
+   * @param {Array<DocumentData>} allDocumentData
+   */
+  #fixPostponedRefCopies(allDocumentData) {
+    for (const { postponedRefCopies, oldRefMapping } of allDocumentData) {
+      for (const [oldRef, actions] of postponedRefCopies.items()) {
+        const newRef = oldRefMapping.get(oldRef);
+        for (const action of actions) {
+          action(newRef);
+        }
+      }
+    }
+  }
+
+  /**
+   * Collect named destinations that are still valid (i.e. pointing to kept
+   * pages).
+   * @param {Array<DocumentData>} allDocumentData
+   */
+  #collectValidDestinations(allDocumentData) {
+    for (const documentData of allDocumentData) {
+      if (!documentData.destinations) {
+        continue;
+      }
+      const { destinations, pagesMap } = documentData;
+      const newDestinations = (documentData.destinations = new Map());
+      for (const [key, dest] of Object.entries(destinations)) {
+        const pageRef = dest[0];
+        const pageData = pagesMap.get(pageRef);
+        if (!pageData) {
+          continue;
+        }
+        (pageData.pointingNamedDestinations ||= new Set()).add(key);
+        newDestinations.set(key, dest);
+      }
+    }
+  }
+
+  #findDuplicateNamedDestinations() {
+    const { namedDestinations } = this;
+    for (let i = 0, ii = this.oldPages.length; i < ii; i++) {
+      const page = this.oldPages[i];
+      const {
+        documentData: {
+          destinations,
+          dedupNamedDestinations,
+          usedNamedDestinations,
+        },
+      } = page;
+      let { pointingNamedDestinations } = page;
+
+      if (!pointingNamedDestinations) {
+        // No named destinations pointing to this page.
+        continue;
+      }
+      // Keep only the named destinations that are still used.
+      page.pointingNamedDestinations = pointingNamedDestinations =
+        pointingNamedDestinations.intersection(usedNamedDestinations);
+
+      for (const pointingDest of pointingNamedDestinations) {
+        if (!usedNamedDestinations.has(pointingDest)) {
+          // If the named destination isn't used, we can keep it as is.
+          continue;
+        }
+        const dest = destinations.get(pointingDest).slice();
+        if (!namedDestinations.has(pointingDest)) {
+          // If the named destination hasn't been used yet, we can keep it
+          // as is.
+          namedDestinations.set(pointingDest, dest);
+          continue;
+        }
+        // Create a new unique named destination.
+        const newName = `${pointingDest}_p${i + 1}`;
+        dedupNamedDestinations.set(pointingDest, newName);
+        namedDestinations.set(newName, dest);
+      }
+    }
+  }
+
+  #fixNamedDestinations(annotations, dedupNamedDestinations) {
+    if (dedupNamedDestinations.size === 0) {
+      return;
+    }
+    const fixDestination = (dict, key, dest) => {
+      if (typeof dest === "string") {
+        dict.set(
+          key,
+          dedupNamedDestinations.get(
+            stringToPDFString(dest, /* keepEscapeSequence = */ true)
+          ) || dest
+        );
+      }
+    };
+
+    for (const annotRef of annotations) {
+      const annotDict = this.xref[annotRef.num];
+      if (!isName(annotDict.get("Subtype"), "Link")) {
+        continue;
+      }
+      const action = annotDict.get("A");
+      if (action instanceof Dict && action.has("D")) {
+        const dest = action.get("D");
+        fixDestination(action, "D", dest);
+        continue;
+      }
+      const dest = annotDict.get("Dest");
+      fixDestination(annotDict, "Dest", dest);
+    }
+  }
+
   async #collectPageLabels() {
     // We can only preserve page labels when editing a single PDF file.
     // This is consistent with behavior in Adobe Acrobat.
@@ -372,14 +552,23 @@ class PDFEditor {
    * @returns {Promise<Ref>} the page reference in the new PDF document.
    */
   async #makePageCopy(pageIndex) {
-    const { page, documentData, annotations } = this.oldPages[pageIndex];
+    const { page, documentData, annotations, pointingNamedDestinations } =
+      this.oldPages[pageIndex];
     this.currentDocument = documentData;
-    const { oldRefMapping } = documentData;
+    const { dedupNamedDestinations, oldRefMapping } = documentData;
     const { xref, rotate, mediaBox, resources, ref: oldPageRef } = page;
     const pageRef = this.newRef;
     const pageDict = (this.xref[pageRef.num] = page.pageDict.clone());
     oldRefMapping.put(oldPageRef, pageRef);
 
+    if (pointingNamedDestinations) {
+      for (const pointingDest of pointingNamedDestinations) {
+        const name = dedupNamedDestinations.get(pointingDest) || pointingDest;
+        const dest = this.namedDestinations.get(name);
+        dest[0] = pageRef;
+      }
+    }
+
     // No need to keep these entries as we'll set them again later.
     for (const key of [
       "Rotate",
@@ -416,10 +605,16 @@ class PDFEditor {
       "Resources",
       await this.#collectDependencies(resources, true, xref)
     );
-    pageDict.setIfArray(
-      "Annots",
-      await this.#collectDependencies(annotations, true, xref)
-    );
+
+    if (annotations) {
+      const newAnnotations = await this.#collectDependencies(
+        annotations,
+        true,
+        xref
+      );
+      this.#fixNamedDestinations(newAnnotations, dedupNamedDestinations);
+      pageDict.setIfArray("Annots", newAnnotations);
+    }
 
     if (this.useObjectStreams) {
       const newLastRef = this.newRefCount;
@@ -540,6 +735,24 @@ class PDFEditor {
     rootDict.set("PageLabels", pageLabelsRef);
   }
 
+  #makeDestinationsTree() {
+    const { namedDestinations } = this;
+    if (namedDestinations.size === 0) {
+      return;
+    }
+    if (!this.namesDict) {
+      [this.namesRef, this.namesDict] = this.newDict;
+      this.rootDict.set("Names", this.namesRef);
+    }
+    this.namesDict.set(
+      "Dests",
+      this.#makeNameNumTree(
+        Array.from(namedDestinations.entries()),
+        /* areNames = */ true
+      )
+    );
+  }
+
   /**
    * Create the root dictionary.
    * @returns {Promise<void>}
@@ -550,6 +763,7 @@ class PDFEditor {
     rootDict.set("Version", this.version);
     this.#makePageTree();
     this.#makePageLabelsTree();
+    this.#makeDestinationsTree();
   }
 
   /**

src/core/primitives.js

@@ -439,6 +439,12 @@ class RefSetCache {
       yield [Ref.fromString(ref), value];
     }
   }
+
+  *keys() {
+    for (const ref of this._map.keys()) {
+      yield Ref.fromString(ref);
+    }
+  }
 }
 
 function isName(v, name) {

test/pdfs/.gitignore

@@ -758,3 +758,4 @@
 !doc_2_3_pages.pdf
 !doc_3_3_pages.pdf
 !labelled_pages.pdf
+!extract_link.pdf