pupeteer-screen-recorder 0.0.1-security → 3.0.6

package/build/main/lib/pageVideoStreamWriter.js

@@ -0,0 +1,303 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const os_1 = __importDefault(require("os"));
+const path_1 = require("path");
+const stream_1 = require("stream");
+const fluent_ffmpeg_1 = __importStar(require("fluent-ffmpeg"));
+const pageVideoStreamTypes_1 = require("./pageVideoStreamTypes");
+/**
+ * @ignore
+ */
+const SUPPORTED_FILE_FORMATS = [
+    pageVideoStreamTypes_1.SupportedFileFormats.MP4,
+    pageVideoStreamTypes_1.SupportedFileFormats.AVI,
+    pageVideoStreamTypes_1.SupportedFileFormats.MOV,
+    pageVideoStreamTypes_1.SupportedFileFormats.WEBM,
+];
+/**
+ * @ignore
+ */
+class PageVideoStreamWriter extends events_1.EventEmitter {
+    constructor(destinationSource, options) {
+        super();
+        this.screenLimit = 10;
+        this.screenCastFrames = [];
+        this.duration = '00:00:00:00';
+        this.frameGain = 0;
+        this.frameLoss = 0;
+        this.status = pageVideoStreamTypes_1.VIDEO_WRITE_STATUS.NOT_STARTED;
+        this.videoMediatorStream = new stream_1.PassThrough();
+        if (options) {
+            this.options = options;
+        }
+        const isWritable = this.isWritableStream(destinationSource);
+        this.configureFFmPegPath();
+        if (isWritable) {
+            this.configureVideoWritableStream(destinationSource);
+        }
+        else {
+            this.configureVideoFile(destinationSource);
+        }
+    }
+    get videoFrameSize() {
+        const { width, height } = this.options.videoFrame;
+        return width !== null && height !== null ? `${width}x${height}` : '100%';
+    }
+    get autopad() {
+        const autopad = this.options.autopad;
+        return !autopad
+            ? { activation: false }
+            : { activation: true, color: autopad.color };
+    }
+    getFfmpegPath() {
+        if (this.options.ffmpeg_Path) {
+            return this.options.ffmpeg_Path;
+        }
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const ffmpeg = require('@ffmpeg-installer/ffmpeg');
+            if (ffmpeg.path) {
+                return ffmpeg.path;
+            }
+            return null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    getDestinationPathExtension(destinationFile) {
+        const fileExtension = (0, path_1.extname)(destinationFile);
+        return fileExtension.includes('.')
+            ? fileExtension.replace('.', '')
+            : fileExtension;
+    }
+    configureFFmPegPath() {
+        const ffmpegPath = this.getFfmpegPath();
+        if (!ffmpegPath) {
+            throw new Error('FFmpeg path is missing, \n Set the FFMPEG_PATH env variable');
+        }
+        (0, fluent_ffmpeg_1.setFfmpegPath)(ffmpegPath);
+    }
+    isWritableStream(destinationSource) {
+        if (destinationSource && typeof destinationSource !== 'string') {
+            if (!(destinationSource instanceof stream_1.Writable) ||
+                !('writable' in destinationSource) ||
+                !destinationSource.writable) {
+                throw new Error('Output should be a writable stream');
+            }
+            return true;
+        }
+        return false;
+    }
+    configureVideoFile(destinationPath) {
+        const fileExt = this.getDestinationPathExtension(destinationPath);
+        if (!SUPPORTED_FILE_FORMATS.includes(fileExt)) {
+            throw new Error('File format is not supported');
+        }
+        this.writerPromise = new Promise((resolve) => {
+            const outputStream = this.getDestinationStream();
+            outputStream
+                .on('error', (e) => {
+                this.handleWriteStreamError(e.message);
+                resolve(false);
+            })
+                .on('stderr', (e) => {
+                this.handleWriteStreamError(e);
+                resolve(false);
+            })
+                .on('end', () => resolve(true))
+                .save(destinationPath);
+            if (fileExt == pageVideoStreamTypes_1.SupportedFileFormats.WEBM) {
+                outputStream
+                    .videoCodec('libvpx')
+                    .videoBitrate(this.options.videoBitrate || 1000, true)
+                    .outputOptions('-flags', '+global_header', '-psnr');
+            }
+        });
+    }
+    configureVideoWritableStream(writableStream) {
+        this.writerPromise = new Promise((resolve) => {
+            const outputStream = this.getDestinationStream();
+            outputStream
+                .on('error', (e) => {
+                writableStream.emit('error', e);
+                resolve(false);
+            })
+                .on('stderr', (e) => {
+                writableStream.emit('error', { message: e });
+                resolve(false);
+            })
+                .on('end', () => {
+                writableStream.end();
+                resolve(true);
+            });
+            outputStream.toFormat('mp4');
+            outputStream.addOutputOptions('-movflags +frag_keyframe+separate_moof+omit_tfhd_offset+empty_moov');
+            outputStream.pipe(writableStream);
+        });
+    }
+    getOutputOption() {
+        var _a, _b;
+        const cpu = Math.max(1, os_1.default.cpus().length - 1);
+        const videoOutputOptions = (_a = this.options.videOutputOptions) !== null && _a !== void 0 ? _a : [];
+        const outputOptions = [];
+        outputOptions.push(`-crf ${(_b = this.options.videoCrf) !== null && _b !== void 0 ? _b : 23}`);
+        outputOptions.push(`-preset ${this.options.videoPreset || 'ultrafast'}`);
+        outputOptions.push(`-pix_fmt ${this.options.videoPixelFormat || 'yuv420p'}`);
+        outputOptions.push(`-minrate ${this.options.videoBitrate || 1000}`);
+        outputOptions.push(`-maxrate ${this.options.videoBitrate || 1000}`);
+        outputOptions.push('-framerate 1');
+        outputOptions.push(`-threads ${cpu}`);
+        outputOptions.push(`-loglevel error`);
+        videoOutputOptions.forEach((options) => {
+            outputOptions.push(options);
+        });
+        return outputOptions;
+    }
+    addVideoMetadata(outputStream) {
+        var _a;
+        const metadataOptions = (_a = this.options.metadata) !== null && _a !== void 0 ? _a : [];
+        for (const metadata of metadataOptions) {
+            outputStream.outputOptions('-metadata', metadata);
+        }
+    }
+    getDestinationStream() {
+        var _a;
+        const outputStream = (0, fluent_ffmpeg_1.default)({
+            source: this.videoMediatorStream,
+            priority: 20,
+        })
+            .videoCodec(this.options.videoCodec || 'libx264')
+            .size(this.videoFrameSize)
+            .aspect(this.options.aspectRatio || '4:3')
+            .autopad(this.autopad.activation, (_a = this.autopad) === null || _a === void 0 ? void 0 : _a.color)
+            .inputFormat('image2pipe')
+            .inputFPS(this.options.fps)
+            .outputOptions(this.getOutputOption())
+            .on('progress', (progressDetails) => {
+            this.duration = progressDetails.timemark;
+        });
+        this.addVideoMetadata(outputStream);
+        if (this.options.recordDurationLimit) {
+            outputStream.duration(this.options.recordDurationLimit);
+        }
+        return outputStream;
+    }
+    handleWriteStreamError(errorMessage) {
+        this.emit('videoStreamWriterError', errorMessage);
+        if (this.status !== pageVideoStreamTypes_1.VIDEO_WRITE_STATUS.IN_PROGRESS &&
+            errorMessage.includes('pipe:0: End of file')) {
+            return;
+        }
+        return console.error(`Error unable to capture video stream: ${errorMessage}`);
+    }
+    findSlot(timestamp) {
+        if (this.screenCastFrames.length === 0) {
+            return 0;
+        }
+        let i;
+        let frame;
+        for (i = this.screenCastFrames.length - 1; i >= 0; i--) {
+            frame = this.screenCastFrames[i];
+            if (timestamp > frame.timestamp) {
+                break;
+            }
+        }
+        return i + 1;
+    }
+    insert(frame) {
+        // reduce the queue into half when it is full
+        if (this.screenCastFrames.length === this.screenLimit) {
+            const numberOfFramesToSplice = Math.floor(this.screenLimit / 2);
+            const framesToProcess = this.screenCastFrames.splice(0, numberOfFramesToSplice);
+            this.processFrameBeforeWrite(framesToProcess, this.screenCastFrames[0].timestamp);
+        }
+        const insertionIndex = this.findSlot(frame.timestamp);
+        if (insertionIndex === this.screenCastFrames.length) {
+            this.screenCastFrames.push(frame);
+        }
+        else {
+            this.screenCastFrames.splice(insertionIndex, 0, frame);
+        }
+    }
+    trimFrame(fameList, chunckEndTime) {
+        return fameList.map((currentFrame, index) => {
+            const endTime = index !== fameList.length - 1
+                ? fameList[index + 1].timestamp
+                : chunckEndTime;
+            const duration = endTime - currentFrame.timestamp;
+            return Object.assign(Object.assign({}, currentFrame), { duration });
+        });
+    }
+    processFrameBeforeWrite(frames, chunckEndTime) {
+        const processedFrames = this.trimFrame(frames, chunckEndTime);
+        processedFrames.forEach(({ blob, duration }) => {
+            this.write(blob, duration);
+        });
+    }
+    write(data, durationSeconds = 1) {
+        this.status = pageVideoStreamTypes_1.VIDEO_WRITE_STATUS.IN_PROGRESS;
+        const totalFrames = durationSeconds * this.options.fps;
+        const floored = Math.floor(totalFrames);
+        let numberOfFPS = Math.max(floored, 1);
+        if (floored === 0) {
+            this.frameGain += 1 - totalFrames;
+        }
+        else {
+            this.frameLoss += totalFrames - floored;
+        }
+        while (1 < this.frameLoss) {
+            this.frameLoss--;
+            numberOfFPS++;
+        }
+        while (1 < this.frameGain) {
+            this.frameGain--;
+            numberOfFPS--;
+        }
+        for (let i = 0; i < numberOfFPS; i++) {
+            this.videoMediatorStream.write(data);
+        }
+    }
+    drainFrames(stoppedTime) {
+        this.processFrameBeforeWrite(this.screenCastFrames, stoppedTime);
+        this.screenCastFrames = [];
+    }
+    stop(stoppedTime = Date.now() / 1000) {
+        if (this.status === pageVideoStreamTypes_1.VIDEO_WRITE_STATUS.COMPLETED) {
+            return this.writerPromise;
+        }
+        this.drainFrames(stoppedTime);
+        this.videoMediatorStream.end();
+        this.status = pageVideoStreamTypes_1.VIDEO_WRITE_STATUS.COMPLETED;
+        return this.writerPromise;
+    }
+}
+exports.default = PageVideoStreamWriter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pageVideoStreamWriter.js","sourceRoot":"","sources":["../../../src/lib/pageVideoStreamWriter.ts"],"names":[],"mappings":"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"}

package/build/module/example/index.d.ts

@@ -0,0 +1 @@
+export {};

package/build/module/example/index.js

@@ -0,0 +1,36 @@
+import puppeteer from 'puppeteer';
+import { PuppeteerScreenRecorder } from '../lib/PuppeteerScreenRecorder';
+/** @ignore */
+function sleep(time) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, time);
+    });
+}
+/** @ignore */
+async function testStartMethod(format) {
+    const executablePath = process.env['PUPPETEER_EXECUTABLE_PATH'];
+    const browser = await puppeteer.launch({
+        ...(executablePath ? { executablePath: executablePath } : {}),
+        headless: false,
+    });
+    const page = await browser.newPage();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const recorder = new PuppeteerScreenRecorder(page);
+    await page.setViewport({
+        width: 1920,
+        height: 1080,
+        deviceScaleFactor: 1,
+    });
+    await recorder.start(format);
+    await page.goto('https://developer.mozilla.org/en-US/docs/Web/CSS/animation');
+    await sleep(10 * 1000);
+    await recorder.stop();
+    await browser.close();
+}
+async function executeSample(format) {
+    return testStartMethod(format);
+}
+executeSample('./report/video/simple1.mp4').then(() => {
+    console.log('completed');
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXhhbXBsZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFNBQVMsTUFBTSxXQUFXLENBQUM7QUFFbEMsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFekUsY0FBYztBQUNkLFNBQVMsS0FBSyxDQUFDLElBQVk7SUFDekIsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFO1FBQzdCLFVBQVUsQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDNUIsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQsY0FBYztBQUNkLEtBQUssVUFBVSxlQUFlLENBQUMsTUFBYztJQUMzQyxNQUFNLGNBQWMsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLDJCQUEyQixDQUFDLENBQUM7SUFDaEUsTUFBTSxPQUFPLEdBQUcsTUFBTSxTQUFTLENBQUMsTUFBTSxDQUFDO1FBQ3JDLEdBQUcsQ0FBQyxjQUFjLENBQUMsQ0FBQyxDQUFDLEVBQUUsY0FBYyxFQUFFLGNBQWMsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFDN0QsUUFBUSxFQUFFLEtBQUs7S0FDaEIsQ0FBQyxDQUFDO0lBQ0gsTUFBTSxJQUFJLEdBQUcsTUFBTSxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDckMsOERBQThEO0lBQzlELE1BQU0sUUFBUSxHQUFHLElBQUksdUJBQXVCLENBQUMsSUFBVyxDQUFDLENBQUM7SUFDMUQsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDO1FBQ3JCLEtBQUssRUFBRSxJQUFJO1FBQ1gsTUFBTSxFQUFFLElBQUk7UUFDWixpQkFBaUIsRUFBRSxDQUFDO0tBQ3JCLENBQUMsQ0FBQztJQUVILE1BQU0sUUFBUSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUU3QixNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsNERBQTRELENBQUMsQ0FBQztJQUM5RSxNQUFNLEtBQUssQ0FBQyxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUM7SUFFdkIsTUFBTSxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDdEIsTUFBTSxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUM7QUFDeEIsQ0FBQztBQUVELEtBQUssVUFBVSxhQUFhLENBQUMsTUFBTTtJQUNqQyxPQUFPLGVBQWUsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUNqQyxDQUFDO0FBRUQsYUFBYSxDQUFDLDRCQUE0QixDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRTtJQUNwRCxPQUFPLENBQUMsR0FBRyxDQUFDLFdBQVcsQ0FBQyxDQUFDO0FBQzNCLENBQUMsQ0FBQyxDQUFDIn0=

package/build/module/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/pageVideoStreamTypes';
+export * from './lib/PuppeteerScreenRecorder';

package/build/module/index.js

@@ -0,0 +1,3 @@
+export * from './lib/pageVideoStreamTypes';
+export * from './lib/PuppeteerScreenRecorder';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLCtCQUErQixDQUFDIn0=

package/build/module/lib/PuppeteerScreenRecorder.d.ts

@@ -0,0 +1,85 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+import { Page } from 'puppeteer';
+/**
+ * PuppeteerScreenRecorder class is responsible for managing the video
+ *
+ * ```typescript
+ * const screenRecorderOptions = {
+ *  followNewTab: true,
+ *  fps: 15,
+ * }
+ * const savePath = "./test/demo.mp4";
+ * const screenRecorder = new PuppeteerScreenRecorder(page, screenRecorderOptions);
+ * await screenRecorder.start(savePath);
+ *  // some puppeteer action or test
+ * await screenRecorder.stop()
+ * ```
+ */
+export declare class PuppeteerScreenRecorder {
+    private page;
+    private options;
+    private streamReader;
+    private streamWriter;
+    private isScreenCaptureEnded;
+    constructor(page: Page, options?: {});
+    /**
+     * @ignore
+     */
+    private setupListeners;
+    /**
+     * @ignore
+     */
+    private ensureDirectoryExist;
+    /**
+     * @ignore
+     * @private
+     * @method startStreamReader
+     * @description start listening for video stream from the page.
+     * @returns PuppeteerScreenRecorder
+     */
+    private startStreamReader;
+    /**
+     * @public
+     * @method getRecordDuration
+     * @description return the total duration of the video recorded,
+     *  1. if this method is called before calling the stop method, it would be return the time till it has recorded.
+     *  2. if this method is called after stop method, it would give the total time for recording
+     * @returns total duration of video
+     */
+    getRecordDuration(): string;
+    /**
+     *
+     * @public
+     * @method start
+     * @param savePath accepts a path string to store the video
+     * @description Start the video capturing session
+     * @returns PuppeteerScreenRecorder
+     * @example
+     * ```
+     *  const savePath = './test/demo.mp4'; //.mp4 is required
+     *  await recorder.start(savePath);
+     * ```
+     */
+    start(savePath: string): Promise<PuppeteerScreenRecorder>;
+    /**
+     *
+     * @public
+     * @method startStream
+     * @description Start the video capturing session in a stream
+     * @returns {PuppeteerScreenRecorder}
+     * @example
+     * ```
+     *  const stream = new PassThrough();
+     *  await recorder.startStream(stream);
+     * ```
+     */
+    startStream(stream: Writable): Promise<PuppeteerScreenRecorder>;
+    /**
+     * @public
+     * @method stop
+     * @description stop the video capturing session
+     * @returns indicate whether stop is completed correct or not, if true without any error else false.
+     */
+    stop(): Promise<boolean>;
+}

package/build/module/lib/PuppeteerScreenRecorder.js

@@ -0,0 +1,146 @@
+import fs from 'fs';
+import { dirname } from 'path';
+import { pageVideoStreamCollector } from './pageVideoStreamCollector';
+import PageVideoStreamWriter from './pageVideoStreamWriter';
+/**
+ * @ignore
+ * @default
+ * @description This will be option passed to the puppeteer screen recorder
+ */
+const defaultPuppeteerScreenRecorderOptions = {
+    followNewTab: true,
+    fps: 15,
+    quality: 100,
+    ffmpeg_Path: null,
+    videoFrame: {
+        width: null,
+        height: null,
+    },
+    aspectRatio: '4:3',
+};
+/**
+ * PuppeteerScreenRecorder class is responsible for managing the video
+ *
+ * ```typescript
+ * const screenRecorderOptions = {
+ *  followNewTab: true,
+ *  fps: 15,
+ * }
+ * const savePath = "./test/demo.mp4";
+ * const screenRecorder = new PuppeteerScreenRecorder(page, screenRecorderOptions);
+ * await screenRecorder.start(savePath);
+ *  // some puppeteer action or test
+ * await screenRecorder.stop()
+ * ```
+ */
+export class PuppeteerScreenRecorder {
+    page;
+    options;
+    streamReader;
+    streamWriter;
+    isScreenCaptureEnded = null;
+    constructor(page, options = {}) {
+        this.options = Object.assign({}, defaultPuppeteerScreenRecorderOptions, options);
+        this.streamReader = new pageVideoStreamCollector(page, this.options);
+        this.page = page;
+    }
+    /**
+     * @ignore
+     */
+    setupListeners() {
+        this.page.once('close', async () => await this.stop());
+        this.streamReader.on('pageScreenFrame', (pageScreenFrame) => {
+            this.streamWriter.insert(pageScreenFrame);
+        });
+        this.streamWriter.once('videoStreamWriterError', () => this.stop());
+    }
+    /**
+     * @ignore
+     */
+    async ensureDirectoryExist(dirPath) {
+        return new Promise((resolve, reject) => {
+            try {
+                fs.mkdirSync(dirPath, { recursive: true });
+                return resolve(dirPath);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * @ignore
+     * @private
+     * @method startStreamReader
+     * @description start listening for video stream from the page.
+     * @returns PuppeteerScreenRecorder
+     */
+    async startStreamReader() {
+        this.setupListeners();
+        await this.streamReader.start();
+        return this;
+    }
+    /**
+     * @public
+     * @method getRecordDuration
+     * @description return the total duration of the video recorded,
+     *  1. if this method is called before calling the stop method, it would be return the time till it has recorded.
+     *  2. if this method is called after stop method, it would give the total time for recording
+     * @returns total duration of video
+     */
+    getRecordDuration() {
+        if (!this.streamWriter) {
+            return '00:00:00:00';
+        }
+        return this.streamWriter.duration;
+    }
+    /**
+     *
+     * @public
+     * @method start
+     * @param savePath accepts a path string to store the video
+     * @description Start the video capturing session
+     * @returns PuppeteerScreenRecorder
+     * @example
+     * ```
+     *  const savePath = './test/demo.mp4'; //.mp4 is required
+     *  await recorder.start(savePath);
+     * ```
+     */
+    async start(savePath) {
+        await this.ensureDirectoryExist(dirname(savePath));
+        this.streamWriter = new PageVideoStreamWriter(savePath, this.options);
+        return this.startStreamReader();
+    }
+    /**
+     *
+     * @public
+     * @method startStream
+     * @description Start the video capturing session in a stream
+     * @returns {PuppeteerScreenRecorder}
+     * @example
+     * ```
+     *  const stream = new PassThrough();
+     *  await recorder.startStream(stream);
+     * ```
+     */
+    async startStream(stream) {
+        this.streamWriter = new PageVideoStreamWriter(stream, this.options);
+        return this.startStreamReader();
+    }
+    /**
+     * @public
+     * @method stop
+     * @description stop the video capturing session
+     * @returns indicate whether stop is completed correct or not, if true without any error else false.
+     */
+    async stop() {
+        if (this.isScreenCaptureEnded !== null) {
+            return this.isScreenCaptureEnded;
+        }
+        await this.streamReader.stop();
+        this.isScreenCaptureEnded = await this.streamWriter.stop();
+        return this.isScreenCaptureEnded;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/pageVideoStreamCollector.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Page } from 'puppeteer';
+import { PuppeteerScreenRecorderOptions } from './pageVideoStreamTypes';
+/**
+ * @ignore
+ */
+export declare class pageVideoStreamCollector extends EventEmitter {
+    private page;
+    private options;
+    private sessionsStack;
+    private isStreamingEnded;
+    private isFrameAckReceived;
+    constructor(page: Page, options: PuppeteerScreenRecorderOptions);
+    private get shouldFollowPopupWindow();
+    private getPageSession;
+    private getCurrentSession;
+    private addListenerOnTabOpens;
+    private removeListenerOnTabClose;
+    private registerTabListener;
+    private startScreenCast;
+    private stopScreenCast;
+    private startSession;
+    private handleScreenCastFrame;
+    private endSession;
+    start(): Promise<void>;
+    stop(): Promise<boolean>;
+}