PDF logical structure reader in JavaScript

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2023 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------
// This sample explores the structure and content of a tagged PDF document and dumps
// the structure information to the console window.
//
// In tagged PDF documents StructTree acts as a central repository for information
// related to a PDF document's logical structure. The tree consists of StructElement-s
// and ContentItem-s which are leaf nodes of the structure tree.
//
// The sample can be extended to access and extract the marked-content elements such
// as text and images.
//---------------------------------------------------------------------------------------

(exports => {










  exports.runLogicalStructureTest = () => {
    const PDFNet = exports.Core.PDFNet;

    const PrintAndIndent = (printState, indent) => {
      if (printState.str) {
        const indentStr = ' '.repeat(printState.indent * 2);
        console.log(indentStr + printState.str);
      }
      printState.str = '';
      printState.indent = indent;
    };

    // Read the structure recursively
    const ReadDocumentStructure = async (element, parent) => {
      if (!(await element.isValid())) {
        return;
      }

      const [type, numKids] = await Promise.all([element.getType(), element.getNumKids()]);

      const elementData = {
        type,
        numKids,
        isLeaf: false,
        children: [],
      };

      if (await element.hasTitle()) {
        elementData.title = await element.getTitle();
      }

      parent.children.push(elementData);

      for (let i = 0; i < elementData.numKids; ++i) {
        // Check is the kid is a leaf node (i.e. it is a ContentItem).
        const contentItem = {
          isLeaf: await element.isContentItem(i),
        };
        if (contentItem.isLeaf) {
          const cont = await element.getAsContentItem(i);
          const [type, page] = await Promise.all([cont.getType(), cont.getPage()]);
          const pageNum = await page.getIndex();

          contentItem.type = type;
          contentItem.pageNum = pageNum;

          switch (type) {
            case PDFNet.ContentItem.Type.e_MCID:
            case PDFNet.ContentItem.Type.e_MCR:
              contentItem.mcid = await cont.getMCID();
              break;
            case PDFNet.ContentItem.Type.e_OBJR:
              {
                const refObj = await cont.getRefObj();
                if (refObj) {
                  contentItem.objNum = refObj.getObjNum();
                }
              }
              break;
            default:
              break;
          }
          elementData.children.push(contentItem);
        } else {
          // the kid is another StructElement node.
          await ReadDocumentStructure(await element.getAsStructElem(i), elementData);
        }
      }
    };

    // Read the elements sequentially with a reader
    const ReadElements = async doc => {
      const elements = [];
      const reader = await PDFNet.ElementReader.create();
      for (let itr = await doc.getPageIterator(); await itr.hasNext(); itr.next()) {
        const page = await itr.current();
        reader.beginOnPage(page);
        const pageNum = await page.getIndex();
        let element;
        while ((element = await reader.next())) {
          // Read page contents
          const readElement = {
            type: await element.getType(),
            pageNum,
          };
          if (readElement.type === PDFNet.Element.Type.e_path || readElement.type === PDFNet.Element.Type.e_text || readElement.type === PDFNet.Element.Type.e_path) {
            readElement.text = await element.getTextString();
            // Check if the element is associated with any structural element.
            // Content items are leaf nodes of the structure tree.
            const structParent = await element.getParentStructElement();
            readElement.isValid = await structParent.isValid();
            if (readElement.isValid) {
              readElement.structType = await structParent.getType();
              readElement.mcid = await element.getStructMCID();
              if (await structParent.hasTitle()) {
                readElement.title = await structParent.getTitle();
              }
              readElement.objNum = await (await structParent.getSDFObj()).getObjNum();
            }
            elements.push(readElement);
          }
        }
        reader.end();
      }
      return elements;
    };

    // Used in code snippet 1.
    const ProcessStructElement = (element, indent, printState) => {
      // Print out the type and title info, if any.
      PrintAndIndent(printState, indent++);
      printState.str += `Type: ${element.type}${element.title ? `. Title: ${element.title}` : ''}`;

      for (let i = 0; i < element.numKids; ++i) {
        const child = element.children[i];
        // Check is the kid is a leaf node (i.e. it is a ContentItem).
        if (child.isLeaf) {
          PrintAndIndent(printState, indent);
          printState.str += `Content Item. Part of page #${child.pageNum}`;

          PrintAndIndent(printState, indent);
          switch (child.type) {
            case PDFNet.ContentItem.Type.e_MCID:
            case PDFNet.ContentItem.Type.e_MCR:
              printState.str += `MCID: ${child.mcid}`;
              break;
            case PDFNet.ContentItem.Type.e_OBJR:
              printState.str += 'OBJR ';
              if (child.objNum) {
                printState.str += `- Referenced Object#: ${child.objNum}`;
              }
              break;
            default:
              break;
          }
        } else {
          // the kid is another StructElement node.
          ProcessStructElement(child, indent, printState);
        }
      }
    };

    // Used in code snippet 2.
    const ProcessElementsArray = (elementsArray, printState) => {
      for (let i = 0; i < elementsArray.length; i++) {
        // Read page contents
        const element = elementsArray[i];
        // In this sample we process only paths & text, but the code can be
        // extended to handle any element type.
        if (element.type === PDFNet.Element.Type.e_path || element.type === PDFNet.Element.Type.e_text || element.type === PDFNet.Element.Type.e_path) {
          switch (element.type) {
            case PDFNet.Element.Type.e_path: // Process path ...
              printState.str += '\nPATH: ';
              break;
            case PDFNet.Element.Type.e_text: // Process text ...
              printState.str += `\nTEXT: ${element.text}\n`;
              break;
            case PDFNet.Element.Type.e_form: // Process form XObjects
              printState.str += '\nFORM XObject: ';
              // reader.formBegin();
              // await ProcessElements(reader);
              // reader.end();
              break;
          }

          if (element.isValid) {
            // Print out the parent structural element's type, title, and object number.
            printState.str += ` Type: ${element.structType}, MCID: ${element.mcid}`;
            if (element.title) {
              printState.str += `. Title: ${element.title}`;
            }
            printState.str += `, Obj#: ${element.objNum}`;
          }
        }
      }
    };

    // Used in code snippet 3.
    const CreateMCIDDocMap = elementsArray => {
      const mcidDocMap = {};
      for (let i = 0; i < elementsArray.length; i++) {
        const element = elementsArray[i];
        if (!mcidDocMap[element.pageNum]) {
          mcidDocMap[element.pageNum] = {};
        }
        const pageMcidMap = mcidDocMap[element.pageNum];
        if (element.mcid >= 0 && element.type === PDFNet.Element.Type.e_text) {
          if (element.mcid in pageMcidMap) {
            pageMcidMap[element.mcid] += element.text;
          } else {
            pageMcidMap[element.mcid] = element.text;
          }
        }
      }
      return mcidDocMap;
    };

    // Used in code snippet 3.
    const ProcessStructElement2 = (element, mcidDocMap, indent, printState) => {
      // Print out the type and title info, if any.
      PrintAndIndent(printState, indent);
      printState.str += `<${element.type}${element.title ? ` title="${element.title}"` : ''}>`;

      for (let i = 0; i < element.numKids; ++i) {
        const child = element.children[i];
        if (child.isLeaf) {
          if (child.type === PDFNet.ContentItem.Type.e_MCID) {
            const pageNum = child.pageNum;
            const mcidPageMap = mcidDocMap[pageNum];
            if (mcidPageMap) {
              const mcid = child.mcid;
              if (mcid in mcidPageMap) {
                printState.str += mcidPageMap[mcid];
              }
            }
          }
        } else {
          // the kid is another StructElement node.
          ProcessStructElement2(child, mcidDocMap, indent + 1, printState);
        }
      }

      PrintAndIndent(printState, indent);
      printState.str += `</${element.type}>`;
    };

    const main = async () => {
      // Relative path to the folder containing test files.
      const inputPath = '../TestFiles/';
      const printState = { str: '' };
      try {
        // Extract logical structure from a PDF document
        const doc = await PDFNet.PDFDoc.createFromURL(`${inputPath}tagged.pdf`);
        doc.initSecurityHandler();

        const tree = await doc.getStructTree();
        const hasValidTree = await tree.isValid();
        const numKidsFromRoot = await tree.getNumKids();
        const structRoot = {
          children: [],
        };
        let elementsArray = [];

        if (hasValidTree) {
          console.log('Document has a StructTree root.');
          const [, elementsArr] = await Promise.all([
            new Promise(async res => {
              for (let i = 0, numKids = numKidsFromRoot; i < numKids; ++i) {
                // Recursively get structure info for all child elements.
                await ReadDocumentStructure(await tree.getKid(i), structRoot);
              }
              res();
            }),
            ReadElements(doc),
          ]);
          elementsArray = elementsArr;
        } else {
          console.log('This document does not contain any logical structure.');
        }

        console.log('____________________________________________________________');
        console.log('Sample 1 - Traverse logical structure tree...');
        for (let i = 0; i < structRoot.children.length; ++i) {
          // Recursively get structure info for all child elements.
          ProcessStructElement(structRoot.children[i], 0, printState);
        }
        PrintAndIndent(printState, 0);
        console.log('Done 1.');

        console.log('____________________________________________________________');
        console.log('Sample 2 - Get parent logical structure elements from');
        console.log('layout elements.');
        ProcessElementsArray(elementsArray, printState);
        PrintAndIndent(printState, 0);
        console.log('Done 2.');

        console.log('____________________________________________________________');
        console.log("Sample 3 - 'XML style' extraction of PDF logical structure and page content.");
        {
          const mcidDocMap = CreateMCIDDocMap(elementsArray);
          if (hasValidTree) {
            for (let i = 0, numKids = numKidsFromRoot; i < numKids; ++i) {
              ProcessStructElement2(structRoot.children[i], mcidDocMap, 0, printState);
            }
          }
        }
        PrintAndIndent(printState, 0);
        console.log('Done 3.');
        const docBuffer = await doc.saveMemoryBuffer(0);
        saveBufferAsPDFDoc(docBuffer, 'bookmark.pdf');
      } catch (err) {
        console.log(err);
      }
    };

    // add your own license key as the second parameter, e.g. PDFNet.runWithCleanup(main, 'YOUR_LICENSE_KEY')
    PDFNet.runWithCleanup(main);
  };
})(window);
// eslint-disable-next-line spaced-comment
//# sourceURL=LogicalStructureTest.js