@remotion/renderer 4.0.0-webhook.26 → 4.1.0-alpha1

package/dist/render-still.d.ts

@@ -1,44 +1,71 @@
-import type { SmallTCompMetadata } from 'remotion';
+/// <reference types="node" />
+import type { AnySmallCompMetadata } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
-import type { DownloadMap } from './assets/download-map';
 import type { BrowserExecutable } from './browser-executable';
-import type { Browser as PuppeteerBrowser } from './browser/Browser';
-import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { BrowserLog } from './browser-log';
+import type { HeadlessBrowser } from './browser/Browser';
 import type { StillImageFormat } from './image-format';
-import type { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';
-declare type InnerStillOptions = {
-    composition: SmallTCompMetadata;
-    output: string;
+import type { RemotionServer } from './prepare-server';
+type InternalRenderStillOptions = {
+    composition: AnySmallCompMetadata;
+    output: string | null;
+    frame: number;
+    inputProps: Record<string, unknown>;
+    imageFormat: StillImageFormat;
+    jpegQuality: number;
+    puppeteerInstance: HeadlessBrowser | null;
+    dumpBrowserLogs: boolean;
+    envVariables: Record<string, string>;
+    overwrite: boolean;
+    browserExecutable: BrowserExecutable;
+    onBrowserLog: null | ((log: BrowserLog) => void);
+    timeoutInMilliseconds: number;
+    chromiumOptions: ChromiumOptions;
+    scale: number;
+    onDownload: RenderMediaOnDownload | null;
+    cancelSignal: CancelSignal | null;
+    indent: boolean;
+    server: RemotionServer | undefined;
+    verbose: boolean;
+    serveUrl: string;
+    port: number | null;
+};
+export type RenderStillOptions = {
+    port?: number | null;
+    composition: AnySmallCompMetadata;
+    output?: string | null;
     frame?: number;
-    inputProps?: unknown;
+    inputProps?: Record<string, unknown>;
     imageFormat?: StillImageFormat;
-    quality?: number;
-    puppeteerInstance?: PuppeteerBrowser;
+    jpegQuality?: number;
+    puppeteerInstance?: HeadlessBrowser;
     dumpBrowserLogs?: boolean;
     envVariables?: Record<string, string>;
     overwrite?: boolean;
     browserExecutable?: BrowserExecutable;
+    onBrowserLog?: (log: BrowserLog) => void;
     timeoutInMilliseconds?: number;
     chromiumOptions?: ChromiumOptions;
     scale?: number;
     onDownload?: RenderMediaOnDownload;
     cancelSignal?: CancelSignal;
-    ffmpegExecutable?: FfmpegExecutable;
-    ffprobeExecutable?: FfmpegExecutable;
+    verbose?: boolean;
+    serveUrl: string;
     /**
-     * @deprecated Only for Remotion internal usage
+     * @deprecated Renamed to `jpegQuality`
      */
-    downloadMap?: DownloadMap;
+    quality?: never;
 };
-export declare type RenderStillOptions = InnerStillOptions & ServeUrlOrWebpackBundle & {
-    port?: number | null;
+type RenderStillReturnValue = {
+    buffer: Buffer | null;
 };
+export declare const internalRenderStill: (options: InternalRenderStillOptions) => Promise<RenderStillReturnValue>;
 /**
  *
  * @description Render a still frame from a composition
- * @link https://www.remotion.dev/docs/renderer/render-still
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/render-still)
  */
-export declare const renderStill: (options: RenderStillOptions) => Promise<void>;
+export declare const renderStill: (options: RenderStillOptions) => Promise<RenderStillReturnValue>;
 export {};

package/dist/render-still.js

@@ -26,69 +26,78 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderStill = void 0;
-const fs_1 = __importStar(require("fs"));
-const path_1 = __importDefault(require("path"));
+exports.renderStill = exports.internalRenderStill = void 0;
+const node_fs_1 = __importStar(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const remotion_1 = require("remotion");
-const download_map_1 = require("./assets/download-map");
 const browser_1 = require("./browser");
+const TimeoutSettings_1 = require("./browser/TimeoutSettings");
 const convert_to_positive_frame_index_1 = require("./convert-to-positive-frame-index");
 const ensure_output_directory_1 = require("./ensure-output-directory");
 const handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
+const find_closest_package_json_1 = require("./find-closest-package-json");
 const image_format_1 = require("./image-format");
-const legacy_webpack_config_1 = require("./legacy-webpack-config");
+const jpeg_quality_1 = require("./jpeg-quality");
+const make_cancel_signal_1 = require("./make-cancel-signal");
 const open_browser_1 = require("./open-browser");
+const overwrite_1 = require("./overwrite");
 const prepare_server_1 = require("./prepare-server");
-const provide_screenshot_1 = require("./provide-screenshot");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
-const quality_1 = require("./quality");
 const seek_to_frame_1 = require("./seek-to-frame");
 const set_props_and_env_1 = require("./set-props-and-env");
-const validate_frame_1 = require("./validate-frame");
+const take_frame_and_compose_1 = require("./take-frame-and-compose");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
 const validate_scale_1 = require("./validate-scale");
-const innerRenderStill = async ({ composition, quality, imageFormat = 'png', serveUrl, puppeteerInstance, dumpBrowserLogs = false, onError, inputProps, envVariables, output, frame = 0, overwrite = true, browserExecutable, timeoutInMilliseconds, chromiumOptions, scale, proxyPort, cancelSignal, }) => {
+const innerRenderStill = async ({ composition, imageFormat = image_format_1.DEFAULT_STILL_IMAGE_FORMAT, serveUrl, puppeteerInstance, dumpBrowserLogs = false, onError, inputProps, envVariables, output, frame = 0, overwrite, browserExecutable, timeoutInMilliseconds, chromiumOptions, scale, proxyPort, cancelSignal, jpegQuality, onBrowserLog, compositor, sourceMapContext, downloadMap, }) => {
     remotion_1.Internals.validateDimension(composition.height, 'height', 'in the `config` object passed to `renderStill()`');
     remotion_1.Internals.validateDimension(composition.width, 'width', 'in the `config` object passed to `renderStill()`');
     remotion_1.Internals.validateFps(composition.fps, 'in the `config` object of `renderStill()`', false);
-    remotion_1.Internals.validateDurationInFrames(composition.durationInFrames, 'in the `config` object passed to `renderStill()`');
-    (0, image_format_1.validateNonNullImageFormat)(imageFormat);
-    (0, validate_frame_1.validateFrame)(frame, composition.durationInFrames);
+    remotion_1.Internals.validateDurationInFrames({
+        durationInFrames: composition.durationInFrames,
+        component: 'in the `config` object passed to `renderStill()`',
+        allowFloats: false,
+    });
+    (0, image_format_1.validateStillImageFormat)(imageFormat);
+    remotion_1.Internals.validateFrame({
+        frame,
+        durationInFrames: composition.durationInFrames,
+        allowFloats: false,
+    });
     const stillFrame = (0, convert_to_positive_frame_index_1.convertToPositiveFrameIndex)({
         durationInFrames: composition.durationInFrames,
         frame,
     });
     (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(timeoutInMilliseconds);
     (0, validate_scale_1.validateScale)(scale);
-    if (typeof output !== 'string') {
-        throw new TypeError('`output` parameter was not passed or is not a string');
-    }
-    output = path_1.default.resolve(process.cwd(), output);
-    if (quality !== undefined && imageFormat !== 'jpeg') {
-        throw new Error("You can only pass the `quality` option if `imageFormat` is 'jpeg'.");
-    }
-    (0, quality_1.validateQuality)(quality);
-    if (fs_1.default.existsSync(output)) {
-        if (!overwrite) {
-            throw new Error(`Cannot render still - "overwrite" option was set to false, but the output destination ${output} already exists.`);
-        }
-        const stat = (0, fs_1.statSync)(output);
-        if (!stat.isFile()) {
-            throw new Error(`The output location ${output} already exists, but is not a file, but something else (e.g. folder). Cannot save to it.`);
+    output =
+        typeof output === 'string' ? node_path_1.default.resolve(process.cwd(), output) : null;
+    (0, jpeg_quality_1.validateJpegQuality)(jpegQuality);
+    if (output) {
+        if (node_fs_1.default.existsSync(output)) {
+            if (!overwrite) {
+                throw new Error(`Cannot render still - "overwrite" option was set to false, but the output destination ${output} already exists.`);
+            }
+            const stat = (0, node_fs_1.statSync)(output);
+            if (!stat.isFile()) {
+                throw new Error(`The output location ${output} already exists, but is not a file, but something else (e.g. folder). Cannot save to it.`);
+            }
         }
+        (0, ensure_output_directory_1.ensureOutputDirectory)(output);
     }
-    (0, ensure_output_directory_1.ensureOutputDirectory)(output);
-    const browserInstance = puppeteerInstance !== null && puppeteerInstance !== void 0 ? puppeteerInstance : (await (0, open_browser_1.openBrowser)(browser_1.DEFAULT_BROWSER, {
+    const browserInstance = puppeteerInstance !== null && puppeteerInstance !== void 0 ? puppeteerInstance : (await (0, open_browser_1.internalOpenBrowser)({
+        browser: browser_1.DEFAULT_BROWSER,
         browserExecutable,
         shouldDumpIo: dumpBrowserLogs,
         chromiumOptions,
-        forceDeviceScaleFactor: scale !== null && scale !== void 0 ? scale : 1,
+        forceDeviceScaleFactor: scale,
+        indent: false,
+        viewport: null,
     }));
-    const page = await browserInstance.newPage();
+    const page = await browserInstance.newPage(sourceMapContext);
     await page.setViewport({
         width: composition.width,
         height: composition.height,
-        deviceScaleFactor: scale !== null && scale !== void 0 ? scale : 1,
+        deviceScaleFactor: scale,
     });
     const errorCallback = (err) => {
         onError(err);
@@ -99,13 +108,21 @@ const innerRenderStill = async ({ composition, quality, imageFormat = 'png', ser
         onError: errorCallback,
         frame: null,
     });
+    const logCallback = (log) => {
+        onBrowserLog === null || onBrowserLog === void 0 ? void 0 : onBrowserLog({
+            stackTrace: log.stackTrace(),
+            text: log.text,
+            type: log.type,
+        });
+    };
     const cleanup = async () => {
         cleanUpJSException();
+        page.off('console', logCallback);
         if (puppeteerInstance) {
             await page.close();
         }
         else {
-            browserInstance.close().catch((err) => {
+            browserInstance.close(true).catch((err) => {
                 console.log('Unable to close browser', err);
             });
         }
@@ -113,6 +130,9 @@ const innerRenderStill = async ({ composition, quality, imageFormat = 'png', ser
     cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
         cleanup();
     });
+    if (onBrowserLog) {
+        page.on('console', logCallback);
+    }
     await (0, set_props_and_env_1.setPropsAndEnv)({
         inputProps,
         envVariables,
@@ -128,7 +148,7 @@ const innerRenderStill = async ({ composition, quality, imageFormat = 'png', ser
     await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         // eslint-disable-next-line max-params
         pageFunction: (id, defaultProps, durationInFrames, fps, height, width) => {
-            window.setBundleMode({
+            window.remotion_setBundleMode({
                 type: 'composition',
                 compositionName: id,
                 compositionDefaultProps: defaultProps,
@@ -150,57 +170,56 @@ const innerRenderStill = async ({ composition, quality, imageFormat = 'png', ser
         page,
     });
     await (0, seek_to_frame_1.seekToFrame)({ frame: stillFrame, page });
-    await (0, provide_screenshot_1.provideScreenshot)({
-        page,
+    const { buffer } = await (0, take_frame_and_compose_1.takeFrameAndCompose)({
+        frame: stillFrame,
+        freePage: page,
+        height: composition.height,
+        width: composition.width,
         imageFormat,
-        quality,
-        options: {
-            frame: stillFrame,
-            output,
-        },
+        scale,
+        output,
+        jpegQuality,
+        wantsBuffer: !output,
+        compositor,
+        downloadMap,
     });
     await cleanup();
+    return { buffer: output ? null : buffer };
 };
-/**
- *
- * @description Render a still frame from a composition
- * @link https://www.remotion.dev/docs/renderer/render-still
- */
-const renderStill = (options) => {
-    var _a, _b;
-    const selectedServeUrl = (0, legacy_webpack_config_1.getServeUrlWithFallback)(options);
-    const downloadMap = (_a = options.downloadMap) !== null && _a !== void 0 ? _a : (0, download_map_1.makeDownloadMap)();
-    const onDownload = (_b = options.onDownload) !== null && _b !== void 0 ? _b : (() => () => undefined);
+const internalRenderStill = (options) => {
+    const cleanup = [];
     const happyPath = new Promise((resolve, reject) => {
-        var _a, _b, _c;
         const onError = (err) => reject(err);
-        let close = null;
-        (0, prepare_server_1.prepareServer)({
-            webpackConfigOrServeUrl: selectedServeUrl,
-            onDownload,
+        (0, prepare_server_1.makeOrReuseServer)(options.server, {
+            webpackConfigOrServeUrl: options.serveUrl,
+            port: options.port,
+            remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
+            concurrency: 1,
+            verbose: options.verbose,
+            indent: options.indent,
+        }, {
+            onDownload: options.onDownload,
             onError,
-            ffmpegExecutable: (_a = options.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
-            ffprobeExecutable: (_b = options.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
-            port: (_c = options.port) !== null && _c !== void 0 ? _c : null,
-            downloadMap,
         })
-            .then(({ serveUrl, closeServer, offthreadPort }) => {
-            close = closeServer;
+            .then(({ server, cleanupServer }) => {
+            cleanup.push(() => cleanupServer(false));
+            const { serveUrl, offthreadPort, compositor, sourceMap, downloadMap } = server;
             return innerRenderStill({
                 ...options,
                 serveUrl,
-                onError: (err) => reject(err),
+                onError,
                 proxyPort: offthreadPort,
+                compositor,
+                sourceMapContext: sourceMap,
+                downloadMap,
             });
         })
             .then((res) => resolve(res))
             .catch((err) => reject(err))
             .finally(() => {
-            // Clean download map if it was not passed in
-            if (!(options === null || options === void 0 ? void 0 : options.downloadMap)) {
-                (0, download_map_1.cleanDownloadMap)(downloadMap);
-            }
-            return close === null || close === void 0 ? void 0 : close();
+            cleanup.forEach((c) => {
+                c();
+            });
         });
     });
     return Promise.race([
@@ -208,9 +227,49 @@ const renderStill = (options) => {
         new Promise((_resolve, reject) => {
             var _a;
             (_a = options.cancelSignal) === null || _a === void 0 ? void 0 : _a.call(options, () => {
-                reject(new Error('renderStill() got cancelled'));
+                reject(new Error(make_cancel_signal_1.cancelErrorMessages.renderStill));
             });
         }),
     ]);
 };
+exports.internalRenderStill = internalRenderStill;
+/**
+ *
+ * @description Render a still frame from a composition
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/render-still)
+ */
+const renderStill = (options) => {
+    var _a;
+    const { composition, serveUrl, browserExecutable, cancelSignal, chromiumOptions, dumpBrowserLogs, envVariables, frame, imageFormat, inputProps, jpegQuality, onBrowserLog, onDownload, output, overwrite, port, puppeteerInstance, scale, timeoutInMilliseconds, verbose, quality, } = options;
+    if (typeof jpegQuality !== 'undefined' && imageFormat !== 'jpeg') {
+        throw new Error("You can only pass the `quality` option if `imageFormat` is 'jpeg'.");
+    }
+    if (quality) {
+        console.warn('Passing `quality()` to `renderStill` is deprecated. Use `jpegQuality` instead.');
+    }
+    return (0, exports.internalRenderStill)({
+        composition,
+        browserExecutable: browserExecutable !== null && browserExecutable !== void 0 ? browserExecutable : null,
+        cancelSignal: cancelSignal !== null && cancelSignal !== void 0 ? cancelSignal : null,
+        chromiumOptions: chromiumOptions !== null && chromiumOptions !== void 0 ? chromiumOptions : {},
+        dumpBrowserLogs: dumpBrowserLogs !== null && dumpBrowserLogs !== void 0 ? dumpBrowserLogs : false,
+        envVariables: envVariables !== null && envVariables !== void 0 ? envVariables : {},
+        frame: frame !== null && frame !== void 0 ? frame : 0,
+        imageFormat: imageFormat !== null && imageFormat !== void 0 ? imageFormat : image_format_1.DEFAULT_STILL_IMAGE_FORMAT,
+        indent: false,
+        inputProps: inputProps !== null && inputProps !== void 0 ? inputProps : {},
+        jpegQuality: (_a = jpegQuality !== null && jpegQuality !== void 0 ? jpegQuality : quality) !== null && _a !== void 0 ? _a : jpeg_quality_1.DEFAULT_JPEG_QUALITY,
+        onBrowserLog: onBrowserLog !== null && onBrowserLog !== void 0 ? onBrowserLog : null,
+        onDownload: onDownload !== null && onDownload !== void 0 ? onDownload : null,
+        output: output !== null && output !== void 0 ? output : null,
+        overwrite: overwrite !== null && overwrite !== void 0 ? overwrite : overwrite_1.DEFAULT_OVERWRITE,
+        port: port !== null && port !== void 0 ? port : null,
+        puppeteerInstance: puppeteerInstance !== null && puppeteerInstance !== void 0 ? puppeteerInstance : null,
+        scale: scale !== null && scale !== void 0 ? scale : 1,
+        server: undefined,
+        serveUrl,
+        timeoutInMilliseconds: timeoutInMilliseconds !== null && timeoutInMilliseconds !== void 0 ? timeoutInMilliseconds : TimeoutSettings_1.DEFAULT_TIMEOUT,
+        verbose: verbose !== null && verbose !== void 0 ? verbose : false,
+    });
+};
 exports.renderStill = renderStill;

package/dist/replace-browser.d.ts

@@ -0,0 +1,6 @@
+import type { HeadlessBrowser } from './browser/Browser';
+export type BrowserReplacer = {
+    getBrowser: () => HeadlessBrowser;
+    replaceBrowser: (make: () => Promise<HeadlessBrowser>, makeNewPages: () => Promise<void>) => Promise<HeadlessBrowser>;
+};
+export declare const handleBrowserCrash: (instance: HeadlessBrowser) => BrowserReplacer;

package/dist/replace-browser.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBrowserCrash = void 0;
+const handleBrowserCrash = (instance) => {
+    let _instance = instance;
+    const waiters = [];
+    let replacing = false;
+    return {
+        getBrowser: () => _instance,
+        replaceBrowser: async (make, makeNewPages) => {
+            if (replacing) {
+                const waiter = new Promise((resolve, reject) => {
+                    waiters.push({
+                        resolve,
+                        reject,
+                    });
+                });
+                return waiter;
+            }
+            try {
+                replacing = true;
+                await _instance
+                    .close(true)
+                    .then(() => {
+                    console.log('Killed previous browser and making new one');
+                })
+                    .catch(() => {
+                    // Ignore as browser crashed
+                });
+                const browser = await make();
+                _instance = browser;
+                await makeNewPages();
+                waiters.forEach((w) => w.resolve(browser));
+                console.log('Made new browser');
+                return browser;
+            }
+            catch (err) {
+                waiters.forEach((w) => w.reject(err));
+                throw err;
+            }
+            finally {
+                replacing = false;
+            }
+        },
+    };
+};
+exports.handleBrowserCrash = handleBrowserCrash;

package/dist/resolve-asset-src.js

@@ -4,14 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAssetSrc = void 0;
-const url_1 = __importDefault(require("url"));
+const node_url_1 = __importDefault(require("node:url"));
 const resolveAssetSrc = (src) => {
     if (!src.startsWith('file:')) {
         return src;
     }
     const { protocol } = new URL(src);
     if (protocol === 'file:')
-        return url_1.default.fileURLToPath(src);
+        return node_url_1.default.fileURLToPath(src);
     throw new TypeError(`Unexpected src ${src}`);
 };
 exports.resolveAssetSrc = resolveAssetSrc;

package/dist/screenshot-dom-element.d.ts

@@ -1,11 +1,15 @@
 /// <reference types="node" />
+import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
-import type { ImageFormat } from './image-format';
-export declare const screenshotDOMElement: ({ page, imageFormat, quality, opts, }: {
+import type { StillImageFormat } from './image-format';
+export declare const screenshotDOMElement: ({ page, imageFormat, jpegQuality, opts, height, width, clipRegion, }: {
     page: Page;
-    imageFormat: ImageFormat;
-    quality: number | undefined;
+    imageFormat: StillImageFormat;
+    jpegQuality: number | undefined;
     opts: {
         path: string | null;
     };
+    height: number;
+    width: number;
+    clipRegion: ClipRegion | null;
 }) => Promise<Buffer>;

package/dist/screenshot-dom-element.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.screenshotDOMElement = void 0;
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
 const puppeteer_screenshot_1 = require("./puppeteer-screenshot");
-const screenshotDOMElement = async ({ page, imageFormat, quality, opts, }) => {
+const screenshotDOMElement = async ({ page, imageFormat, jpegQuality, opts, height, width, clipRegion, }) => {
     const { path } = opts;
-    if (imageFormat === 'png') {
+    if (imageFormat === 'png' ||
+        imageFormat === 'pdf' ||
+        imageFormat === 'webp') {
         await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
             pageFunction: () => {
                 document.body.style.background = 'transparent';
@@ -25,14 +27,23 @@ const screenshotDOMElement = async ({ page, imageFormat, quality, opts, }) => {
             page,
         });
     }
+    // @ts-expect-error
     if (imageFormat === 'none') {
         throw new TypeError('Tried to make a screenshot with format "none"');
     }
-    return (0, puppeteer_screenshot_1.screenshot)(page, {
+    const buf = await (0, puppeteer_screenshot_1.screenshot)({
+        page,
         omitBackground: imageFormat === 'png',
         path: path !== null && path !== void 0 ? path : undefined,
         type: imageFormat,
-        quality,
+        jpegQuality,
+        width,
+        height,
+        clipRegion,
     });
+    if (typeof buf === 'string') {
+        throw new TypeError('Expected a buffer');
+    }
+    return buf;
 };
 exports.screenshotDOMElement = screenshotDOMElement;

package/dist/screenshot-task.d.ts

@@ -1,5 +1,14 @@
 /// <reference types="node" />
+import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
-import type { ScreenshotOptions } from './browser/ScreenshotOptions';
 import type { StillImageFormat } from './image-format';
-export declare const _screenshotTask: (page: Page, format: StillImageFormat, options: ScreenshotOptions) => Promise<Buffer | string>;
+export declare const screenshotTask: ({ format, height, omitBackground, page, width, path, jpegQuality, clipRegion, }: {
+    page: Page;
+    format: StillImageFormat;
+    path?: string | undefined;
+    jpegQuality?: number | undefined;
+    omitBackground: boolean;
+    width: number;
+    height: number;
+    clipRegion: ClipRegion | null;
+}) => Promise<Buffer | string>;

package/dist/screenshot-task.js

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._screenshotTask = void 0;
-const fs_1 = __importDefault(require("fs"));
+exports.screenshotTask = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
 const perf_1 = require("./perf");
-const _screenshotTask = async (page, format, options) => {
+const screenshotTask = async ({ format, height, omitBackground, page, width, path, jpegQuality, clipRegion, }) => {
     var _a;
     const client = page._client();
     const target = page.target();
@@ -15,26 +15,56 @@ const _screenshotTask = async (page, format, options) => {
         targetId: target._targetId,
     });
     (0, perf_1.stopPerfMeasure)(perfTarget);
-    const shouldSetDefaultBackground = options.omitBackground && format === 'png';
+    const shouldSetDefaultBackground = omitBackground;
     if (shouldSetDefaultBackground)
         await client.send('Emulation.setDefaultBackgroundColorOverride', {
             color: { r: 0, g: 0, b: 0, a: 0 },
         });
     const cap = (0, perf_1.startPerfMeasure)('capture');
     try {
-        const result = await client.send('Page.captureScreenshot', {
-            format,
-            quality: options.quality,
-            clip: undefined,
-            captureBeyondViewport: true,
-        });
+        let result;
+        if (format === 'pdf') {
+            result = await client.send('Page.printToPDF', {
+                paperWidth: width / 96,
+                paperHeight: height / 96,
+                marginTop: 0,
+                marginBottom: 0,
+                marginLeft: 0,
+                marginRight: 0,
+                scale: 1,
+                printBackground: true,
+            });
+        }
+        else {
+            result = await client.send('Page.captureScreenshot', {
+                format,
+                quality: jpegQuality,
+                clip: clipRegion !== null && clipRegion !== 'hide'
+                    ? {
+                        x: clipRegion.x,
+                        y: clipRegion.y,
+                        height: clipRegion.height,
+                        scale: 1,
+                        width: clipRegion.width,
+                    }
+                    : {
+                        x: 0,
+                        y: 0,
+                        height,
+                        scale: 1,
+                        width,
+                    },
+                captureBeyondViewport: true,
+                optimizeForSpeed: true,
+            });
+        }
         (0, perf_1.stopPerfMeasure)(cap);
         if (shouldSetDefaultBackground)
             await client.send('Emulation.setDefaultBackgroundColorOverride');
         const saveMarker = (0, perf_1.startPerfMeasure)('save');
         const buffer = Buffer.from(result.data, 'base64');
-        if (options.path)
-            await fs_1.default.promises.writeFile(options.path, buffer);
+        if (path)
+            await node_fs_1.default.promises.writeFile(path, buffer);
         (0, perf_1.stopPerfMeasure)(saveMarker);
         return buffer;
     }
@@ -51,4 +81,4 @@ const _screenshotTask = async (page, format, options) => {
         throw err;
     }
 };
-exports._screenshotTask = _screenshotTask;
+exports.screenshotTask = screenshotTask;

package/dist/seek-to-frame.d.ts

@@ -1,4 +1,5 @@
 import type { Page } from './browser/BrowserPage';
+export declare const waitForReady: (page: Page) => Promise<unknown>;
 export declare const seekToFrame: ({ frame, page, }: {
     frame: number;
     page: Page;