n8n-nodes-pdfbro 0.1.7 → 0.1.9

package/README.md

@@ -30,19 +30,28 @@ npm install n8n-nodes-pdfbro
 ## Operations
 
 ### Merge PDFs
-Merges all input items containing PDF binary data into a single output item with the merged PDF.
+Link multiple binary fields (up to 10+ via "Add PDF Input") to combine them into a single PDF.
 
 ### Split Pages
-Splits a PDF into multiple items, one per page.
+Split a PDF into separate pages or ranges.
+**Supported Ranges:**
+- `*` : Split every page into a separate file (Burst).
+- `1, 3, 5` : Extract specific pages.
+- `1-5` : Extract bytes 1 to 5.
+- `7-` : Extract from page 7 to the end.
+- `-1` : Extract the last page.
+
+### Invoice Maker (HTML to PDF)
+Convert valid HTML content into a PDF. Useful for generating invoices, reports, or simple documents.
 
 ### Extract Text
-Extracts all text from the PDF and adds it to the JSON output.
+Extracts all text from the PDF.
 
 ### Extract Metadata
-Adds PDF metadata (Title, Author, Creation Date, etc.) to the JSON output.
+Gets title, author, creation date, etc.
 
 ### Rotate Pages
-Rotates all pages in the PDF by the specified degrees (default 90).
+Rotates all pages by X degrees.
 
 ## License
 
@@ -53,6 +62,9 @@ MIT
 This node powers its PDF magic using these awesome open-source libraries:
 
 *   **[pdf-lib](https://github.com/Hopding/pdf-lib)** (MIT License) - PDF creation and modification.
+*   **[pdfmake](http://pdfmake.org/)** (MIT License) - PDF generation engine.
+*   **[html-to-pdfmake](https://github.com/Aymkdn/html-to-pdfmake)** (MIT License) - HTML to PDFMake conversion.
+*   **[jsdom](https://github.com/jsdom/jsdom)** (MIT License) - DOM environment.
 *   **[pdf-parse](https://gitlab.com/autokent/pdf-parse)** (MIT License) - PDF text extraction.
 
 We are grateful to the maintainers of these projects!

package/dist/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodes = void 0;
-const PdfBro_node_1 = require("./nodes/PdfUtils/PdfBro.node");
+const PdfBro_node_1 = require("./nodes/PdfBro/PdfBro.node");
 exports.nodes = [PdfBro_node_1.PdfBro];

package/dist/nodes/PdfBro/PdfBro.node.js

@@ -0,0 +1,366 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PdfBro = void 0;
+const pdf_lib_1 = require("pdf-lib");
+// @ts-ignore
+const pdf_parse_1 = __importDefault(require("pdf-parse"));
+// @ts-ignore
+const pdfmake_1 = __importDefault(require("pdfmake/build/pdfmake"));
+// @ts-ignore
+const vfs_fonts_1 = __importDefault(require("pdfmake/build/vfs_fonts"));
+// @ts-ignore
+const html_to_pdfmake_1 = __importDefault(require("html-to-pdfmake"));
+// @ts-ignore
+const jsdom_1 = require("jsdom");
+// Initialize pdfmake fonts
+// @ts-ignore
+pdfmake_1.default.vfs = vfs_fonts_1.default.pdfMake.vfs;
+class PdfBro {
+    constructor() {
+        this.description = {
+            displayName: 'PdfBro',
+            name: 'pdfBro',
+            icon: 'file:pdfUtils.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'The ultimate PDF utility (powered by pdf-lib & pdf-parse)',
+            defaults: {
+                name: 'PdfBro',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Merge PDFs',
+                            value: 'merge',
+                            description: 'Merge multiple binary fields into a single PDF',
+                        },
+                        {
+                            name: 'Split Pages',
+                            value: 'split',
+                            description: 'Split a PDF into separate pages or ranges',
+                        },
+                        {
+                            name: 'Invoice Maker (HTML to PDF)',
+                            value: 'invoice',
+                            description: 'Convert HTML to PDF',
+                        },
+                        {
+                            name: 'Extract Text',
+                            value: 'extractText',
+                            description: 'Extract text content from PDF',
+                        },
+                        {
+                            name: 'Extract Metadata',
+                            value: 'metadata',
+                            description: 'Get PDF metadata (title, author, pages)',
+                        },
+                        {
+                            name: 'Rotate Pages',
+                            value: 'rotate',
+                            description: 'Rotate all pages in a PDF',
+                        },
+                    ],
+                    default: 'merge',
+                },
+                // MERGE Operations: Multiple Inputs
+                {
+                    displayName: 'Input PDF Files',
+                    name: 'inputBinaries',
+                    placeholder: 'Add PDF Input',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                        },
+                    },
+                    default: {},
+                    options: [
+                        {
+                            name: 'files',
+                            displayName: 'Files',
+                            values: [
+                                {
+                                    displayName: 'Binary Property',
+                                    name: 'binaryPropertyName',
+                                    type: 'string',
+                                    default: 'data',
+                                    description: 'Name of the binary property containing the PDF to merge',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                // Common input for single-file operations
+                {
+                    displayName: 'Input Binary Field',
+                    name: 'binaryPropertyName',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['split', 'extractText', 'metadata', 'rotate'],
+                        },
+                    },
+                    description: 'The name of the binary field containing the PDF',
+                },
+                // SPLIT Operations
+                {
+                    displayName: 'Split Range',
+                    name: 'splitRange',
+                    type: 'string',
+                    default: '*',
+                    displayOptions: {
+                        show: {
+                            operation: ['split'],
+                        },
+                    },
+                    description: 'Pages to extract. Examples: "1" (1st page), "1-3" (1st to 3rd), "7-" (7th to end), "-1" (last page), "*" (all pages separately).',
+                },
+                // INVOICE Operations
+                {
+                    displayName: 'HTML Content',
+                    name: 'htmlContent',
+                    type: 'string',
+                    default: '<h1>Invoice</h1><p>Content here...</p>',
+                    typeOptions: {
+                        rows: 5,
+                    },
+                    displayOptions: {
+                        show: {
+                            operation: ['invoice'],
+                        },
+                    },
+                    description: 'The HTML content to convert to PDF',
+                },
+                // ROTATE Operations
+                {
+                    displayName: 'Rotation Degrees',
+                    name: 'rotationDegrees',
+                    type: 'number',
+                    default: 90,
+                    displayOptions: {
+                        show: {
+                            operation: ['rotate'],
+                        },
+                    },
+                    description: 'Clockwise rotation (e.g. 90, 180, 270)',
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a;
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        // --- Helper: Parse Split Range ---
+        const parseRange = (rangeStr, totalPages) => {
+            if (rangeStr === '*') {
+                // Return all page indexes
+                return Array.from({ length: totalPages }, (_, i) => i);
+            }
+            const pages = new Set();
+            const parts = rangeStr.split(',').map(p => p.trim());
+            for (const part of parts) {
+                if (part.includes('-')) {
+                    let [startStr, endStr] = part.split('-');
+                    // Handle "7-" (7 to end)
+                    if (startStr && !endStr) {
+                        let start = parseInt(startStr);
+                        if (start < 0)
+                            start = totalPages + start + 1; // 1-based logic to index
+                        for (let i = start; i <= totalPages; i++) {
+                            pages.add(i - 1);
+                        }
+                        continue;
+                    }
+                    let start = parseInt(startStr);
+                    let end = parseInt(endStr);
+                    // Handle negative numbers (from end)
+                    if (start < 0)
+                        start = totalPages + start + 1;
+                    if (end < 0)
+                        end = totalPages + end + 1;
+                    // Clamp
+                    start = Math.max(1, start);
+                    end = Math.min(totalPages, end);
+                    for (let i = start; i <= end; i++) {
+                        pages.add(i - 1);
+                    }
+                }
+                else {
+                    let page = parseInt(part);
+                    if (page < 0)
+                        page = totalPages + page + 1;
+                    if (page >= 1 && page <= totalPages) {
+                        pages.add(page - 1);
+                    }
+                }
+            }
+            return Array.from(pages).sort((a, b) => a - b);
+        };
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (operation === 'merge') {
+                    const mergedPdf = await pdf_lib_1.PDFDocument.create();
+                    // Get fixed collection
+                    // @ts-ignore
+                    const binaries = ((_a = this.getNodeParameter('inputBinaries', i)) === null || _a === void 0 ? void 0 : _a.files) || [];
+                    // If user provided no binaries, just skip
+                    if (binaries.length === 0)
+                        continue;
+                    for (const entry of binaries) {
+                        const propName = entry.binaryPropertyName;
+                        if (this.helpers.assertBinaryData(i, propName)) {
+                            const validBuffer = await this.helpers.getBinaryDataBuffer(i, propName);
+                            const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
+                            const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+                            copiedPages.forEach((page) => mergedPdf.addPage(page));
+                        }
+                    }
+                    const mergedPdfBuffer = await mergedPdf.save();
+                    returnData.push({
+                        json: { success: true, pageCount: mergedPdf.getPageCount() },
+                        binary: {
+                            data: await this.helpers.prepareBinaryData(Buffer.from(mergedPdfBuffer), 'merged.pdf', 'application/pdf'),
+                        },
+                    });
+                }
+                else if (operation === 'split') {
+                    const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i);
+                    const rangeStr = this.getNodeParameter('splitRange', i);
+                    const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
+                    const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
+                    const totalPages = pdf.getPageCount();
+                    // Parse logic
+                    let indicesToKeep = parseRange(rangeStr, totalPages);
+                    if (rangeStr === '*') {
+                        // Burst mode: return separate items
+                        for (const pageIndex of indicesToKeep) {
+                            const newPdf = await pdf_lib_1.PDFDocument.create();
+                            const [copiedPage] = await newPdf.copyPages(pdf, [pageIndex]);
+                            newPdf.addPage(copiedPage);
+                            const newPdfBuffer = await newPdf.save();
+                            returnData.push({
+                                json: { ...items[i].json, pageNumber: pageIndex + 1, totalPages },
+                                binary: {
+                                    data: await this.helpers.prepareBinaryData(Buffer.from(newPdfBuffer), `page_${pageIndex + 1}.pdf`, 'application/pdf'),
+                                },
+                            });
+                        }
+                    }
+                    else {
+                        // Range mode: return single PDF with selected pages
+                        // Unless the range logic implies multiple? User said "Use * to split each page".
+                        // "1-3" usually means "Create a PDF with pages 1 to 3".
+                        const newPdf = await pdf_lib_1.PDFDocument.create();
+                        const copiedPages = await newPdf.copyPages(pdf, indicesToKeep);
+                        copiedPages.forEach(p => newPdf.addPage(p));
+                        const newPdfBuffer = await newPdf.save();
+                        returnData.push({
+                            json: { ...items[i].json, extractedPages: indicesToKeep.map(p => p + 1).join(', ') },
+                            binary: {
+                                data: await this.helpers.prepareBinaryData(Buffer.from(newPdfBuffer), 'extracted.pdf', 'application/pdf'),
+                            },
+                        });
+                    }
+                }
+                else if (operation === 'invoice') {
+                    const htmlContent = this.getNodeParameter('htmlContent', i);
+                    // convert html to pdfmake format (requires window)
+                    const { window } = new jsdom_1.JSDOM('');
+                    const docDefContent = (0, html_to_pdfmake_1.default)(htmlContent, { window });
+                    const docDefinition = {
+                        content: docDefContent,
+                    };
+                    const pdfDocGenerator = pdfmake_1.default.createPdf(docDefinition);
+                    const buffer = await new Promise((resolve, reject) => {
+                        pdfDocGenerator.getBuffer((buffer) => {
+                            resolve(buffer);
+                        });
+                    });
+                    returnData.push({
+                        json: { success: true },
+                        binary: {
+                            data: await this.helpers.prepareBinaryData(buffer, 'invoice.pdf', 'application/pdf'),
+                        },
+                    });
+                }
+                else if (operation === 'rotate') {
+                    const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i);
+                    const degreesVal = this.getNodeParameter('rotationDegrees', i);
+                    const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
+                    const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
+                    const pages = pdf.getPages();
+                    pages.forEach(page => {
+                        const currentRotation = page.getRotation().angle;
+                        page.setRotation((0, pdf_lib_1.degrees)(currentRotation + degreesVal));
+                    });
+                    const rotatedPdfBuffer = await pdf.save();
+                    returnData.push({
+                        json: items[i].json,
+                        binary: {
+                            [binaryPropertyName]: await this.helpers.prepareBinaryData(Buffer.from(rotatedPdfBuffer), 'rotated.pdf', 'application/pdf'),
+                        },
+                    });
+                }
+                else if (operation === 'extractText') {
+                    const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i);
+                    const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
+                    const data = await (0, pdf_parse_1.default)(validBuffer);
+                    returnData.push({
+                        json: {
+                            ...items[i].json,
+                            text: data.text,
+                            numpages: data.numpages,
+                            info: data.info,
+                        },
+                        binary: items[i].binary,
+                    });
+                }
+                else if (operation === 'metadata') {
+                    const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i);
+                    const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
+                    const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
+                    returnData.push({
+                        json: {
+                            ...items[i].json,
+                            title: pdf.getTitle(),
+                            author: pdf.getAuthor(),
+                            subject: pdf.getSubject(),
+                            creator: pdf.getCreator(),
+                            producer: pdf.getProducer(),
+                            keywords: pdf.getKeywords(),
+                            pageCount: pdf.getPageCount(),
+                            creationDate: pdf.getCreationDate(),
+                            modificationDate: pdf.getModificationDate(),
+                        },
+                        binary: items[i].binary,
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.PdfBro = PdfBro;

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "n8n-nodes-pdfbro",
-    "version": "0.1.7",
+    "version": "0.1.9",
     "description": "Offline PDF utility node for n8n",
     "keywords": [
         "n8n-community-node"
     ],
     "n8n": {
         "nodes": [
-            "dist/nodes/PdfUtils/PdfBro.node.js"
+            "dist/nodes/PdfBro/PdfBro.node.js"
         ]
     },
     "license": "MIT",
@@ -25,11 +25,16 @@
         "dist"
     ],
     "dependencies": {
+        "html-to-pdfmake": "^2.5.32",
+        "jsdom": "^27.3.0",
         "pdf-lib": "^1.17.1",
-        "pdf-parse": "^1.1.1"
+        "pdf-parse": "^1.1.1",
+        "pdfmake": "^0.2.21"
     },
     "devDependencies": {
+        "@types/jsdom": "^27.0.0",
         "@types/node": "^16.0.0",
+        "@types/pdfmake": "^0.2.12",
         "copyfiles": "^2.4.1",
         "n8n-workflow": "*",
         "typescript": "^5.0.0"

package/dist/nodes/PdfUtils/PdfBro.node.js

@@ -1,274 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PdfBro = void 0;
-const pdf_lib_1 = require("pdf-lib");
-// @ts-ignore
-const pdf_parse_1 = __importDefault(require("pdf-parse"));
-class PdfBro {
-    constructor() {
-        this.description = {
-            displayName: 'PdfBro',
-            name: 'pdfBro',
-            icon: 'file:pdfUtils.svg',
-            group: ['transform'],
-            version: 1,
-            description: 'The ultimate PDF utility (powered by pdf-lib & pdf-parse)',
-            defaults: {
-                name: 'PdfBro',
-            },
-            inputs: ['main'],
-            outputs: ['main'],
-            properties: [
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'Merge PDFs',
-                            value: 'merge',
-                            description: 'Merge multiple PDF items into a single PDF',
-                        },
-                        {
-                            name: 'Split Pages',
-                            value: 'split',
-                            description: 'Split a PDF into separate pages',
-                        },
-                        {
-                            name: 'Extract Text',
-                            value: 'extractText',
-                            description: 'Extract text content from PDF',
-                        },
-                        {
-                            name: 'Extract Metadata',
-                            value: 'metadata',
-                            description: 'Get PDF metadata (title, author, pages)',
-                        },
-                        {
-                            name: 'Rotate Pages',
-                            value: 'rotate',
-                            description: 'Rotate all pages in a PDF',
-                        },
-                    ],
-                    default: 'merge',
-                },
-                /*
-                            displayName: 'Input Binary Field',
-                            name: 'binaryPropertyName',
-                            type: 'string',
-                            default: 'data',
-                            required: true,
-                            description: 'The name of the binary field containing the PDF',
-                        */
-                // Replaced with fixedCollection for merge, simple string for others
-                {
-                    displayName: 'Input Binary Fields',
-                    name: 'binaryProperties',
-                    type: 'fixedCollection',
-                    typeOptions: {
-                        multipleValues: true,
-                    },
-                    displayOptions: {
-                        show: {
-                            operation: ['merge'],
-                        },
-                    },
-                    default: {},
-                    options: [
-                        {
-                            name: 'properties',
-                            displayName: 'Binary Property',
-                            values: [
-                                {
-                                    displayName: 'Property Name',
-                                    name: 'property',
-                                    type: 'string',
-                                    default: 'data',
-                                    description: 'Name of the binary property to merge',
-                                },
-                            ],
-                        },
-                    ],
-                    description: 'Add more binary properties to merge (e.g. data2, attachment_1)',
-                },
-                {
-                    displayName: 'Input Binary Field',
-                    name: 'binaryPropertyName',
-                    type: 'string',
-                    default: 'data',
-                    required: true,
-                    description: 'The name of the binary field containing the PDF',
-                },
-                {
-                    displayName: 'Output Binary Field',
-                    name: 'outputPropertyName',
-                    type: 'string',
-                    default: 'merged',
-                    required: true,
-                    displayOptions: {
-                        show: {
-                            operation: ['merge'],
-                        },
-                    },
-                    description: 'The name of the binary field to put the merged PDF in',
-                },
-                {
-                    displayName: 'Rotation Degrees',
-                    name: 'rotationDegrees',
-                    type: 'number',
-                    default: 90,
-                    displayOptions: {
-                        show: {
-                            operation: ['rotate'],
-                        },
-                    },
-                    description: 'Clockwise rotation (e.g. 90, 180, 270)',
-                },
-            ],
-        };
-    }
-    async execute() {
-        const items = this.getInputData();
-        const returnData = [];
-        const operation = this.getNodeParameter('operation', 0);
-        if (operation === 'merge') {
-            // Merge multiple binary properties FROM ALL ITEMS into ONE SINGLE PDF
-            const outputPropertyName = this.getNodeParameter('outputPropertyName', 0);
-            // Default primary property
-            const primaryBinaryProp = this.getNodeParameter('binaryPropertyName', 0);
-            const mergedPdf = await pdf_lib_1.PDFDocument.create();
-            for (let i = 0; i < items.length; i++) {
-                try {
-                    const binaryProps = this.getNodeParameter('binaryProperties', i);
-                    let propsToMerge = [];
-                    if (binaryProps && binaryProps.properties) {
-                        propsToMerge = binaryProps.properties.map((p) => p.property);
-                    }
-                    // Fallback: If no ADDITIONAL properties specified, use the PRIMARY one.
-                    // Also, IF properties ARE specified, do we include the primary one? 
-                    // UX Decision: If user specified explicit list, they likely want just that list. 
-                    // BUT, to keep it simple: If list is empty, use primary. 
-                    if (propsToMerge.length === 0) {
-                        propsToMerge.push(primaryBinaryProp);
-                    }
-                    for (const propName of propsToMerge) {
-                        // Check if binary data exists
-                        if (!items[i].binary || !items[i].binary[propName]) {
-                            continue;
-                        }
-                        const validBuffer = await this.helpers.getBinaryDataBuffer(i, propName);
-                        const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
-                        const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
-                        copiedPages.forEach((page) => mergedPdf.addPage(page));
-                    }
-                }
-                catch (error) {
-                    if (this.continueOnFail()) {
-                        continue;
-                    }
-                    throw error;
-                }
-            }
-            if (mergedPdf.getPageCount() === 0) {
-                throw new Error('No PDF pages found to merge! Please check your input binary fields.');
-            }
-            // Return single item
-            const mergedPdfBuffer = await mergedPdf.save();
-            // Use the first item's JSON as a base, or empty if no items
-            const jsonOutput = items.length > 0 ? items[0].json : {};
-            const binaryOutput = items.length > 0 && items[0].binary ? items[0].binary : {};
-            returnData.push({
-                json: { ...jsonOutput, success: true, pageCount: mergedPdf.getPageCount() },
-                binary: {
-                    ...binaryOutput,
-                    [outputPropertyName]: await this.helpers.prepareBinaryData(Buffer.from(mergedPdfBuffer), 'merged.pdf', 'application/pdf'),
-                },
-            });
-        }
-        else {
-            // For other operations, get the single binaryPropertyName
-            const binaryPropertyName = this.getNodeParameter('binaryPropertyName', 0);
-            if (operation === 'split') {
-                // Split each input PDF into single pages
-                for (let i = 0; i < items.length; i++) {
-                    const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                    const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
-                    const numberOfPages = pdf.getPageCount();
-                    for (let j = 0; j < numberOfPages; j++) {
-                        const newPdf = await pdf_lib_1.PDFDocument.create();
-                        const [copiedPage] = await newPdf.copyPages(pdf, [j]);
-                        newPdf.addPage(copiedPage);
-                        const newPdfBuffer = await newPdf.save();
-                        returnData.push({
-                            json: { ...items[i].json, pageNumber: j + 1, totalPages: numberOfPages },
-                            binary: {
-                                [binaryPropertyName]: await this.helpers.prepareBinaryData(Buffer.from(newPdfBuffer), `page_${j + 1}.pdf`, 'application/pdf'),
-                            },
-                        });
-                    }
-                }
-            }
-            else if (operation === 'rotate') {
-                const degreesVal = this.getNodeParameter('rotationDegrees', 0);
-                for (let i = 0; i < items.length; i++) {
-                    const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                    const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
-                    const pages = pdf.getPages();
-                    pages.forEach(page => {
-                        const currentRotation = page.getRotation().angle;
-                        page.setRotation((0, pdf_lib_1.degrees)(currentRotation + degreesVal));
-                    });
-                    const rotatedPdfBuffer = await pdf.save();
-                    returnData.push({
-                        json: items[i].json,
-                        binary: {
-                            [binaryPropertyName]: await this.helpers.prepareBinaryData(Buffer.from(rotatedPdfBuffer), 'rotated.pdf', 'application/pdf'),
-                        },
-                    });
-                }
-            }
-            else if (operation === 'extractText') {
-                for (let i = 0; i < items.length; i++) {
-                    const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                    const data = await (0, pdf_parse_1.default)(validBuffer);
-                    returnData.push({
-                        json: {
-                            ...items[i].json,
-                            text: data.text,
-                            numpages: data.numpages,
-                            info: data.info,
-                        },
-                        binary: items[i].binary,
-                    });
-                }
-            }
-            else if (operation === 'metadata') {
-                for (let i = 0; i < items.length; i++) {
-                    const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                    const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
-                    returnData.push({
-                        json: {
-                            ...items[i].json,
-                            title: pdf.getTitle(),
-                            author: pdf.getAuthor(),
-                            subject: pdf.getSubject(),
-                            creator: pdf.getCreator(),
-                            producer: pdf.getProducer(),
-                            keywords: pdf.getKeywords(),
-                            pageCount: pdf.getPageCount(),
-                            creationDate: pdf.getCreationDate(),
-                            modificationDate: pdf.getModificationDate(),
-                        },
-                        binary: items[i].binary,
-                    });
-                }
-            }
-        }
-        return [returnData];
-    }
-}
-exports.PdfBro = PdfBro;

package/dist/nodes/PdfUtils/PdfUtils.node.js

@@ -1,191 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PdfUtils = void 0;
-const pdf_lib_1 = require("pdf-lib");
-// @ts-ignore
-const pdf_parse_1 = __importDefault(require("pdf-parse"));
-class PdfUtils {
-    constructor() {
-        this.description = {
-            displayName: 'PDF Utils',
-            name: 'pdfUtils',
-            icon: 'file:pdfUtils.svg',
-            group: ['transform'],
-            version: 1,
-            description: 'Offline PDF operations',
-            defaults: {
-                name: 'PDF Utils',
-            },
-            inputs: ['main'],
-            outputs: ['main'],
-            properties: [
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'Merge PDFs',
-                            value: 'merge',
-                            description: 'Merge multiple PDF items into a single PDF',
-                        },
-                        {
-                            name: 'Split Pages',
-                            value: 'split',
-                            description: 'Split a PDF into separate pages',
-                        },
-                        {
-                            name: 'Extract Text',
-                            value: 'extractText',
-                            description: 'Extract text content from PDF',
-                        },
-                        {
-                            name: 'Extract Metadata',
-                            value: 'metadata',
-                            description: 'Get PDF metadata (title, author, pages)',
-                        },
-                        {
-                            name: 'Rotate Pages',
-                            value: 'rotate',
-                            description: 'Rotate all pages in a PDF',
-                        },
-                    ],
-                    default: 'merge',
-                },
-                {
-                    displayName: 'Input Binary Field',
-                    name: 'binaryPropertyName',
-                    type: 'string',
-                    default: 'data',
-                    required: true,
-                    description: 'The name of the binary field containing the PDF',
-                },
-                {
-                    displayName: 'Rotation Degrees',
-                    name: 'rotationDegrees',
-                    type: 'number',
-                    default: 90,
-                    displayOptions: {
-                        show: {
-                            operation: ['rotate'],
-                        },
-                    },
-                    description: 'Clockwise rotation (e.g. 90, 180, 270)',
-                },
-            ],
-        };
-    }
-    async execute() {
-        const items = this.getInputData();
-        const returnData = [];
-        const operation = this.getNodeParameter('operation', 0);
-        const binaryPropertyName = this.getNodeParameter('binaryPropertyName', 0);
-        if (operation === 'merge') {
-            // Merge all inputs into one PDF
-            const mergedPdf = await pdf_lib_1.PDFDocument.create();
-            for (let i = 0; i < items.length; i++) {
-                try {
-                    const binaryData = this.helpers.assertBinaryData(i, binaryPropertyName);
-                    const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                    const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
-                    const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
-                    copiedPages.forEach((page) => mergedPdf.addPage(page));
-                }
-                catch (error) {
-                    if (this.continueOnFail()) {
-                        continue;
-                    }
-                    throw error;
-                }
-            }
-            const mergedPdfBuffer = await mergedPdf.save();
-            returnData.push({
-                json: { success: true, pageCount: mergedPdf.getPageCount() },
-                binary: {
-                    [binaryPropertyName]: await this.helpers.prepareBinaryData(Buffer.from(mergedPdfBuffer), 'merged.pdf', 'application/pdf'),
-                },
-            });
-        }
-        else if (operation === 'split') {
-            // Split each input PDF into single pages
-            for (let i = 0; i < items.length; i++) {
-                const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
-                const numberOfPages = pdf.getPageCount();
-                for (let j = 0; j < numberOfPages; j++) {
-                    const newPdf = await pdf_lib_1.PDFDocument.create();
-                    const [copiedPage] = await newPdf.copyPages(pdf, [j]);
-                    newPdf.addPage(copiedPage);
-                    const newPdfBuffer = await newPdf.save();
-                    returnData.push({
-                        json: { ...items[i].json, pageNumber: j + 1, totalPages: numberOfPages },
-                        binary: {
-                            [binaryPropertyName]: await this.helpers.prepareBinaryData(Buffer.from(newPdfBuffer), `page_${j + 1}.pdf`, 'application/pdf'),
-                        },
-                    });
-                }
-            }
-        }
-        else if (operation === 'rotate') {
-            const degreesVal = this.getNodeParameter('rotationDegrees', 0);
-            for (let i = 0; i < items.length; i++) {
-                const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
-                const pages = pdf.getPages();
-                pages.forEach(page => {
-                    const currentRotation = page.getRotation().angle;
-                    page.setRotation((0, pdf_lib_1.degrees)(currentRotation + degreesVal));
-                });
-                const rotatedPdfBuffer = await pdf.save();
-                returnData.push({
-                    json: items[i].json,
-                    binary: {
-                        [binaryPropertyName]: await this.helpers.prepareBinaryData(Buffer.from(rotatedPdfBuffer), 'rotated.pdf', 'application/pdf'),
-                    },
-                });
-            }
-        }
-        else if (operation === 'extractText') {
-            for (let i = 0; i < items.length; i++) {
-                const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                const data = await (0, pdf_parse_1.default)(validBuffer);
-                returnData.push({
-                    json: {
-                        ...items[i].json,
-                        text: data.text,
-                        numpages: data.numpages,
-                        info: data.info,
-                    },
-                    binary: items[i].binary,
-                });
-            }
-        }
-        else if (operation === 'metadata') {
-            for (let i = 0; i < items.length; i++) {
-                const validBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                const pdf = await pdf_lib_1.PDFDocument.load(validBuffer);
-                returnData.push({
-                    json: {
-                        ...items[i].json,
-                        title: pdf.getTitle(),
-                        author: pdf.getAuthor(),
-                        subject: pdf.getSubject(),
-                        creator: pdf.getCreator(),
-                        producer: pdf.getProducer(),
-                        keywords: pdf.getKeywords(),
-                        pageCount: pdf.getPageCount(),
-                        creationDate: pdf.getCreationDate(),
-                        modificationDate: pdf.getModificationDate(),
-                    },
-                    binary: items[i].binary,
-                });
-            }
-        }
-        return [returnData];
-    }
-}
-exports.PdfUtils = PdfUtils;

package/dist/nodes/PdfUtils/pdfUtils.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#ff0000" width="24px" height="24px"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M20 2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-8.5 7.5c0 .83-.67 1.5-1.5 1.5H9v2H7.5V7H10c.83 0 1.5.67 1.5 1.5v1zm5 2c0 .83-.67 1.5-1.5 1.5h-2.5V7H15c.83 0 1.5.67 1.5 1.5v3zm4-3H19v1h1.5V11H19v2h-1.5V7h3v1.5zM9 9.5h1v-1H9v1zM4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm10 5.5h1v-3h-1v3z"/></svg>