@appium/base-driver 8.2.4 → 8.4.0

package/build/lib/basedriver/commands/timeout.js

@@ -5,12 +5,10 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.helpers = exports.default = exports.commands = void 0;
+exports.TimeoutMixin = TimeoutMixin;
 
 require("source-map-support/register");
 
-var _logger = _interopRequireDefault(require("../logger"));
-
 var _asyncbox = require("asyncbox");
 
 var _lodash = _interopRequireDefault(require("lodash"));
@@ -19,178 +17,154 @@ var _support = require("@appium/support");
 
 var _protocol = require("../../protocol");
 
-let commands = {},
-    helpers = {},
-    extensions = {};
-exports.helpers = helpers;
-exports.commands = commands;
 const MIN_TIMEOUT = 0;
 
-commands.timeouts = async function timeouts(type, ms, script, pageLoad, implicit) {
-  if (_support.util.hasValue(type) && _support.util.hasValue(ms)) {
-    _logger.default.debug(`MJSONWP timeout arguments: ${JSON.stringify({
-      type,
-      ms
-    })}}`);
-
-    switch (type) {
-      case 'command':
-        await this.newCommandTimeout(ms);
-        return;
+function TimeoutMixin(Base) {
+  class TimeoutCommands extends Base {
+    async timeouts(type, ms, script, pageLoad, implicit) {
+      if (_support.util.hasValue(type) && _support.util.hasValue(ms)) {
+        this.log.debug(`MJSONWP timeout arguments: ${JSON.stringify({
+          type,
+          ms
+        })}}`);
+
+        switch (type) {
+          case 'command':
+            await this.newCommandTimeout(ms);
+            return;
+
+          case 'implicit':
+            await this.implicitWaitMJSONWP(ms);
+            return;
+
+          case 'page load':
+            await this.pageLoadTimeoutMJSONWP(ms);
+            return;
+
+          case 'script':
+            await this.scriptTimeoutMJSONWP(ms);
+            return;
+
+          default:
+            throw new Error(`'${type}' type is not supported for MJSONWP timeout`);
+        }
+      }
 
-      case 'implicit':
-        await this.implicitWaitMJSONWP(ms);
-        return;
+      this.log.debug(`W3C timeout argument: ${JSON.stringify({
+        script,
+        pageLoad,
+        implicit
+      })}}`);
 
-      case 'page load':
-        await this.pageLoadTimeoutMJSONWP(ms);
-        return;
+      if (_support.util.hasValue(script)) {
+        await this.scriptTimeoutW3C(script);
+      }
 
-      case 'script':
-        await this.scriptTimeoutMJSONWP(ms);
-        return;
+      if (_support.util.hasValue(pageLoad)) {
+        await this.pageLoadTimeoutW3C(pageLoad);
+      }
 
-      default:
-        throw new Error(`'${type}' type is not supported for MJSONWP timeout`);
+      if (_support.util.hasValue(implicit)) {
+        await this.implicitWaitW3C(implicit);
+      }
     }
-  }
 
-  _logger.default.debug(`W3C timeout argument: ${JSON.stringify({
-    script,
-    pageLoad,
-    implicit
-  })}}`);
+    async getTimeouts() {
+      return {
+        command: this.newCommandTimeoutMs,
+        implicit: this.implicitWaitMs
+      };
+    }
 
-  if (_support.util.hasValue(script)) {
-    await this.scriptTimeoutW3C(script);
-  }
+    async implicitWaitW3C(ms) {
+      await this.implicitWait(ms);
+    }
 
-  if (_support.util.hasValue(pageLoad)) {
-    await this.pageLoadTimeoutW3C(pageLoad);
-  }
+    async implicitWaitMJSONWP(ms) {
+      await this.implicitWait(ms);
+    }
 
-  if (_support.util.hasValue(implicit)) {
-    await this.implicitWaitW3C(implicit);
-  }
-};
+    async implicitWait(ms) {
+      await this.setImplicitWait(this.parseTimeoutArgument(ms));
+    }
 
-commands.getTimeouts = async function getTimeouts() {
-  return {
-    command: this.newCommandTimeoutMs,
-    implicit: this.implicitWaitMs
-  };
-};
+    async pageLoadTimeoutW3C(ms) {
+      throw new _protocol.errors.NotImplementedError('Not implemented yet for pageLoad.');
+    }
 
-commands.implicitWaitW3C = async function implicitWaitW3C(ms) {
-  await this.implicitWait(ms);
-};
+    async pageLoadTimeoutMJSONWP(ms) {
+      throw new _protocol.errors.NotImplementedError('Not implemented yet for pageLoad.');
+    }
 
-commands.implicitWaitMJSONWP = async function implicitWaitMJSONWP(ms) {
-  await this.implicitWait(ms);
-};
+    async scriptTimeoutW3C(ms) {
+      throw new _protocol.errors.NotImplementedError('Not implemented yet for script.');
+    }
 
-commands.implicitWait = async function implicitWait(ms) {
-  await this.setImplicitWait(this.parseTimeoutArgument(ms));
-};
+    async scriptTimeoutMJSONWP(ms) {
+      throw new _protocol.errors.NotImplementedError('Not implemented yet for script.');
+    }
 
-helpers.setImplicitWait = function setImplicitWait(ms) {
-  this.implicitWaitMs = ms;
+    async newCommandTimeout(ms) {
+      this.setNewCommandTimeout(this.parseTimeoutArgument(ms));
+    }
 
-  _logger.default.debug(`Set implicit wait to ${ms}ms`);
+    setImplicitWait(ms) {
+      this.implicitWaitMs = ms;
+      this.log.debug(`Set implicit wait to ${ms}ms`);
 
-  if (this.managedDrivers && this.managedDrivers.length) {
-    _logger.default.debug('Setting implicit wait on managed drivers');
+      if (this.managedDrivers && this.managedDrivers.length) {
+        this.log.debug('Setting implicit wait on managed drivers');
 
-    for (let driver of this.managedDrivers) {
-      if (_lodash.default.isFunction(driver.setImplicitWait)) {
-        driver.setImplicitWait(ms);
+        for (let driver of this.managedDrivers) {
+          if (_lodash.default.isFunction(driver.setImplicitWait)) {
+            driver.setImplicitWait(ms);
+          }
+        }
       }
     }
-  }
-};
-
-commands.pageLoadTimeoutW3C = async function pageLoadTimeoutW3C(ms) {
-  throw new _protocol.errors.NotImplementedError('Not implemented yet for pageLoad.');
-};
 
-commands.pageLoadTimeoutMJSONWP = async function pageLoadTimeoutMJSONWP(ms) {
-  throw new _protocol.errors.NotImplementedError('Not implemented yet for pageLoad.');
-};
+    setNewCommandTimeout(ms) {
+      this.newCommandTimeoutMs = ms;
+      this.log.debug(`Set new command timeout to ${ms}ms`);
 
-commands.scriptTimeoutW3C = async function scriptTimeoutW3C(ms) {
-  throw new _protocol.errors.NotImplementedError('Not implemented yet for script.');
-};
+      if (this.managedDrivers && this.managedDrivers.length) {
+        this.log.debug('Setting new command timeout on managed drivers');
 
-commands.scriptTimeoutMJSONWP = async function scriptTimeoutMJSONWP(ms) {
-  throw new _protocol.errors.NotImplementedError('Not implemented yet for script.');
-};
+        for (let driver of this.managedDrivers) {
+          if (_lodash.default.isFunction(driver.setNewCommandTimeout)) {
+            driver.setNewCommandTimeout(ms);
+          }
+        }
+      }
+    }
 
-commands.newCommandTimeout = async function newCommandTimeout(ms) {
-  this.setNewCommandTimeout(this.parseTimeoutArgument(ms));
-};
+    async implicitWaitForCondition(condFn) {
+      this.log.debug(`Waiting up to ${this.implicitWaitMs} ms for condition`);
 
-helpers.setNewCommandTimeout = function setNewCommandTimeout(ms) {
-  this.newCommandTimeoutMs = ms;
+      let wrappedCondFn = async (...args) => {
+        await this.clearNewCommandTimeout();
+        return await condFn(...args);
+      };
 
-  _logger.default.debug(`Set new command timeout to ${ms}ms`);
+      return await (0, _asyncbox.waitForCondition)(wrappedCondFn, {
+        waitMs: this.implicitWaitMs,
+        intervalMs: 500,
+        logger: this.log
+      });
+    }
 
-  if (this.managedDrivers && this.managedDrivers.length) {
-    _logger.default.debug('Setting new command timeout on managed drivers');
+    parseTimeoutArgument(ms) {
+      let duration = parseInt(ms, 10);
 
-    for (let driver of this.managedDrivers) {
-      if (_lodash.default.isFunction(driver.setNewCommandTimeout)) {
-        driver.setNewCommandTimeout(ms);
+      if (_lodash.default.isNaN(duration) || duration < MIN_TIMEOUT) {
+        throw new _protocol.errors.UnknownError(`Invalid timeout value '${ms}'`);
       }
+
+      return duration;
     }
-  }
-};
 
-helpers.clearNewCommandTimeout = function clearNewCommandTimeout() {
-  if (this.noCommandTimer) {
-    clearTimeout(this.noCommandTimer);
-    this.noCommandTimer = null;
-  }
-};
-
-helpers.startNewCommandTimeout = function startNewCommandTimeout() {
-  this.clearNewCommandTimeout();
-  if (!this.newCommandTimeoutMs) return;
-  this.noCommandTimer = setTimeout(async () => {
-    _logger.default.warn(`Shutting down because we waited ` + `${this.newCommandTimeoutMs / 1000.0} seconds for a command`);
-
-    const errorMessage = `New Command Timeout of ` + `${this.newCommandTimeoutMs / 1000.0} seconds ` + `expired. Try customizing the timeout using the ` + `'newCommandTimeout' desired capability`;
-    await this.startUnexpectedShutdown(new Error(errorMessage));
-  }, this.newCommandTimeoutMs);
-};
-
-helpers.implicitWaitForCondition = async function implicitWaitForCondition(condFn) {
-  _logger.default.debug(`Waiting up to ${this.implicitWaitMs} ms for condition`);
-
-  let wrappedCondFn = async (...args) => {
-    this.clearNewCommandTimeout();
-    return await condFn(...args);
-  };
-
-  return await (0, _asyncbox.waitForCondition)(wrappedCondFn, {
-    waitMs: this.implicitWaitMs,
-    intervalMs: 500,
-    logger: _logger.default
-  });
-};
-
-helpers.parseTimeoutArgument = function parseTimeoutArgument(ms) {
-  let duration = parseInt(ms, 10);
-
-  if (_lodash.default.isNaN(duration) || duration < MIN_TIMEOUT) {
-    throw new _protocol.errors.UnknownError(`Invalid timeout value '${ms}'`);
   }
 
-  return duration;
-};
-
-Object.assign(extensions, commands, helpers);
-var _default = extensions;
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/basedriver/commands/timeout.js"],"names":["commands","helpers","extensions","MIN_TIMEOUT","timeouts","type","ms","script","pageLoad","implicit","util","hasValue","log","debug","JSON","stringify","newCommandTimeout","implicitWaitMJSONWP","pageLoadTimeoutMJSONWP","scriptTimeoutMJSONWP","Error","scriptTimeoutW3C","pageLoadTimeoutW3C","implicitWaitW3C","getTimeouts","command","newCommandTimeoutMs","implicitWaitMs","implicitWait","setImplicitWait","parseTimeoutArgument","managedDrivers","length","driver","_","isFunction","errors","NotImplementedError","setNewCommandTimeout","clearNewCommandTimeout","noCommandTimer","clearTimeout","startNewCommandTimeout","setTimeout","warn","errorMessage","startUnexpectedShutdown","implicitWaitForCondition","condFn","wrappedCondFn","args","waitMs","intervalMs","logger","duration","parseInt","isNaN","UnknownError","Object","assign"],"mappings":"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","sourcesContent":["import log from '../logger';\nimport { waitForCondition } from 'asyncbox';\nimport _ from 'lodash';\nimport { util } from '@appium/support';\nimport { errors } from '../../protocol';\n\n\nlet commands = {}, helpers = {}, extensions = {};\n\nconst MIN_TIMEOUT = 0;\n\ncommands.timeouts = async function timeouts (type, ms, script, pageLoad, implicit) {\n  if (util.hasValue(type) && util.hasValue(ms)) {\n    log.debug(`MJSONWP timeout arguments: ${JSON.stringify({type, ms})}}`);\n\n    switch (type) {\n      case 'command':\n        await this.newCommandTimeout(ms);\n        return;\n      case 'implicit':\n        await this.implicitWaitMJSONWP(ms);\n        return;\n      case 'page load':\n        await this.pageLoadTimeoutMJSONWP(ms);\n        return;\n      case 'script':\n        await this.scriptTimeoutMJSONWP(ms);\n        return;\n      default:\n        throw new Error(`'${type}' type is not supported for MJSONWP timeout`);\n    }\n  }\n\n  // Otherwise assume it is W3C protocol\n  log.debug(`W3C timeout argument: ${JSON.stringify({script, pageLoad, implicit})}}`);\n  if (util.hasValue(script)) {\n    await this.scriptTimeoutW3C(script);\n  }\n  if (util.hasValue(pageLoad)) {\n    await this.pageLoadTimeoutW3C(pageLoad);\n  }\n  if (util.hasValue(implicit)) {\n    await this.implicitWaitW3C(implicit);\n  }\n};\n\ncommands.getTimeouts = async function getTimeouts () { // eslint-disable-line require-await\n  return {\n    command: this.newCommandTimeoutMs,\n    implicit: this.implicitWaitMs,\n  };\n};\n\n// implicit\ncommands.implicitWaitW3C = async function implicitWaitW3C (ms) {\n  await this.implicitWait(ms);\n};\n\ncommands.implicitWaitMJSONWP = async function implicitWaitMJSONWP (ms) {\n  await this.implicitWait(ms);\n};\n\ncommands.implicitWait = async function implicitWait (ms) {\n  await this.setImplicitWait(this.parseTimeoutArgument(ms));\n};\n\nhelpers.setImplicitWait = function setImplicitWait (ms) { // eslint-disable-line require-await\n  this.implicitWaitMs = ms;\n  log.debug(`Set implicit wait to ${ms}ms`);\n  if (this.managedDrivers && this.managedDrivers.length) {\n    log.debug('Setting implicit wait on managed drivers');\n    for (let driver of this.managedDrivers) {\n      if (_.isFunction(driver.setImplicitWait)) {\n        driver.setImplicitWait(ms);\n      }\n    }\n  }\n};\n\n// pageLoad\n// eslint-disable-next-line no-unused-vars\ncommands.pageLoadTimeoutW3C = async function pageLoadTimeoutW3C (ms) { // eslint-disable-line require-await\n  throw new errors.NotImplementedError('Not implemented yet for pageLoad.');\n};\n\n// eslint-disable-next-line no-unused-vars\ncommands.pageLoadTimeoutMJSONWP = async function pageLoadTimeoutMJSONWP (ms) { // eslint-disable-line require-await\n  throw new errors.NotImplementedError('Not implemented yet for pageLoad.');\n};\n\n// script\n// eslint-disable-next-line no-unused-vars\ncommands.scriptTimeoutW3C = async function scriptTimeoutW3C (ms) { // eslint-disable-line require-await\n  throw new errors.NotImplementedError('Not implemented yet for script.');\n};\n\n// eslint-disable-next-line no-unused-vars\ncommands.scriptTimeoutMJSONWP = async function scriptTimeoutMJSONWP (ms) { // eslint-disable-line require-await\n  throw new errors.NotImplementedError('Not implemented yet for script.');\n};\n\n// command\ncommands.newCommandTimeout = async function newCommandTimeout (ms) { // eslint-disable-line require-await\n  this.setNewCommandTimeout(this.parseTimeoutArgument(ms));\n};\n\nhelpers.setNewCommandTimeout = function setNewCommandTimeout (ms) {\n  this.newCommandTimeoutMs = ms;\n  log.debug(`Set new command timeout to ${ms}ms`);\n  if (this.managedDrivers && this.managedDrivers.length) {\n    log.debug('Setting new command timeout on managed drivers');\n    for (let driver of this.managedDrivers) {\n      if (_.isFunction(driver.setNewCommandTimeout)) {\n        driver.setNewCommandTimeout(ms);\n      }\n    }\n  }\n};\n\nhelpers.clearNewCommandTimeout = function clearNewCommandTimeout () {\n  if (this.noCommandTimer) {\n    clearTimeout(this.noCommandTimer);\n    this.noCommandTimer = null;\n  }\n};\n\nhelpers.startNewCommandTimeout = function startNewCommandTimeout () {\n  // make sure there are no rogue timeouts\n  this.clearNewCommandTimeout();\n\n  // if command timeout is 0, it is disabled\n  if (!this.newCommandTimeoutMs) return; // eslint-disable-line curly\n\n  this.noCommandTimer = setTimeout(async () => {\n    log.warn(`Shutting down because we waited ` +\n              `${this.newCommandTimeoutMs / 1000.0} seconds for a command`);\n    const errorMessage = `New Command Timeout of ` +\n              `${this.newCommandTimeoutMs / 1000.0} seconds ` +\n              `expired. Try customizing the timeout using the ` +\n              `'newCommandTimeout' desired capability`;\n    await this.startUnexpectedShutdown(new Error(errorMessage));\n  }, this.newCommandTimeoutMs);\n};\n\nhelpers.implicitWaitForCondition = async function implicitWaitForCondition (condFn) {\n  log.debug(`Waiting up to ${this.implicitWaitMs} ms for condition`);\n  let wrappedCondFn = async (...args) => {\n    // reset command timeout\n    this.clearNewCommandTimeout();\n\n    return await condFn(...args);\n  };\n  return await waitForCondition(wrappedCondFn, {\n    waitMs: this.implicitWaitMs, intervalMs: 500, logger: log\n  });\n};\n\nhelpers.parseTimeoutArgument = function parseTimeoutArgument (ms) {\n  let duration = parseInt(ms, 10);\n  if (_.isNaN(duration) || duration < MIN_TIMEOUT) {\n    throw new errors.UnknownError(`Invalid timeout value '${ms}'`);\n  }\n  return duration;\n};\n\nObject.assign(extensions, commands, helpers);\nexport { commands, helpers };\nexport default extensions;\n"],"file":"lib/basedriver/commands/timeout.js","sourceRoot":"../../../.."}
+  return TimeoutCommands;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../lib/basedriver/commands/timeout.js"],"names":["MIN_TIMEOUT","TimeoutMixin","Base","TimeoutCommands","timeouts","type","ms","script","pageLoad","implicit","util","hasValue","log","debug","JSON","stringify","newCommandTimeout","implicitWaitMJSONWP","pageLoadTimeoutMJSONWP","scriptTimeoutMJSONWP","Error","scriptTimeoutW3C","pageLoadTimeoutW3C","implicitWaitW3C","getTimeouts","command","newCommandTimeoutMs","implicitWaitMs","implicitWait","setImplicitWait","parseTimeoutArgument","errors","NotImplementedError","setNewCommandTimeout","managedDrivers","length","driver","_","isFunction","implicitWaitForCondition","condFn","wrappedCondFn","args","clearNewCommandTimeout","waitMs","intervalMs","logger","duration","parseInt","isNaN","UnknownError"],"mappings":"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","sourcesContent":["// @ts-check\n\n/* eslint-disable no-unused-vars */\n/* eslint-disable require-await */\nimport {waitForCondition} from 'asyncbox';\nimport _ from 'lodash';\nimport {util} from '@appium/support';\nimport {errors} from '../../protocol';\n\nconst MIN_TIMEOUT = 0;\n\n/**\n * @param {import('../driver').BaseDriverBase} Base\n * @returns {TimeoutBase}\n */\nexport function TimeoutMixin (Base) {\n\n  /**\n   * @implements {ITimeoutCommands}\n   */\n  class TimeoutCommands extends Base {\n    async timeouts (type, ms, script, pageLoad, implicit) {\n      if (util.hasValue(type) && util.hasValue(ms)) {\n        this.log.debug(\n          `MJSONWP timeout arguments: ${JSON.stringify({type, ms})}}`,\n        );\n\n        switch (type) {\n          case 'command':\n            await this.newCommandTimeout(ms);\n            return;\n          case 'implicit':\n            await this.implicitWaitMJSONWP(ms);\n            return;\n          case 'page load':\n            await this.pageLoadTimeoutMJSONWP(ms);\n            return;\n          case 'script':\n            await this.scriptTimeoutMJSONWP(ms);\n            return;\n          default:\n            throw new Error(\n              `'${type}' type is not supported for MJSONWP timeout`,\n            );\n        }\n      }\n\n      // Otherwise assume it is W3C protocol\n      this.log.debug(\n        `W3C timeout argument: ${JSON.stringify({\n          script,\n          pageLoad,\n          implicit,\n        })}}`,\n      );\n      if (util.hasValue(script)) {\n        await this.scriptTimeoutW3C(script);\n      }\n      if (util.hasValue(pageLoad)) {\n        await this.pageLoadTimeoutW3C(pageLoad);\n      }\n      if (util.hasValue(implicit)) {\n        await this.implicitWaitW3C(implicit);\n      }\n    }\n\n    async getTimeouts () {\n      return {\n        command: this.newCommandTimeoutMs,\n        implicit: this.implicitWaitMs,\n      };\n    }\n\n    // implicit\n    async implicitWaitW3C (ms) {\n      await this.implicitWait(ms);\n    }\n\n    async implicitWaitMJSONWP (ms) {\n      await this.implicitWait(ms);\n    }\n\n    async implicitWait (ms) {\n      await this.setImplicitWait(this.parseTimeoutArgument(ms));\n    }\n\n    // pageLoad\n    async pageLoadTimeoutW3C (ms) {\n      throw new errors.NotImplementedError('Not implemented yet for pageLoad.');\n    }\n\n    async pageLoadTimeoutMJSONWP (ms) {\n      throw new errors.NotImplementedError('Not implemented yet for pageLoad.');\n    }\n\n    // script\n    async scriptTimeoutW3C (ms) {\n      throw new errors.NotImplementedError('Not implemented yet for script.');\n    }\n\n    async scriptTimeoutMJSONWP (ms) {\n      throw new errors.NotImplementedError('Not implemented yet for script.');\n    }\n\n    // command\n    async newCommandTimeout (ms) {\n      this.setNewCommandTimeout(this.parseTimeoutArgument(ms));\n    }\n\n    setImplicitWait (ms) {\n      // eslint-disable-line require-await\n      this.implicitWaitMs = ms;\n      this.log.debug(`Set implicit wait to ${ms}ms`);\n      if (this.managedDrivers && this.managedDrivers.length) {\n        this.log.debug('Setting implicit wait on managed drivers');\n        for (let driver of this.managedDrivers) {\n          if (_.isFunction(driver.setImplicitWait)) {\n            driver.setImplicitWait(ms);\n          }\n        }\n      }\n    }\n\n    setNewCommandTimeout (ms) {\n      this.newCommandTimeoutMs = ms;\n      this.log.debug(`Set new command timeout to ${ms}ms`);\n      if (this.managedDrivers && this.managedDrivers.length) {\n        this.log.debug('Setting new command timeout on managed drivers');\n        for (let driver of this.managedDrivers) {\n          if (_.isFunction(driver.setNewCommandTimeout)) {\n            driver.setNewCommandTimeout(ms);\n          }\n        }\n      }\n    }\n\n    async implicitWaitForCondition (condFn) {\n      this.log.debug(`Waiting up to ${this.implicitWaitMs} ms for condition`);\n      let wrappedCondFn = async (...args) => {\n        // reset command timeout\n        await this.clearNewCommandTimeout();\n\n        return await condFn(...args);\n      };\n      return await waitForCondition(wrappedCondFn, {\n        waitMs: this.implicitWaitMs,\n        intervalMs: 500,\n        logger: this.log,\n      });\n    }\n\n    parseTimeoutArgument (ms) {\n      let duration = parseInt(ms, 10);\n      if (_.isNaN(duration) || duration < MIN_TIMEOUT) {\n        throw new errors.UnknownError(`Invalid timeout value '${ms}'`);\n      }\n      return duration;\n    }\n  }\n\n  return TimeoutCommands;\n}\n\n/**\n * @typedef {import('@appium/types').TimeoutCommands} ITimeoutCommands\n * @typedef {import('../driver').BaseDriverBase<ITimeoutCommands>} TimeoutBase\n */\n"]}

package/build/lib/basedriver/core.d.ts

@@ -0,0 +1,235 @@
+export type Capabilities = import('@appium/types').Capabilities;
+export type W3CCapabilities = import('@appium/types').W3CCapabilities;
+export type Driver = import('@appium/types').Driver;
+export type Core = import('@appium/types').Core;
+export type DriverOpts = import('@appium/types').DriverOpts;
+export type EventHistory = import('@appium/types').EventHistory;
+export type AppiumLogger = import('@appium/types').AppiumLogger;
+/**
+ * @implements {Core}
+ */
+export class DriverCore implements Core {
+    /**
+     * Make the basedriver version available so for any driver which inherits from this package, we
+     * know which version of basedriver it inherited from
+     */
+    static baseVersion: any;
+    constructor(opts?: import("@appium/types").DriverOpts, shouldValidateCaps?: boolean);
+    /**
+    * @type {string?}
+    */
+    sessionId: string | null;
+    /**
+    * @type {DriverOpts & Capabilities}
+    */
+    opts: import("@appium/types").DriverOpts & Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumCapabilities & {
+        [x: string]: any;
+    }>;
+    /**
+    * @type {DriverOpts}
+    */
+    initialOpts: DriverOpts;
+    /**
+    * @type {Capabilities}
+    */
+    caps: Capabilities;
+    /**
+    * @type {W3CCapabilities}
+    */
+    originalCaps: W3CCapabilities;
+    helpers: import("@appium/types").DriverHelpers;
+    /**
+    * basePath is used for several purposes, for example in setting up
+    * proxying to other drivers, since we need to know what the base path
+    * of any incoming request might look like. We set it to the default
+    * initially but it is automatically updated during any actual program
+    * execution by the routeConfiguringFunction, which is necessarily run as
+    * the entrypoint for any Appium server
+    */
+    basePath: string;
+    relaxedSecurityEnabled: boolean;
+    /** @type {string[]} */
+    allowInsecure: string[];
+    /** @type {string[]} */
+    denyInsecure: string[];
+    newCommandTimeoutMs: number;
+    implicitWaitMs: number;
+    /** @type {string[]} */
+    locatorStrategies: string[];
+    /** @type {string[]} */
+    webLocatorStrategies: string[];
+    /** @type {Driver[]} */
+    managedDrivers: Driver[];
+    /** @type {NodeJS.Timeout?} */
+    noCommandTimer: NodeJS.Timeout | null;
+    /** @type {EventHistory} */
+    _eventHistory: EventHistory;
+    _constraints: import("@appium/types").Constraints;
+    /** @type {NodeJS.EventEmitter} */
+    eventEmitter: NodeJS.EventEmitter;
+    /**
+    * @type {AppiumLogger}
+    */
+    _log: AppiumLogger;
+    /**
+    * @protected
+    */
+    protected shutdownUnexpectedly: boolean;
+    /**
+    * @type {boolean}
+    * @protected
+    */
+    protected shouldValidateCaps: boolean;
+    /**
+    * @protected
+    */
+    protected commandsQueueGuard: AsyncLock;
+    /**
+    * settings should be instantiated by drivers which extend BaseDriver, but
+    * we set it to an empty DeviceSettings instance here to make sure that the
+    * default settings are applied even if an extending driver doesn't utilize
+    * the settings functionality itself
+    */
+    settings: DeviceSettings<Record<string, unknown>>;
+    get log(): import("@appium/types").AppiumLogger;
+    /**
+    * Set a callback handler if needed to execute a custom piece of code
+    * when the driver is shut down unexpectedly. Multiple calls to this method
+    * will cause the handler to be executed mutiple times
+    *
+    * @param {(...args: any[]) => void} handler The code to be executed on unexpected shutdown.
+    * The function may accept one argument, which is the actual error instance, which
+    * caused the driver to shut down.
+    */
+    onUnexpectedShutdown(handler: (...args: any[]) => void): void;
+    /**
+    * This property is used by AppiumDriver to store the data of the
+    * specific driver sessions. This data can be later used to adjust
+    * properties for driver instances running in parallel.
+    * Override it in inherited driver classes if necessary.
+    *
+    * @return {Record<string,unknown>} Driver properties mapping
+    */
+    get driverData(): Record<string, unknown>;
+    /**
+    * This property controls the way {#executeCommand} method
+    * handles new driver commands received from the client.
+    * Override it for inherited classes only in special cases.
+    *
+    * @return {boolean} If the returned value is true (default) then all the commands
+    *   received by the particular driver instance are going to be put into the queue,
+    *   so each following command will not be executed until the previous command
+    *   execution is completed. False value disables that queue, so each driver command
+    *   is executed independently and does not wait for anything.
+    */
+    get isCommandsQueueEnabled(): boolean;
+    get eventHistory(): import("@appium/types").EventHistory;
+    /**
+    * API method for driver developers to log timings for important events
+    * @param {string} eventName
+    */
+    logEvent(eventName: string): void;
+    /**
+    * Overridden in appium driver, but here so that individual drivers can be
+    * tested with clients that poll
+    */
+    getStatus(): Promise<{}>;
+    set desiredCapConstraints(arg: import("@appium/types").Constraints);
+    get desiredCapConstraints(): import("@appium/types").Constraints;
+    /**
+    * method required by MJSONWP in order to determine whether it should
+    * respond with an invalid session response
+    * @param {string} [sessionId]
+    * @returns {boolean}
+    */
+    sessionExists(sessionId?: string | undefined): boolean;
+    /**
+    * method required by MJSONWP in order to determine if the command should
+    * be proxied directly to the driver
+    * @param {string} sessionId
+    * @returns {this | import('@appium/types').Driver}
+    */
+    driverForSession(sessionId: string): import("@appium/types").Driver | DriverCore;
+    /**
+    *
+    * @param {Capabilities} caps
+    */
+    logExtraCaps(caps: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumCapabilities & {
+        [x: string]: any;
+    }>): void;
+    /**
+    *
+    * @param {Capabilities} caps
+    * @returns {boolean}
+    */
+    validateDesiredCaps(caps: Capabilities): boolean;
+    isMjsonwpProtocol(): boolean;
+    isW3CProtocol(): boolean;
+    setProtocolMJSONWP(): void;
+    protocol: string | undefined;
+    setProtocolW3C(): void;
+    /**
+    * Check whether a given feature is enabled via its name
+    *
+    * @param {string} name - name of feature/command
+    *
+    * @returns {Boolean}
+    */
+    isFeatureEnabled(name: string): boolean;
+    /**
+    * Assert that a given feature is enabled and throw a helpful error if it's
+    * not
+    *
+    * @param {string} name - name of feature/command
+    */
+    ensureFeatureEnabled(name: string): void;
+    /**
+    *
+    * @param {string} strategy
+    * @param {boolean} [webContext]
+    */
+    validateLocatorStrategy(strategy: string, webContext?: boolean | undefined): void;
+    /**
+    *
+    * @param {string} [sessionId]
+    * @returns {boolean}
+    */
+    proxyActive(sessionId?: string | undefined): boolean;
+    /**
+    *
+    * @param {string} sessionId
+    * @returns {[string, RegExp][]}
+    */
+    getProxyAvoidList(sessionId: string): [string, RegExp][];
+    /**
+    *
+    * @param {string} [sessionId]
+    * @returns {boolean}
+    */
+    canProxy(sessionId?: string | undefined): boolean;
+    /**
+    * Whether a given command route (expressed as method and url) should not be
+    * proxied according to this driver
+    *
+    * @param {string} sessionId - the current sessionId (in case the driver runs
+    * multiple session ids and requires it). This is not used in this method but
+    * should be made available to overridden methods.
+    * @param {import('@appium/types').HTTPMethod} method - HTTP method of the route
+    * @param {string} url - url of the route
+    * @param {any} [body] - webdriver request body
+    *
+    * @returns {boolean} - whether the route should be avoided
+    */
+    proxyRouteIsAvoided(sessionId: string, method: import('@appium/types').HTTPMethod, url: string, body?: any): boolean;
+    /**
+    *
+    * @param {Driver} driver
+    */
+    addManagedDriver(driver: Driver): void;
+    getManagedDrivers(): import("@appium/types").Driver[];
+    clearNewCommandTimeout(): Promise<void>;
+}
+import { EventEmitter } from "events";
+import AsyncLock from "async-lock";
+import DeviceSettings from "./device-settings";
+//# sourceMappingURL=core.d.ts.map

package/build/lib/basedriver/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/core.js"],"names":[],"mappings":"2BAyea,OAAO,eAAe,EAAE,YAAY;8BACpC,OAAO,eAAe,EAAE,eAAe;qBACvC,OAAO,eAAe,EAAE,MAAM;mBAC9B,OAAO,eAAe,EAAE,IAAI;yBAC5B,OAAO,eAAe,EAAE,UAAU;2BAClC,OAAO,eAAe,EAAE,YAAY;2BACpC,OAAO,eAAe,EAAE,YAAY;AAzdjD;;GAEG;AACH;IAEE;;;OAGG;IACH,wBAAoC;IAqGpC,qFAqBC;IAxHD;;MAEE;IACF,WAFS,MAAM,QAEE;IAEjB;;MAEE;IACF;;OAAK;IAEL;;MAEE;IACF,aAFS,UAAU,CAEP;IAEZ;;MAEE;IACF,MAFS,YAAY,CAEhB;IAEL;;MAEE;IACF,cAFS,eAAe,CAEX;IAEb,+CAAkB;IAElB;;;;;;;MAOE;IACF,iBAA6B;IAE7B,gCAA+B;IAE/B,uBAAuB;IACvB,eADW,MAAM,EAAE,CACA;IAEnB,uBAAuB;IACvB,cADW,MAAM,EAAE,CACD;IAElB,4BAA6C;IAE7C,uBAAmB;IAEnB,uBAAuB;IACvB,mBADW,MAAM,EAAE,CACI;IAEvB,uBAAuB;IACvB,sBADW,MAAM,EAAE,CACO;IAE1B,uBAAuB;IACvB,gBADW,MAAM,EAAE,CACC;IAEpB,8BAA8B;IAC9B,gBADW,OAAO,OAAO,QACH;IAEtB,2BAA2B;IAC3B,eADW,YAAY,CACQ;IAE/B,kDAAyD;IAGzD,kCAAkC;IAClC,cADW,mBAAmB,CACI;IAElC;;MAEE;IACF,MAFS,YAAY,CAEhB;IAEL;;MAEE;IACF,wCAA6B;IAE7B;;;MAGE;IACF,8BAHS,OAAO,CAGG;IAEnB;;MAEE;IACF,wCAAqC;IAErC;;;;;MAKE;IACF,kDAAgC;IAyBhC,gDAEC;IAED;;;;;;;;MAQE;IACF,wCAJoB,GAAG,EAAE,KAAK,IAAI,QAMjC;IAED;;;;;;;MAOE;IACF,0CAEC;IAED;;;;;;;;;;MAUE;IACF,sCAEC;IAMD,yDAEC;IAED;;;MAGE;IACF,oBAFU,MAAM,QAgBf;IAED;;;MAGE;IACF,yBAEC;IAGD,oEAWC;IAED,iEAEC;IAED;;;;;MAKE;IACF,+CAFY,OAAO,CAKlB;IAED;;;;;MAKE;IACF,4BAHU,MAAM,+CAKf;IAED;;;MAGE;IACF;;cAWC;IAED;;;;MAIE;IACF,0BAHU,YAAY,GACV,OAAO,CAqBlB;IAED,6BAEC;IAED,yBAEC;IAED,2BAEC;IADC,6BAAiC;IAGnC,uBAEC;IAED;;;;;;MAME;IACF,uBAJU,MAAM,WAuBf;IAED;;;;;MAKE;IACF,2BAFU,MAAM,QAYf;IAED;;;;MAIE;IACF,kCAHU,MAAM,0CAoBf;IAED;;;;MAIE;IACF,6CAFY,OAAO,CAIlB;IAED;;;;MAIE;IACF,6BAHU,MAAM,GACJ,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAI7B;IAED;;;;MAIE;IACF,0CAFY,OAAO,CAIlB;IAED;;;;;;;;;;;;MAYE;IACF,+BATU,MAAM,UAGN,OAAO,eAAe,EAAE,UAAU,OAClC,MAAM,SACN,GAAG,GAED,OAAO,CAuBlB;IAED;;;MAGE;IACF,yBAFU,MAAM,QAIf;IAED,sDAEC;IAED,wCAKC;CACF"}