muhammara 3.5.0 → 3.6.0

package/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## [3.6.0] - 2023-01-24
+
+### Added
+
+- Pre builts for arm64 / musl architecture (M1 using alpine)
+- Hummus-recipe / Muhammara-recipe as part of this lib
+
+### Fixed
+
+- Memory leak in ByteReaderWithPositionDriver when reading PDF files
+
 ## [3.5.0] - 2022-12-07
 
 ### Added
@@ -332,7 +343,8 @@ with the following changes.
 
 - Initial release
 
-[unreleased]: https://github.com/julianhille/MuhammaraJS/compare/3.5.0...HEAD
+[unreleased]: https://github.com/julianhille/MuhammaraJS/compare/3.6.0...HEAD
+[3.6.0]: https://github.com/julianhille/MuhammaraJS/compare/3.5.0...3.6.0
 [3.5.0]: https://github.com/julianhille/MuhammaraJS/compare/3.4.0...3.5.0
 [3.4.0]: https://github.com/julianhille/MuhammaraJS/compare/3.3.0...3.4.0
 [3.3.0]: https://github.com/julianhille/MuhammaraJS/compare/3.2.0...3.3.0

package/README.md

@@ -3,19 +3,28 @@
 [![NPM version](http://img.shields.io/npm/v/muhammara.svg?style=flat)](https://www.npmjs.org/package/muhammara)
 [![Build status](https://github.com/julianhille/MuhammaraJS/actions/workflows/build.yml/badge.svg?branch=develop)](https://github.com/julianhille/MuhammaraJS/actions/workflows/build.yml)
 
+Welcome to MuhammaraJS.
+A Fast NodeJS Module for Creating, Parsing an Manipulating PDF Files and Streams.
+
+Original Project (CPP base version)
+Project site is [here](http://www.pdfhummus.com).
+
+If you are looking for a C++ Library go [here](https://github.com/galkahana/PDF-Writer).
+
+## Hummus JS is the base
+
 This is a drop in replacement for hummusJS originally made by Galkahana.
 He did an awesome job, but discontinued hummusjs.
 
 The documentation for MuhammaraJS / HummusJS is still located at the
 hummusJS github wiki: available [here](https://github.com/galkahana/HummusJS/wiki)
 
-Welcome to HummusJS.
-A Fast NodeJS Module for Creating, Parsing an Manipulating PDF Files and Streams.
+## muhammara-recipe '(formerly known as hummus-recipe) as been added
 
-Original Project
-Project site is [here](http://www.pdfhummus.com).
+Muhammara-recipe and hummus-recipe has been integrated, dependencies updated
+and is now shipped along with muhammara itself.
 
-If you are looking for a C++ Library go [here](https://github.com/galkahana/PDF-Writer).
+It serves as a drop in replacement.
 
 # Caution
 
@@ -36,7 +45,7 @@ npm install muhammara
 
 ```
 
-# Replace hummusJS with MuhammaraJS
+# Replace hummusJS with MuhammaraJS for hummus
 
 Replace:
 
@@ -50,6 +59,26 @@ With:
 let muhammara = require('muhammara')
 ```
 
+# Replace hummus-recipe or muhammara-recipe with MuhammaraJS
+
+Replace:
+
+`const HummusRecipe = require('hummus-recipe');`
+
+With:
+
+```
+const HummusRecipe = require('muhammara').Receipe;
+```
+
 # Documentation
 
+## Muhammara
+
 You can find samples and documentation [here](./docs/Home.md)
+
+### Muhammara Recipe:
+
+To generate the documentation you could clone this repo and execute:
+
+`npm run recipe-jsdoc`

package/lib/Recipe.js

@@ -0,0 +1,325 @@
+const muhammara = require("./muhammara");
+const path = require("path");
+const fs = require("fs");
+const streams = require("memory-streams");
+
+/**
+ * @name Recipe
+ * @desc Create a pdfDoc
+ * @namespace
+ * @constructor
+ * @param {string} src - The file path or Buffer of the src file.
+ * @param {string} output - The path of the output file.
+ * @param {Object} [options] - The options for pdfDoc
+ * @param {number} [options.version] - The pdf version
+ * @param {string} [options.author] - The author
+ * @param {string} [options.title] - The title
+ * @param {string} [options.subject] - The subject
+ * @param {string} [options.colorspace] - The default colorspace: rgb, cmyk, gray
+ * @param {string[]} [options.keywords] - The array of keywords
+ * @param {string} [options.password] - permission password
+ * @param {string} [options.userPassword] - this 'view' password also enables encryption
+ * @param {string} [options.ownerPassword] - this allows owner to 'edit' file
+ * @param {string} [options.userProtectionFlag] - encryption security level (see permissions)
+ * @param {string|string[]} [options.fontSrcPath] - directory location(s) of additional fonts
+ */
+class Recipe {
+  constructor(src, output, options = {}) {
+    this.src = src;
+    // detect the src is Buffer or not
+    this.isBufferSrc = this.src instanceof Buffer;
+    this.isNewPDF = !this.isBufferSrc && src.toLowerCase() === "new";
+    this.encryptOptions = this._getEncryptOptions(options, this.isNewPDF);
+    this.options = Object.assign({}, options, this.encryptOptions);
+    this.current = {};
+    this.current.defaultFontSize = 14;
+
+    if (this.isBufferSrc) {
+      this.outStream = new streams.WritableStream();
+      this.output = output;
+    } else {
+      this.output = output || src;
+      if (this.src) {
+        this.filename = path.basename(this.src);
+      }
+    }
+    this.muhammara = muhammara;
+    this.logFile = "muhammara-error.log";
+
+    this.textMarkupAnnotations = [
+      "Highlight",
+      "Underline",
+      "StrikeOut",
+      "Squiggly",
+    ];
+
+    this.annotationsToWrite = [];
+    this.annotations = [];
+    this.vectorsToWrite = [];
+
+    this.xObjects = [];
+
+    this.needToEncrypt = false;
+
+    this.needToInsertPages = false;
+
+    this._setParameters(options);
+
+    this._loadFonts(path.join(__dirname, "../fonts"));
+
+    if (options.fontSrcPath) {
+      this._loadFonts(options.fontSrcPath);
+    }
+    this._createWriter();
+  }
+
+  _createWriter() {
+    if (this.isNewPDF) {
+      this.writer = muhammara.createWriter(
+        this.output,
+        Object.assign({}, this.encryptOptions, {
+          version: this._getVersion(this.options.version),
+        })
+      );
+    } else {
+      this.read();
+      try {
+        if (this.isBufferSrc) {
+          this.writer = muhammara.createWriterToModify(
+            new muhammara.PDFRStreamForBuffer(this.src),
+            new muhammara.PDFStreamForResponse(this.outStream),
+            Object.assign({}, this.encryptOptions, {
+              log: this.logFile,
+            })
+          );
+        } else {
+          this.writer = muhammara.createWriterToModify(
+            this.src,
+            Object.assign({}, this.encryptOptions, {
+              modifiedFilePath: this.output,
+              log: this.logFile,
+            })
+          );
+        }
+      } catch (err) {
+        throw new Error(err);
+      }
+    }
+
+    this.info(this.options);
+  }
+
+  _getVersion(version) {
+    const supportedVersions = [1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7];
+    if (!supportedVersions.includes(version)) {
+      version = 1.7;
+    }
+    version = muhammara[`ePDFVersion${version * 10}`];
+
+    return version;
+  }
+
+  get position() {
+    const { ox, oy } = this._reverseCoordinate(
+      this._position.x,
+      this._position.y
+    );
+    return {
+      x: ox,
+      y: oy,
+    };
+  }
+
+  read(inSrc) {
+    const isForExternal = inSrc ? true : false;
+    try {
+      let src = isForExternal ? inSrc : this.src;
+      if (this.isBufferSrc) {
+        src = new muhammara.PDFRStreamForBuffer(this.src);
+      }
+      const pdfReader = muhammara.createReader(src, this.encryptOptions);
+      const pages = pdfReader.getPagesCount();
+      if (pages == 0) {
+        // broken or modify password protected
+        throw "HummusJS: Unable to read/edit PDF file (pages=0)";
+      }
+      const metadata = {
+        pages,
+      };
+      for (var i = 0; i < pages; i++) {
+        const info = pdfReader.parsePage(i);
+        const dimensions = info.getMediaBox();
+        const rotate = info.getRotate();
+
+        let layout, width, height, pageSize;
+        let side1 = Math.abs(dimensions[2] - dimensions[0]);
+        let side2 = Math.abs(dimensions[3] - dimensions[1]);
+        if (side1 > side2 && rotate % 180 === 0) {
+          layout = "landscape";
+        } else if (side1 < side2 && rotate % 180 !== 0) {
+          layout = "landscape";
+        } else {
+          layout = "portrait";
+        }
+
+        if (layout === "landscape") {
+          width = side1 > side2 ? side1 : side2;
+          height = side1 > side2 ? side2 : side1;
+        } else {
+          width = side1 > side2 ? side2 : side1;
+          height = side1 > side2 ? side1 : side2;
+        }
+
+        pageSize = [width, height].sort((a, b) => {
+          return a > b ? 1 : -1;
+        });
+
+        const page = {
+          pageNumber: i + 1,
+          mediaBox: dimensions,
+          layout,
+          rotate,
+          width,
+          height,
+          size: pageSize,
+          // usually 0
+          offsetX: dimensions[0],
+          offsetY: dimensions[1],
+        };
+        metadata[page.pageNumber] = page;
+      }
+      if (!isForExternal) {
+        this.pdfReader = pdfReader;
+        this.metadata = metadata;
+      }
+      return metadata;
+    } catch (err) {
+      throw new Error(err);
+    }
+  }
+
+  /**
+   * End the pdfDoc
+   * @function
+   * @memberof Recipe
+   * @param {function} callback - The callback function.
+   */
+  endPDF(callback) {
+    this._writeInfo();
+    this.writer.end();
+    // This is a temporary work around for copying context will overwrite the current one
+    // write annotations at the end.
+    if (
+      (this.annotations && this.annotations.length > 0) ||
+      (this.annotationsToWrite && this.annotationsToWrite.length > 0)
+    ) {
+      if (this.isBufferSrc) {
+        const oldStream = this.outStream;
+        this.outStream = new streams.WritableStream();
+
+        this.writer = muhammara.createWriterToModify(
+          new muhammara.PDFRStreamForBuffer(oldStream.toBuffer()),
+          new muhammara.PDFStreamForResponse(this.outStream),
+          Object.assign({}, this.encryptOptions, {
+            log: this.logFile,
+          })
+        );
+      } else {
+        this.writer = muhammara.createWriterToModify(
+          this.output,
+          Object.assign({}, this.encryptOptions, {
+            modifiedFilePath: this.output,
+            log: this.logFile,
+          })
+        );
+      }
+
+      this._writeAnnotations();
+      this._writeInfo();
+      this.writer.end();
+    }
+    if (this.needToInsertPages) {
+      if (this.isBufferSrc) {
+        // eslint-disable-next-line no-console
+        console.log(
+          "Feature: Inserting Pages is not supported in Buffer Mode yet."
+        );
+      } else {
+        this._insertPages();
+      }
+    }
+    if (this.needToEncrypt) {
+      if (this.isBufferSrc) {
+        // eslint-disable-next-line no-console
+        console.log("Feature: Encryption is not supported in Buffer Mode yet.");
+      } else {
+        this._encrypt();
+      }
+    }
+
+    if (this.isBufferSrc && this.output) {
+      fs.writeFileSync(this.output, this.outStream.toBuffer());
+    }
+
+    if (callback) {
+      if (this.isBufferSrc) {
+        if (this.output) {
+          return callback(this.output);
+        } else {
+          return callback(this.outStream.toBuffer());
+        }
+      } else {
+        return callback();
+      }
+    }
+  }
+
+  /**
+   * Register callback procedure with hummus-recipe.
+   * @function
+   * @memberof Recipe
+   * @param {string} key name assigned to given callback. Note that if an actual function is being
+   * registered, and its given name is what is to be used to access it, the key is unnecessary.
+   * @param {Function} callback procedure that can be accessed through hummus-recipe
+   */
+  register(key, callback) {
+    // Assume simply registering a function which will have an embedded name
+    if (typeof key !== "string") {
+      if (!key.name) {
+        throw "Cannot register unnamed callback function. Provide 'name' as first argument, then callback function.";
+      }
+      callback = key;
+      key = key.name;
+    }
+
+    if (this.__proto__[key]) {
+      throw `Found conflict in Recipe prototypes. ${key} already exists.`;
+    }
+
+    if (typeof callback !== "function") {
+      throw `${key} expecting callback to be of type function.`;
+    }
+
+    this.__proto__[key] = callback;
+  }
+}
+
+function loadPrototypes() {
+  const ignores = ["xObjectForm.js"];
+  fs.readdirSync(path.join(__dirname, "recipe"))
+    .filter((file) => {
+      return file[0] != "." && !ignores.includes(file);
+    })
+    .forEach((file) => {
+      const module = require(path.join(__dirname, "recipe", file));
+      for (let key in module) {
+        if (Recipe.prototype[key]) {
+          throw `Found conflict prototypes=${key} in ${file}.`;
+        }
+        Recipe.prototype[key] = module[key];
+      }
+    });
+}
+
+loadPrototypes();
+module.exports = Recipe;

package/lib/index.js

@@ -0,0 +1,2 @@
+module.exports = require("./muhammara");
+module.exports.Recipe = require("./Recipe.js");

package/{muhammara.js → lib/muhammara.js}

@@ -1,8 +1,7 @@
-var fs = require("fs");
 var path = require("path");
 var pregyp = require("@mapbox/node-pre-gyp");
 var binding_path = pregyp.find(
-  path.resolve(path.join(__dirname, "./package.json"))
+  path.resolve(path.join(__dirname, "../package.json"))
 );
 var muhammara = (module.exports = require(binding_path));
 var EventEmitter = require("events").EventEmitter;