pupeteer-capture 0.0.1-security → 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Oleksii PELYKH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,125 @@
-# Security holding package
+# puppeteer-capture
 
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
+![node-current](https://img.shields.io/node/v/puppeteer-capture)
+![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/alexey-pelykh/puppeteer-capture/ci.yml?branch=main)
+![Codecov](https://img.shields.io/codecov/c/gh/alexey-pelykh/puppeteer-capture)
+![Code Climate maintainability](https://img.shields.io/codeclimate/maintainability/alexey-pelykh/puppeteer-capture)
+[![GitHub license](https://img.shields.io/github/license/alexey-pelykh/puppeteer-capture)](https://github.com/alexey-pelykh/puppeteer-capture/blob/main/LICENSE)
 
-Please refer to www.npmjs.com/advisories?search=pupeteer-capture for more information.
+A Puppeteer plugin for capturing page as a video.
+
+## Under The Hood
+
+[`HeadlessExperimental`](https://chromedevtools.github.io/devtools-protocol/tot/HeadlessExperimental/) is used to capture frames in a deterministic way. This approach allows to achieve better quality than using screencast.
+
+## Getting Started
+
+```js
+const { capture, launch } = require('puppeteer-capture')
+
+(async () => {
+  const browser = await launch()
+  const page = await browser.newPage()
+  const recorder = await capture(page)
+  await page.goto('https://google.com', {
+    waitUntil: 'networkidle0',
+  })
+  await recorder.start('capture.mp4')
+  await page.waitForTimeout(1000)
+  await recorder.stop()
+  await recorder.detach()
+  await browser.close()
+})()
+```
+
+## Known Issues
+
+### MacOS is not supported
+
+Unfortunately, [it is so](https://source.chromium.org/chromium/chromium/src/+/main:headless/lib/browser/protocol/target_handler.cc;drc=5811aa08e60ba5ac7622f029163213cfbdb682f7;l=32).
+
+## No capturing == Nothing happens
+
+This relates to timers, animations, clicks, etc. To process interaction with the page, frame requests have to be submitted and thus capturing have to be active.
+
+## Setting `defaultViewport` causes rendering to freeze
+
+The exact origin of the issue is not yet known, yet it's likely to be related to the deterministic mode.
+
+Calling `page.setViewport()` before starting the capture behaves the same, yet calling it _after_ starting the capture works yet not always. Thus it's safe to assume that there's some sort of race condition, since adding `page.waitForTimeout(100)` just before setting the viewport workarounds the issue.
+
+Also it should be taken into account that since frame size is going to change over the time of the recording, frame size autodetection will fail. To workaround this issue, frame size have to be specified:
+```js
+const recorder = await capture(page, {
+  size: `${viewportWidth}x${viewportHeight}`,
+})
+await recorder.start('capture.mp4', { waitForTimeout: false })
+await page.waitForTimeout(100)
+await page.setViewport({
+  width: viewportWidth,
+  height: viewportHeight,
+  deviceScaleFactor: 1.0,
+})
+```
+
+A friendlier workaround is enabled by default: `recorder.start()` automatically waits for the first frame to be captured.
+This approach seems to allow bypassing the alleged race condition:
+
+```js
+const recorder = await capture(page, {
+  size: `${viewportWidth}x${viewportHeight}`,
+})
+await recorder.start('capture.mp4')
+await page.setViewport({
+  width: viewportWidth,
+  height: viewportHeight,
+  deviceScaleFactor: 1.0,
+})
+```
+
+## `waitForTimeout()` won't work
+
+The `Page.waitForTimeout()` method implementation essentially forwards the call to the `Frame.waitForTimeout()` on the `page.mainFrame()`. The latter is implemented via `setTimeout()`, thus can not work in deterministic mode at all.
+
+To workaround this issue, there's a `PuppeteerCapture.waitForTimeout()` that waits for the timeout in the timeline of the captured page, which is not real time at all. For convenience, while capturing is active, the page's `waitForTimeout()` becomes a wrapper for `PuppeteerCapture.waitForTimeout()`.
+
+## Multiple `start()`/`stop()` fail
+
+It's unclear why, yet after disabling and re-enabling the capture, callbacks from browser stop arriving.
+
+## Time-related functions are affected
+
+The following functions have to be overriden with injected versions:
+
+- `setTimeout` & `clearTimeout`
+- `setInterval` & `clearInterval`
+- `requestAnimationFrame` & `cancelAnimationFrame`
+- `Date()` & `Date.now()`
+- `performance.now()`
+
+The injection should happen before page content loads:
+
+```js
+const recorder = await capture(page) // Injection happens here during attach()
+await page.goto('https://google.com') // Possible capture would happen here, thus injected versions would be captured
+```
+
+## Events
+
+`PuppeteerCapture` supports following events:
+
+ - `captureStarted`: capture was successfully started
+ - `frameCaptured`: frame was captured
+ - `frameCaptureFailed`: frame capture failed
+ - `frameRecorded`: frame has been submitted to `ffmpeg`
+ - `captureStopped`: capture was stopped
+
+## Dependencies
+
+### `ffmpeg`
+
+It is resolved in the following order:
+
+1. `FFMPEG` environment variable, should point to the executable
+2. The executable that's available via the `PATH` environment variable
+3. Via `@ffmpeg-installer/ffmpeg`, if it's installed as dependency

package/lib/MissingHeadlessExperimentalRequiredArgs.d.ts

@@ -0,0 +1,3 @@
+export declare class MissingHeadlessExperimentalRequiredArgs extends Error {
+    constructor();
+}

package/lib/MissingHeadlessExperimentalRequiredArgs.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingHeadlessExperimentalRequiredArgs = void 0;
+const PuppeteerCaptureViaHeadlessExperimental_1 = require("./PuppeteerCaptureViaHeadlessExperimental");
+class MissingHeadlessExperimentalRequiredArgs extends Error {
+    constructor() {
+        super('Missing one or more of required arguments: ' + PuppeteerCaptureViaHeadlessExperimental_1.PuppeteerCaptureViaHeadlessExperimental.REQUIRED_ARGS.join(', '));
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.MissingHeadlessExperimentalRequiredArgs = MissingHeadlessExperimentalRequiredArgs;

package/lib/PuppeteerCapture.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import type { Page as PuppeteerPage } from 'puppeteer';
+import { Writable } from 'stream';
+import { PuppeteerCaptureEvents } from './PuppeteerCaptureEvents';
+import { PuppeteerCaptureStartOptions } from './PuppeteerCaptureStartOptions';
+export interface PuppeteerCapture {
+    page: PuppeteerPage | null;
+    isCapturing: boolean;
+    captureTimestamp: number;
+    capturedFrames: number;
+    dropCapturedFrames: boolean;
+    recordedFrames: number;
+    attach: (page: PuppeteerPage) => Promise<void>;
+    detach: () => Promise<void>;
+    start: (target: string | Writable, options?: PuppeteerCaptureStartOptions) => Promise<void>;
+    stop: () => Promise<void>;
+    waitForTimeout: (milliseconds: number) => Promise<void>;
+    on: <Event extends keyof PuppeteerCaptureEvents>(event: Event, listener: PuppeteerCaptureEvents[Event]) => this;
+}

package/lib/PuppeteerCapture.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/PuppeteerCaptureBase.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Mutex } from 'async-mutex';
+import { FfmpegCommand } from 'fluent-ffmpeg';
+import { EventEmitter } from 'node:events';
+import type { Page as PuppeteerPage } from 'puppeteer';
+import { PassThrough, Writable } from 'stream';
+import { PuppeteerCapture } from './PuppeteerCapture';
+import { PuppeteerCaptureEvents } from './PuppeteerCaptureEvents';
+import { PuppeteerCaptureOptions } from './PuppeteerCaptureOptions';
+import { PuppeteerCaptureStartOptions } from './PuppeteerCaptureStartOptions';
+export declare abstract class PuppeteerCaptureBase extends EventEmitter implements PuppeteerCapture {
+    static readonly DEFAULT_OPTIONS: PuppeteerCaptureOptions;
+    static readonly DEFAULT_START_OPTIONS: PuppeteerCaptureStartOptions;
+    protected readonly _options: PuppeteerCaptureOptions;
+    protected readonly _frameInterval: number;
+    protected readonly _onPageClose: () => void;
+    protected readonly _startStopMutex: Mutex;
+    protected _page: PuppeteerPage | null;
+    protected _target: string | Writable | null;
+    protected _frameBeingCaptured: Promise<void> | null;
+    protected _captureTimestamp: number;
+    protected _capturedFrames: number;
+    protected _dropCapturedFrames: boolean;
+    protected _recordedFrames: number;
+    protected _error: any | null;
+    protected _framesStream: PassThrough | null;
+    protected _ffmpegStream: FfmpegCommand | null;
+    protected _ffmpegStarted: Promise<void> | null;
+    protected _ffmpegExited: Promise<void> | null;
+    protected _ffmpegExitedResolve: (() => void) | null;
+    protected _pageWaitForTimeout: ((milliseconds: number) => Promise<void>) | null;
+    protected _isCapturing: boolean;
+    constructor(options?: PuppeteerCaptureOptions);
+    get page(): PuppeteerPage | null;
+    get isCapturing(): boolean;
+    get captureTimestamp(): number;
+    get capturedFrames(): number;
+    get dropCapturedFrames(): boolean;
+    set dropCapturedFrames(dropCaptiuredFrames: boolean);
+    get recordedFrames(): number;
+    attach(page: PuppeteerPage): Promise<void>;
+    protected _attach(page: PuppeteerPage): Promise<void>;
+    detach(): Promise<void>;
+    protected _detach(page: PuppeteerPage): Promise<void>;
+    start(target: string | Writable, options?: PuppeteerCaptureStartOptions): Promise<void>;
+    protected _start(target: string | Writable, options?: PuppeteerCaptureStartOptions): Promise<void>;
+    stop(): Promise<void>;
+    protected _stop(): Promise<void>;
+    waitForTimeout(milliseconds: number): Promise<void>;
+    emit<Event extends keyof PuppeteerCaptureEvents>(eventName: Event, ...args: Parameters<PuppeteerCaptureEvents[Event]>): boolean;
+    protected onPostCaptureStarted(): Promise<void>;
+    protected onPostCaptureStopped(): Promise<void>;
+    protected onFrameCaptured(timestamp: number, data: Buffer): Promise<void>;
+    protected onFrameCaptureFailed(reason?: any): Promise<void>;
+    protected onPageClose(): void;
+    private static findFfmpeg;
+}

package/lib/PuppeteerCaptureBase.js

@@ -0,0 +1,394 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerCaptureBase = void 0;
+const async_mutex_1 = require("async-mutex");
+const fluent_ffmpeg_1 = __importStar(require("fluent-ffmpeg"));
+const promises_1 = require("fs/promises");
+const node_events_1 = require("node:events");
+const path_1 = require("path");
+const stream_1 = require("stream");
+const which_1 = __importDefault(require("which"));
+const PuppeteerCaptureFormat_1 = require("./PuppeteerCaptureFormat");
+class PuppeteerCaptureBase extends node_events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this._options = Object.assign(Object.assign({}, PuppeteerCaptureBase.DEFAULT_OPTIONS), (options !== null ? options : {}));
+        if (this._options.fps == null) {
+            throw new Error('options.fps needs to be set');
+        }
+        if (this._options.fps < 0) {
+            throw new Error(`options.fps can not be set to ${this._options.fps}`);
+        }
+        this._frameInterval = 1000.0 / this._options.fps;
+        this._onPageClose = this.onPageClose.bind(this);
+        this._startStopMutex = new async_mutex_1.Mutex();
+        this._page = null;
+        this._target = null;
+        this._frameBeingCaptured = null;
+        this._captureTimestamp = 0;
+        this._capturedFrames = 0;
+        this._dropCapturedFrames = false;
+        this._recordedFrames = 0;
+        this._error = null;
+        this._framesStream = null;
+        this._ffmpegStream = null;
+        this._ffmpegStarted = null;
+        this._ffmpegExited = null;
+        this._ffmpegExitedResolve = null;
+        this._pageWaitForTimeout = null;
+        this._isCapturing = false;
+    }
+    get page() {
+        return this._page;
+    }
+    get isCapturing() {
+        return this._isCapturing;
+    }
+    get captureTimestamp() {
+        return this._captureTimestamp;
+    }
+    get capturedFrames() {
+        return this._capturedFrames;
+    }
+    get dropCapturedFrames() {
+        return this._dropCapturedFrames;
+    }
+    set dropCapturedFrames(dropCaptiuredFrames) {
+        this._dropCapturedFrames = dropCaptiuredFrames;
+    }
+    get recordedFrames() {
+        return this._recordedFrames;
+    }
+    attach(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._page != null) {
+                throw new Error('Already attached to a page');
+            }
+            yield this._attach(page);
+            this._page = page;
+        });
+    }
+    _attach(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    detach() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._page == null) {
+                throw new Error('Already detached from a page');
+            }
+            yield this._detach(this._page);
+            this._page = null;
+        });
+    }
+    _detach(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    start(target, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._startStopMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () { return yield this._start(target, options); }));
+        });
+    }
+    _start(target, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            options = Object.assign(Object.assign({}, PuppeteerCaptureBase.DEFAULT_START_OPTIONS), (options !== null ? options : {}));
+            if (options.waitForFirstFrame == null) {
+                throw new Error('options.waitForFirstFrame can not be null or undefined');
+            }
+            if (options.waitForFirstFrame == null) {
+                throw new Error('options.waitForFirstFrame can not be null or undefined');
+            }
+            if (this._page == null) {
+                throw new Error('Not attached to a page');
+            }
+            if (this._isCapturing) {
+                throw new Error('Capture is in progress');
+            }
+            if (this._page.isClosed()) {
+                throw new Error('Can not start capturing a closed page');
+            }
+            if (typeof target === 'string' || target instanceof String) {
+                yield (0, promises_1.mkdir)((0, path_1.dirname)(target.toString()), { recursive: true });
+            }
+            const framesStream = new stream_1.PassThrough();
+            (0, fluent_ffmpeg_1.setFfmpegPath)(this._options.ffmpeg != null
+                ? this._options.ffmpeg
+                : yield PuppeteerCaptureBase.findFfmpeg());
+            const ffmpegStream = (0, fluent_ffmpeg_1.default)();
+            ffmpegStream
+                .input(framesStream)
+                .inputFormat('image2pipe')
+                .inputFPS(this._options.fps); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            ffmpegStream
+                .output(target)
+                .outputFPS(this._options.fps); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            if (this._options.size != null) {
+                ffmpegStream
+                    .size(this._options.size);
+            }
+            yield this._options.format(ffmpegStream); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            if (this._options.customFfmpegConfig != null) {
+                yield this._options.customFfmpegConfig(ffmpegStream);
+            }
+            this._page.once('close', this._onPageClose);
+            this._target = target;
+            this._captureTimestamp = 0;
+            this._capturedFrames = 0;
+            this._dropCapturedFrames = options.dropCapturedFrames; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            this._recordedFrames = 0;
+            this._error = null;
+            this._framesStream = framesStream;
+            this._ffmpegStream = ffmpegStream;
+            this._ffmpegStarted = new Promise((resolve, reject) => {
+                const onStart = () => {
+                    ffmpegStream.off('error', onError);
+                    resolve();
+                };
+                const onError = (reason) => {
+                    ffmpegStream.off('start', onStart);
+                    reject(reason);
+                };
+                ffmpegStream
+                    .once('start', onStart)
+                    .once('error', onError);
+            });
+            this._ffmpegExited = new Promise((resolve) => {
+                this._ffmpegExitedResolve = resolve;
+                const onEnd = () => {
+                    ffmpegStream.off('error', onError);
+                    resolve();
+                };
+                const onError = (reason) => {
+                    ffmpegStream.off('end', onEnd);
+                    this._error = reason;
+                    resolve();
+                    this._startStopMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () { return yield this._stop(); }))
+                        .then(() => { })
+                        .catch(() => { });
+                };
+                ffmpegStream
+                    .once('error', onError)
+                    .once('end', onEnd);
+            });
+            this._ffmpegStream.run();
+            yield this._ffmpegStarted;
+            this._pageWaitForTimeout = this._page.waitForTimeout;
+            this._page.waitForTimeout = (milliseconds) => __awaiter(this, void 0, void 0, function* () {
+                yield this.waitForTimeout(milliseconds);
+            });
+            this._isCapturing = true;
+            this.emit('captureStarted');
+            yield this.onPostCaptureStarted();
+            if (options.waitForFirstFrame) {
+                yield new Promise((resolve, reject) => {
+                    const onFrameCaptured = () => {
+                        this.off('frameCaptureFailed', onFrameCaptureFailed);
+                        resolve();
+                    };
+                    const onFrameCaptureFailed = (reason) => {
+                        this.off('frameCaptured', onFrameCaptured);
+                        reject(reason);
+                    };
+                    this
+                        .once('frameCaptured', onFrameCaptured)
+                        .once('frameCaptureFailed', onFrameCaptureFailed);
+                });
+            }
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._error != null) {
+                const error = this._error;
+                this._error = null;
+                throw error;
+            }
+            yield this._startStopMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () { return yield this._stop(); }));
+        });
+    }
+    _stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._page == null) {
+                throw new Error('Not attached to a page');
+            }
+            if (!this._isCapturing) {
+                throw new Error('Capture is not in progress');
+            }
+            this._isCapturing = false;
+            while (this._frameBeingCaptured != null) {
+                yield this._frameBeingCaptured;
+            }
+            if (this._ffmpegStarted != null) {
+                yield this._ffmpegStarted;
+                this._ffmpegStarted = null;
+            }
+            if (this._framesStream != null) {
+                if (this._ffmpegStream != null) {
+                    this._ffmpegStream.removeAllListeners('error');
+                    this._ffmpegStream.once('error', () => {
+                        if (this._ffmpegExitedResolve != null) {
+                            this._ffmpegExitedResolve();
+                        }
+                    });
+                }
+                this._framesStream.end();
+                this._framesStream = null;
+            }
+            if (this._ffmpegExited != null) {
+                yield this._ffmpegExited;
+                this._ffmpegExited = null;
+                this._ffmpegExitedResolve = null;
+            }
+            if (this._ffmpegStream != null) {
+                this._ffmpegStream = null;
+            }
+            if (this._target != null) {
+                this._target = null;
+            }
+            if (this._pageWaitForTimeout != null) {
+                this._page.waitForTimeout = this._pageWaitForTimeout;
+            }
+            this._page.off('close', this._onPageClose);
+            this.emit('captureStopped');
+            yield this.onPostCaptureStopped();
+        });
+    }
+    waitForTimeout(milliseconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._isCapturing) {
+                throw new Error('Can not wait for timeout while not capturing');
+            }
+            const desiredCaptureTimestamp = this._captureTimestamp + milliseconds;
+            let waitPromiseResolve;
+            let waitPromiseReject;
+            const waitPromise = new Promise((resolve, reject) => {
+                waitPromiseResolve = resolve;
+                waitPromiseReject = reject;
+            });
+            const onFrameCaptured = () => {
+                if (this._captureTimestamp < desiredCaptureTimestamp) {
+                    return;
+                }
+                this
+                    .off('frameCaptured', onFrameCaptured)
+                    .off('frameCaptureFailed', onFrameCaptureFailed);
+                waitPromiseResolve();
+            };
+            const onFrameCaptureFailed = (reason) => {
+                this
+                    .off('frameCaptured', onFrameCaptured)
+                    .off('frameCaptureFailed', onFrameCaptureFailed);
+                waitPromiseReject(reason);
+            };
+            this
+                .on('frameCaptured', onFrameCaptured)
+                .on('frameCaptureFailed', onFrameCaptureFailed);
+            yield waitPromise;
+        });
+    }
+    emit(eventName, ...args) {
+        return super.emit(eventName, ...args);
+    }
+    onPostCaptureStarted() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    onPostCaptureStopped() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    onFrameCaptured(timestamp, data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.emit('frameCaptured', this._capturedFrames, timestamp, data);
+            this._capturedFrames += 1;
+            if (this._dropCapturedFrames) {
+                return;
+            }
+            (_a = this._framesStream) === null || _a === void 0 ? void 0 : _a.write(data);
+            this.emit('frameRecorded', this._recordedFrames, timestamp, data);
+            this._recordedFrames += 1;
+        });
+    }
+    onFrameCaptureFailed(reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.stop();
+            this._error = reason;
+            this.emit('frameCaptureFailed', reason);
+        });
+    }
+    onPageClose() {
+        this._error = new Error('Page was closed');
+        this._startStopMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () {
+            if (this._isCapturing) {
+                yield this._stop();
+            }
+            yield this.detach();
+        }))
+            .then(() => { })
+            .catch(() => { });
+    }
+    static findFfmpeg() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (process.env.FFMPEG != null) {
+                return process.env.FFMPEG;
+            }
+            try {
+                const systemFfmpeg = yield (0, which_1.default)('ffmpeg');
+                return systemFfmpeg;
+            }
+            catch (e) { }
+            try {
+                const ffmpeg = require('@ffmpeg-installer/ffmpeg'); // eslint-disable-line @typescript-eslint/no-var-requires
+                return ffmpeg.path;
+            }
+            catch (e) { }
+            throw new Error('ffmpeg not available: specify FFMPEG environment variable, or make it available via PATH, or add @ffmpeg-installer/ffmpeg to the project');
+        });
+    }
+}
+exports.PuppeteerCaptureBase = PuppeteerCaptureBase;
+PuppeteerCaptureBase.DEFAULT_OPTIONS = {
+    fps: 60,
+    format: (0, PuppeteerCaptureFormat_1.MP4)()
+};
+PuppeteerCaptureBase.DEFAULT_START_OPTIONS = {
+    waitForFirstFrame: true,
+    dropCapturedFrames: false
+};

package/lib/PuppeteerCaptureEvents.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+export interface PuppeteerCaptureEvents {
+    captureStarted: () => void;
+    frameCaptured: (index: number, timestamp: number, data: Buffer) => void;
+    frameCaptureFailed: (reason?: any) => void;
+    frameRecorded: (index: number, timestamp: number, data: Buffer) => void;
+    captureStopped: () => void;
+}

package/lib/PuppeteerCaptureEvents.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/PuppeteerCaptureFormat.d.ts

@@ -0,0 +1,2 @@
+import { FfmpegCommand } from 'fluent-ffmpeg';
+export declare function MP4(preset?: 'ultrafast' | 'superfast' | 'veryfast' | 'faster' | 'fast' | 'medium' | 'slow' | 'slower' | 'veryslow', videoCodec?: string): (ffmpeg: FfmpegCommand) => Promise<void>;