chromiumly 2.6.0 → 2.8.0

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);