pdfreader

The PdfReader class is the primary interface for parsing PDF files. You can instantiate it with an optional configuration object, such as { debug: true } for troubleshooting.

Parsing is performed using either parseFileItems(filename, callback) or parseBuffer(buffer, callback). Both methods use a callback that is invoked for every item found during parsing.

An item object can be one of the following:

• null: Indicates the end of the file or that an error occurred.
• {file: {path: string}}: File metadata, always the first item.
• {page: integer, width: float, height: float}: Page metadata (page numbers start at 1). This acts as a boundary for coordinate-based text processing.
• {text: string, x: float, y: float, w: float, ...}: A text item containing the string and its 2D AABB coordinates on the page.

import { PdfReader } from "pdfreader";

new PdfReader().parseFileItems("test/sample.pdf", (err, item) => {
  if (err) console.error("error:", err);
  else if (!item) console.warn("end of file");
  else if (item.text) console.log(item.text);
});

The Rule class allows you to define specific extraction strategies using "accumulators". You can create an item processor using Rule.makeItemProcessor() which evaluates items against defined rules (like regex matches or table parsing) and executes a callback when a rule matches.

Common rule patterns include:

• Rule.on(regexp).extractRegexpValues(): Extracts values based on a regular expression.
• Rule.on(regexp).parseNextItemValue(): Parses the value of the next item after a match.
• Rule.on(regexp).parseTable(columns): Parses a table with a specific number of columns.
• Rule.on(regexp).accumulateAfterHeading(): Accumulates data following a specific heading.

const processItem = Rule.makeItemProcessor([
  Rule.on(/^Hello "(.*)"$/)
    .extractRegexpValues()
    .then(displayValue),
  Rule.on(/^Value//)
    .parseNextItemValue()
    .then(displayValue),
  Rule.on(/^c1$/).parseTable(3).then(displayTable),
  Rule.on(/^Values//)
    .accumulateAfterHeading()
    .then(displayValue),
]);

new PdfReader().parseFileItems("test/sample.pdf", (err, item) => {
  if (err) console.error(err);
  else processItem(item);
});

The lib/parseTable.js module provides several utility functions to transform parsed PDF table structures into human-readable or machine-readable string formats (like Tab-Separated Values).

• renderTable(table): Converts a 2D array of rows into a TSV string. Each cell's text is truncated to the first 7 characters.
• renderMatrix(matrix): Converts a matrix (where cells may contain multiple items) into a TSV string. If a cell contains multiple items, they are joined with a + separator and truncated to 7 characters.
• renderRows(rows): Renders rows with their index and the x-coordinate/text of each item (e.g., 0:123:text).
• renderItems(items): Renders a flat list of items as y_coordinate\t x_coordinate\t text.

import { renderTable, renderMatrix, renderItems } from './lib/parseTable.js';

// Example: rendering a simple table
const table = [['Header1', 'Header2'], ['Val1', 'Val2']];
console.log(renderTable(table));

// Example: rendering items
const items = [{x: 10, y: 20, text: 'Hello'}];
console.log(renderItems(items));

The parseTable function is a factory that creates an accumulator function designed to be used within a pdfreader Rule. It manages the collection of items and organizes them into rows and a matrix once parsing is complete.

Usage Pattern

1. Call parseTable(nbRows, headerRow) to create the accumulator.
2. The returned function should be used as the accumulate method for a Rule.
3. When the rule's whenDone lifecycle hook is triggered, the accumulator processes the collected items.

Parameters

• nbRows (Number): The expected number of rows in the table. Used to calculate row clusters.
• headerRow (Number): The index of the row containing column headers. This is used to determine column boundaries.

Output Structure

The rule.output object will be populated with:

• items: The raw list of collected items.
• rows: A 2D array of items classified into rows.
• matrix: A 2D array of items classified into rows and columns.

import { parseTable } from './lib/parseTable.js';

// Inside a pdfreader Rule definition
const myRule = new Rule();

// Initialize the accumulator
// nbRows: 5, headerRow: 0
myRule.accumulate = parseTable(5, 0);

myRule.whenDone(function() {
  const { rows, matrix } = this.output;
  console.log('Parsed rows:', rows);
  console.log('Parsed matrix:', matrix);
});