@appium/support 2.55.4 → 2.57.0

package/build/lib/log-internal.d.ts

@@ -0,0 +1,74 @@
+export default SECURE_VALUES_PREPROCESSOR;
+export type Rule = {
+    /**
+     * A valid RegExp pattern to be replaced
+     */
+    pattern: string;
+    /**
+     * A text match to replace. Either this property or the
+     * above one must be provided. `pattern` has priority over `text` if both are provided.
+     */
+    text: string;
+    /**
+     * Regular expression flags for the given pattern.
+     * Supported flag are the same as for the standard JavaScript RegExp constructor:
+     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Advanced_searching_with_flags_2
+     * The 'g' (global matching) is always enabled though.
+     */
+    flags?: string | undefined;
+    /**
+     * The replacer value to use. By default
+     * equals to `DEFAULT_SECURE_REPLACER`
+     */
+    replacer?: string | undefined;
+};
+export type SecureValuePreprocessingRule = {
+    /**
+     * The parsed pattern which is going to be used for replacement
+     */
+    pattern: RegExp;
+    /**
+     * The replacer value to use. By default
+     * equals to `DEFAULT_SECURE_REPLACER`
+     */
+    replacer?: string | undefined;
+};
+export const SECURE_VALUES_PREPROCESSOR: SecureValuesPreprocessor;
+export class SecureValuesPreprocessor {
+    _rules: any[];
+    /**
+     * @returns {Array<SecureValuePreprocessingRule>} The list of successfully
+     * parsed preprocessing rules
+     */
+    get rules(): SecureValuePreprocessingRule[];
+    /**
+     * Parses single rule from the given JSON file
+     *
+     * @param {string|Rule} rule The rule might either be represented as a single string
+     * or a configuration object
+     * @throws {Error} If there was an error while parsing the rule
+     * @returns {SecureValuePreprocessingRule} The parsed rule
+     */
+    parseRule(rule: string | Rule): SecureValuePreprocessingRule;
+    /**
+     * Loads rules from the given JSON file
+     *
+     * @param {string|string[]|Rule[]} source The full path to the JSON file containing secure
+     * values replacement rules or the rules themselves represented as an array
+     * @throws {Error} If the format of the source file is invalid or
+     * it does not exist
+     * @returns {Promise<string[]>} The list of issues found while parsing each rule.
+     * An empty list is returned if no rule parsing issues were found
+     */
+    loadRules(source: string | string[] | Rule[]): Promise<string[]>;
+    /**
+     * Performs secure values replacement inside the given string
+     * according to the previously loaded rules. No replacement is made
+     * if there are no rules or the given value is not a string
+     *
+     * @param {string} str The string to make replacements in
+     * @returns {string} The string with replacements made
+     */
+    preprocess(str: string): string;
+}
+//# sourceMappingURL=log-internal.d.ts.map

package/build/lib/log-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-internal.d.ts","sourceRoot":"","sources":["../../lib/log-internal.js"],"names":[],"mappings":";;;;;aA+Ic,MAAM;;;;;UACN,MAAM;;;;;;;;;;;;;;;;;;aAYN,MAAM;;;;;;;AApBpB,kEAAkE;AAlIlE;IAEI,cAAgB;IAGlB;;;OAGG;IACH,4CAEC;IAED;;;;;;;OAOG;IACH,gBALW,MAAM,GAAC,IAAI,GAGT,4BAA4B,CAgDxC;IAED;;;;;;;;;OASG;IACH,kBAPW,MAAM,GAAC,MAAM,EAAE,GAAC,IAAI,EAAE,GAIpB,QAAQ,MAAM,EAAE,CAAC,CA+B7B;IAED;;;;;;;OAOG;IACH,gBAHW,MAAM,GACJ,MAAM,CAYlB;CACF"}

package/build/lib/log-internal.js

@@ -25,37 +25,33 @@ class SecureValuesPreprocessor {
   }
 
   parseRule(rule) {
-    const raiseError = msg => {
-      throw new Error(`${JSON.stringify(rule)} -> ${msg}`);
-    };
-
     let pattern;
     let replacer = DEFAULT_REPLACER;
     let flags = ['g'];
 
     if (_lodash.default.isString(rule)) {
       if (rule.length === 0) {
-        raiseError('The value must not be empty');
+        throw new Error(`${JSON.stringify(rule)} -> The value must not be empty`);
       }
 
       pattern = `\\b${_lodash.default.escapeRegExp(rule)}\\b`;
     } else if (_lodash.default.isPlainObject(rule)) {
       if (_lodash.default.has(rule, 'pattern')) {
         if (!_lodash.default.isString(rule.pattern) || rule.pattern.length === 0) {
-          raiseError(`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 (_lodash.default.has(rule, 'text')) {
         if (!_lodash.default.isString(rule.text) || rule.text.length === 0) {
-          raiseError(`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${_lodash.default.escapeRegExp(rule.text)}\\b`;
       }
 
       if (!pattern) {
-        raiseError(`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 (_lodash.default.has(rule, 'flags')) {
@@ -72,17 +68,13 @@ class SecureValuesPreprocessor {
         replacer = rule.replacer;
       }
     } else {
-      raiseError('Must either be a string or an object');
+      throw new Error(`${JSON.stringify(rule)} -> Must either be a string or an object`);
     }
 
-    try {
-      return {
-        pattern: new RegExp(pattern, flags.join('')),
-        replacer
-      };
-    } catch (e) {
-      raiseError(e.message);
-    }
+    return {
+      pattern: new RegExp(pattern, flags.join('')),
+      replacer
+    };
   }
 
   async loadRules(source) {
@@ -140,7 +132,5 @@ exports.SecureValuesPreprocessor = SecureValuesPreprocessor;
 const SECURE_VALUES_PREPROCESSOR = new SecureValuesPreprocessor();
 exports.SECURE_VALUES_PREPROCESSOR = SECURE_VALUES_PREPROCESSOR;
 var _default = SECURE_VALUES_PREPROCESSOR;
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/log-internal.js"],"names":["DEFAULT_REPLACER","SecureValuesPreprocessor","constructor","_rules","rules","parseRule","rule","raiseError","msg","Error","JSON","stringify","pattern","replacer","flags","_","isString","length","escapeRegExp","isPlainObject","has","text","flag","includes","push","uniq","RegExp","join","e","message","loadRules","source","isArray","fs","exists","parse","readFile","issues","preprocess","str","result","replace","SECURE_VALUES_PREPROCESSOR"],"mappings":"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","sourcesContent":["import fs from './fs';\nimport _ from 'lodash';\n\nconst DEFAULT_REPLACER = '**SECURE**';\n\n/**\n * @typedef {Object} SecureValuePreprocessingRule\n * @property {RegExp} pattern The parsed pattern which is going to be used for replacement\n * @property {string} replacer [DEFAULT_SECURE_REPLACER] The replacer value to use. By default\n * equals to `DEFAULT_SECURE_REPLACER`\n */\n\nclass SecureValuesPreprocessor {\n  constructor () {\n    this._rules = [];\n  }\n\n  /**\n   * @returns {Array<SecureValuePreprocessingRule>} The list of successfully\n   * parsed preprocessing rules\n   */\n  get rules () {\n    return this._rules;\n  }\n\n  /**\n   * @typedef {Object} Rule\n   * @property {string} pattern A valid RegExp pattern to be replaced\n   * @property {string} text A text match to replace. Either this property or the\n   * above one must be provided. `pattern` has priority over `text` if both are provided.\n   * @property {string} flags ['g'] Regular expression flags for the given pattern.\n   * Supported flag are the same as for the standard JavaScript RegExp constructor:\n   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Advanced_searching_with_flags_2\n   * The 'g' (global matching) is always enabled though.\n   * @property {string} replacer [DEFAULT_SECURE_REPLACER] The replacer value to use. By default\n   * equals to `DEFAULT_SECURE_REPLACER`\n   */\n\n  /**\n   * Parses single rule from the given JSON file\n   *\n   * @param {string|Rule} rule The rule might either be represented as a single string\n   * or a configuration object\n   * @throws {Error} If there was an error while parsing the rule\n   * @returns {SecureValuePreprocessingRule} The parsed rule\n   */\n  parseRule (rule) {\n    const raiseError = (msg) => {\n      throw new Error(`${JSON.stringify(rule)} -> ${msg}`);\n    };\n\n    let pattern;\n    let replacer = DEFAULT_REPLACER;\n    let flags = ['g'];\n    if (_.isString(rule)) {\n      if (rule.length === 0) {\n        raiseError('The value must not be empty');\n      }\n      pattern = `\\\\b${_.escapeRegExp(rule)}\\\\b`;\n    } else if (_.isPlainObject(rule)) {\n      if (_.has(rule, 'pattern')) {\n        if (!_.isString(rule.pattern) || rule.pattern.length === 0) {\n          raiseError(`The value of 'pattern' must be a valid non-empty string`);\n        }\n        pattern = rule.pattern;\n      } else if (_.has(rule, 'text')) {\n        if (!_.isString(rule.text) || rule.text.length === 0) {\n          raiseError(`The value of 'text' must be a valid non-empty string`);\n        }\n        pattern = `\\\\b${_.escapeRegExp(rule.text)}\\\\b`;\n      }\n      if (!pattern) {\n        raiseError(`Must either have a field named 'pattern' or 'text'`);\n      }\n\n      if (_.has(rule, 'flags')) {\n        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Advanced_searching_with_flags_2\n        for (const flag of ['i', 'g', 'm', 's', 'u', 'y']) {\n          if (_.includes(rule.flags, flag)) {\n            flags.push(flag);\n          }\n        }\n        flags = _.uniq(flags);\n      }\n\n      if (_.isString(rule.replacer)) {\n        replacer = rule.replacer;\n      }\n    } else {\n      raiseError('Must either be a string or an object');\n    }\n\n    try {\n      return {\n        pattern: new RegExp(pattern, flags.join('')),\n        replacer,\n      };\n    } catch (e) {\n      raiseError(e.message);\n    }\n  }\n\n  /**\n   * Loads rules from the given JSON file\n   *\n   * @param {string|string[]|Rule[]>} source The full path to the JSON file containing secure\n   * values replacement rules or the rules themselves represented as an array\n   * @throws {Error} If the format of the source file is invalid or\n   * it does not exist\n   * @returns {Array<string>} The list of issues found while parsing each rule.\n   * An empty list is returned if no rule parsing issues were found\n   */\n  async loadRules (source) {\n    let rules;\n    if (_.isArray(source)) {\n      rules = source;\n    } else {\n      if (!await fs.exists(source)) {\n        throw new Error(`'${source}' does not exist or is not accessible`);\n      }\n      try {\n        rules = JSON.parse(await fs.readFile(source, 'utf8'));\n      } catch (e) {\n        throw new Error(`'${source}' must be a valid JSON file. Original error: ${e.message}`);\n      }\n      if (!_.isArray(rules)) {\n        throw new Error(`'${source}' must contain a valid JSON array`);\n      }\n    }\n\n    const issues = [];\n    this._rules = [];\n    for (const rule of rules) {\n      try {\n        this._rules.push(this.parseRule(rule));\n      } catch (e) {\n        issues.push(e.message);\n      }\n    }\n    return issues;\n  }\n\n  /**\n   * Performs secure values replacement inside the given string\n   * according to the previously loaded rules. No replacement is made\n   * if there are no rules or the given value is not a string\n   *\n   * @param {string} str The string to make replacements in\n   * @returns {string} The string with replacements made\n   */\n  preprocess (str) {\n    if (this._rules.length === 0 || !_.isString(str)) {\n      return str;\n    }\n\n    let result = str;\n    for (const rule of this._rules) {\n      result = result.replace(rule.pattern, rule.replacer);\n    }\n    return result;\n  }\n}\n\nconst SECURE_VALUES_PREPROCESSOR = new SecureValuesPreprocessor();\n\nexport { SECURE_VALUES_PREPROCESSOR, SecureValuesPreprocessor };\nexport default SECURE_VALUES_PREPROCESSOR;\n"],"file":"lib/log-internal.js","sourceRoot":"../.."}
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/log-internal.js"],"names":["DEFAULT_REPLACER","SecureValuesPreprocessor","constructor","_rules","rules","parseRule","rule","pattern","replacer","flags","_","isString","length","Error","JSON","stringify","escapeRegExp","isPlainObject","has","text","flag","includes","push","uniq","RegExp","join","loadRules","source","isArray","fs","exists","parse","readFile","e","message","issues","preprocess","str","result","replace","SECURE_VALUES_PREPROCESSOR"],"mappings":"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","sourcesContent":["import fs from './fs';\nimport _ from 'lodash';\n\nconst DEFAULT_REPLACER = '**SECURE**';\n\n\nclass SecureValuesPreprocessor {\n  constructor () {\n    this._rules = [];\n  }\n\n  /**\n   * @returns {Array<SecureValuePreprocessingRule>} The list of successfully\n   * parsed preprocessing rules\n   */\n  get rules () {\n    return this._rules;\n  }\n\n  /**\n   * Parses single rule from the given JSON file\n   *\n   * @param {string|Rule} rule The rule might either be represented as a single string\n   * or a configuration object\n   * @throws {Error} If there was an error while parsing the rule\n   * @returns {SecureValuePreprocessingRule} The parsed rule\n   */\n  parseRule (rule) {\n    let pattern;\n    let replacer = DEFAULT_REPLACER;\n    let flags = ['g'];\n    if (_.isString(rule)) {\n      if (rule.length === 0) {\n        throw new Error(`${JSON.stringify(rule)} -> The value must not be empty`);\n      }\n      pattern = `\\\\b${_.escapeRegExp(rule)}\\\\b`;\n    } else if (_.isPlainObject(rule)) {\n      if (_.has(rule, 'pattern')) {\n        if (!_.isString(rule.pattern) || rule.pattern.length === 0) {\n          throw new Error(`${JSON.stringify(rule)} -> The value of 'pattern' must be a valid non-empty string`);\n        }\n        pattern = rule.pattern;\n      } else if (_.has(rule, 'text')) {\n        if (!_.isString(rule.text) || rule.text.length === 0) {\n          throw new Error(`${JSON.stringify(rule)} -> The value of 'text' must be a valid non-empty string`);\n        }\n        pattern = `\\\\b${_.escapeRegExp(rule.text)}\\\\b`;\n      }\n      if (!pattern) {\n        throw new Error(`${JSON.stringify(rule)} -> Must either have a field named 'pattern' or 'text'`);\n      }\n\n      if (_.has(rule, 'flags')) {\n        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Advanced_searching_with_flags_2\n        for (const flag of ['i', 'g', 'm', 's', 'u', 'y']) {\n          if (_.includes(rule.flags, flag)) {\n            flags.push(flag);\n          }\n        }\n        flags = _.uniq(flags);\n      }\n\n      if (_.isString(rule.replacer)) {\n        replacer = rule.replacer;\n      }\n    } else {\n      throw new Error(`${JSON.stringify(rule)} -> Must either be a string or an object`);\n    }\n\n    return {\n      pattern: new RegExp(pattern, flags.join('')),\n      replacer,\n    };\n  }\n\n  /**\n   * Loads rules from the given JSON file\n   *\n   * @param {string|string[]|Rule[]} source The full path to the JSON file containing secure\n   * values replacement rules or the rules themselves represented as an array\n   * @throws {Error} If the format of the source file is invalid or\n   * it does not exist\n   * @returns {Promise<string[]>} The list of issues found while parsing each rule.\n   * An empty list is returned if no rule parsing issues were found\n   */\n  async loadRules (source) {\n    let rules;\n    if (_.isArray(source)) {\n      rules = source;\n    } else {\n      if (!await fs.exists(source)) {\n        throw new Error(`'${source}' does not exist or is not accessible`);\n      }\n      try {\n        rules = JSON.parse(await fs.readFile(source, 'utf8'));\n      } catch (e) {\n        throw new Error(`'${source}' must be a valid JSON file. Original error: ${e.message}`);\n      }\n      if (!_.isArray(rules)) {\n        throw new Error(`'${source}' must contain a valid JSON array`);\n      }\n    }\n\n    const issues = [];\n    this._rules = [];\n    for (const rule of rules) {\n      try {\n        this._rules.push(this.parseRule(rule));\n      } catch (e) {\n        issues.push(e.message);\n      }\n    }\n    return issues;\n  }\n\n  /**\n   * Performs secure values replacement inside the given string\n   * according to the previously loaded rules. No replacement is made\n   * if there are no rules or the given value is not a string\n   *\n   * @param {string} str The string to make replacements in\n   * @returns {string} The string with replacements made\n   */\n  preprocess (str) {\n    if (this._rules.length === 0 || !_.isString(str)) {\n      return str;\n    }\n\n    let result = str;\n    for (const rule of this._rules) {\n      result = result.replace(rule.pattern, rule.replacer);\n    }\n    return result;\n  }\n}\n\nconst SECURE_VALUES_PREPROCESSOR = new SecureValuesPreprocessor();\n\nexport { SECURE_VALUES_PREPROCESSOR, SecureValuesPreprocessor };\nexport default SECURE_VALUES_PREPROCESSOR;\n\n/**\n * @typedef Rule\n * @property {string} pattern A valid RegExp pattern to be replaced\n * @property {string} text A text match to replace. Either this property or the\n * above one must be provided. `pattern` has priority over `text` if both are provided.\n * @property {string} [flags] Regular expression flags for the given pattern.\n * Supported flag are the same as for the standard JavaScript RegExp constructor:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Advanced_searching_with_flags_2\n * The 'g' (global matching) is always enabled though.\n * @property {string} [replacer] The replacer value to use. By default\n * equals to `DEFAULT_SECURE_REPLACER`\n */\n\n/**\n * @typedef SecureValuePreprocessingRule\n * @property {RegExp} pattern The parsed pattern which is going to be used for replacement\n * @property {string} [replacer] The replacer value to use. By default\n * equals to `DEFAULT_SECURE_REPLACER`\n */\n"]}

package/build/lib/logger.d.ts

@@ -0,0 +1,3 @@
+export default log;
+declare let log: import("@appium/types").AppiumLogger;
+//# sourceMappingURL=logger.d.ts.map

package/build/lib/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../lib/logger.js"],"names":[],"mappings":";AAEA,sDAA+B"}

package/build/lib/logger.js

@@ -11,7 +11,5 @@ var _logging = require("./logging");
 
 let log = (0, _logging.getLogger)('Support');
 var _default = log;
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9sb2dnZXIuanMiXSwibmFtZXMiOlsibG9nIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQTs7QUFFQSxJQUFJQSxHQUFHLEdBQUcsd0JBQVUsU0FBVixDQUFWO2VBRWVBLEciLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBnZXRMb2dnZXIgfSBmcm9tICcuL2xvZ2dpbmcnO1xuXG5sZXQgbG9nID0gZ2V0TG9nZ2VyKCdTdXBwb3J0Jyk7XG5cbmV4cG9ydCBkZWZhdWx0IGxvZztcbiJdLCJmaWxlIjoibGliL2xvZ2dlci5qcyIsInNvdXJjZVJvb3QiOiIuLi8uLiJ9
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9sb2dnZXIuanMiXSwibmFtZXMiOlsibG9nIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQTs7QUFFQSxJQUFJQSxHQUFHLEdBQUcsd0JBQVUsU0FBVixDQUFWO2VBRWVBLEciLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBnZXRMb2dnZXIgfSBmcm9tICcuL2xvZ2dpbmcnO1xuXG5sZXQgbG9nID0gZ2V0TG9nZ2VyKCdTdXBwb3J0Jyk7XG5cbmV4cG9ydCBkZWZhdWx0IGxvZztcbiJdfQ==

package/build/lib/logging.d.ts

@@ -0,0 +1,45 @@
+export default log;
+export type LoadResult = {
+    /**
+     * The list of rule parsing issues (one item per rule).
+     * Rules with issues are skipped. An empty list is returned if no parsing issues exist.
+     */
+    issues: string[];
+    /**
+     * The list of successfully loaded
+     * replacement rules. The list could be empty if no rules were loaded.
+     */
+    rules: import('./log-internal').SecureValuePreprocessingRule[];
+};
+export type Prefix = import('@appium/types').Prefix;
+export type AppiumLogger = import('@appium/types').AppiumLogger;
+export const log: import("@appium/types").AppiumLogger;
+export function patchLogger(logger: any): void;
+/**
+ *
+ * @param {Prefix?} prefix
+ * @returns {AppiumLogger}
+ */
+export function getLogger(prefix?: Prefix | null): AppiumLogger;
+/**
+ * @typedef LoadResult
+ * @property {string[]} issues The list of rule parsing issues (one item per rule).
+ * Rules with issues are skipped. An empty list is returned if no parsing issues exist.
+ * @property {import('./log-internal').SecureValuePreprocessingRule[]} rules The list of successfully loaded
+ * replacement rules. The list could be empty if no rules were loaded.
+ */
+/**
+ * Loads the JSON file containing secure values replacement rules.
+ * This might be necessary to hide sensitive values that may possibly
+ * appear in Appium logs.
+ * Each call to this method replaces the previously loaded rules if any existed.
+ *
+ * @param {string|string[]|import('./log-internal').Rule[]} rulesJsonPath The full path to the JSON file containing
+ * the replacement rules. Each rule could either be a string to be replaced
+ * or an object with predefined properties. See the `Rule` type definition in
+ * `log-internals.js` to get more details on its format.
+ * @throws {Error} If the given file cannot be loaded
+ * @returns {Promise<LoadResult>}
+ */
+export function loadSecureValuesPreprocessingRules(rulesJsonPath: string | string[] | import('./log-internal').Rule[]): Promise<LoadResult>;
+//# sourceMappingURL=logging.d.ts.map

package/build/lib/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../lib/logging.js"],"names":[],"mappings":";;;;;;YA2Hc,MAAM,EAAE;;;;;WAER,OAAO,gBAAgB,EAAE,4BAA4B,EAAE;;qBAgCxD,OAAO,eAAe,EAAE,MAAM;2BAI9B,OAAO,eAAe,EAAE,YAAY;AAVjD,uDAAwB;AArIxB,+CAIC;AAwCD;;;;GAIG;AACH,mCAHW,MAAM,UACJ,YAAY,CAsDxB;AAED;;;;;;GAMG;AAEH;;;;;;;;;;;;GAYG;AACH,kEAPW,MAAM,GAAC,MAAM,EAAE,GAAC,OAAO,gBAAgB,EAAE,IAAI,EAAE,GAK7C,QAAQ,UAAU,CAAC,CAQ/B"}

package/build/lib/logging.js

@@ -42,8 +42,8 @@ function patchLogger(logger) {
 }
 
 function _getLogger() {
-  const testingMode = parseInt(process.env._TESTING, 10) === 1;
-  const forceLogMode = parseInt(process.env._FORCE_LOGS, 10) === 1;
+  const testingMode = process.env._TESTING === '1';
+  const forceLogMode = process.env._FORCE_LOGS === '1';
   const usingGlobalLog = !!global._global_npmlog;
   let logger;
 
@@ -59,20 +59,19 @@ function _getLogger() {
 }
 
 function getActualPrefix(prefix, logTimestamp = false) {
-  let actualPrefix = _lodash.default.isFunction(prefix) ? prefix() : prefix;
+  var _ref;
 
-  if (logTimestamp) {
-    actualPrefix = `[${(0, _moment.default)().format(PREFIX_TIMESTAMP_FORMAT)}] ${actualPrefix}`;
-  }
-
-  return actualPrefix;
+  const result = (_ref = _lodash.default.isFunction(prefix) ? prefix() : prefix) !== null && _ref !== void 0 ? _ref : '';
+  return logTimestamp ? `[${(0, _moment.default)().format(PREFIX_TIMESTAMP_FORMAT)}] ${result}` : result;
 }
 
 function getLogger(prefix = null) {
   let [logger, usingGlobalLog] = _getLogger();
 
   let wrappedLogger = {
-    unwrap: () => logger
+    unwrap: () => logger,
+    levels: NPM_LEVELS,
+    prefix
   };
   Object.defineProperty(wrappedLogger, 'level', {
     get() {
@@ -86,11 +85,11 @@ function getLogger(prefix = null) {
     enumerable: true,
     configurable: true
   });
-  const logTimestamp = parseInt(process.env._LOG_TIMESTAMP, 10) === 1;
+  const logTimestamp = process.env._LOG_TIMESTAMP === '1';
 
   for (const level of NPM_LEVELS) {
     wrappedLogger[level] = function (...args) {
-      const actualPrefix = getActualPrefix(prefix, logTimestamp);
+      const actualPrefix = getActualPrefix(this.prefix, logTimestamp);
 
       for (const arg of args) {
         const out = _lodash.default.isError(arg) && arg.stack ? arg.stack : `${arg}`;
@@ -112,7 +111,6 @@ function getLogger(prefix = null) {
     wrappedLogger.level = 'verbose';
   }
 
-  wrappedLogger.levels = NPM_LEVELS;
   return wrappedLogger;
 }
 
@@ -127,7 +125,5 @@ async function loadSecureValuesPreprocessingRules(rulesJsonPath) {
 const log = getLogger();
 exports.log = log;
 var _default = log;
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/logging.js"],"names":["NPM_LEVELS","MAX_LOG_RECORDS_COUNT","PREFIX_TIMESTAMP_FORMAT","mockLog","level","patchLogger","logger","debug","addLevel","fg","bg","_getLogger","testingMode","parseInt","process","env","_TESTING","forceLogMode","_FORCE_LOGS","usingGlobalLog","global","_global_npmlog","npmlog","maxRecordSize","getActualPrefix","prefix","logTimestamp","actualPrefix","_","isFunction","format","getLogger","wrappedLogger","unwrap","Object","defineProperty","get","set","newValue","enumerable","configurable","_LOG_TIMESTAMP","args","arg","out","isError","stack","line","split","unleakedLine","SECURE_VALUES_PREPROCESSOR","preprocess","errorAndThrow","err","error","Error","levels","loadSecureValuesPreprocessingRules","rulesJsonPath","issues","loadRules","rules","cloneDeep","log"],"mappings":"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","sourcesContent":["import npmlog from 'npmlog';\nimport _ from 'lodash';\nimport { unleakString } from './util';\nimport moment from 'moment';\nimport SECURE_VALUES_PREPROCESSOR from './log-internal';\n\n// levels that are available from `npmlog`\nconst NPM_LEVELS = ['silly', 'verbose', 'debug', 'info', 'http', 'warn', 'error'];\nconst MAX_LOG_RECORDS_COUNT = 3000;\n\nconst PREFIX_TIMESTAMP_FORMAT = 'HH-mm-ss:SSS';\n\n// mock log object used in testing mode\nlet mockLog = {};\nfor (let level of NPM_LEVELS) {\n  mockLog[level] = () => {};\n}\n\nfunction patchLogger (logger) {\n  if (!logger.debug) {\n    logger.addLevel('debug', 1000, { fg: 'blue', bg: 'black' }, 'dbug');\n  }\n}\n\nfunction _getLogger () {\n  // check if the user set the `_TESTING` or `_FORCE_LOGS` flag\n  const testingMode = parseInt(process.env._TESTING, 10) === 1;\n  const forceLogMode = parseInt(process.env._FORCE_LOGS, 10) === 1;\n\n  // if is possible that there is a logger instance that is already around,\n  // in which case we want t o use that\n  const usingGlobalLog = !!global._global_npmlog;\n  let logger;\n  if (testingMode && !forceLogMode) {\n    // in testing mode, use a mock logger object that we can query\n    logger = mockLog;\n  } else {\n    // otherwise, either use the global, or a new `npmlog` object\n    logger = global._global_npmlog || npmlog;\n    // The default value is 10000, which causes excessive memory usage\n    logger.maxRecordSize = MAX_LOG_RECORDS_COUNT;\n  }\n  patchLogger(logger);\n  return [logger, usingGlobalLog];\n}\n\nfunction getActualPrefix (prefix, logTimestamp = false) {\n  let actualPrefix = _.isFunction(prefix) ? prefix() : prefix;\n  if (logTimestamp) {\n    actualPrefix = `[${moment().format(PREFIX_TIMESTAMP_FORMAT)}] ${actualPrefix}`;\n  }\n  return actualPrefix;\n}\n\nfunction getLogger (prefix = null) {\n  let [logger, usingGlobalLog] = _getLogger();\n\n  // wrap the logger so that we can catch and modify any logging\n  let wrappedLogger = {unwrap: () => logger};\n\n  // allow access to the level of the underlying logger\n  Object.defineProperty(wrappedLogger, 'level', {\n    get () {\n      return logger.level;\n    },\n    set (newValue) {\n      logger.level = newValue;\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  const logTimestamp = parseInt(process.env._LOG_TIMESTAMP, 10) === 1;\n\n  // add all the levels from `npmlog`, and map to the underlying logger\n  for (const level of NPM_LEVELS) {\n    wrappedLogger[level] = function (...args) {\n      const actualPrefix = getActualPrefix(prefix, logTimestamp);\n      for (const arg of args) {\n        const out = (_.isError(arg) && arg.stack) ? arg.stack : `${arg}`;\n        for (const line of out.split('\\n')) {\n          // it is necessary to unleak each line because `split` call\n          // creates \"views\" to the original string as well as the `substring` one\n          const unleakedLine = unleakString(line);\n          logger[level](actualPrefix, SECURE_VALUES_PREPROCESSOR.preprocess(unleakedLine));\n        }\n      }\n    };\n  }\n  // add method to log an error, and throw it, for convenience\n  wrappedLogger.errorAndThrow = function (err) {\n    this.error(err);\n    // make sure we have an `Error` object. Wrap if necessary\n    throw (_.isError(err) ? err : new Error(unleakString(err)));\n  };\n  if (!usingGlobalLog) {\n    // if we're not using a global log specified from some top-level package,\n    // set the log level to a default of verbose. Otherwise, let the top-level\n    // package set the log level\n    wrappedLogger.level = 'verbose';\n  }\n  wrappedLogger.levels = NPM_LEVELS;\n  return wrappedLogger;\n}\n\n/**\n * @typedef {Object} LoadResult\n * @property {List<string>} issues The list of rule parsing issues (one item per rule).\n * Rules with issues are skipped. An empty list is returned if no parsing issues exist.\n * @property {List<SecureValuePreprocessingRule>} rules The list of successfully loaded\n * replacement rules. The list could be empty if no rules were loaded.\n */\n\n/**\n * Loads the JSON file containing secure values replacement rules.\n * This might be necessary to hide sensitive values that may possibly\n * appear in Appium logs.\n * Each call to this method replaces the previously loaded rules if any existed.\n *\n * @param {string|string[]|Rule[]} rulesJsonPath The full path to the JSON file containing\n * the replacement rules. Each rule could either be a string to be replaced\n * or an object with predefined properties. See the `Rule` type definition in\n * `log-internals.js` to get more details on its format.\n * @throws {Error} If the given file cannot be loaded\n * @returns {LoadResult}\n */\nasync function loadSecureValuesPreprocessingRules (rulesJsonPath) {\n  const issues = await SECURE_VALUES_PREPROCESSOR.loadRules(rulesJsonPath);\n  return {\n    issues,\n    rules: _.cloneDeep(SECURE_VALUES_PREPROCESSOR.rules),\n  };\n}\n\n// export a default logger with no prefix\nconst log = getLogger();\n\nexport { log, patchLogger, getLogger, loadSecureValuesPreprocessingRules };\nexport default log;\n"],"file":"lib/logging.js","sourceRoot":"../.."}
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/logging.js"],"names":["NPM_LEVELS","MAX_LOG_RECORDS_COUNT","PREFIX_TIMESTAMP_FORMAT","mockLog","level","patchLogger","logger","debug","addLevel","fg","bg","_getLogger","testingMode","process","env","_TESTING","forceLogMode","_FORCE_LOGS","usingGlobalLog","global","_global_npmlog","npmlog","maxRecordSize","getActualPrefix","prefix","logTimestamp","result","_","isFunction","format","getLogger","wrappedLogger","unwrap","levels","Object","defineProperty","get","set","newValue","enumerable","configurable","_LOG_TIMESTAMP","args","actualPrefix","arg","out","isError","stack","line","split","unleakedLine","SECURE_VALUES_PREPROCESSOR","preprocess","errorAndThrow","err","error","Error","loadSecureValuesPreprocessingRules","rulesJsonPath","issues","loadRules","rules","cloneDeep","log"],"mappings":"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","sourcesContent":["import npmlog from 'npmlog';\nimport _ from 'lodash';\nimport { unleakString } from './util';\nimport moment from 'moment';\nimport SECURE_VALUES_PREPROCESSOR from './log-internal';\n\n// levels that are available from `npmlog`\nconst NPM_LEVELS = ['silly', 'verbose', 'debug', 'info', 'http', 'warn', 'error'];\nconst MAX_LOG_RECORDS_COUNT = 3000;\n\nconst PREFIX_TIMESTAMP_FORMAT = 'HH-mm-ss:SSS';\n\n// mock log object used in testing mode\nlet mockLog = {};\nfor (let level of NPM_LEVELS) {\n  mockLog[level] = () => {};\n}\n\nfunction patchLogger (logger) {\n  if (!logger.debug) {\n    logger.addLevel('debug', 1000, { fg: 'blue', bg: 'black' }, 'dbug');\n  }\n}\n\n/**\n *\n * @returns {[npmlog.Logger, boolean]}\n */\nfunction _getLogger () {\n  // check if the user set the `_TESTING` or `_FORCE_LOGS` flag\n  const testingMode = process.env._TESTING === '1';\n  const forceLogMode = process.env._FORCE_LOGS === '1';\n\n  // if is possible that there is a logger instance that is already around,\n  // in which case we want t o use that\n  const usingGlobalLog = !!global._global_npmlog;\n  let logger;\n  if (testingMode && !forceLogMode) {\n    // in testing mode, use a mock logger object that we can query\n    logger = mockLog;\n  } else {\n    // otherwise, either use the global, or a new `npmlog` object\n    logger = global._global_npmlog || npmlog;\n    // The default value is 10000, which causes excessive memory usage\n    logger.maxRecordSize = MAX_LOG_RECORDS_COUNT;\n  }\n  patchLogger(logger);\n  return [logger, usingGlobalLog];\n}\n\n/**\n * @param {Prefix?} prefix\n * @param {boolean} logTimestamp whether to include timestamps into log prefixes\n * @returns {string}\n */\nfunction getActualPrefix (prefix, logTimestamp = false) {\n  const result = (_.isFunction(prefix) ? prefix() : prefix) ?? '';\n  return logTimestamp\n    ? `[${moment().format(PREFIX_TIMESTAMP_FORMAT)}] ${result}`\n    : result;\n}\n\n/**\n *\n * @param {Prefix?} prefix\n * @returns {AppiumLogger}\n */\nfunction getLogger (prefix = null) {\n  let [logger, usingGlobalLog] = _getLogger();\n\n  // wrap the logger so that we can catch and modify any logging\n  let wrappedLogger = {\n    unwrap: () => logger,\n    levels: NPM_LEVELS,\n    prefix,\n  };\n\n  // allow access to the level of the underlying logger\n  Object.defineProperty(wrappedLogger, 'level', {\n    get () {\n      return logger.level;\n    },\n    set (newValue) {\n      logger.level = newValue;\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  const logTimestamp = process.env._LOG_TIMESTAMP === '1';\n\n  // add all the levels from `npmlog`, and map to the underlying logger\n  for (const level of NPM_LEVELS) {\n    wrappedLogger[level] = function (...args) {\n      const actualPrefix = getActualPrefix(this.prefix, logTimestamp);\n      for (const arg of args) {\n        const out = (_.isError(arg) && arg.stack) ? arg.stack : `${arg}`;\n        for (const line of out.split('\\n')) {\n          // it is necessary to unleak each line because `split` call\n          // creates \"views\" to the original string as well as the `substring` one\n          const unleakedLine = unleakString(line);\n          logger[level](actualPrefix, SECURE_VALUES_PREPROCESSOR.preprocess(unleakedLine));\n        }\n      }\n    };\n  }\n  // add method to log an error, and throw it, for convenience\n  wrappedLogger.errorAndThrow = function (err) {\n    this.error(err);\n    // make sure we have an `Error` object. Wrap if necessary\n    throw (_.isError(err) ? err : new Error(unleakString(err)));\n  };\n  if (!usingGlobalLog) {\n    // if we're not using a global log specified from some top-level package,\n    // set the log level to a default of verbose. Otherwise, let the top-level\n    // package set the log level\n    wrappedLogger.level = 'verbose';\n  }\n  return /** @type {AppiumLogger} */(wrappedLogger);\n}\n\n/**\n * @typedef LoadResult\n * @property {string[]} issues The list of rule parsing issues (one item per rule).\n * Rules with issues are skipped. An empty list is returned if no parsing issues exist.\n * @property {import('./log-internal').SecureValuePreprocessingRule[]} rules The list of successfully loaded\n * replacement rules. The list could be empty if no rules were loaded.\n */\n\n/**\n * Loads the JSON file containing secure values replacement rules.\n * This might be necessary to hide sensitive values that may possibly\n * appear in Appium logs.\n * Each call to this method replaces the previously loaded rules if any existed.\n *\n * @param {string|string[]|import('./log-internal').Rule[]} rulesJsonPath The full path to the JSON file containing\n * the replacement rules. Each rule could either be a string to be replaced\n * or an object with predefined properties. See the `Rule` type definition in\n * `log-internals.js` to get more details on its format.\n * @throws {Error} If the given file cannot be loaded\n * @returns {Promise<LoadResult>}\n */\nasync function loadSecureValuesPreprocessingRules (rulesJsonPath) {\n  const issues = await SECURE_VALUES_PREPROCESSOR.loadRules(rulesJsonPath);\n  return {\n    issues,\n    rules: _.cloneDeep(SECURE_VALUES_PREPROCESSOR.rules),\n  };\n}\n\n// export a default logger with no prefix\nconst log = getLogger();\n\nexport { log, patchLogger, getLogger, loadSecureValuesPreprocessingRules };\nexport default log;\n\n/**\n * @typedef {import('@appium/types').Prefix} Prefix\n */\n\n/**\n * @typedef {import('@appium/types').AppiumLogger} AppiumLogger\n */\n"]}

package/build/lib/mjpeg.d.ts

@@ -0,0 +1,65 @@
+/** Class which stores the last bit of data streamed into it */
+export class MJpegStream extends Writable {
+    /**
+     * Create an MJpegStream
+     * @param {string} mJpegUrl - URL of MJPEG-over-HTTP stream
+     * @param {function} [errorHandler=noop] - additional function that will be
+     * called in the case of any errors.
+     * @param {object} [options={}] - Options to pass to the Writable constructor
+     */
+    constructor(mJpegUrl: string, errorHandler?: Function | undefined, options?: object);
+    /**
+     * @type {number}
+     */
+    updateCount: number;
+    errorHandler: Function;
+    url: string;
+    /**
+     * Get the base64-encoded version of the JPEG
+     *
+     * @returns {?string} base64-encoded JPEG image data
+     * or `null` if no image can be parsed
+     */
+    get lastChunkBase64(): string | null;
+    /**
+     * Get the PNG version of the JPEG buffer
+     *
+     * @returns {Promise<Buffer?>} PNG image data or `null` if no PNG
+     * image can be parsed
+     */
+    lastChunkPNG(): Promise<Buffer | null>;
+    /**
+     * Get the base64-encoded version of the PNG
+     *
+     * @returns {Promise<string?>} base64-encoded PNG image data
+     * or `null` if no image can be parsed
+     */
+    lastChunkPNGBase64(): Promise<string | null>;
+    /**
+     * Reset internal state
+     */
+    clear(): void;
+    registerStartSuccess: ((thenableOrResult?: any) => void) | null | undefined;
+    registerStartFailure: ((error?: any) => void) | null | undefined;
+    responseStream: any;
+    consumer: any;
+    lastChunk: Buffer | null | undefined;
+    /**
+     * Start reading the MJpeg stream and storing the last image
+     */
+    start(serverTimeout?: number): Promise<void>;
+    /**
+     * Stop reading the MJpeg stream. Ensure we disconnect all the pipes and stop
+     * the HTTP request itself. Then reset the state.
+     */
+    stop(): void;
+    /**
+     * Override the Writable write() method in order to save the last image and
+     * log the number of images we have received
+     * @override
+     * @param {Buffer} data - binary data streamed from the MJpeg consumer
+     */
+    override write(data: Buffer): boolean;
+}
+import { Writable } from "stream";
+//# sourceMappingURL=mjpeg.d.ts.map

package/build/lib/mjpeg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mjpeg.d.ts","sourceRoot":"","sources":["../../lib/mjpeg.js"],"names":[],"mappings":"AA6BA,+DAA+D;AAC/D;IAOE;;;;;;OAMG;IACH,sBALW,MAAM,iDAGN,MAAM,EAQhB;IAlBD;;OAEG;IACH,aAFU,MAAM,CAEA;IAYd,uBAAgC;IAChC,YAAmB;IAIrB;;;;;OAKG;IACH,qCAKC;IAED;;;;;OAKG;IACH,gBAHa,QAAQ,MAAM,QAAE,CAe5B;IAED;;;;;OAKG;IACH,sBAHa,QAAQ,MAAM,QAAE,CAM5B;IAED;;OAEG;IACH,cAOC;IANC,4EAAgC;IAChC,iEAAgC;IAChC,oBAA0B;IAC1B,cAAoB;IACpB,qCAAqB;IAIvB;;OAEG;IACH,6CAoDC;IAED;;;OAGG;IACH,aASC;IAED;;;;;OAKG;IACH,qBAFW,MAAM,WAYhB;CACF"}

package/build/lib/mjpeg.js

@@ -40,6 +40,8 @@ async function initMJpegConsumer() {
 const MJPEG_SERVER_TIMEOUT_MS = 10000;
 
 class MJpegStream extends _stream.Writable {
+  updateCount = 0;
+
   constructor(mJpegUrl, errorHandler = _lodash.default.noop, options = {}) {
     super(options);
     this.errorHandler = errorHandler;
@@ -48,16 +50,19 @@ class MJpegStream extends _stream.Writable {
   }
 
   get lastChunkBase64() {
-    return !_lodash.default.isEmpty(this.lastChunk) && _lodash.default.isBuffer(this.lastChunk) ? this.lastChunk.toString('base64') : null;
+    const lastChunk = this.lastChunk;
+    return !_lodash.default.isEmpty(this.lastChunk) && _lodash.default.isBuffer(this.lastChunk) ? lastChunk.toString('base64') : null;
   }
 
   async lastChunkPNG() {
-    if (_lodash.default.isEmpty(this.lastChunk) || !_lodash.default.isBuffer(this.lastChunk)) {
+    const lastChunk = this.lastChunk;
+
+    if (_lodash.default.isEmpty(lastChunk) || !_lodash.default.isBuffer(lastChunk)) {
       return null;
     }
 
     try {
-      const jpg = await (0, _imageUtil.getJimpImage)(this.lastChunk);
+      const jpg = await (0, _imageUtil.getJimpImage)(lastChunk);
       return await jpg.getBuffer(_imageUtil.MIME_PNG);
     } catch (e) {
       return null;
@@ -139,11 +144,11 @@ class MJpegStream extends _stream.Writable {
       this.registerStartSuccess();
       this.registerStartSuccess = null;
     }
+
+    return true;
   }
 
 }
 
-exports.MJpegStream = MJpegStream;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/mjpeg.js"],"names":["MJpegConsumer","initMJpegConsumer","ign","Error","MJPEG_SERVER_TIMEOUT_MS","MJpegStream","Writable","constructor","mJpegUrl","errorHandler","_","noop","options","url","clear","lastChunkBase64","isEmpty","lastChunk","isBuffer","toString","lastChunkPNG","jpg","getBuffer","MIME_PNG","e","lastChunkPNGBase64","png","registerStartSuccess","registerStartFailure","responseStream","consumer","updateCount","start","serverTimeout","stop","startPromise","B","res","rej","timeout","onErr","err","log","error","message","onClose","debug","responseType","data","once","on","pipe","unpipe","destroy","write"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA,IAAIA,aAAa,GAAG,IAApB;;AAKA,eAAeC,iBAAf,GAAoC;AAClC,MAAI,CAACD,aAAL,EAAoB;AAClB,QAAI;AACFA,MAAAA,aAAa,GAAG,MAAM,0BAAe,gBAAf,CAAtB;AACD,KAFD,CAEE,OAAOE,GAAP,EAAY,CAAE;AACjB;;AACD,MAAI,CAACF,aAAL,EAAoB;AAClB,UAAM,IAAIG,KAAJ,CAAU,wEACA,uEADV,CAAN;AAED;AACF;;AAGD,MAAMC,uBAAuB,GAAG,KAAhC;;AAGA,MAAMC,WAAN,SAA0BC,gBAA1B,CAAmC;AASjCC,EAAAA,WAAW,CAAEC,QAAF,EAAYC,YAAY,GAAGC,gBAAEC,IAA7B,EAAmCC,OAAO,GAAG,EAA7C,EAAiD;AAC1D,UAAMA,OAAN;AAEA,SAAKH,YAAL,GAAoBA,YAApB;AACA,SAAKI,GAAL,GAAWL,QAAX;AACA,SAAKM,KAAL;AACD;;AAQkB,MAAfC,eAAe,GAAI;AACrB,WAAO,CAACL,gBAAEM,OAAF,CAAU,KAAKC,SAAf,CAAD,IAA8BP,gBAAEQ,QAAF,CAAW,KAAKD,SAAhB,CAA9B,GACH,KAAKA,SAAL,CAAeE,QAAf,CAAwB,QAAxB,CADG,GAEH,IAFJ;AAGD;;AAQiB,QAAZC,YAAY,GAAI;AACpB,QAAIV,gBAAEM,OAAF,CAAU,KAAKC,SAAf,KAA6B,CAACP,gBAAEQ,QAAF,CAAW,KAAKD,SAAhB,CAAlC,EAA8D;AAC5D,aAAO,IAAP;AACD;;AAED,QAAI;AACF,YAAMI,GAAG,GAAG,MAAM,6BAAa,KAAKJ,SAAlB,CAAlB;AACA,aAAO,MAAMI,GAAG,CAACC,SAAJ,CAAcC,mBAAd,CAAb;AACD,KAHD,CAGE,OAAOC,CAAP,EAAU;AACV,aAAO,IAAP;AACD;AACF;;AAQuB,QAAlBC,kBAAkB,GAAI;AAC1B,UAAMC,GAAG,GAAG,MAAM,KAAKN,YAAL,EAAlB;AACA,WAAOM,GAAG,GAAGA,GAAG,CAACP,QAAJ,CAAa,QAAb,CAAH,GAA4B,IAAtC;AACD;;AAKDL,EAAAA,KAAK,GAAI;AACP,SAAKa,oBAAL,GAA4B,IAA5B;AACA,SAAKC,oBAAL,GAA4B,IAA5B;AACA,SAAKC,cAAL,GAAsB,IAAtB;AACA,SAAKC,QAAL,GAAgB,IAAhB;AACA,SAAKb,SAAL,GAAiB,IAAjB;AACA,SAAKc,WAAL,GAAmB,CAAnB;AACD;;AAKU,QAALC,KAAK,CAAEC,aAAa,GAAG7B,uBAAlB,EAA2C;AAEpD,SAAK8B,IAAL;AAEA,UAAMjC,iBAAiB,EAAvB;AAEA,SAAK6B,QAAL,GAAgB,IAAI9B,aAAJ,EAAhB;AAIA,UAAMmC,YAAY,GAAG,IAAIC,iBAAJ,CAAM,CAACC,GAAD,EAAMC,GAAN,KAAc;AACvC,WAAKX,oBAAL,GAA4BU,GAA5B;AACA,WAAKT,oBAAL,GAA4BU,GAA5B;AACD,KAHoB,EAMlBC,OANkB,CAMVN,aANU,EAOhB,UAASA,aAAc,+CAPP,CAArB;AASA,UAAMpB,GAAG,GAAG,KAAKA,GAAjB;;AACA,UAAM2B,KAAK,GAAIC,GAAD,IAAS;AAErB,WAAKxB,SAAL,GAAiB,IAAjB;;AAEAyB,sBAAIC,KAAJ,CAAW,yCAAwCF,GAAG,CAACG,OAAQ,EAA/D;;AACA,WAAKnC,YAAL,CAAkBgC,GAAlB;;AACA,UAAI,KAAKb,oBAAT,EAA+B;AAC7B,aAAKA,oBAAL,CAA0Ba,GAA1B;AACD;AACF,KATD;;AAUA,UAAMI,OAAO,GAAG,MAAM;AACpBH,sBAAII,KAAJ,CAAW,qCAAoCjC,GAAI,kBAAnD;;AACA,WAAKI,SAAL,GAAiB,IAAjB;AACD,KAHD;;AAKA,QAAI;AACF,WAAKY,cAAL,GAAsB,CAAC,MAAM,oBAAM;AACjChB,QAAAA,GADiC;AAEjCkC,QAAAA,YAAY,EAAE,QAFmB;AAGjCR,QAAAA,OAAO,EAAEN;AAHwB,OAAN,CAAP,EAIlBe,IAJJ;AAKD,KAND,CAME,OAAOxB,CAAP,EAAU;AACV,aAAOgB,KAAK,CAAChB,CAAD,CAAZ;AACD;;AAED,SAAKK,cAAL,CACGoB,IADH,CACQ,OADR,EACiBJ,OADjB,EAEGK,EAFH,CAEM,OAFN,EAEeV,KAFf,EAGGW,IAHH,CAGQ,KAAKrB,QAHb,EAIGqB,IAJH,CAIQ,IAJR;AAMA,UAAMhB,YAAN;AACD;;AAMDD,EAAAA,IAAI,GAAI;AACN,QAAI,CAAC,KAAKJ,QAAV,EAAoB;AAClB;AACD;;AAED,SAAKD,cAAL,CAAoBuB,MAApB,CAA2B,KAAKtB,QAAhC;AACA,SAAKA,QAAL,CAAcsB,MAAd,CAAqB,IAArB;AACA,SAAKvB,cAAL,CAAoBwB,OAApB;AACA,SAAKvC,KAAL;AACD;;AAQDwC,EAAAA,KAAK,CAAEN,IAAF,EAAQ;AACX,SAAK/B,SAAL,GAAiB+B,IAAjB;AACA,SAAKjB,WAAL;;AAEA,QAAI,KAAKJ,oBAAT,EAA+B;AAC7B,WAAKA,oBAAL;AACA,WAAKA,oBAAL,GAA4B,IAA5B;AACD;AACF;;AA7JgC","sourcesContent":["import _ from 'lodash';\nimport log from './logger';\nimport B from 'bluebird';\nimport { getJimpImage, MIME_PNG } from './image-util';\nimport { Writable } from 'stream';\nimport { requirePackage } from './node';\nimport axios from 'axios';\n\n// lazy load this, as it might not be available\nlet MJpegConsumer = null;\n\n/**\n * @throws {Error} If `mjpeg-consumer` module is not installed or cannot be loaded\n */\nasync function initMJpegConsumer () {\n  if (!MJpegConsumer) {\n    try {\n      MJpegConsumer = await requirePackage('mjpeg-consumer');\n    } catch (ign) {}\n  }\n  if (!MJpegConsumer) {\n    throw new Error('mjpeg-consumer module is required to use MJPEG-over-HTTP features. ' +\n                    'Please install it first (npm i -g mjpeg-consumer) and restart Appium.');\n  }\n}\n\n// amount of time to wait for the first image in the stream\nconst MJPEG_SERVER_TIMEOUT_MS = 10000;\n\n/** Class which stores the last bit of data streamed into it */\nclass MJpegStream extends Writable {\n\n  /**\n   * Create an MJpegStream\n   * @param {string} mJpegUrl - URL of MJPEG-over-HTTP stream\n   * @param {function} [errorHandler=noop] - additional function that will be\n   * called in the case of any errors.\n   * @param {object} [options={}] - Options to pass to the Writable constructor\n   */\n  constructor (mJpegUrl, errorHandler = _.noop, options = {}) {\n    super(options);\n\n    this.errorHandler = errorHandler;\n    this.url = mJpegUrl;\n    this.clear();\n  }\n\n  /**\n   * Get the base64-encoded version of the JPEG\n   *\n   * @returns {?string} base64-encoded JPEG image data\n   * or `null` if no image can be parsed\n   */\n  get lastChunkBase64 () {\n    return !_.isEmpty(this.lastChunk) && _.isBuffer(this.lastChunk)\n      ? this.lastChunk.toString('base64')\n      : null;\n  }\n\n  /**\n   * Get the PNG version of the JPEG buffer\n   *\n   * @returns {?Buffer} PNG image data or `null` if no PNG\n   * image can be parsed\n   */\n  async lastChunkPNG () {\n    if (_.isEmpty(this.lastChunk) || !_.isBuffer(this.lastChunk)) {\n      return null;\n    }\n\n    try {\n      const jpg = await getJimpImage(this.lastChunk);\n      return await jpg.getBuffer(MIME_PNG);\n    } catch (e) {\n      return null;\n    }\n  }\n\n  /**\n   * Get the base64-encoded version of the PNG\n   *\n   * @returns {?string} base64-encoded PNG image data\n   * or `null` if no image can be parsed\n   */\n  async lastChunkPNGBase64 () {\n    const png = await this.lastChunkPNG();\n    return png ? png.toString('base64') : null;\n  }\n\n  /**\n   * Reset internal state\n   */\n  clear () {\n    this.registerStartSuccess = null;\n    this.registerStartFailure = null;\n    this.responseStream = null;\n    this.consumer = null;\n    this.lastChunk = null;\n    this.updateCount = 0;\n  }\n\n  /**\n   * Start reading the MJpeg stream and storing the last image\n   */\n  async start (serverTimeout = MJPEG_SERVER_TIMEOUT_MS) {\n    // ensure we're not started already\n    this.stop();\n\n    await initMJpegConsumer();\n\n    this.consumer = new MJpegConsumer();\n\n    // use the deferred pattern so we can wait for the start of the stream\n    // based on what comes in from an external pipe\n    const startPromise = new B((res, rej) => {\n      this.registerStartSuccess = res;\n      this.registerStartFailure = rej;\n    })\n    // start a timeout so that if the server does not return data, we don't\n    // block forever.\n      .timeout(serverTimeout,\n        `Waited ${serverTimeout}ms but the MJPEG server never sent any images`);\n\n    const url = this.url;\n    const onErr = (err) => {\n      // Make sure we don't get an outdated screenshot if there was an error\n      this.lastChunk = null;\n\n      log.error(`Error getting MJpeg screenshot chunk: ${err.message}`);\n      this.errorHandler(err);\n      if (this.registerStartFailure) {\n        this.registerStartFailure(err);\n      }\n    };\n    const onClose = () => {\n      log.debug(`The connection to MJPEG server at ${url} has been closed`);\n      this.lastChunk = null;\n    };\n\n    try {\n      this.responseStream = (await axios({\n        url,\n        responseType: 'stream',\n        timeout: serverTimeout,\n      })).data;\n    } catch (e) {\n      return onErr(e);\n    }\n\n    this.responseStream\n      .once('close', onClose)\n      .on('error', onErr) // ensure we do something with errors\n      .pipe(this.consumer) // allow chunking and transforming of jpeg data\n      .pipe(this); // send the actual jpegs to ourself\n\n    await startPromise;\n  }\n\n  /**\n   * Stop reading the MJpeg stream. Ensure we disconnect all the pipes and stop\n   * the HTTP request itself. Then reset the state.\n   */\n  stop () {\n    if (!this.consumer) {\n      return;\n    }\n\n    this.responseStream.unpipe(this.consumer);\n    this.consumer.unpipe(this);\n    this.responseStream.destroy();\n    this.clear();\n  }\n\n  /**\n   * Override the Writable write() method in order to save the last image and\n   * log the number of images we have received\n   * @override\n   * @param {Buffer} data - binary data streamed from the MJpeg consumer\n   */\n  write (data) {\n    this.lastChunk = data;\n    this.updateCount++;\n\n    if (this.registerStartSuccess) {\n      this.registerStartSuccess();\n      this.registerStartSuccess = null;\n    }\n  }\n}\n\nexport { MJpegStream };\n"],"file":"lib/mjpeg.js","sourceRoot":"../.."}
+exports.MJpegStream = MJpegStream;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/mjpeg.js"],"names":["MJpegConsumer","initMJpegConsumer","ign","Error","MJPEG_SERVER_TIMEOUT_MS","MJpegStream","Writable","updateCount","constructor","mJpegUrl","errorHandler","_","noop","options","url","clear","lastChunkBase64","lastChunk","isEmpty","isBuffer","toString","lastChunkPNG","jpg","getBuffer","MIME_PNG","e","lastChunkPNGBase64","png","registerStartSuccess","registerStartFailure","responseStream","consumer","start","serverTimeout","stop","startPromise","B","res","rej","timeout","onErr","err","log","error","message","onClose","debug","responseType","data","once","on","pipe","unpipe","destroy","write"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport log from './logger';\nimport B from 'bluebird';\nimport { getJimpImage, MIME_PNG } from './image-util';\nimport { Writable } from 'stream';\nimport { requirePackage } from './node';\nimport axios from 'axios';\n\n// lazy load this, as it might not be available\nlet MJpegConsumer = null;\n\n/**\n * @throws {Error} If `mjpeg-consumer` module is not installed or cannot be loaded\n */\nasync function initMJpegConsumer () {\n  if (!MJpegConsumer) {\n    try {\n      MJpegConsumer = await requirePackage('mjpeg-consumer');\n    } catch (ign) {}\n  }\n  if (!MJpegConsumer) {\n    throw new Error('mjpeg-consumer module is required to use MJPEG-over-HTTP features. ' +\n                    'Please install it first (npm i -g mjpeg-consumer) and restart Appium.');\n  }\n}\n\n// amount of time to wait for the first image in the stream\nconst MJPEG_SERVER_TIMEOUT_MS = 10000;\n\n/** Class which stores the last bit of data streamed into it */\nclass MJpegStream extends Writable {\n\n  /**\n   * @type {number}\n   */\n  updateCount = 0;\n\n  /**\n   * Create an MJpegStream\n   * @param {string} mJpegUrl - URL of MJPEG-over-HTTP stream\n   * @param {function} [errorHandler=noop] - additional function that will be\n   * called in the case of any errors.\n   * @param {object} [options={}] - Options to pass to the Writable constructor\n   */\n  constructor (mJpegUrl, errorHandler = _.noop, options = {}) {\n    super(options);\n\n    this.errorHandler = errorHandler;\n    this.url = mJpegUrl;\n    this.clear();\n  }\n\n  /**\n   * Get the base64-encoded version of the JPEG\n   *\n   * @returns {?string} base64-encoded JPEG image data\n   * or `null` if no image can be parsed\n   */\n  get lastChunkBase64 () {\n    const lastChunk = /** @type {Buffer} */(this.lastChunk);\n    return !_.isEmpty(this.lastChunk) && _.isBuffer(this.lastChunk)\n      ? lastChunk.toString('base64')\n      : null;\n  }\n\n  /**\n   * Get the PNG version of the JPEG buffer\n   *\n   * @returns {Promise<Buffer?>} PNG image data or `null` if no PNG\n   * image can be parsed\n   */\n  async lastChunkPNG () {\n    const lastChunk = /** @type {Buffer} */(this.lastChunk);\n    if (_.isEmpty(lastChunk) || !_.isBuffer(lastChunk)) {\n      return null;\n    }\n\n    try {\n      const jpg = await getJimpImage(lastChunk);\n      return await jpg.getBuffer(MIME_PNG);\n    } catch (e) {\n      return null;\n    }\n  }\n\n  /**\n   * Get the base64-encoded version of the PNG\n   *\n   * @returns {Promise<string?>} base64-encoded PNG image data\n   * or `null` if no image can be parsed\n   */\n  async lastChunkPNGBase64 () {\n    const png = await this.lastChunkPNG();\n    return png ? png.toString('base64') : null;\n  }\n\n  /**\n   * Reset internal state\n   */\n  clear () {\n    this.registerStartSuccess = null;\n    this.registerStartFailure = null;\n    this.responseStream = null;\n    this.consumer = null;\n    this.lastChunk = null;\n    this.updateCount = 0;\n  }\n\n  /**\n   * Start reading the MJpeg stream and storing the last image\n   */\n  async start (serverTimeout = MJPEG_SERVER_TIMEOUT_MS) {\n    // ensure we're not started already\n    this.stop();\n\n    await initMJpegConsumer();\n\n    this.consumer = new MJpegConsumer();\n\n    // use the deferred pattern so we can wait for the start of the stream\n    // based on what comes in from an external pipe\n    const startPromise = new B((res, rej) => {\n      this.registerStartSuccess = res;\n      this.registerStartFailure = rej;\n    })\n    // start a timeout so that if the server does not return data, we don't\n    // block forever.\n      .timeout(serverTimeout,\n        `Waited ${serverTimeout}ms but the MJPEG server never sent any images`);\n\n    const url = this.url;\n    const onErr = (err) => {\n      // Make sure we don't get an outdated screenshot if there was an error\n      this.lastChunk = null;\n\n      log.error(`Error getting MJpeg screenshot chunk: ${err.message}`);\n      this.errorHandler(err);\n      if (this.registerStartFailure) {\n        this.registerStartFailure(err);\n      }\n    };\n    const onClose = () => {\n      log.debug(`The connection to MJPEG server at ${url} has been closed`);\n      this.lastChunk = null;\n    };\n\n    try {\n      this.responseStream = (await axios({\n        url,\n        responseType: 'stream',\n        timeout: serverTimeout,\n      })).data;\n    } catch (e) {\n      return onErr(e);\n    }\n\n    this.responseStream\n      .once('close', onClose)\n      .on('error', onErr) // ensure we do something with errors\n      .pipe(this.consumer) // allow chunking and transforming of jpeg data\n      .pipe(this); // send the actual jpegs to ourself\n\n    await startPromise;\n  }\n\n  /**\n   * Stop reading the MJpeg stream. Ensure we disconnect all the pipes and stop\n   * the HTTP request itself. Then reset the state.\n   */\n  stop () {\n    if (!this.consumer) {\n      return;\n    }\n\n    this.responseStream.unpipe(this.consumer);\n    this.consumer.unpipe(this);\n    this.responseStream.destroy();\n    this.clear();\n  }\n\n  /**\n   * Override the Writable write() method in order to save the last image and\n   * log the number of images we have received\n   * @override\n   * @param {Buffer} data - binary data streamed from the MJpeg consumer\n   */\n  write (data) {\n    this.lastChunk = data;\n    this.updateCount++;\n\n    if (this.registerStartSuccess) {\n      this.registerStartSuccess();\n      this.registerStartSuccess = null;\n    }\n\n    return true;\n  }\n}\n\nexport { MJpegStream };\n"]}

package/build/lib/mkdirp.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export const mkdirp: (dir: import("fs").PathLike) => Promise<string | undefined>;
+//# sourceMappingURL=mkdirp.d.ts.map

package/build/lib/mkdirp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mkdirp.d.ts","sourceRoot":"","sources":["../../lib/mkdirp.js"],"names":[],"mappings":""}

package/build/lib/mkdirp.js

@@ -1,20 +1,16 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "mkdirp", {
-  enumerable: true,
-  get: function () {
-    return _mkdirp.default;
-  }
-});
+exports.mkdirp = void 0;
 
 require("source-map-support/register");
 
-var _mkdirp = _interopRequireDefault(require("mkdirp"));require('source-map-support').install();
-
+var _fs = require("./fs");
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9ta2RpcnAuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IG1rZGlycCBmcm9tICdta2RpcnAnO1xuXG4vKipcbiAqIFRPRE86IG9uY2Ugd2UgZHJvcCBzdXBwb3J0IGZvciBOb2RlIDEwLCB0aGlzIHNob3VsZCBiZSByZW1vdmVkIGluIGZhdm9yXG4gKiBvZiBmcy5ta2RpcihkaXIsIHtyZWN1cnNpdmU6IHRydWV9KTtcbiAqL1xuXG5cbmV4cG9ydCB7IG1rZGlycCB9O1xuIl0sImZpbGUiOiJsaWIvbWtkaXJwLmpzIiwic291cmNlUm9vdCI6Ii4uLy4uIn0=
+const {
+  mkdirp
+} = _fs.fs;
+exports.mkdirp = mkdirp;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9ta2RpcnAuanMiXSwibmFtZXMiOlsibWtkaXJwIiwiZnMiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBOztBQUlBLE1BQU07QUFBRUEsRUFBQUE7QUFBRixJQUFhQyxNQUFuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGZzIH0gZnJvbSAnLi9mcyc7XG4vKipcbiAqIEBkZXByZWNhdGVkIFVzZSBgZnMubWtkaXJwYCBpbnN0ZWFkLlxuICovXG5jb25zdCB7IG1rZGlycCB9ID0gZnM7XG5leHBvcnQgeyBta2RpcnAgfTtcbiJdfQ==