chromiumly 2.5.1 → 2.7.0

package/src/main.config.ts

@@ -1,13 +1,13 @@
-import {Gotenberg} from "./gotenberg";
+import { Gotenberg } from './gotenberg';
 
 /**
  * Enum representing the available Chromium routes for conversion.
  * @enum {string}
  */
 export enum ChromiumRoute {
-    URL = "url",
-    HTML = "html",
-    MARKDOWN = "markdown",
+    URL = 'url',
+    HTML = 'html',
+    MARKDOWN = 'markdown'
 }
 
 /**
@@ -15,7 +15,7 @@ export enum ChromiumRoute {
  * @enum {string}
  */
 enum PdfEngineRoute {
-    MERGE = "merge",
+    MERGE = 'merge'
 }
 
 /**
@@ -23,7 +23,7 @@ enum PdfEngineRoute {
  * @enum {string}
  */
 enum LibreOfficeRoute {
-    CONVERT = "convert",
+    CONVERT = 'convert'
 }
 
 /**
@@ -40,19 +40,19 @@ export class Chromiumly {
      * The path for Chromium-related conversions.
      * @type {string}
      */
-    public static readonly CHROMIUM_PATH = "forms/chromium/convert";
+    public static readonly CHROMIUM_CONVERT_PATH = 'forms/chromium/convert';
 
     /**
      * The path for PDF engine-related operations.
      * @type {string}
      */
-    public static readonly PDF_ENGINES_PATH = "forms/pdfengines";
+    public static readonly PDF_ENGINES_PATH = 'forms/pdfengines';
 
     /**
      * The path for LibreOffice-related conversions.
      * @type {string}
      */
-    public static readonly LIBRE_OFFICE_PATH = "forms/libreoffice";
+    public static readonly LIBRE_OFFICE_PATH = 'forms/libreoffice';
 
     /**
      * Routes for Chromium conversions.
@@ -61,7 +61,7 @@ export class Chromiumly {
     public static readonly CHROMIUM_ROUTES = {
         url: ChromiumRoute.URL,
         html: ChromiumRoute.HTML,
-        markdown: ChromiumRoute.MARKDOWN,
+        markdown: ChromiumRoute.MARKDOWN
     };
 
     /**
@@ -69,7 +69,7 @@ export class Chromiumly {
      * @type {Object}
      */
     public static readonly PDF_ENGINE_ROUTES = {
-        merge: PdfEngineRoute.MERGE,
+        merge: PdfEngineRoute.MERGE
     };
 
     /**
@@ -77,6 +77,6 @@ export class Chromiumly {
      * @type {Object}
      */
     public static readonly LIBRE_OFFICE_ROUTES = {
-        convert: LibreOfficeRoute.CONVERT,
+        convert: LibreOfficeRoute.CONVERT
     };
-}
+}

package/src/main.ts

@@ -1,3 +1,3 @@
-export {PdfFormat} from "./common/constants";
-export {HtmlConverter, MarkdownConverter, UrlConverter} from "./chromium";
-export {PDFEngine} from "./pdf-engines";
+export { PdfFormat } from './common/constants';
+export { HtmlConverter, MarkdownConverter, UrlConverter } from './chromium';
+export { PDFEngine } from './pdf-engines';

package/src/pdf-engines/index.ts

@@ -1 +1 @@
-export {PDFEngine} from "./pdf.engine";
+export { PDFEngine } from './pdf.engine';

package/src/pdf-engines/pdf.engine.ts

@@ -1,12 +1,12 @@
-import {promises} from "fs";
-import path from "path";
+import { promises } from 'fs';
+import path from 'path';
 
-import FormData from "form-data";
+import FormData from 'form-data';
 
-import {Chromiumly} from "../main.config";
-import {GotenbergUtils, PathLikeOrReadStream, PdfFormat} from "../common";
-import {LibreOfficeUtils, PageProperties} from "../libre-office";
-import {PDFEngineUtils} from "./utils/engine.utils";
+import { Chromiumly } from '../main.config';
+import { GotenbergUtils, PathLikeOrReadStream, PdfFormat } from '../common';
+import { LibreOfficeUtils, PageProperties } from '../libre-office';
+import { PDFEngineUtils } from './utils/engine.utils';
 
 /**
  * Class representing a PDF engine for various operations such as merging and conversion.
@@ -19,7 +19,11 @@ export class PDFEngine {
      * @param {PathLikeOrReadStream[]} options.files - An array of PathLikes or ReadStreams to the PDF files to be merged.
      * @returns {Promise<Buffer>} A Promise resolving to the merged PDF content as a Buffer.
      */
-    public static async merge({files}: { files: PathLikeOrReadStream[] }): Promise<Buffer> {
+    public static async merge({
+        files
+    }: {
+        files: PathLikeOrReadStream[];
+    }): Promise<Buffer> {
         const data = new FormData();
         await PDFEngineUtils.addFiles(files, data);
         const endpoint = `${Chromiumly.GOTENBERG_ENDPOINT}/${Chromiumly.PDF_ENGINES_PATH}/${Chromiumly.PDF_ENGINE_ROUTES.merge}`;
@@ -38,12 +42,12 @@ export class PDFEngine {
      * @returns {Promise<Buffer>} A Promise resolving to the converted PDF content as a Buffer.
      */
     public static async convert({
-                                    files,
-                                    properties,
-                                    pdfFormat,
-                                    pdfUA,
-                                    merge,
-                                }: {
+        files,
+        properties,
+        pdfFormat,
+        pdfUA,
+        merge
+    }: {
         files: PathLikeOrReadStream[];
         properties?: PageProperties;
         pdfFormat?: PdfFormat;
@@ -53,15 +57,15 @@ export class PDFEngine {
         const data = new FormData();
 
         if (pdfFormat) {
-            data.append("pdfa", pdfFormat);
+            data.append('pdfa', pdfFormat);
         }
 
         if (pdfUA) {
-            data.append("pdfUA", String(pdfUA));
+            data.append('pdfUA', String(pdfUA));
         }
 
         if (merge) {
-            data.append("merge", String(merge));
+            data.append('merge', String(merge));
         }
 
         if (properties) {
@@ -86,8 +90,8 @@ export class PDFEngine {
         filename: string,
         buffer: Buffer
     ): Promise<void> {
-        const __generated__ = path.resolve(process.cwd(), "__generated__");
-        await promises.mkdir(path.resolve(__generated__), {recursive: true});
+        const __generated__ = path.resolve(process.cwd(), '__generated__');
+        await promises.mkdir(path.resolve(__generated__), { recursive: true });
         await promises.writeFile(path.resolve(__generated__, filename), buffer);
     }
 }

package/src/pdf-engines/tests/pdf.engine.test.ts

@@ -1,20 +1,20 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import {createReadStream, promises} from "fs";
-import FormData from "form-data";
-import fs from "fs/promises";
-import fetch from "node-fetch";
-import path from "path";
+import { createReadStream, promises } from 'fs';
+import FormData from 'form-data';
+import fs from 'fs/promises';
+import fetch from 'node-fetch';
+import path from 'path';
 
-import {PdfFormat} from "../../common";
-import {PDFEngine} from "../pdf.engine";
+import { PdfFormat } from '../../common';
+import { PDFEngine } from '../pdf.engine';
 
-const {Response} = jest.requireActual("node-fetch");
-jest.mock("node-fetch", () => jest.fn());
+const { Response } = jest.requireActual('node-fetch');
+jest.mock('node-fetch', () => jest.fn());
 
-describe("PDFEngine", () => {
-    const mockPromisesAccess = jest.spyOn(promises, "access");
+describe('PDFEngine', () => {
+    const mockPromisesAccess = jest.spyOn(promises, 'access');
     const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
-    const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+    const mockFormDataAppend = jest.spyOn(FormData.prototype, 'append');
 
     beforeEach(() => {
         (createReadStream as jest.Mock) = jest
@@ -26,72 +26,75 @@ describe("PDFEngine", () => {
         jest.resetAllMocks();
     });
 
-    describe("convert", () => {
-        describe("when no properties are passed", () => {
-            it("should return a buffer", async () => {
+    describe('convert', () => {
+        describe('when no properties are passed', () => {
+            it('should return a buffer', async () => {
                 mockPromisesAccess.mockResolvedValue();
-                mockFetch.mockResolvedValue(new Response("content"));
+                mockFetch.mockResolvedValue(new Response('content'));
                 const buffer = await PDFEngine.convert({
-                    files: ["path/to/file.docx", "path/to/file.bib"],
+                    files: ['path/to/file.docx', 'path/to/file.bib']
                 });
-                expect(buffer).toEqual(Buffer.from("content"));
+                expect(buffer).toEqual(Buffer.from('content'));
                 expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
             });
         });
 
-        describe("when properties are passed", () => {
-            it("should return a buffer", async () => {
+        describe('when properties are passed', () => {
+            it('should return a buffer', async () => {
                 mockPromisesAccess.mockResolvedValue();
-                mockFetch.mockResolvedValue(new Response("content"));
+                mockFetch.mockResolvedValue(new Response('content'));
                 const buffer = await PDFEngine.convert({
-                    files: ["path/to/file.docx", "path/to/file.bib"],
-                    properties: {landscape: true},
+                    files: ['path/to/file.docx', 'path/to/file.bib'],
+                    properties: { landscape: true },
                     pdfFormat: PdfFormat.A_1a,
                     pdfUA: true,
-                    merge: true,
+                    merge: true
                 });
-                expect(buffer).toEqual(Buffer.from("content"));
+                expect(buffer).toEqual(Buffer.from('content'));
                 expect(mockFormDataAppend).toHaveBeenCalledTimes(6);
             });
         });
     });
 
-    describe("merge", () => {
-        it("should return a buffer", async () => {
+    describe('merge', () => {
+        it('should return a buffer', async () => {
             mockPromisesAccess.mockResolvedValue();
-            mockFetch.mockResolvedValue(new Response("content"));
+            mockFetch.mockResolvedValue(new Response('content'));
             const buffer = await PDFEngine.merge({
-                files: ["path/to/file.pdf", "path/to/another-file.pdf"],
+                files: ['path/to/file.pdf', 'path/to/another-file.pdf']
             });
-            expect(buffer).toEqual(Buffer.from("content"));
+            expect(buffer).toEqual(Buffer.from('content'));
             expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
         });
     });
 
-    describe("generate", () => {
-        const mockFilename = "test.pdf";
-        const mockBuffer = Buffer.from("mock pdf content");
+    describe('generate', () => {
+        const mockFilename = 'test.pdf';
+        const mockBuffer = Buffer.from('mock pdf content');
 
         afterAll(() => {
             jest.restoreAllMocks();
         });
 
-        it("should generate a PDF file", async () => {
-            const mockGeneratedDir = path.join(process.cwd(), "__generated__");
-            const mockGeneratedFilePath = path.join(mockGeneratedDir, mockFilename);
+        it('should generate a PDF file', async () => {
+            const mockGeneratedDir = path.join(process.cwd(), '__generated__');
+            const mockGeneratedFilePath = path.join(
+                mockGeneratedDir,
+                mockFilename
+            );
 
             const mockPromisesMkDir = jest
-                .spyOn(fs, "mkdir")
+                .spyOn(fs, 'mkdir')
                 .mockResolvedValueOnce(mockGeneratedDir);
 
             const mockPromisesWriteFile = jest
-                .spyOn(fs, "writeFile")
+                .spyOn(fs, 'writeFile')
                 .mockResolvedValueOnce();
 
             await PDFEngine.generate(mockFilename, mockBuffer);
 
             expect(mockPromisesMkDir).toHaveBeenCalledWith(mockGeneratedDir, {
-                recursive: true,
+                recursive: true
             });
 
             expect(mockPromisesWriteFile).toHaveBeenCalledWith(
@@ -100,24 +103,24 @@ describe("PDFEngine", () => {
             );
         });
 
-        it("should handle errors during file generation", async () => {
-            jest
-                .spyOn(fs, "mkdir")
-                .mockRejectedValueOnce(new Error("Cannot create directory"));
+        it('should handle errors during file generation', async () => {
+            jest.spyOn(fs, 'mkdir').mockRejectedValueOnce(
+                new Error('Cannot create directory')
+            );
 
             await expect(
                 PDFEngine.generate(mockFilename, mockBuffer)
-            ).rejects.toThrow("Cannot create directory");
+            ).rejects.toThrow('Cannot create directory');
         });
 
-        it("should handle errors during file writing", async () => {
-            jest
-                .spyOn(fs, "writeFile")
-                .mockRejectedValueOnce(new Error("Failed to write to file"));
+        it('should handle errors during file writing', async () => {
+            jest.spyOn(fs, 'writeFile').mockRejectedValueOnce(
+                new Error('Failed to write to file')
+            );
 
             await expect(
                 PDFEngine.generate(mockFilename, mockBuffer)
-            ).rejects.toThrow("Failed to write to file");
+            ).rejects.toThrow('Failed to write to file');
         });
     });
 });

package/src/pdf-engines/utils/engine.utils.ts

@@ -1,8 +1,8 @@
-import {constants, createReadStream, promises, ReadStream} from "fs";
-import path from "path";
+import { constants, createReadStream, promises, ReadStream } from 'fs';
+import path from 'path';
 
-import FormData from "form-data";
-import {PathLikeOrReadStream} from "../../common";
+import FormData from 'form-data';
+import { PathLikeOrReadStream } from '../../common';
 
 /**
  * Utility class for handling common tasks related to PDF engine operations.
@@ -15,18 +15,21 @@ export class PDFEngineUtils {
      * @param {FormData} data - The FormData object to which PDF files will be added.
      * @throws {Error} Throws an error if the file extension is not supported.
      */
-    public static async addFiles(files: PathLikeOrReadStream[], data: FormData) {
+    public static async addFiles(
+        files: PathLikeOrReadStream[],
+        data: FormData
+    ) {
         for (const [key, file] of files.entries()) {
-            const filename = `file${key}.pdf`
+            const filename = `file${key}.pdf`;
             if (Buffer.isBuffer(file)) {
-                data.append("files", file, filename);
+                data.append('files', file, filename);
             } else if (file instanceof ReadStream) {
-                data.append("files", file, filename);
+                data.append('files', file, filename);
             } else {
                 await promises.access(file, constants.R_OK);
                 const filename = path.basename(file.toString());
                 const extension = path.extname(filename);
-                if (extension === ".pdf") {
+                if (extension === '.pdf') {
                     data.append(filename, createReadStream(file));
                 } else {
                     throw new Error(`${extension} is not supported`);

package/src/pdf-engines/utils/tests/engine.utils.test.ts

@@ -1,12 +1,12 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import {createReadStream, promises} from "fs";
-import FormData from "form-data";
+import { createReadStream, promises } from 'fs';
+import FormData from 'form-data';
 
-import {PDFEngineUtils} from "../engine.utils";
+import { PDFEngineUtils } from '../engine.utils';
 
-describe("PDFEngineUtils", () => {
-    const mockPromisesAccess = jest.spyOn(promises, "access");
-    const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+describe('PDFEngineUtils', () => {
+    const mockPromisesAccess = jest.spyOn(promises, 'access');
+    const mockFormDataAppend = jest.spyOn(FormData.prototype, 'append');
     const data = new FormData();
 
     beforeEach(() => {
@@ -19,50 +19,50 @@ describe("PDFEngineUtils", () => {
         jest.resetAllMocks();
     });
 
-    describe("addFiles", () => {
-        describe("when files exist", () => {
-            describe("when files parameter contains paths", () => {
-                it("should append each file to data", async () => {
+    describe('addFiles', () => {
+        describe('when files exist', () => {
+            describe('when files parameter contains paths', () => {
+                it('should append each file to data', async () => {
                     mockPromisesAccess.mockResolvedValue();
                     await PDFEngineUtils.addFiles(
-                        ["path/to/file.pdf", "path/to/another-file.pdf"],
+                        ['path/to/file.pdf', 'path/to/another-file.pdf'],
                         data
                     );
                     expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
                 });
-            })
-            describe("when files parameter contains a buffer", () => {
-                it("should append each file to data", async () => {
+            });
+            describe('when files parameter contains a buffer', () => {
+                it('should append each file to data', async () => {
                     mockPromisesAccess.mockResolvedValue();
                     await PDFEngineUtils.addFiles(
-                        [Buffer.from("data"), "path/to/another-file.pdf"],
+                        [Buffer.from('data'), 'path/to/another-file.pdf'],
                         data
                     );
                     expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
                 });
-            })
+            });
         });
 
-        describe("when one of the files is not PDF", () => {
-            it("should throw an error", async () => {
+        describe('when one of the files is not PDF', () => {
+            it('should throw an error', async () => {
                 mockPromisesAccess.mockResolvedValue();
                 await expect(() =>
                     PDFEngineUtils.addFiles(
-                        ["path/to/file.docx", "path/to/file.pdf"],
+                        ['path/to/file.docx', 'path/to/file.pdf'],
                         data
                     )
-                ).rejects.toThrow(".docx is not supported");
+                ).rejects.toThrow('.docx is not supported');
             });
         });
 
-        describe("when one of the files does not exist", () => {
-            it("should throw an error", async () => {
+        describe('when one of the files does not exist', () => {
+            it('should throw an error', async () => {
                 const errorMessage =
                     "ENOENT: no such file or directory, access 'path/to/index.html'";
                 mockPromisesAccess.mockRejectedValue(new Error(errorMessage));
                 await expect(() =>
                     PDFEngineUtils.addFiles(
-                        ["path/to/file.pdf", "path/to/another-file.pdf"],
+                        ['path/to/file.pdf', 'path/to/another-file.pdf'],
                         data
                     )
                 ).rejects.toThrow(errorMessage);