browsertime 16.16.0 → 17.0.0-beta.0

package/lib/video/screenRecording/desktop/desktopRecorder.js

@@ -1,24 +1,29 @@
-'use strict';
+import { promisify } from 'node:util';
+import { unlink as _unlink, rename as _rename } from 'node:fs';
+import intel from 'intel';
+import get from 'lodash.get';
+import { start as _start, stop as _stop } from './ffmpegRecorder.js';
+import convert from './convert.js';
+import {
+  xvfbDisplay,
+  framerate as _framerate,
+  crf as _crf,
+  convert as _convert,
+  threads as _threads
+} from '../../defaults.js';
+import getViewPort from '../../../support/getViewPort.js';
+const unlink = promisify(_unlink);
+const rename = promisify(_rename);
+const log = intel.getLogger('browsertime.video');
 
-const log = require('intel').getLogger('browsertime.video');
-const get = require('lodash.get');
-const util = require('util');
-const fs = require('fs');
-const ffmpegRecorder = require('./ffmpegRecorder');
-const convert = require('./convert');
-const defaults = require('../../defaults');
-const getViewPort = require('../../../support/getViewPort');
-const unlink = util.promisify(fs.unlink);
-const rename = util.promisify(fs.rename);
-
-module.exports = class DesktopRecorder {
+export default class DesktopRecorder {
   constructor(options) {
-    this.display = get(options, 'xvfbParams.display', defaults.xvfbDisplay);
-    this.framerate = get(options, 'videoParams.framerate', defaults.framerate);
+    this.display = get(options, 'xvfbParams.display', xvfbDisplay);
+    this.framerate = get(options, 'videoParams.framerate', _framerate);
     this.nice = get(options, 'videoParams.nice', 0);
-    this.crf = get(options, 'videoParams.crf', defaults.crf);
-    this.convert = get(options, 'videoParams.convert', defaults.convert);
-    this.threads = get(options, 'videoParams.threads', defaults.threads);
+    this.crf = get(options, 'videoParams.crf', _crf);
+    this.convert = get(options, 'videoParams.convert', _convert);
+    this.threads = get(options, 'videoParams.threads', _threads);
     this.viewPort = getViewPort(options);
     this.origin = '0,0';
     this.offset = { x: 0, y: 0 };
@@ -28,7 +33,7 @@ module.exports = class DesktopRecorder {
   async start(file) {
     this.filePath = file;
 
-    this.recording = ffmpegRecorder.start({
+    this.recording = _start({
       display: this.display,
       size: this.viewPort,
       filePath: this.filePath,
@@ -45,14 +50,14 @@ module.exports = class DesktopRecorder {
 
   async stop(destination) {
     log.debug('Stop screen recording');
-    await ffmpegRecorder.stop(this.recording);
+    await _stop(this.recording);
     // FIXME update to rename/move file
     // The destination file could exixt of we use --resultDir
     // so make sure we remove it first
     if (this.options.resultDir) {
       try {
         await unlink(destination);
-      } catch (e) {
+      } catch {
         // Nothing to see here
       }
     }
@@ -63,15 +68,15 @@ module.exports = class DesktopRecorder {
       } else {
         await rename(this.filePath, destination);
       }
-    } catch (e) {
+    } catch (error) {
       log.error(
         'Converting the video failed. Converting from ' +
           this.filePath +
           ' to ' +
           destination
       );
-      throw e;
+      throw error;
     }
     log.debug(`Writing to ${destination}`);
   }
-};
+}

package/lib/video/screenRecording/desktop/ffmpegRecorder.js

@@ -1,11 +1,10 @@
-'use strict';
+import { execa } from 'execa';
+import intel from 'intel';
+import getScreenOnOSX from './osx/getScreen.js';
+import getSPDisplaysDataType from './osx/getSPDisplaysDataType.js';
+const log = intel.getLogger('browsertime.video');
 
-const execa = require('execa');
-const log = require('intel').getLogger('browsertime.video');
-const getScreenOnOSX = require('./osx/getScreen');
-const getSPDisplaysDataType = require('./osx/getSPDisplaysDataType');
-
-async function buildX11FfmpegArgs({
+async function buildX11FfmpegArguments({
   display,
   screen = 0,
   framerate = 30,
@@ -23,7 +22,7 @@ async function buildX11FfmpegArgs({
     const uiregex = /(?<=UI Looks like:\s*)(\d+\s*x\s*\d+)/gm;
     const uiLooksLike = SPDisplaysDataType.match(uiregex);
     const widthAndHeight = size.split('x');
-    let devicePixelRatio = SPDisplaysDataType.indexOf('Retina') > -1 ? 2 : 1;
+    let devicePixelRatio = SPDisplaysDataType.includes('Retina') ? 2 : 1;
     // Lets add better check in the future. Right now: If we have uilookslike and
     // is not the same as the resolution, say it DPI 2
     if (uiLooksLike && resolution[0].trim() !== uiLooksLike[0].trim()) {
@@ -85,12 +84,12 @@ async function buildX11FfmpegArgs({
   }
 }
 
-async function startRecording(ffmpegArgs, nice, filePath) {
+async function startRecording(ffmpegArguments, nice, filePath) {
   async function waitForRecording(readableStream) {
     return new Promise((resolve, reject) => {
       readableStream.on('data', data => {
         log.trace(data.toString());
-        if (data.toString().match(/Press \[q] to stop/)) {
+        if (/Press \[q] to stop/.test(data.toString())) {
           // readableStream.removeAllListeners('data');
           return resolve();
         }
@@ -100,78 +99,76 @@ async function startRecording(ffmpegArgs, nice, filePath) {
   }
   let ffmpegProcess;
   if (nice !== 0) {
-    ffmpegArgs.unshift('ffmpeg');
-    ffmpegArgs.unshift(`${nice}`);
-    ffmpegArgs.unshift('-n');
-    log.debug('Start FFMPEG with %j', ffmpegArgs);
-    ffmpegProcess = execa('nice', ffmpegArgs);
+    ffmpegArguments.unshift('ffmpeg');
+    ffmpegArguments.unshift(`${nice}`);
+    ffmpegArguments.unshift('-n');
+    log.debug('Start FFMPEG with %j', ffmpegArguments);
+    ffmpegProcess = execa('nice', ffmpegArguments);
   } else {
-    log.debug('Start FFMPEG with %j', ffmpegArgs);
-    ffmpegProcess = execa('ffmpeg', ffmpegArgs);
+    log.debug('Start FFMPEG with %j', ffmpegArguments);
+    ffmpegProcess = execa('ffmpeg', ffmpegArguments);
   }
 
   // Race to catch if ffmpeg exists early, or if recording has started
   return Promise.race([ffmpegProcess, waitForRecording(ffmpegProcess.stderr)])
     .then(() => {
-      log.debug('Started ffmpeg with ' + ffmpegArgs.join(' '));
+      log.debug('Started ffmpeg with ' + ffmpegArguments.join(' '));
 
       return {
         filePath,
         ffmpegProcess
       };
     })
-    .catch(e => {
-      log.error(e);
-      throw e;
+    .catch(error => {
+      log.error(error);
+      throw error;
     });
 }
 
-module.exports = {
-  /**
-   * @returns A promise for a recording object. Pass it to stopRecording.
-   */
-  async start({
+export /**
+ * @returns A promise for a recording object. Pass it to stopRecording.
+ */
+async function start({
+  display,
+  origin,
+  size,
+  filePath,
+  offset,
+  framerate,
+  crf,
+  nice,
+  threads
+}) {
+  const widthAndHeight = size.split('x');
+  const withoutTopBar =
+    Number.parseInt(widthAndHeight[0]) -
+    offset.x +
+    'x' +
+    (Number.parseInt(widthAndHeight[1]) - offset.y);
+
+  const ffmpegArguments = await buildX11FfmpegArguments({
     display,
     origin,
-    size,
+    size: withoutTopBar,
     filePath,
-    offset,
     framerate,
     crf,
-    nice,
+    offset,
     threads
-  }) {
-    const widthAndHeight = size.split('x');
-    const withoutTopBar =
-      parseInt(widthAndHeight[0]) -
-      offset.x +
-      'x' +
-      (parseInt(widthAndHeight[1]) - offset.y);
-
-    const ffmpegArgs = await buildX11FfmpegArgs({
-      display,
-      origin,
-      size: withoutTopBar,
-      filePath,
-      framerate,
-      crf,
-      offset,
-      threads
-    });
-    return startRecording(ffmpegArgs, nice, filePath);
-  },
-  /**
-   * @returns A promise for a recording result, with a filePath property.
-   */
-  async stop(recording) {
-    return Promise.resolve(recording).then(rec => {
-      const process = rec.ffmpegProcess;
-      delete rec.ffmpegProcess;
-      process.stdin.write('q');
-      return Promise.resolve(process).then(() => {
-        log.debug('Stopped ffmpeg');
-        return rec;
-      });
+  });
+  return startRecording(ffmpegArguments, nice, filePath);
+}
+export /**
+ * @returns A promise for a recording result, with a filePath property.
+ */
+async function stop(recording) {
+  return Promise.resolve(recording).then(rec => {
+    const process = rec.ffmpegProcess;
+    delete rec.ffmpegProcess;
+    process.stdin.write('q');
+    return Promise.resolve(process).then(() => {
+      log.debug('Stopped ffmpeg');
+      return rec;
     });
-  }
-};
+  });
+}

package/lib/video/screenRecording/desktop/osx/getSPDisplaysDataType.js

@@ -1,10 +1,8 @@
-'use strict';
+import { execaCommand as command } from 'execa';
 
-const execa = require('execa');
-
-module.exports = async function () {
-  const output = await execa.command('system_profiler SPDisplaysDataType', {
+export default async function () {
+  const output = await command('system_profiler SPDisplaysDataType', {
     shell: true
   });
   return output.stdout;
-};
+}

package/lib/video/screenRecording/desktop/osx/getScreen.js

@@ -1,10 +1,9 @@
-'use strict';
+import { execa } from 'execa';
+import intel from 'intel';
+const log = intel.getLogger('browsertime.video');
 
-const execa = require('execa');
-const log = require('intel').getLogger('browsertime.video');
-
-module.exports = async function () {
-  const scriptArgs = [
+export default async function () {
+  const scriptArguments = [
     '-hide_banner',
     '-f',
     'avfoundation',
@@ -13,7 +12,7 @@ module.exports = async function () {
     '-i',
     0
   ];
-  log.debug('Getting screen on OS X using %j', scriptArgs);
+  log.debug('Getting screen on OS X using %j', scriptArguments);
 
   /*
    ffmpeg  -hide_banner -f avfoundation -list_devices true -i 0
@@ -25,8 +24,8 @@ module.exports = async function () {
     [AVFoundation input device @ 0x7fb919e00780] [0] Built-in Microphone
 */
 
-  const output = await execa('ffmpeg', scriptArgs, { reject: false });
+  const output = await execa('ffmpeg', scriptArguments, { reject: false });
   log.debug('Output: %s', output.stderr);
-  const reg = /\[(\d+)\] Capture screen/;
+  const reg = /\[(\d+)] Capture screen/;
   return output.stderr.match(reg)[1];
-};
+}

package/lib/video/screenRecording/firefox/firefoxWindowRecorder.js

@@ -1,21 +1,22 @@
-'use strict';
-
-const log = require('intel').getLogger('browsertime.video');
-const util = require('util');
-const fs = require('fs');
-const path = require('path');
-const execa = require('execa');
-const { removeDirAndFiles } = require('../../../support/fileUtil');
-const { Android } = require('../../../android');
-
-const unlink = util.promisify(fs.unlink);
+import { promisify } from 'node:util';
+import {
+  unlink as _unlink,
+  readdirSync,
+  statSync,
+  createWriteStream,
+  copyFileSync
+} from 'node:fs';
+import { join } from 'node:path';
+import intel from 'intel';
+import { execa } from 'execa';
+import { removeDirAndFiles } from '../../../support/fileUtil.js';
+import { Android, isAndroidConfigured } from '../../../android/index.js';
+const log = intel.getLogger('browsertime.video');
+
+const unlink = promisify(_unlink);
 
 async function enableWindowRecorder(enable, browser) {
-  if (enable) {
-    enable = 'true';
-  } else {
-    enable = 'false';
-  }
+  enable = enable ? 'true' : 'false';
 
   // We wrap windowUtils.setCompositionRecording(...) in Promise.resolve() to
   // work on both the older (synchronous) and newer (asynchronous)
@@ -30,25 +31,24 @@ async function enableWindowRecorder(enable, browser) {
 
   return browser.runPrivilegedAsyncScript(
     script,
-    'toggle composition recorder',
-    undefined
+    'toggle composition recorder'
   );
 }
 
 function findRecordingDirectory(baseDir) {
   let closest_mtime = 0;
-  let directory = undefined;
+  let directory;
 
-  fs.readdirSync(baseDir).forEach(file => {
+  for (const file of readdirSync(baseDir)) {
     if (file.startsWith('windowrecording-')) {
-      let fullPath = path.join(baseDir, file);
-      let mtime = fs.statSync(fullPath).mtime;
+      let fullPath = join(baseDir, file);
+      let mtime = statSync(fullPath).mtime;
       if (mtime > closest_mtime) {
         closest_mtime = mtime;
         directory = fullPath;
       }
     }
-  });
+  }
 
   log.debug('Using window recording directory: ' + directory);
   if (directory === undefined) {
@@ -60,36 +60,36 @@ function findRecordingDirectory(baseDir) {
 function findRecordingStartTime(recordingDir) {
   // Recording directory has the following format:
   // .../browsertime-results/<web address>/<date time>/windowrecording-<unix recording start time>
-  return recordingDir.substr(recordingDir.lastIndexOf('-') + 1);
+  return recordingDir.slice(recordingDir.lastIndexOf('-') + 1);
 }
 
 function findTimeToFirstFrame(recordingDir) {
-  const files = fs.readdirSync(recordingDir);
-  if (files === undefined || files.length < 1) {
+  const files = readdirSync(recordingDir);
+  if (files === undefined || files.length === 0) {
     log.error('Could not find recordings in ' + recordingDir);
   } else {
     // Iterate through files, extract the time from the filenames, and return the smallest time
-    return files.reduce((acc, fileName) => {
-      const time = parseInt(fileName.split('-')[2].split('.')[0], 10);
-      return Math.min(acc, time);
-    }, Infinity);
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return files.reduce((accumulator, fileName) => {
+      const time = Number.parseInt(fileName.split('-')[2].split('.')[0], 10);
+      return Math.min(accumulator, time);
+    }, Number.POSITIVE_INFINITY);
   }
 }
 
 function writeFrameDurationsToFile(directoryName, imageFiles) {
   return new Promise((resolve, reject) => {
-    const stream = fs.createWriteStream(
-      path.join(directoryName, 'durations.txt')
-    );
+    const stream = createWriteStream(join(directoryName, 'durations.txt'));
     stream.once('open', function () {
       stream.write(
-        "file '" + path.join(directoryName, imageFiles[0].filename) + "'\n"
+        "file '" + join(directoryName, imageFiles[0].filename) + "'\n"
       );
-      for (let i = 1; i < imageFiles.length; i++) {
-        let duration = (imageFiles[i].offset - imageFiles[i - 1].offset) / 1000;
+      for (let index = 1; index < imageFiles.length; index++) {
+        let duration =
+          (imageFiles[index].offset - imageFiles[index - 1].offset) / 1000;
         stream.write('duration ' + duration.toString() + '\n');
         stream.write(
-          "file '" + path.join(directoryName, imageFiles[i].filename) + "'\n"
+          "file '" + join(directoryName, imageFiles[index].filename) + "'\n"
         );
       }
       stream.end();
@@ -97,7 +97,7 @@ function writeFrameDurationsToFile(directoryName, imageFiles) {
         resolve(true);
       });
       stream.on('error', () => {
-        reject(Error('Error writing durations to file.'));
+        reject(new Error('Error writing durations to file.'));
       });
     });
   });
@@ -106,19 +106,19 @@ function writeFrameDurationsToFile(directoryName, imageFiles) {
 async function generateVideo(destination, recordingDirectoryName) {
   let imageFiles = [];
 
-  fs.readdirSync(recordingDirectoryName).forEach(file => {
+  for (const file of readdirSync(recordingDirectoryName)) {
     // Format of the filenames are "frame-<num>-<offset>.png"
     // where num is frame number and offset is time since capture start in ms.
     let fields = file.split('-');
     let frameno = ('0000' + fields[1]).slice(-4);
     let newFilename = 'frame' + frameno + '.png';
     let offset = fields[2].split('.')[0];
-    fs.copyFileSync(
-      path.join(recordingDirectoryName, file),
-      path.join(recordingDirectoryName, newFilename)
+    copyFileSync(
+      join(recordingDirectoryName, file),
+      join(recordingDirectoryName, newFilename)
     );
     imageFiles.push({ filename: newFilename, offset: offset });
-  });
+  }
 
   imageFiles.sort(function (a, b) {
     if (a.filename < b.filename) return -1;
@@ -127,13 +127,13 @@ async function generateVideo(destination, recordingDirectoryName) {
   });
   await writeFrameDurationsToFile(recordingDirectoryName, imageFiles);
 
-  const vfr_args = [
+  const vfr_arguments = [
     '-f',
     'concat',
     '-safe',
     '0',
     '-i',
-    path.join(recordingDirectoryName, 'durations.txt'),
+    join(recordingDirectoryName, 'durations.txt'),
     '-vf',
     'pad=ceil(iw/2)*2:ceil(ih/2)*2',
     '-vsync',
@@ -142,24 +142,24 @@ async function generateVideo(destination, recordingDirectoryName) {
     'yuv420p',
     destination
   ];
-  log.debug('Executing command: ffmpeg ' + vfr_args.join(' '));
-  await execa('ffmpeg', vfr_args);
+  log.debug('Executing command: ffmpeg ' + vfr_arguments.join(' '));
+  await execa('ffmpeg', vfr_arguments);
   return removeDirAndFiles(recordingDirectoryName);
 }
 
-module.exports = class FirefoxWindowRecorder {
+export default class FirefoxWindowRecorder {
   constructor(options, browser, baseDir) {
     this.options = options;
     this.browser = browser;
     this.baseDir = baseDir;
-    this.recordingStartTime = null;
-    this.timeToFirstFrame = null;
+    this.recordingStartTime = undefined;
+    this.timeToFirstFrame = undefined;
   }
 
   async start() {
     log.info('Start firefox window recorder.');
 
-    if (this.options.android) {
+    if (isAndroidConfigured(this.options)) {
       this.android = new Android(this.options);
       await this.android.removePathOnSdCard(
         'browsertime-firefox-windowrecording'
@@ -174,7 +174,7 @@ module.exports = class FirefoxWindowRecorder {
     log.info('Stop firefox window recorder.');
     await enableWindowRecorder(false, this.browser);
 
-    if (this.options.android) {
+    if (isAndroidConfigured(this.options)) {
       const fullPathOnSdCard = this.android.getFullPathOnSdCard(
         'browsertime-firefox-windowrecording'
       );
@@ -187,7 +187,7 @@ module.exports = class FirefoxWindowRecorder {
     if (this.options.resultDir) {
       try {
         await unlink(destination);
-      } catch (e) {
+      } catch {
         // Nothing to see here
       }
     }
@@ -203,4 +203,4 @@ module.exports = class FirefoxWindowRecorder {
     );
     log.debug(`Writing to ${destination}`);
   }
-};
+}

package/lib/video/screenRecording/ios/convertToMp4.js

@@ -1,23 +1,22 @@
-'use strict';
+import { execa } from 'execa';
+import intel from 'intel';
+const log = intel.getLogger('browsertime.video');
 
-const execa = require('execa');
-const log = require('intel').getLogger('browsertime.video');
-
-module.exports = async function convert(src, dest) {
-  const scriptArgs = [
+export default async function convert(source, destination) {
+  const scriptArguments = [
     '-framerate',
     60,
     '-i',
-    src,
+    source,
     '-c:v',
     'copy',
     '-f',
     'mp4',
-    dest,
+    destination,
     '-y'
   ];
 
-  log.debug('Converting video from h264 to mp4 %j', scriptArgs);
+  log.debug('Converting video from h264 to mp4 %j', scriptArguments);
 
-  return execa('ffmpeg', scriptArgs);
-};
+  return execa('ffmpeg', scriptArguments);
+}

package/lib/video/screenRecording/ios/iosRecorder.js

@@ -1,36 +1,38 @@
-const log = require('intel').getLogger('browsertime.video');
-const path = require('path');
-const execa = require('execa');
-const util = require('util');
-const fs = require('fs');
-const unlink = util.promisify(fs.unlink);
-const convert = require('./convertToMp4');
-const moduleRootPath = path.resolve(__dirname, '..', '..', '..', '..');
-const QVH = path.resolve(moduleRootPath, 'vendor', 'mac', 'x86', 'qvh');
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { resolve, join } from 'node:path';
+import { execaCommand as command } from 'execa';
+import { promisify } from 'node:util';
+import { unlink as _unlink } from 'node:fs';
+import convert from './convertToMp4.js';
+import intel from 'intel';
+const log = intel.getLogger('browsertime.video');
+const unlink = promisify(_unlink);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const moduleRootPath = resolve(__dirname, '..', '..', '..', '..');
+const QVH = resolve(moduleRootPath, 'vendor', 'mac', 'x86', 'qvh');
 const delay = ms => new Promise(res => setTimeout(res, ms));
 
-module.exports = class IOSRecorder {
+export default class IOSRecorder {
   constructor(options, baseDir) {
     this.options = options;
     this.uuid = options.safari.deviceUDID;
-    this.tmpVideo = path.join(baseDir, 'tmp.h264');
-    this.tmpSound = path.join(baseDir, 'tmp.wav');
+    this.tmpVideo = join(baseDir, 'tmp.h264');
+    this.tmpSound = join(baseDir, 'tmp.wav');
   }
 
   static async activate() {
     log.debug('Activate configuration for IOS recorder.');
-    return execa
-      .command(
-        QVH + ' activate ' + (this.uuid ? '--udid=' + this.uuid + ' ' : ''),
-        { shell: true }
-      )
-      .stdout.pipe(process.stdout);
+    return command(
+      QVH + ' activate ' + (this.uuid ? '--udid=' + this.uuid + ' ' : ''),
+      { shell: true }
+    ).stdout.pipe(process.stdout);
   }
 
   async start() {
     log.info('Start IOS recorder.');
 
-    this.qvhProcessProcess = execa.command(
+    this.qvhProcessProcess = command(
       QVH +
         ' record ' +
         (this.uuid ? '--udid=' + this.uuid + ' ' : '') +
@@ -62,6 +64,6 @@ module.exports = class IOSRecorder {
     await unlink(this.tmpVideo);
     await unlink(this.tmpSound);
     // await rename(this.tmpVideo, destination);
-    return Promise.resolve(this.qvhProcessProcess);
+    return this.qvhProcessProcess;
   }
-};
+}