@pdftron/pdfnet-node-samples 9.4.2 → 9.5.0-beta

package/samples/ElementReaderAdvTest/NODEJS/ElementReaderAdvTest.js

@@ -0,0 +1,305 @@
+//---------------------------------------------------------------------------------------
+// Copyright (c) 2001-2021 by PDFTron Systems Inc. All Rights Reserved.
+// Consult legal.txt regarding legal and license information.
+//---------------------------------------------------------------------------------------
+
+
+const { PDFNet } = require('../../../lib/pdfnet.js');
+const PDFTronLicense = require('../../LicenseKey/NODEJS/LicenseKey');
+
+((exports) => {
+
+  exports.runElementReaderAdvTest = () => {
+
+    const processPath = async (reader, path) => {
+      if (await path.isClippingPath()) {
+        console.log('This is a clipping path');
+      }
+
+      const d = await path.getPathData();
+
+      const opr = d.operators;
+      const opr_len = opr.byteLength;
+      const data = d.points;
+      let data_idx = 0, data_len = data.byteLength / data.BYTES_PER_ELEMENT;
+
+      let x1, y1, x2, y2, x3, y3;
+
+      // Use path.GetCTM() if you are interested in CTM (current transformation matrix).
+
+      let path_str = ' Path Data Points := "';
+      for (let opr_idx = 0; opr_idx < opr_len; ++opr_idx) {
+        switch (opr[opr_idx]) {
+          case PDFNet.Element.PathSegmentType.e_moveto:
+            x1 = data[data_idx]; ++data_idx;
+            y1 = data[data_idx]; ++data_idx;
+            path_str += 'M' + Math.round(x1) + ' ' + Math.round(y1);
+            break;
+          case PDFNet.Element.PathSegmentType.e_lineto:
+            x1 = data[data_idx]; ++data_idx;
+            y1 = data[data_idx]; ++data_idx;
+            path_str += 'L' + Math.round(x1) + ' ' + Math.round(y1);
+            break;
+          case PDFNet.Element.PathSegmentType.e_cubicto:
+            x1 = data[data_idx]; ++data_idx;
+            y1 = data[data_idx]; ++data_idx;
+            x2 = data[data_idx]; ++data_idx;
+            y2 = data[data_idx]; ++data_idx;
+            x3 = data[data_idx]; ++data_idx;
+            y3 = data[data_idx]; ++data_idx;
+            path_str += 'C' + Math.round(x1) + ' ' + Math.round(y1) + ' ' + Math.round(x2)
+             + ' ' + Math.round(y2) + ' ' + Math.round(x3) + ' ' + Math.round(y3);
+            break;
+          case PDFNet.Element.PathSegmentType.e_rect:
+            x1 = data[data_idx]; ++data_idx;
+            y1 = data[data_idx]; ++data_idx;
+            const w = data[data_idx]; ++data_idx;
+            const h = data[data_idx]; ++data_idx;
+            x2 = x1 + w;
+            y2 = y1;
+            x3 = x2;
+            y3 = y1 + h;
+            const x4 = x1;
+            const y4 = y3;
+            path_str += 'M' + Math.round(x1) + ' ' + Math.round(y1) + ' L' + Math.round(x2) + ' ' + Math.round(y2)
+             + ' L' + Math.round(x3) + ' ' + Math.round(y3) + ' L' + Math.round(x4) + ' ' + Math.round(y4) + ' Z';
+            break;
+          case PDFNet.Element.PathSegmentType.e_closepath:
+            path_str += ' Close Path\n';
+            break;
+          default:
+            throw ''
+            break;
+        }
+      }
+
+      path_str += '" ';
+
+      const gs = await path.getGState();
+
+      // Set Path State 0 (stroke, fill, fill-rule) -----------------------------------
+      if (await path.isStroked()) {
+        console.log(path_str + 'Stroke path');
+        path_str = '';
+
+        if (await (await gs.getStrokeColorSpace()).getType() === PDFNet.ColorSpace.Type.e_pattern) {
+          console.log('Path has associated pattern');
+        } else {
+          // Get stroke color (you can use PDFNet color conversion facilities)
+          // ColorPt rgb;
+          // gs.GetStrokeColorSpace().Convert2RGB(gs.GetStrokeColor(), rgb);
+        }
+      } else {
+        // Do not stroke path
+      }
+
+      if (await path.isFilled()) {
+        console.log(path_str + 'Fill path');
+        path_str = '';
+
+        if (await (await gs.getFillColorSpace()).getType() === PDFNet.ColorSpace.Type.e_pattern) {
+          console.log('Path has associated pattern');
+        } else {
+          // ColorPt rgb;
+          // gs.GetFillColorSpace().Convert2RGB(gs.GetFillColor(), rgb);
+        }
+      } else {
+        // Do not fill path
+      }
+
+      if (path_str) {
+        console.log(path_str);
+      }
+
+      // Process any changes in graphics state  ---------------------------------
+
+      const gs_itr = await reader.getChangesIterator();
+      for (; await gs_itr.hasNext(); await gs_itr.next()) {
+        switch (await gs_itr.current()) {
+          case PDFNet.GState.Attribute.e_transform:
+            // Get transform matrix for this element. Unlike path.GetCTM() 
+            // that return full transformation matrix gs.GetTransform() return 
+            // only the transformation matrix that was installed for this element.
+            //
+            // gs.GetTransform();
+            break;
+          case PDFNet.GState.Attribute.e_line_width:
+            // gs.GetLineWidth();
+            break;
+          case PDFNet.GState.Attribute.e_line_cap:
+            // gs.GetLineCap();
+            break;
+          case PDFNet.GState.Attribute.e_line_join:
+            // gs.GetLineJoin();
+            break;
+          case PDFNet.GState.Attribute.e_flatness:
+            break;
+          case PDFNet.GState.Attribute.e_miter_limit:
+            // gs.GetMiterLimit();
+            break;
+          case PDFNet.GState.Attribute.e_dash_pattern:
+            {
+              // std::vector<double> dashes;
+              // gs.GetDashes(dashes);
+              // gs.GetPhase()
+            }
+            break;
+          case PDFNet.GState.Attribute.e_fill_color:
+            {
+              if (await (await gs.getFillColorSpace()).getType() === PDFNet.ColorSpace.Type.e_pattern &&
+                await (await gs.getFillPattern()).getType() !== PDFNet.PatternColor.Type.e_shading) {
+                //process the pattern data
+                await reader.patternBegin(true);
+                await processElements(reader);
+                await reader.end();
+              }
+            }
+            break;
+        }
+      }
+      await reader.clearChangeList();
+    };
+
+    const processText = async (pageReader) => {
+      // Begin text element
+      console.log('Begin Text Block:');
+
+      let element;
+      while (element = await pageReader.next()) {
+        switch (await element.getType()) {
+          case PDFNet.Element.Type.e_text_end:
+            // Finish the text block
+            console.log('End Text Block.');
+            return;
+
+          case PDFNet.Element.Type.e_text:
+            const gs = await element.getGState();
+
+            const cs_fill = await gs.getFillColorSpace();
+            const fill = await gs.getFillColor();
+
+            const out = await cs_fill.convert2RGB(fill);
+
+
+            const cs_stroke = await gs.getStrokeColorSpace();
+            const stroke = await gs.getStrokeColor();
+
+            const font = await gs.getFont();
+
+            console.log('Font Name: ' + await font.getName());
+
+            let outPutStr = '';
+            if (await font.getType() == PDFNet.Font.Type.e_Type3) {
+              //type 3 font, process its data
+              for (const itr = await element.getCharIterator(); await itr.hasNext(); await itr.next()) {
+                await pageReader.type3FontBegin(await itr.current());
+                await processElements(pageReader);
+                await pageReader.end();
+              }
+            } else {
+              const text_mtx = await element.getTextMatrix();
+
+              for (const itr = await element.getCharIterator(); await itr.hasNext(); await itr.next()) {
+                outPutStr += 'Character code: ';
+                const charData = await itr.current();
+                const charCode = charData.char_code;
+                if (charCode >= 32 || charCode <= 127) {
+                  // Print if in ASCII range...
+                  outPutStr += String.fromCharCode(charCode);
+                }
+
+                const x = charData.x;		// character positioning information
+                const y = charData.y;
+
+                // Use element.GetCTM() if you are interested in the CTM 
+                // (current transformation matrix).
+                const ctm = await element.getCTM();
+
+                // To get the exact character positioning information you need to 
+                // concatenate current text matrix with CTM and then multiply 
+                // relative positioning coordinates with the resulting matrix.
+                await ctm.multiply(text_mtx);
+                await ctm.mult(x, y);
+              }
+            }
+            console.log(outPutStr);
+            break;
+        }
+      }
+    };
+
+    const processImage = async (image) => {
+      const width = await image.getImageWidth();
+      const height = await image.getImageHeight();
+      const out_data_sz = await width * height * 3;
+
+      console.log('Image: width=\'' + width + '\' height=\'' + height + '\'');
+
+      const img_conv = await PDFNet.Filter.createImage2RGBFromElement(image);	// Extract and convert image to RGB 8-bpc format
+      const reader = await PDFNet.FilterReader.create(img_conv);
+
+      const image_data_out = await reader.read(out_data_sz);
+
+      // Note that you don't need to read a whole image at a time. Alternatively
+      // you can read a chuck at a time by repeatedly calling reader.Read(buf, buf_sz) 
+      // until the function returns 0. 
+    }
+
+    const processElements = async (reader) => {
+      let element;
+      while (element = await reader.next()) {	// Read page contents
+        switch (await element.getType()) {
+          case PDFNet.Element.Type.e_path:						// Process path data...
+            await processPath(reader, element);
+            break;
+          case PDFNet.Element.Type.e_text_begin: 				// Process text block...
+            await processText(reader);
+            break;
+          case PDFNet.Element.Type.e_form:						// Process form XObjects
+            await reader.formBegin();
+            await processElements(reader);
+            await reader.end();
+            break;
+          case PDFNet.Element.Type.e_image:						// Process Images
+            await processImage(element);
+            break;
+        }
+      }
+    }
+
+    const main = async () => {
+      // Relative path to the folder containing test files.
+      const inputPath = '../../TestFiles/';
+      try {
+        console.log('-------------------------------------------------');
+        console.log('Extract page element information from all ');
+        console.log('pages in the document.');
+
+        const doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'newsletter.pdf');
+        doc.initSecurityHandler();
+
+        const pgnum = await doc.getPageCount();
+        const pageBegin = await doc.getPageIterator();
+
+        const pageReader = await PDFNet.ElementReader.create();
+
+        for (const itr = pageBegin; await itr.hasNext(); await itr.next())		//  Read every page
+        {
+          const curPage = await itr.current();
+          console.log('Page ' + await curPage.getIndex() + '----------------------------------------');
+          await pageReader.beginOnPage(curPage);
+          await processElements(pageReader);
+          await pageReader.end();
+        }
+
+        console.log('Done.');
+      } catch (err) {
+        console.log(err);
+      }
+    };
+    PDFNet.runWithCleanup(main, PDFTronLicense.Key).catch(function (error) { console.log('Error: ' + JSON.stringify(error)); }).then(function () { return PDFNet.shutdown(); });
+  };
+  exports.runElementReaderAdvTest();
+})(exports);
+// eslint-disable-next-line spaced-comment
+//# sourceURL=ElementReaderAdvTest.js

package/samples/ElementReaderAdvTest/NODEJS/RunTest.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+node ElementReaderAdvTest.js

package/samples/ElementReaderTest/ElementReaderTest.js

@@ -1,5 +1,5 @@
 //---------------------------------------------------------------------------------------
-// Copyright (c) 2001-2022 by PDFTron Systems Inc. All Rights Reserved.
+// Copyright (c) 2001-2023 by PDFTron Systems Inc. All Rights Reserved.
 // Consult legal.txt regarding legal and license information.
 //---------------------------------------------------------------------------------------
 

package/samples/ElementReaderTest/NODEJS/ElementReaderTest.js

@@ -0,0 +1,77 @@
+//---------------------------------------------------------------------------------------
+// Copyright (c) 2001-2021 by PDFTron Systems Inc. All Rights Reserved.
+// Consult legal.txt regarding legal and license information.
+//---------------------------------------------------------------------------------------
+
+
+const { PDFNet } = require('../../../lib/pdfnet.js');
+const PDFTronLicense = require('../../LicenseKey/NODEJS/LicenseKey');
+
+((exports) => {
+
+  exports.runElementReaderTest = () => {
+
+    const ProcessElements = async(reader) => {
+      // Read page contents
+      for (let element = await reader.next(); element !== null; element = await reader.next()) {
+        const temp = await element.getType();
+        switch (temp) {
+          case PDFNet.Element.Type.e_path: // Process path data...
+            {
+              const data = await element.getPathData();
+              /* eslint-disable no-unused-vars */
+              const operators = data.operators;
+              const points = data.points;
+              /* eslint-enable no-unused-vars */
+            }
+            break;
+          case PDFNet.Element.Type.e_text: // Process text strings...
+            {
+              const data = await element.getTextString();
+              console.log(data);
+            }
+            break;
+          case PDFNet.Element.Type.e_form: // Process form XObjects
+            reader.formBegin();
+            await ProcessElements(reader);
+            reader.end();
+            break;
+          default:
+        }
+      }
+    };
+
+    const main = async() => {
+      console.log('-------------------------------------------------');
+      console.log('Sample 1 - Extract text data from all pages in the document.');
+      console.log('Opening the input pdf...');
+      const ret = 0;
+
+      // Relative path to the folder containing test files.
+      const inputUrl = '../../TestFiles/';
+
+      const doc = await PDFNet.PDFDoc.createFromFilePath(inputUrl + 'newsletter.pdf');// await if there is ret that we care about.
+      doc.initSecurityHandler();
+
+      // eslint-disable-next-line no-unused-vars
+      const pgnum = await doc.getPageCount();
+      const pageReader = await PDFNet.ElementReader.create();
+      const itr = await doc.getPageIterator(1);
+
+      // Read every page
+      for (itr; await itr.hasNext(); itr.next()) {
+        const curritr = await itr.current();
+        pageReader.beginOnPage(curritr);
+        await ProcessElements(pageReader);
+        pageReader.end();
+      }
+
+      console.log('Done.');
+      return ret;
+    };
+    PDFNet.runWithCleanup(main, PDFTronLicense.Key).catch(function(error){console.log('Error: ' + JSON.stringify(error));}).then(function(){return PDFNet.shutdown();});
+  };
+  exports.runElementReaderTest();
+})(exports);
+// eslint-disable-next-line spaced-comment
+//# sourceURL=ElementReaderTest.js

package/samples/ElementReaderTest/NODEJS/RunTest.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+node ElementReaderTest.js

package/samples/EncTest/EncTest.js

@@ -1,5 +1,5 @@
 //---------------------------------------------------------------------------------------
-// Copyright (c) 2001-2022 by PDFTron Systems Inc. All Rights Reserved.
+// Copyright (c) 2001-2023 by PDFTron Systems Inc. All Rights Reserved.
 // Consult legal.txt regarding legal and license information.
 //---------------------------------------------------------------------------------------
 

package/samples/EncTest/NODEJS/EncTest.js

@@ -0,0 +1,176 @@
+//---------------------------------------------------------------------------------------
+// Copyright (c) 2001-2021 by PDFTron Systems Inc. All Rights Reserved.
+// Consult legal.txt regarding legal and license information.
+//---------------------------------------------------------------------------------------
+
+//---------------------------------------------------------------------------------------
+// This sample shows encryption support in PDFNet. The sample reads an encrypted document and 
+// sets a new SecurityHandler. The sample also illustrates how password protection can 
+// be removed from an existing PDF document.
+//---------------------------------------------------------------------------------------
+const { PDFNet } = require('../../../lib/pdfnet.js');
+const PDFTronLicense = require('../../LicenseKey/NODEJS/LicenseKey');
+
+((exports) => {
+  exports.runEncTest = () => {
+
+    const main = async () => {
+      let ret = 0;
+      // Relative path to the folder containing test files.
+      const inputPath = '../../TestFiles/';
+      const outputPath = inputPath + 'Output/';
+      // Example 1:
+      // secure a PDF document with password protection and adjust permissions
+      try {
+        // Open the test file
+        console.log('-------------------------------------------------/nSecuring an existing document...');
+        const doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'fish.pdf');
+        if (!(await doc.initSecurityHandler())) {
+          console.log('Document authentication error...');
+          ret = 1;
+        }
+
+        const performOperation = true; // optional parameter
+
+        // Perform some operation on the document. In this case we use low level SDF API
+        // to replace the content stream of the first page with contents of file 'my_stream.txt'
+        // Results in fish.pdf becoming a pair of feathers.
+        if (performOperation) {
+          console.log('Replacing the content stream, use Flate compression...');
+          // Get the page dictionary using the following path: trailer/Root/Pages/Kids/0
+          const pageTrailer = await doc.getTrailer();
+          const pageRoot = await pageTrailer.get('Root');
+          const pageRootValue = await pageRoot.value();
+          const pages = await pageRootValue.get('Pages');
+          const pagesVal = await pages.value();
+          const kids = await pagesVal.get('Kids');
+          const kidsVal = await kids.value();
+          const pageDict = await kidsVal.getAt(0);
+
+          const embedFile = await PDFNet.Filter.createMappedFileFromUString(inputPath + 'my_stream.txt');
+          const mystm = await PDFNet.FilterReader.create(embedFile);
+
+          const flateEncode = await PDFNet.Filter.createFlateEncode();
+
+          const indStream = await doc.createIndirectStreamFromFilter(mystm, flateEncode);
+          await pageDict.put('Contents', indStream);
+        }
+
+        // Encrypt the document
+        // Apply a new security handler with given security settings.
+        // In order to open saved PDF you will need a user password 'test'.
+        const newHandler = await PDFNet.SecurityHandler.createDefault();
+
+        // Set a new password required to open a document
+        newHandler.changeUserPasswordUString('test');
+
+        // Set Permissions
+        newHandler.setPermission(PDFNet.SecurityHandler.Permission.e_print, true);
+        await newHandler.setPermission(PDFNet.SecurityHandler.Permission.e_extract_content, false);
+
+        // Note: document takes the ownership of newHandler.
+        doc.setSecurityHandler(newHandler);
+
+        // Save the changes
+        console.log('Saving modified file...');
+        await doc.save(outputPath + 'secured.pdf', 0);
+        console.log('Done. Result saved in secured.pdf');
+      } catch (err) {
+        console.log(err);
+        console.log(err.stack);
+        ret = 1;
+      }
+
+      // Example 2:
+      // Opens an encrypted PDF document and removes its security.
+      try {
+        console.log('-------------------------------------------------');
+        console.log('Open the password protected document from the first example...');
+        const securedDoc = await PDFNet.PDFDoc.createFromFilePath(outputPath + 'secured.pdf');
+        console.log('Initializing security handler without any user interaction...');
+
+        // At this point MySecurityHandler callbacks will be invoked. 
+        // MySecurityHandler.GetAuthorizationData() should collect the password and 
+        // AuthorizeFailed() is called if user repeatedly enters a wrong password.
+        if (!(await securedDoc.initStdSecurityHandlerUString('test'))) {
+          console.log('Document authentication error.../nThe password is not valid.');
+          ret = 1;
+          return ret;
+        }
+
+        console.log('The password is correct! Document can now be used for reading and editing');
+
+        // Remove the password security and save the changes to a new file.
+        securedDoc.removeSecurity();
+        await securedDoc.save(outputPath + 'secured_nomore1.pdf', 0);
+        console.log('Done. Result saved in secured_nomore1.pdf');
+
+        /*
+        const hdlr = await securedDoc.getSecurityHandler();
+
+        console.log('Document Open Password: ' + (await hdlr.isUserPasswordRequired()));
+        console.log('Permissions Password: ' + (await hdlr.isMasterPasswordRequired()));
+        console.log('Permissions: ');
+        console.log("\tHas 'owner' permissions: " + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_owner)));
+
+        console.log('\tOpen and decrypt the document: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_doc_open)));
+        console.log('\tAllow content extraction: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_extract_content)));
+        console.log('\tAllow full document editing: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_doc_modify)));
+        console.log('\tAllow printing: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_print)));
+        console.log('\tAllow high resolution printing: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_print_high)));
+        console.log('\tAllow annotation editing: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_mod_annot)));
+        console.log('\tAllow form fill: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_fill_forms)));
+        console.log('\tAllow content extraction for accessibility: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_access_support)));
+        console.log('\tAllow document assembly: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_assemble_doc)));
+        */
+      } catch (err) {
+        console.log(err.stack);
+        ret = 1;
+      }
+
+      // Example 3:
+      // Encrypt/Decrypt a PDF using PDFTron custom security handler
+      try {
+        console.log('-------------------------------------------------');
+        console.log('Encrypt a document using PDFTron Custom Security handler with a custom id and password...');
+        const doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + "BusinessCardTemplate.pdf");
+
+        // Create PDFTron custom security handler with a custom id. Replace this with your own integer
+        const custom_id = 123456789;
+        const custom_handler = await PDFNet.PDFTronCustomSecurityHandler.create(custom_id);
+
+        // Add a password to the custom security handler
+        const pass = 'test';
+        await custom_handler.changeUserPasswordUString(pass);
+
+        // Save the encrypted document
+        doc.setSecurityHandler(custom_handler);
+        await doc.save(outputPath + 'BusinessCardTemplate_enc.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
+
+        console.log('Decrypt the PDFTron custom security encrypted document above...');
+        // Register the PDFTron Custom Security handler with the same custom id used in encryption
+        await PDFNet.addPDFTronCustomHandler(custom_id);
+
+        const doc_enc = await PDFNet.PDFDoc.createFromFilePath(outputPath + 'BusinessCardTemplate_enc.pdf');
+        doc_enc.initStdSecurityHandlerUString(pass);
+        doc_enc.removeSecurity();
+        // Save the decrypted document
+        await doc_enc.save(outputPath + 'BusinessCardTemplate_enc_dec.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
+        console.log('Done. Result saved in BusinessCardTemplate_enc_dec.pdf');
+      } catch (err) {
+        console.log(err.stack);
+        ret = 1;
+      }
+
+      console.log('-------------------------------------------------');
+      console.log('Tests completed.');
+
+      return ret;
+    };
+
+    PDFNet.runWithCleanup(main, PDFTronLicense.Key).catch(function (error) { console.log('Error: ' + JSON.stringify(error)); }).then(function () { return PDFNet.shutdown(); });
+  };
+  exports.runEncTest();
+})(exports);
+// eslint-disable-next-line spaced-comment
+//# sourceURL=EncTest.js

package/samples/EncTest/NODEJS/RunTest.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+node EncTest.js