chromiumly 2.6.0 → 2.8.0

package/src/chromium/converters/tests/url.converter.test.ts

@@ -1,138 +1,162 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import {createReadStream} from "fs";
-import FormData from "form-data";
-import fetch from "node-fetch";
+import { createReadStream } from 'fs';
+import FormData from 'form-data';
+import fetch from 'node-fetch';
 
-import {PdfFormat} from "../../../common";
-import {UrlConverter} from "../url.converter";
+import { PdfFormat } from '../../../common';
+import { UrlConverter } from '../url.converter';
 
-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("HtmlConverter", () => {
+describe('HtmlConverter', () => {
     const converter = new UrlConverter();
 
-    describe("endpoint", () => {
-        it("should route to Chromium HTML route", () => {
+    describe('endpoint', () => {
+        it('should route to Chromium HTML route', () => {
             expect(converter.endpoint).toEqual(
-                "http://localhost:3000/forms/chromium/convert/url"
+                'http://localhost:3000/forms/chromium/convert/url'
             );
         });
     });
 
-    describe("convert", () => {
+    describe('convert', () => {
         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.fn()
+            (createReadStream as jest.Mock) = jest.fn();
         });
 
         afterEach(() => {
             jest.resetAllMocks();
         });
 
-        describe("when URL is valid", () => {
-            it("should return a buffer", async () => {
-                mockFetch.mockResolvedValueOnce(new Response("content"));
+        describe('when URL is valid', () => {
+            it('should return a buffer', async () => {
+                mockFetch.mockResolvedValueOnce(new Response('content'));
                 const buffer = await converter.convert({
-                    url: "http://www.example.com/",
+                    url: 'http://www.example.com/'
                 });
-                expect(buffer).toEqual(Buffer.from("content"));
+                expect(buffer).toEqual(Buffer.from('content'));
             });
         });
 
-        describe("when header parameter is passed", () => {
-            it("should return a buffer", async () => {
-                mockFetch.mockResolvedValueOnce(new Response("content"));
+        describe('when header parameter is passed', () => {
+            it('should return a buffer', async () => {
+                mockFetch.mockResolvedValueOnce(new Response('content'));
                 const buffer = await converter.convert({
-                    url: "http://www.example.com/",
-                    header: Buffer.from("header"),
+                    url: 'http://www.example.com/',
+                    header: Buffer.from('header')
                 });
                 expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-                expect(buffer).toEqual(Buffer.from("content"));
+                expect(buffer).toEqual(Buffer.from('content'));
             });
         });
 
-        describe("when footer parameter is passed", () => {
-            it("should return a buffer", async () => {
-                mockFetch.mockResolvedValueOnce(new Response("content"));
+        describe('when footer parameter is passed', () => {
+            it('should return a buffer', async () => {
+                mockFetch.mockResolvedValueOnce(new Response('content'));
                 const buffer = await converter.convert({
-                    url: "http://www.example.com/",
-                    footer: Buffer.from("footer"),
+                    url: 'http://www.example.com/',
+                    footer: Buffer.from('footer')
                 });
                 expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-                expect(buffer).toEqual(Buffer.from("content"));
+                expect(buffer).toEqual(Buffer.from('content'));
             });
         });
 
-        describe("when pdf format parameter is passed", () => {
-            it("should return a buffer", async () => {
-                mockFetch.mockResolvedValueOnce(new Response("content"));
+        describe('when pdf format parameter is passed', () => {
+            it('should return a buffer', async () => {
+                mockFetch.mockResolvedValueOnce(new Response('content'));
                 const buffer = await converter.convert({
-                    url: "http://www.example.com/",
-                    pdfFormat: PdfFormat.A_3b,
+                    url: 'http://www.example.com/',
+                    pdfFormat: PdfFormat.A_3b
                 });
                 expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-                expect(buffer).toEqual(Buffer.from("content"));
+                expect(buffer).toEqual(Buffer.from('content'));
             });
         });
 
-        describe("when page properties parameter is passed", () => {
-            it("should return a buffer", async () => {
-                mockFetch.mockResolvedValueOnce(new Response("content"));
+        describe('when page properties parameter is passed', () => {
+            it('should return a buffer', async () => {
+                mockFetch.mockResolvedValueOnce(new Response('content'));
                 const buffer = await converter.convert({
-                    url: "http://www.example.com/",
-                    properties: {size: {width: 8.3, height: 11.7}},
+                    url: 'http://www.example.com/',
+                    properties: { size: { width: 8.3, height: 11.7 } }
                 });
                 expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
-                expect(buffer).toEqual(Buffer.from("content"));
+                expect(buffer).toEqual(Buffer.from('content'));
             });
         });
 
-        describe("when emulatedMediaType parameter is passed", () => {
-            it("should return a buffer", async () => {
-                mockFetch.mockResolvedValue(new Response("content"));
+        describe('when emulatedMediaType parameter is passed', () => {
+            it('should return a buffer', async () => {
+                mockFetch.mockResolvedValue(new Response('content'));
                 const buffer = await converter.convert({
-                    url: "http://www.example.com/",
-                    emulatedMediaType: "screen",
+                    url: 'http://www.example.com/',
+                    emulatedMediaType: 'screen'
                 });
                 expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-                expect(buffer).toEqual(Buffer.from("content"));
+                expect(buffer).toEqual(Buffer.from('content'));
             });
         });
 
-        describe("when all parameters are passed", () => {
-            it("should return a buffer", async () => {
-                mockFetch.mockResolvedValue(new Response("content"));
+        describe('when failOnHttpStatusCodes parameter is passed', () => {
+            it('should return a buffer', async () => {
+                mockFetch.mockResolvedValue(new Response('content'));
                 const buffer = await converter.convert({
-                    url: "http://www.example.com/",
-                    header: Buffer.from("header"),
-                    footer: Buffer.from("footer"),
+                    url: 'http://www.example.com/',
+                    failOnHttpStatusCodes: [499, 599]
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                expect(buffer).toEqual(Buffer.from('content'));
+            });
+        });
+
+        describe('when skipNetworkIdleEvent parameter is passed', () => {
+            it('should return a buffer', async () => {
+                mockFetch.mockResolvedValue(new Response('content'));
+                const buffer = await converter.convert({
+                    url: 'http://www.example.com/',
+                    skipNetworkIdleEvent: true
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                expect(buffer).toEqual(Buffer.from('content'));
+            });
+        });
+
+        describe('when all parameters are passed', () => {
+            it('should return a buffer', async () => {
+                mockFetch.mockResolvedValue(new Response('content'));
+                const buffer = await converter.convert({
+                    url: 'http://www.example.com/',
+                    header: Buffer.from('header'),
+                    footer: Buffer.from('footer'),
                     pdfFormat: PdfFormat.A_1a,
-                    emulatedMediaType: "screen",
-                    properties: {size: {width: 8.3, height: 11.7}},
+                    emulatedMediaType: 'screen',
+                    properties: { size: { width: 8.3, height: 11.7 } }
                 });
                 expect(mockFormDataAppend).toHaveBeenCalledTimes(7);
-                expect(buffer).toEqual(Buffer.from("content"));
+                expect(buffer).toEqual(Buffer.from('content'));
             });
         });
 
-        describe("when URL is invalid", () => {
-            it("should throw an error", async () => {
+        describe('when URL is invalid', () => {
+            it('should throw an error', async () => {
                 await expect(() =>
-                    converter.convert({url: "invalid url"})
-                ).rejects.toThrow("Invalid URL");
+                    converter.convert({ url: 'invalid url' })
+                ).rejects.toThrow('Invalid URL');
             });
         });
 
-        describe("when fetch request fails", () => {
-            it("should throw an error", async () => {
+        describe('when fetch request fails', () => {
+            it('should throw an error', async () => {
                 const errorMessage =
-                    "FetchError: request to http://localhost:3000/forms/chromium/convert/html failed";
+                    'FetchError: request to http://localhost:3000/forms/chromium/convert/html failed';
                 mockFetch.mockRejectedValueOnce(new Error(errorMessage));
                 await expect(() =>
-                    converter.convert({url: "http://www.example.com/"})
+                    converter.convert({ url: 'http://www.example.com/' })
                 ).rejects.toThrow(errorMessage);
             });
         });

package/src/chromium/converters/url.converter.ts

@@ -1,13 +1,11 @@
-import {URL} from "url";
-import FormData from "form-data";
-import {GotenbergUtils, PdfFormat, PathLikeOrReadStream} from "../../common";
-import {
-    EmulatedMediaType,
-    PageProperties,
-} from "../interfaces/converter.types";
-import {ConverterUtils} from "../utils/converter.utils";
-import {Converter} from "./converter";
-import {ChromiumRoute} from "../../main.config";
+import { URL } from 'url';
+import FormData from 'form-data';
+import { GotenbergUtils, PdfFormat, PathLikeOrReadStream } from '../../common';
+import { PageProperties } from '../interfaces/converter.types';
+import { ConverterUtils } from '../utils/converter.utils';
+import { Converter } from './converter';
+import { ChromiumRoute } from '../../main.config';
+import { EmulatedMediaType } from '../interfaces/common.types';
 
 /**
  * Class representing a URL converter that extends the base Converter class.
@@ -39,23 +37,27 @@ export class UrlConverter extends Converter {
      * @param {string} [options.waitForExpression] - JavaScript expression to wait for before completing the conversion.
      * @param {string} [options.userAgent] - User agent string to use during the conversion.
      * @param {Record<string, string>} [options.extraHttpHeaders] - Additional HTTP headers for the conversion.
+     * @param {number[]} [options.failOnHttpStatusCodes] - Whether to fail on HTTP status code.
      * @param {boolean} [options.failOnConsoleExceptions] - Whether to fail on console exceptions during conversion.
+     * @param {boolean} [options.skipNetworkIdleEvent] - Whether to skip network idle event.
      * @returns {Promise<Buffer>} A Promise resolving to the converted PDF content as a Buffer.
      */
     async convert({
-                      url,
-                      header,
-                      footer,
-                      properties,
-                      pdfFormat,
-                      pdfUA,
-                      emulatedMediaType,
-                      waitDelay,
-                      waitForExpression,
-                      userAgent,
-                      extraHttpHeaders,
-                      failOnConsoleExceptions,
-                  }: {
+        url,
+        header,
+        footer,
+        properties,
+        pdfFormat,
+        pdfUA,
+        emulatedMediaType,
+        waitDelay,
+        waitForExpression,
+        userAgent,
+        extraHttpHeaders,
+        failOnHttpStatusCodes,
+        failOnConsoleExceptions,
+        skipNetworkIdleEvent
+    }: {
         url: string;
         header?: PathLikeOrReadStream;
         footer?: PathLikeOrReadStream;
@@ -67,12 +69,14 @@ export class UrlConverter extends Converter {
         waitForExpression?: string;
         userAgent?: string;
         extraHttpHeaders?: Record<string, string>;
+        failOnHttpStatusCodes?: number[];
         failOnConsoleExceptions?: boolean;
+        skipNetworkIdleEvent?: boolean;
     }): Promise<Buffer> {
         const _url = new URL(url);
         const data = new FormData();
 
-        data.append("url", _url.href);
+        data.append('url', _url.href);
 
         await ConverterUtils.customize(data, {
             header,
@@ -85,9 +89,11 @@ export class UrlConverter extends Converter {
             waitForExpression,
             userAgent,
             extraHttpHeaders,
+            failOnHttpStatusCodes,
             failOnConsoleExceptions,
+            skipNetworkIdleEvent
         });
 
         return GotenbergUtils.fetch(this.endpoint, data);
     }
-}
+}

package/src/chromium/index.ts

@@ -1,3 +1,6 @@
-export {HtmlConverter} from "./converters/html.converter";
-export {MarkdownConverter} from "./converters/markdown.converter";
-export {UrlConverter} from "./converters/url.converter";
+export { UrlScreenshot } from './screenshots/url.screenshot';
+export { MarkdownScreenshot } from './screenshots/markdown.screenshot';
+export { HtmlScreenshot } from './screenshots/html.screenshot';
+export { HtmlConverter } from './converters/html.converter';
+export { MarkdownConverter } from './converters/markdown.converter';
+export { UrlConverter } from './converters/url.converter';

package/src/chromium/interfaces/common.types.ts

@@ -0,0 +1,15 @@
+import { PathLikeOrReadStream } from '../../common';
+
+export type EmulatedMediaType = 'screen' | 'print';
+
+export type ChromiumOptions = {
+    header?: PathLikeOrReadStream;
+    footer?: PathLikeOrReadStream;
+    emulatedMediaType?: EmulatedMediaType;
+    waitDelay?: string; // Duration (e.g, '5s') to wait when loading an HTML document before convertion.
+    waitForExpression?: string; // JavaScript's expression to wait before converting an HTML document into PDF until it returns true.
+    extraHttpHeaders?: Record<string, string>;
+    failOnHttpStatusCodes?: number[]; // Return a 409 Conflict response if the HTTP status code is in the list (default [499,599])
+    failOnConsoleExceptions?: boolean; // Return a 409 Conflict response if there are exceptions in the Chromium console (default false)
+    skipNetworkIdleEvent?: boolean; // Do not wait for Chromium network to be idle (default false)
+};

package/src/chromium/interfaces/converter.types.ts

@@ -1,4 +1,5 @@
-import {PathLikeOrReadStream, PdfFormat} from "../../common";
+import { PdfFormat } from '../../common';
+import { ChromiumOptions } from './common.types';
 
 type PageSize = {
     width: number; // Paper width, in inches (default 8.5)
@@ -13,6 +14,7 @@ type PageMargins = {
 };
 
 export type PageProperties = {
+    singlePage?: boolean; // Print the entire content in one single page (default false)
     size?: PageSize;
     margins?: PageMargins;
     preferCssPageSize?: boolean; // Define whether to prefer page size as defined by CSS (default false)
@@ -23,19 +25,9 @@ export type PageProperties = {
     nativePageRanges?: { from: number; to: number }; // Page ranges to print
 };
 
-export type EmulatedMediaType = "screen" | "print";
-
-
-export type ConversionOptions = {
-    header?: PathLikeOrReadStream;
-    footer?: PathLikeOrReadStream;
+export type ConversionOptions = ChromiumOptions & {
     properties?: PageProperties;
     pdfFormat?: PdfFormat;
     pdfUA?: boolean; // Enable PDF for Universal Access for optimal accessibility (default false)
-    emulatedMediaType?: EmulatedMediaType;
-    waitDelay?: string; // Duration (e.g, '5s') to wait when loading an HTML document before converting it into PDF
-    waitForExpression?: string; // JavaScript's expression to wait before converting an HTML document into PDF until it returns true.
     userAgent?: string;
-    extraHttpHeaders?: Record<string, string>;
-    failOnConsoleExceptions?: boolean; // Return a 409 Conflict response if there are exceptions in the Chromium console (default false)
 };

package/src/chromium/interfaces/screenshot.types.ts

@@ -0,0 +1,12 @@
+import { ChromiumOptions } from './common.types';
+
+export type ImageProperties = {
+    format: 'png' | 'jpeg' | 'webp'; //The image compression format, either "png", "jpeg" or "webp".
+    quality?: number; // The compression quality from range 0 to 100 (jpeg only).
+    omitBackground?: boolean; // Hide the default white background and allow generating screenshots with transparency.
+};
+
+export type ScreenshotOptions = ChromiumOptions & {
+    properties?: ImageProperties;
+    optimizeForSpeed?: boolean; // Define whether to optimize image encoding for speed, not for resulting size.
+};

package/src/chromium/screenshots/html.screenshot.ts

@@ -0,0 +1,100 @@
+import FormData from 'form-data';
+
+import { GotenbergUtils, PathLikeOrReadStream } from '../../common';
+import { ChromiumRoute } from '../../main.config';
+import { EmulatedMediaType } from '../interfaces/common.types';
+import { ScreenshotUtils } from '../utils/screenshot.utils';
+import { Screenshot } from './screenshot';
+import { ImageProperties } from '../interfaces/screenshot.types';
+
+/**
+ * Class representing an HTML Screenshot that extends the base Screenshot class.
+ * This class is used to screenshot HTML content using Gotenberg service.
+ *
+ * @extends Screenshot
+ */
+export class HtmlScreenshot extends Screenshot {
+    /**
+     * Creates an instance of HtmlScreenshot.
+     * Initializes the Screenshot with the HTML screenshot route.
+     */
+    constructor() {
+        super(ChromiumRoute.HTML);
+    }
+
+    /**
+     * Screenshots HTML content.
+     *
+     * @param {Object} options - Screenshot options.
+     * @param {PathLikeOrReadStream} options.html - PathLike or ReadStream of the HTML content to be screenshoted.
+     * @param {PathLikeOrReadStream} [options.header] - PathLike or ReadStream of the header HTML content.
+     * @param {PathLikeOrReadStream} [options.footer] - PathLike or ReadStream of the footer HTML content.
+     * @param {ImageProperties} [options.properties] - Image properties for the screenshot.
+     * @param {EmulatedMediaType} [options.emulatedMediaType] - Emulated media type for the screenshot.
+     * @param {string} [options.waitDelay] - Delay before the screenshot process starts.
+     * @param {string} [options.waitForExpression] - JavaScript expression to wait for before completing the screenshot.
+     * @param {Record<string, string>} [options.extraHttpHeaders] - Additional HTTP headers for the screenshot.
+     * @param {number []} [options.failOnHttpStatusCodes] - Whether to fail on HTTP status code.
+     * @param {boolean} [options.failOnConsoleExceptions] - Whether to fail on console exceptions during screenshot.
+     * @param {boolean} [options.skipNetworkIdleEvent] - Whether to skip network idle event.
+     * @param {boolean} [options.optimizeForSpeed] - Whether to optimize for speed.
+     * @returns {Promise<Buffer>} A Promise resolving to the image buffer.
+     */
+    async capture({
+        html,
+        assets,
+        header,
+        footer,
+        properties,
+        emulatedMediaType,
+        waitDelay,
+        waitForExpression,
+        extraHttpHeaders,
+        failOnConsoleExceptions,
+        failOnHttpStatusCodes,
+        skipNetworkIdleEvent,
+        optimizeForSpeed
+    }: {
+        html: PathLikeOrReadStream;
+        assets?: { file: PathLikeOrReadStream; name: string }[];
+        header?: PathLikeOrReadStream;
+        footer?: PathLikeOrReadStream;
+        properties?: ImageProperties;
+        emulatedMediaType?: EmulatedMediaType;
+        waitDelay?: string;
+        waitForExpression?: string;
+        extraHttpHeaders?: Record<string, string>;
+        failOnConsoleExceptions?: boolean;
+        failOnHttpStatusCodes?: number[];
+        skipNetworkIdleEvent?: boolean;
+        optimizeForSpeed?: boolean;
+    }): Promise<Buffer> {
+        const data = new FormData();
+
+        await GotenbergUtils.addFile(data, html, 'index.html');
+
+        if (assets?.length) {
+            await Promise.all(
+                assets.map(({ file, name }) =>
+                    GotenbergUtils.addFile(data, file, name)
+                )
+            );
+        }
+
+        await ScreenshotUtils.customize(data, {
+            header,
+            footer,
+            properties,
+            emulatedMediaType,
+            waitDelay,
+            waitForExpression,
+            extraHttpHeaders,
+            failOnHttpStatusCodes,
+            failOnConsoleExceptions,
+            skipNetworkIdleEvent,
+            optimizeForSpeed
+        });
+
+        return GotenbergUtils.fetch(this.endpoint, data);
+    }
+}

package/src/chromium/screenshots/markdown.screenshot.ts

@@ -0,0 +1,95 @@
+import FormData from 'form-data';
+
+import { GotenbergUtils, PathLikeOrReadStream } from '../../common';
+import { ImageProperties } from '../interfaces/screenshot.types';
+import { ScreenshotUtils } from '../utils/screenshot.utils';
+import { Screenshot } from './screenshot';
+import { ChromiumRoute } from '../../main.config';
+import { EmulatedMediaType } from '../interfaces/common.types';
+
+/**
+ * Class representing a Markdown screenshot that extends the base Screenshot class.
+ * This class is used to screenshots HTML with markdown content using Gotenberg service.
+ *
+ * @extends Screenshot
+ */
+export class MarkdownScreenshot extends Screenshot {
+    /**
+     * Creates an instance of MarkdownScreenshot.
+     * Initializes the Screenshot with the Markdown screenshot route.
+     */
+    constructor() {
+        super(ChromiumRoute.MARKDOWN);
+    }
+
+    /**
+     * Screenshots HTML with markdown.
+     *
+     * @param {Object} options - Screenshot options.
+     * @param {PathLikeOrReadStream} options.html - PathLike or ReadStream of the HTML content to be screenshoted.
+     * @param {PathLikeOrReadStream} options.markdown - PathLike or ReadStream of the Markdown content to be screenshoted.
+     * @param {PathLikeOrReadStream} [options.header] - PathLike or ReadStream of the header HTML content.
+     * @param {PathLikeOrReadStream} [options.footer] - PathLike or ReadStream of the footer HTML content.
+     * @param {ImageProperties} [options.properties] - Image properties for the screenshot.
+     * @param {EmulatedMediaType} [options.emulatedMediaType] - Emulated media type for the screenshot.
+     * @param {string} [options.waitDelay] - Delay before the screenshot process starts.
+     * @param {string} [options.waitForExpression] - JavaScript expression to wait for before completing the screenshot.
+     * @param {Record<string, string>} [options.extraHttpHeaders] - Additional HTTP headers for the screenshot.
+     * @param {number []} [options.failOnHttpStatusCodes] - Whether to fail on HTTP status code.
+     * @param {boolean} [options.failOnConsoleExceptions] - Whether to fail on console exceptions during screenshot.
+     * @param {boolean} [options.skipNetworkIdleEvent] - Whether to skip network idle event.
+     * @param {boolean} [options.optimizeForSpeed] - Whether to optimize for speed.
+     * @returns {Promise<Buffer>} A Promise resolving to the image buffer.
+     */
+    async capture({
+        html,
+        markdown,
+        header,
+        footer,
+        properties,
+        emulatedMediaType,
+        waitDelay,
+        waitForExpression,
+        extraHttpHeaders,
+        failOnHttpStatusCodes,
+        failOnConsoleExceptions,
+        skipNetworkIdleEvent,
+        optimizeForSpeed
+    }: {
+        html: PathLikeOrReadStream;
+        markdown: PathLikeOrReadStream;
+        header?: PathLikeOrReadStream;
+        footer?: PathLikeOrReadStream;
+        properties?: ImageProperties;
+        emulatedMediaType?: EmulatedMediaType;
+        waitDelay?: string;
+        waitForExpression?: string;
+        extraHttpHeaders?: Record<string, string>;
+        failOnHttpStatusCodes?: number[];
+        failOnConsoleExceptions?: boolean;
+        skipNetworkIdleEvent?: boolean;
+        optimizeForSpeed?: boolean;
+    }): Promise<Buffer> {
+        const data = new FormData();
+
+        await GotenbergUtils.addFile(data, html, 'index.html');
+
+        await GotenbergUtils.addFile(data, markdown, 'file.md');
+
+        await ScreenshotUtils.customize(data, {
+            header,
+            footer,
+            properties,
+            emulatedMediaType,
+            waitDelay,
+            waitForExpression,
+            extraHttpHeaders,
+            failOnHttpStatusCodes,
+            failOnConsoleExceptions,
+            skipNetworkIdleEvent,
+            optimizeForSpeed
+        });
+
+        return GotenbergUtils.fetch(this.endpoint, data);
+    }
+}

package/src/chromium/screenshots/screenshot.ts

@@ -0,0 +1,22 @@
+import { Chromiumly, ChromiumRoute } from '../../main.config';
+
+/**
+ * Abstract class representing a generic screenshot.
+ * Concrete screenshot classes should extend this class and implement specific screenshot logic.
+ */
+export abstract class Screenshot {
+    /**
+     * The endpoint URL for the screenshot.
+     */
+    readonly endpoint: string;
+
+    /**
+     * Creates an instance of the screenshot class.
+     * Initializes the endpoint URL based on the provided ChromiumRoute.
+     *
+     * @param {ChromiumRoute} route - The ChromiumRoute enum value representing the screenshot route.
+     */
+    constructor(route: ChromiumRoute) {
+        this.endpoint = `${Chromiumly.GOTENBERG_ENDPOINT}/${Chromiumly.CHROMIUM_SCREENSHOT_PATH}/${Chromiumly.CHROMIUM_ROUTES[route]}`;
+    }
+}