@appium/support 2.58.0 → 2.59.0

package/lib/image-util.js

@@ -1,12 +1,12 @@
 import _ from 'lodash';
 import Jimp from 'jimp';
-import { Buffer } from 'buffer';
-import { PNG } from 'pngjs';
+import {Buffer} from 'buffer';
+import {PNG} from 'pngjs';
 import B from 'bluebird';
 
 const BYTES_IN_PIXEL_BLOCK = 4;
 const SCANLINE_FILTER_METHOD = 4;
-const { MIME_JPEG, MIME_PNG, MIME_BMP } = Jimp;
+const {MIME_JPEG, MIME_PNG, MIME_BMP} = Jimp;
 
 /**
  * Utility function to get a Jimp image object from buffer or base64 data. Jimp
@@ -17,7 +17,7 @@ const { MIME_JPEG, MIME_PNG, MIME_BMP } = Jimp;
  * string
  * @returns {Promise<AppiumJimp>} - the jimp image object
  */
-async function getJimpImage (data) {
+async function getJimpImage(data) {
   return await new B((resolve, reject) => {
     if (!_.isString(data) && !_.isBuffer(data)) {
       return reject(new Error('Must initialize jimp object with string or buffer'));
@@ -26,21 +26,25 @@ async function getJimpImage (data) {
     if (_.isString(data)) {
       data = Buffer.from(data, 'base64');
     }
-    new Jimp(data,
+    new Jimp(
+      data,
       /**
        * @param {Error?} err
        * @param {AppiumJimp} imgObj
        */
-    (err, imgObj) => {
-      if (err) {
-        return reject(err);
-      }
-      if (!imgObj) {
-        return reject(new Error('Could not create jimp image from that data'));
+      (err, imgObj) => {
+        if (err) {
+          return reject(err);
+        }
+        if (!imgObj) {
+          return reject(new Error('Could not create jimp image from that data'));
+        }
+        imgObj.getBuffer = B.promisify(imgObj.getBuffer.bind(imgObj), {
+          context: imgObj,
+        });
+        resolve(imgObj);
       }
-      imgObj.getBuffer = B.promisify(imgObj.getBuffer.bind(imgObj), {context: imgObj});
-      resolve(imgObj);
-    });
+    );
   });
 }
 
@@ -51,7 +55,7 @@ async function getJimpImage (data) {
  * @param {Region} rect The selected region of image
  * @return {Promise<string>} base64 encoded string of cropped image
  */
-async function cropBase64Image (base64Image, rect) {
+async function cropBase64Image(base64Image, rect) {
   const image = await base64ToImage(base64Image);
   cropImage(image, rect);
   return await imageToBase64(image);
@@ -63,11 +67,12 @@ async function cropBase64Image (base64Image, rect) {
  * @param {string} base64Image The string with base64 encoded image
  * @return {Promise<PNG>} The image object
  */
-async function base64ToImage (base64Image) {
+async function base64ToImage(base64Image) {
   const imageBuffer = Buffer.from(base64Image, 'base64');
   return await new B((resolve, reject) => {
     const image = new PNG({filterType: SCANLINE_FILTER_METHOD});
-    image.parse(imageBuffer, (err, image) => { // eslint-disable-line promise/prefer-await-to-callbacks
+    image.parse(imageBuffer, (err, image) => {
+      // eslint-disable-line promise/prefer-await-to-callbacks
       if (err) {
         return reject(err);
       }
@@ -82,16 +87,19 @@ async function base64ToImage (base64Image) {
  * @param {PNG} image The image object
  * @return {Promise<string>} The string with base64 encoded image
  */
-async function imageToBase64 (image) {
+async function imageToBase64(image) {
   return await new B((resolve, reject) => {
     const chunks = [];
-    image.pack()
-    .on('data', (chunk) => chunks.push(chunk)).on('end', () => {
-      resolve(Buffer.concat(chunks).toString('base64'));
-    })
-    .on('error', (err) => { // eslint-disable-line promise/prefer-await-to-callbacks
-      reject(err);
-    });
+    image
+      .pack()
+      .on('data', (chunk) => chunks.push(chunk))
+      .on('end', () => {
+        resolve(Buffer.concat(chunks).toString('base64'));
+      })
+      .on('error', (err) => {
+        // eslint-disable-line promise/prefer-await-to-callbacks
+        reject(err);
+      });
   });
 }
 
@@ -101,11 +109,15 @@ async function imageToBase64 (image) {
  * @param {PNG} image The image to mutate by cropping
  * @param {Region} rect The selected region of image
  */
-function cropImage (image, rect) {
+function cropImage(image, rect) {
   const imageRect = {width: image.width, height: image.height};
   const interRect = getRectIntersection(rect, imageRect);
   if (interRect.width < rect.width || interRect.height < rect.height) {
-    throw new Error(`Cannot crop ${JSON.stringify(rect)} from ${JSON.stringify(imageRect)} because the intersection between them was not the size of the rect`);
+    throw new Error(
+      `Cannot crop ${JSON.stringify(rect)} from ${JSON.stringify(
+        imageRect
+      )} because the intersection between them was not the size of the rect`
+    );
   }
 
   const firstVerticalPixel = interRect.top;
@@ -130,17 +142,23 @@ function cropImage (image, rect) {
   return image;
 }
 
-function getRectIntersection (rect, imageSize) {
+function getRectIntersection(rect, imageSize) {
   const left = rect.left >= imageSize.width ? imageSize.width : rect.left;
   const top = rect.top >= imageSize.height ? imageSize.height : rect.top;
-  const width = imageSize.width >= (left + rect.width) ? rect.width : (imageSize.width - left);
-  const height = imageSize.height >= (top + rect.height) ? rect.height : (imageSize.height - top);
+  const width = imageSize.width >= left + rect.width ? rect.width : imageSize.width - left;
+  const height = imageSize.height >= top + rect.height ? rect.height : imageSize.height - top;
   return {left, top, width, height};
 }
 
 export {
-  cropBase64Image, base64ToImage, imageToBase64, cropImage,
-  getJimpImage, MIME_JPEG, MIME_PNG, MIME_BMP
+  cropBase64Image,
+  base64ToImage,
+  imageToBase64,
+  cropImage,
+  getJimpImage,
+  MIME_JPEG,
+  MIME_PNG,
+  MIME_BMP,
 };
 
 /**

package/lib/index.js

@@ -1,10 +1,10 @@
 import * as tempDir from './tempdir';
 import * as system from './system';
 import * as util from './util';
-import { fs } from './fs';
+import {fs} from './fs';
 import * as net from './net';
 import * as plist from './plist';
-import { mkdirp } from './mkdirp';
+import {mkdirp} from './mkdirp';
 import * as logger from './logging';
 import * as process from './process';
 import * as zip from './zip';
@@ -13,16 +13,47 @@ import * as mjpeg from './mjpeg';
 import * as node from './node';
 import * as timing from './timing';
 import * as env from './env';
+import * as console from './console';
 
-export { npm } from './npm';
+export {npm} from './npm';
 
-const { cancellableDelay } = util;
+const {cancellableDelay} = util;
 
 export {
-  tempDir, system, util, fs, cancellableDelay, plist, mkdirp, logger, process,
-  zip, imageUtil, net, mjpeg, node, timing, env
+  tempDir,
+  system,
+  util,
+  fs,
+  cancellableDelay,
+  plist,
+  mkdirp,
+  logger,
+  process,
+  zip,
+  imageUtil,
+  net,
+  mjpeg,
+  node,
+  timing,
+  env,
+  console,
 };
 export default {
-  tempDir, system, util, fs, cancellableDelay, plist, mkdirp, logger, process,
-  zip, imageUtil, net, mjpeg, node, timing, env
+  tempDir,
+  system,
+  util,
+  fs,
+  cancellableDelay,
+  plist,
+  mkdirp,
+  logger,
+  process,
+  zip,
+  imageUtil,
+  net,
+  mjpeg,
+  node,
+  timing,
+  env,
+  console,
 };

package/lib/log-internal.js

@@ -3,9 +3,8 @@ import _ from 'lodash';
 
 const DEFAULT_REPLACER = '**SECURE**';
 
-
 class SecureValuesPreprocessor {
-  constructor () {
+  constructor() {
     this._rules = [];
   }
 
@@ -13,7 +12,7 @@ class SecureValuesPreprocessor {
    * @returns {Array<SecureValuePreprocessingRule>} The list of successfully
    * parsed preprocessing rules
    */
-  get rules () {
+  get rules() {
     return this._rules;
   }
 
@@ -25,7 +24,7 @@ class SecureValuesPreprocessor {
    * @throws {Error} If there was an error while parsing the rule
    * @returns {SecureValuePreprocessingRule} The parsed rule
    */
-  parseRule (rule) {
+  parseRule(rule) {
     let pattern;
     let replacer = DEFAULT_REPLACER;
     let flags = ['g'];
@@ -37,17 +36,23 @@ class SecureValuesPreprocessor {
     } else if (_.isPlainObject(rule)) {
       if (_.has(rule, 'pattern')) {
         if (!_.isString(rule.pattern) || rule.pattern.length === 0) {
-          throw new Error(`${JSON.stringify(rule)} -> The value of 'pattern' must be a valid non-empty string`);
+          throw new Error(
+            `${JSON.stringify(rule)} -> The value of 'pattern' must be a valid non-empty string`
+          );
         }
         pattern = rule.pattern;
       } else if (_.has(rule, 'text')) {
         if (!_.isString(rule.text) || rule.text.length === 0) {
-          throw new Error(`${JSON.stringify(rule)} -> The value of 'text' must be a valid non-empty string`);
+          throw new Error(
+            `${JSON.stringify(rule)} -> The value of 'text' must be a valid non-empty string`
+          );
         }
         pattern = `\\b${_.escapeRegExp(rule.text)}\\b`;
       }
       if (!pattern) {
-        throw new Error(`${JSON.stringify(rule)} -> Must either have a field named 'pattern' or 'text'`);
+        throw new Error(
+          `${JSON.stringify(rule)} -> Must either have a field named 'pattern' or 'text'`
+        );
       }
 
       if (_.has(rule, 'flags')) {
@@ -83,12 +88,12 @@ class SecureValuesPreprocessor {
    * @returns {Promise<string[]>} The list of issues found while parsing each rule.
    * An empty list is returned if no rule parsing issues were found
    */
-  async loadRules (source) {
+  async loadRules(source) {
     let rules;
     if (_.isArray(source)) {
       rules = source;
     } else {
-      if (!await fs.exists(source)) {
+      if (!(await fs.exists(source))) {
         throw new Error(`'${source}' does not exist or is not accessible`);
       }
       try {
@@ -121,7 +126,7 @@ class SecureValuesPreprocessor {
    * @param {string} str The string to make replacements in
    * @returns {string} The string with replacements made
    */
-  preprocess (str) {
+  preprocess(str) {
     if (this._rules.length === 0 || !_.isString(str)) {
       return str;
     }
@@ -136,7 +141,7 @@ class SecureValuesPreprocessor {
 
 const SECURE_VALUES_PREPROCESSOR = new SecureValuesPreprocessor();
 
-export { SECURE_VALUES_PREPROCESSOR, SecureValuesPreprocessor };
+export {SECURE_VALUES_PREPROCESSOR, SecureValuesPreprocessor};
 export default SECURE_VALUES_PREPROCESSOR;
 
 /**

package/lib/logger.js

@@ -1,4 +1,4 @@
-import { getLogger } from './logging';
+import {getLogger} from './logging';
 
 let log = getLogger('Support');
 

package/lib/logging.js

@@ -1,32 +1,38 @@
+// @ts-check
+
 import npmlog from 'npmlog';
 import _ from 'lodash';
-import { unleakString } from './util';
+import {unleakString} from './util';
 import moment from 'moment';
 import SECURE_VALUES_PREPROCESSOR from './log-internal';
 
-// levels that are available from `npmlog`
-const NPM_LEVELS = ['silly', 'verbose', 'debug', 'info', 'http', 'warn', 'error'];
+/** @type {import('@appium/types').AppiumLoggerLevel[]} */
+export const LEVELS = ['silly', 'verbose', 'debug', 'info', 'http', 'warn', 'error'];
 const MAX_LOG_RECORDS_COUNT = 3000;
 
 const PREFIX_TIMESTAMP_FORMAT = 'HH-mm-ss:SSS';
 
 // mock log object used in testing mode
 let mockLog = {};
-for (let level of NPM_LEVELS) {
+for (let level of LEVELS) {
   mockLog[level] = () => {};
 }
 
-function patchLogger (logger) {
+/**
+ *
+ * @param {import('npmlog').Logger} logger
+ */
+function patchLogger(logger) {
   if (!logger.debug) {
-    logger.addLevel('debug', 1000, { fg: 'blue', bg: 'black' }, 'dbug');
+    logger.addLevel('debug', 1000, {fg: 'blue', bg: 'black'}, 'dbug');
   }
 }
 
 /**
  *
- * @returns {[npmlog.Logger, boolean]}
+ * @returns {[import('npmlog').Logger, boolean]}
  */
-function _getLogger () {
+function _getLogger() {
   // check if the user set the `_TESTING` or `_FORCE_LOGS` flag
   const testingMode = process.env._TESTING === '1';
   const forceLogMode = process.env._FORCE_LOGS === '1';
@@ -49,52 +55,50 @@ function _getLogger () {
 }
 
 /**
- * @param {Prefix?} prefix
+ * @param {AppiumLoggerPrefix?} prefix
  * @param {boolean} logTimestamp whether to include timestamps into log prefixes
  * @returns {string}
  */
-function getActualPrefix (prefix, logTimestamp = false) {
+function getActualPrefix(prefix, logTimestamp = false) {
   const result = (_.isFunction(prefix) ? prefix() : prefix) ?? '';
-  return logTimestamp
-    ? `[${moment().format(PREFIX_TIMESTAMP_FORMAT)}] ${result}`
-    : result;
+  return logTimestamp ? `[${moment().format(PREFIX_TIMESTAMP_FORMAT)}] ${result}` : result;
 }
 
 /**
  *
- * @param {Prefix?} prefix
+ * @param {AppiumLoggerPrefix?} prefix
  * @returns {AppiumLogger}
  */
-function getLogger (prefix = null) {
+function getLogger(prefix = null) {
   let [logger, usingGlobalLog] = _getLogger();
 
   // wrap the logger so that we can catch and modify any logging
   let wrappedLogger = {
     unwrap: () => logger,
-    levels: NPM_LEVELS,
+    levels: LEVELS,
     prefix,
   };
 
   // allow access to the level of the underlying logger
   Object.defineProperty(wrappedLogger, 'level', {
-    get () {
+    get() {
       return logger.level;
     },
-    set (newValue) {
+    set(newValue) {
       logger.level = newValue;
     },
     enumerable: true,
-    configurable: true
+    configurable: true,
   });
 
   const logTimestamp = process.env._LOG_TIMESTAMP === '1';
 
   // add all the levels from `npmlog`, and map to the underlying logger
-  for (const level of NPM_LEVELS) {
-    wrappedLogger[level] = function (...args) {
+  for (const level of LEVELS) {
+    wrappedLogger[level] = /** @param {...any} args */ function (...args) {
       const actualPrefix = getActualPrefix(this.prefix, logTimestamp);
       for (const arg of args) {
-        const out = (_.isError(arg) && arg.stack) ? arg.stack : `${arg}`;
+        const out = _.isError(arg) && arg.stack ? arg.stack : `${arg}`;
         for (const line of out.split('\n')) {
           // it is necessary to unleak each line because `split` call
           // creates "views" to the original string as well as the `substring` one
@@ -108,7 +112,7 @@ function getLogger (prefix = null) {
   wrappedLogger.errorAndThrow = function (err) {
     this.error(err);
     // make sure we have an `Error` object. Wrap if necessary
-    throw (_.isError(err) ? err : new Error(unleakString(err)));
+    throw _.isError(err) ? err : new Error(unleakString(err));
   };
   if (!usingGlobalLog) {
     // if we're not using a global log specified from some top-level package,
@@ -116,7 +120,7 @@ function getLogger (prefix = null) {
     // package set the log level
     wrappedLogger.level = 'verbose';
   }
-  return /** @type {AppiumLogger} */(wrappedLogger);
+  return /** @type {AppiumLogger} */ (wrappedLogger);
 }
 
 /**
@@ -140,7 +144,7 @@ function getLogger (prefix = null) {
  * @throws {Error} If the given file cannot be loaded
  * @returns {Promise<LoadResult>}
  */
-async function loadSecureValuesPreprocessingRules (rulesJsonPath) {
+async function loadSecureValuesPreprocessingRules(rulesJsonPath) {
   const issues = await SECURE_VALUES_PREPROCESSOR.loadRules(rulesJsonPath);
   return {
     issues,
@@ -151,13 +155,11 @@ async function loadSecureValuesPreprocessingRules (rulesJsonPath) {
 // export a default logger with no prefix
 const log = getLogger();
 
-export { log, patchLogger, getLogger, loadSecureValuesPreprocessingRules };
+export {log, patchLogger, getLogger, loadSecureValuesPreprocessingRules};
 export default log;
 
 /**
- * @typedef {import('@appium/types').Prefix} Prefix
- */
-
-/**
+ * @typedef {import('@appium/types').AppiumLoggerPrefix} AppiumLoggerPrefix
  * @typedef {import('@appium/types').AppiumLogger} AppiumLogger
+ * @typedef {import('@appium/types').AppiumLoggerLevel} AppiumLoggerLevel
  */

package/lib/mjpeg.js

@@ -1,9 +1,9 @@
 import _ from 'lodash';
 import log from './logger';
 import B from 'bluebird';
-import { getJimpImage, MIME_PNG } from './image-util';
-import { Writable } from 'stream';
-import { requirePackage } from './node';
+import {getJimpImage, MIME_PNG} from './image-util';
+import {Writable} from 'stream';
+import {requirePackage} from './node';
 import axios from 'axios';
 
 // lazy load this, as it might not be available
@@ -12,15 +12,17 @@ let MJpegConsumer = null;
 /**
  * @throws {Error} If `mjpeg-consumer` module is not installed or cannot be loaded
  */
-async function initMJpegConsumer () {
+async function initMJpegConsumer() {
   if (!MJpegConsumer) {
     try {
       MJpegConsumer = await requirePackage('mjpeg-consumer');
     } catch (ign) {}
   }
   if (!MJpegConsumer) {
-    throw new Error('mjpeg-consumer module is required to use MJPEG-over-HTTP features. ' +
-                    'Please install it first (npm i -g mjpeg-consumer) and restart Appium.');
+    throw new Error(
+      'mjpeg-consumer module is required to use MJPEG-over-HTTP features. ' +
+        'Please install it first (npm i -g mjpeg-consumer) and restart Appium.'
+    );
   }
 }
 
@@ -29,7 +31,6 @@ const MJPEG_SERVER_TIMEOUT_MS = 10000;
 
 /** Class which stores the last bit of data streamed into it */
 class MJpegStream extends Writable {
-
   /**
    * @type {number}
    */
@@ -42,7 +43,7 @@ class MJpegStream extends Writable {
    * called in the case of any errors.
    * @param {object} [options={}] - Options to pass to the Writable constructor
    */
-  constructor (mJpegUrl, errorHandler = _.noop, options = {}) {
+  constructor(mJpegUrl, errorHandler = _.noop, options = {}) {
     super(options);
 
     this.errorHandler = errorHandler;
@@ -56,8 +57,8 @@ class MJpegStream extends Writable {
    * @returns {?string} base64-encoded JPEG image data
    * or `null` if no image can be parsed
    */
-  get lastChunkBase64 () {
-    const lastChunk = /** @type {Buffer} */(this.lastChunk);
+  get lastChunkBase64() {
+    const lastChunk = /** @type {Buffer} */ (this.lastChunk);
     return !_.isEmpty(this.lastChunk) && _.isBuffer(this.lastChunk)
       ? lastChunk.toString('base64')
       : null;
@@ -69,8 +70,8 @@ class MJpegStream extends Writable {
    * @returns {Promise<Buffer?>} PNG image data or `null` if no PNG
    * image can be parsed
    */
-  async lastChunkPNG () {
-    const lastChunk = /** @type {Buffer} */(this.lastChunk);
+  async lastChunkPNG() {
+    const lastChunk = /** @type {Buffer} */ (this.lastChunk);
     if (_.isEmpty(lastChunk) || !_.isBuffer(lastChunk)) {
       return null;
     }
@@ -89,7 +90,7 @@ class MJpegStream extends Writable {
    * @returns {Promise<string?>} base64-encoded PNG image data
    * or `null` if no image can be parsed
    */
-  async lastChunkPNGBase64 () {
+  async lastChunkPNGBase64() {
     const png = await this.lastChunkPNG();
     return png ? png.toString('base64') : null;
   }
@@ -97,7 +98,7 @@ class MJpegStream extends Writable {
   /**
    * Reset internal state
    */
-  clear () {
+  clear() {
     this.registerStartSuccess = null;
     this.registerStartFailure = null;
     this.responseStream = null;
@@ -109,7 +110,7 @@ class MJpegStream extends Writable {
   /**
    * Start reading the MJpeg stream and storing the last image
    */
-  async start (serverTimeout = MJPEG_SERVER_TIMEOUT_MS) {
+  async start(serverTimeout = MJPEG_SERVER_TIMEOUT_MS) {
     // ensure we're not started already
     this.stop();
 
@@ -123,10 +124,12 @@ class MJpegStream extends Writable {
       this.registerStartSuccess = res;
       this.registerStartFailure = rej;
     })
-    // start a timeout so that if the server does not return data, we don't
-    // block forever.
-      .timeout(serverTimeout,
-        `Waited ${serverTimeout}ms but the MJPEG server never sent any images`);
+      // start a timeout so that if the server does not return data, we don't
+      // block forever.
+      .timeout(
+        serverTimeout,
+        `Waited ${serverTimeout}ms but the MJPEG server never sent any images`
+      );
 
     const url = this.url;
     const onErr = (err) => {
@@ -145,11 +148,13 @@ class MJpegStream extends Writable {
     };
 
     try {
-      this.responseStream = (await axios({
-        url,
-        responseType: 'stream',
-        timeout: serverTimeout,
-      })).data;
+      this.responseStream = (
+        await axios({
+          url,
+          responseType: 'stream',
+          timeout: serverTimeout,
+        })
+      ).data;
     } catch (e) {
       return onErr(e);
     }
@@ -167,7 +172,7 @@ class MJpegStream extends Writable {
    * Stop reading the MJpeg stream. Ensure we disconnect all the pipes and stop
    * the HTTP request itself. Then reset the state.
    */
-  stop () {
+  stop() {
     if (!this.consumer) {
       return;
     }
@@ -184,7 +189,7 @@ class MJpegStream extends Writable {
    * @override
    * @param {Buffer} data - binary data streamed from the MJpeg consumer
    */
-  write (data) {
+  write(data) {
     this.lastChunk = data;
     this.updateCount++;
 
@@ -197,4 +202,4 @@ class MJpegStream extends Writable {
   }
 }
 
-export { MJpegStream };
+export {MJpegStream};

package/lib/mkdirp.js

@@ -1,6 +1,6 @@
-import { fs } from './fs';
+import {fs} from './fs';
 /**
  * @deprecated Use `fs.mkdirp` instead.
  */
-const { mkdirp } = fs;
-export { mkdirp };
+const {mkdirp} = fs;
+export {mkdirp};