Initial commit

Author: scriptcoded

.babelrc

@@ -0,0 +1,7 @@
+{
+  "presets": [["airbnb", {
+    "targets": {
+      "node": 8
+    }
+  }]]
+}

.eslintrc

@@ -0,0 +1,3 @@
+{
+  "extends": "airbnb-base"
+}

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+*.log

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Malcolm Nihlén
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,166 @@
+# simple-pdf
+
+`simple-pdf` aims to be a simple drop-in module for extracting text and images
+from PDF files. It exposes a promise-based and an event-based API.
+
+## Table of contents
+- [Features](#features)
+- [Reasons not to use this library](#reasons-not-to-use-this-library)
+- [Minimal example](#minimal-example)
+- [Installation](#installation)
+- [Docs](#docs)
+  - [Options](#options)
+  - [Basic parsing](#basic-parsing)
+  - [Advanced parsing](#advanced-parsing)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Features
+
+- Extracts both text and images
+- Handles most image encodings
+
+## Reasons not to use this library
+
+Let's be real. This might not be the library for you. Here are a few reasons why.
+
+- **Slow with images** - Images can be embedded in a PDF in many different ways. To ensure that all types of images can be extracted we render the whole PDF and then use [sharp](https://github.com/lovell/sharp) to extract the images from the rendered page. This adds extra processing time for pages that contains images (provided that you don't disable image extraction).
+- **New to the game** - This library is brand new and haven't been battle tested yet. If you're looking for a reliable solution, this library might not be the best choice for you.
+- **No automated testing** - Though I'm working on this 🙃
+
+## Minimal example
+
+More examples can be found in the `examples` directory
+
+```javascript
+const fs = require('fs');
+const { SimplePDFParser } = require('simple-pdf');
+
+const fileBuffer = fs.readFileSync('somefile.pdf');
+
+const parser = new SimplePDFParser(fileBuffer);
+
+parser.parse().then((result) => {
+  console.log(result)
+});
+```
+
+## Installation
+
+```bash
+npm i simple-pdf
+```
+
+## Docs
+
+The only exposed interface is the `SimplePDFParser` class. It takes a `Buffer` containing a PDF file as well as an optional options object.
+
+```javascript
+new SimplePDFParser(fileBuffer, {
+  // options
+})
+```
+
+### Options
+|Option|Value type|Default value|Description|
+|-|-|-|-|
+|`paragraphThreshold`|integer|`25`|The minimum distance between two lines on the y-axis to consider them part of separate paragraphs. This option only affects the `parse` method.
+|`lineThreshold`|integer|`1`|The minimum distance between two lines on the y-axis to consider them part of the same line. PDFs usually suffer from issues with floating point numbers. This value is used to give a little room for error. You shouldn't have to change this value unless you're dealing with PDFs generated with OCR or other odd PDFs.
+|`imageScale`|integer|`2`|Scaling applied to the PDF before extrating images. Higher value results in greater image resolution, but quadratically increases rendering times.
+|`extractImages`|boolean|`true`|Controls whether or not to extract images. Image extraction requires rendering of each page, which might take a long time depending on the size of the PDF, configured `imageScale` and underlying hardware. If you don't need to extract images, setting this option to `false` is recommended.
+|`ignoreEmptyText`|boolean|`true`|Controls whether or not to ignore empty text elements. Text elements are considered empty if their text content contains nothing by whitespace.
+|`joinParagraphs`|boolean|`false`|Controls whether or not to join paragraphs. Enabling this option will join each line that's not separated by a non-text element (paragraph break or image) which will effectively make each line contain a paragraph. Paragraph breaks will be omitted from the final output. This option only affects the `parse` method.
+
+### Basic parsing
+
+This is probaly the easiest way to use this library. It parses all pages in parallel and returns the result when finished. Paragraphs and lines are automatically joined based on the options passed to the constructor.
+
+*Example:*
+```javascript
+const parser = new SimplePDFParser(fileBuffer)
+
+const result = await parser.parse()
+```
+
+*Result:*
+```javascript
+[
+  {
+    "type": "text",
+    "pageIndex": 0,
+    "items": [
+      {
+        "text": "Lorem ipsum",
+        "font": "g_d0_f1"
+      }
+    ]
+  },
+  {
+    "type": "image",
+    "pageIndex": 0,
+    "imageBuffer": Buffer
+  }
+]
+```
+
+### Advanced parsing
+
+If you need more granuar control of the resulting data structure you might want to use the advanced parsing. You can choose to either just await the result or use the events to process each page as it is finished parsing. Note that pages are not guaranteed to be returned in order.
+
+*Example:*
+```javascript
+const parser = new SimplePDFParser(fileBuffer)
+
+// Called with each page
+parser.on('page', (page) => {
+  console.log(`Page ${page.index}:`);
+  console.log('Text elements: ', page.textElements);
+  console.log('Image elements:', page.imageElements);
+});
+
+// Called when the parsing is finished
+parser.on('done', () => {
+  console.log('Parser done');
+});
+
+// This must be run even if you just use the events API, but then you may ignore the return value
+const result = await parser.parseRaw()
+```
+
+*Result (each page):*
+
+```javascript
+{
+  index: 0, // Page index
+  textElements: [{
+    x: 123.456,
+    y: 654.321,
+    items: [{
+      text: 'Lorem ipsum',
+      font: 'g_d0_f1'
+    }]
+  }],
+  imageElements: [{
+    x: 4.2,
+    y: 83.11,
+    width: 120,
+    height: 80,
+    imageBuffer: Buffer
+  }]
+}
+```
+
+## Contributing
+
+Contributions and PRs are very welcome! PRs should go towards the `develop` branch.
+
+We use the [Airbnb style guide](https://github.com/airbnb/javascript). Please
+run ESLint before committing any changes:
+```bash
+npx eslint src
+npx eslint src --fix
+```
+
+## License
+
+This project is licensed under the MIT license.

examples/events.js

@@ -0,0 +1,37 @@
+/* eslint-disable no-restricted-syntax */
+
+const fs = require('fs');
+const util = require('util');
+const path = require('path');
+
+const { SimplePDFParser } = require('../lib');
+
+// Promisifying fs.readFile so that we can use it with promises
+const readFile = util.promisify(fs.readFile);
+
+// Wrap everything in an async function so that we can use async/await
+async function start() {
+  // const fileBuffer = await readFile(path.join(__dirname, './pdfs/text-only.pdf'));
+  const fileBuffer = await readFile(path.join(__dirname, './pdfs/images-and-formatting.pdf'));
+
+  // Create a new parser without options
+  const parser = new SimplePDFParser(fileBuffer);
+
+  // Called with each page
+  parser.on('page', (page) => {
+    console.log(`Page ${page.index}:`);
+    console.log('Text elements: ', page.textElements);
+    console.log('Image elements:', page.imageElements);
+  });
+
+  // Called when the parsing is finished
+  parser.on('done', () => {
+    console.log('Parser done');
+  });
+
+  // Start the parser and wait for it to finish
+  await parser.parseRaw();
+}
+
+// Start the program
+start();

examples/pdfs/images-and-formatting.pdf

@@ -0,0 +1,37 @@
+/* eslint-disable no-restricted-syntax */
+
+const fs = require('fs');
+const util = require('util');
+const path = require('path');
+
+const { SimplePDFParser } = require('../lib');
+
+// Promisifying fs.readFile so that we can use it with promises
+const readFile = util.promisify(fs.readFile);
+
+// Wrap everything in an async function so that we can use async/await
+async function start() {
+  // const fileBuffer = await readFile(path.join(__dirname, './pdfs/text-only.pdf'));
+  const fileBuffer = await readFile(path.join(__dirname, './pdfs/images-and-formatting.pdf'));
+
+  // Create a new parser with joinParagraphs enabled
+  const parser = new SimplePDFParser(fileBuffer, {
+    joinParagraphs: true,
+  });
+
+  // Run the parser
+  const result = await parser.parse();
+
+  // Print each line
+  for (const line of result) {
+    // If it's a text line, print it. Else, print the type.
+    if (line.type === 'text') {
+      console.log(line.items.map((item) => item.text).join(''));
+    } else {
+      console.log(`[${line.type}]`);
+    }
+  }
+}
+
+// Start the program
+start();

examples/pdfs/text-only.pdf

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _canvas = _interopRequireDefault(require("canvas"));
+
+var _assert = require("assert");
+
+/* eslint-disable no-param-reassign */
+
+/* eslint-disable class-methods-use-this */
+
+/*
+ * This code was taken from https://github.com/mozilla/pdf.js/blob/master/examples/node/pdf2png/pdf2png.js
+ */
+class NodeCanvasFactory {
+  create(width, height) {
+    (0, _assert.strict)(width > 0 && height > 0, 'Invalid canvas size');
+
+    const canvas = _canvas["default"].createCanvas(width, height);
+
+    const context = canvas.getContext('2d');
+    return {
+      canvas,
+      context
+    };
+  }
+
+  reset(canvasAndContext, width, height) {
+    (0, _assert.strict)(canvasAndContext.canvas, 'Canvas is not specified');
+    (0, _assert.strict)(width > 0 && height > 0, 'Invalid canvas size');
+    canvasAndContext.canvas.width = width;
+    canvasAndContext.canvas.height = height;
+  }
+
+  destroy(canvasAndContext) {
+    (0, _assert.strict)(canvasAndContext.canvas, 'Canvas is not specified'); // Zeroing the width and height cause Firefox to release graphics
+    // resources immediately, which can greatly reduce memory consumption.
+
+    canvasAndContext.canvas.width = 0;
+    canvasAndContext.canvas.height = 0;
+    canvasAndContext.canvas = null;
+    canvasAndContext.context = null;
+  }
+
+}
+
+exports["default"] = NodeCanvasFactory;