@appium/base-driver 8.3.0 → 8.4.1

package/build/lib/basedriver/core.js

@@ -0,0 +1,283 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DriverCore = void 0;
+
+require("source-map-support/register");
+
+var _support = require("@appium/support");
+
+var _asyncLock = _interopRequireDefault(require("async-lock"));
+
+var _events = require("events");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _os = _interopRequireDefault(require("os"));
+
+var _constants = require("../constants");
+
+var _protocol = require("../protocol");
+
+var _capabilities = require("./capabilities");
+
+var _desiredCaps = require("./desired-caps");
+
+var _deviceSettings = _interopRequireDefault(require("./device-settings"));
+
+var _helpers = _interopRequireDefault(require("./helpers"));
+
+const {
+  version: BASEDRIVER_VER
+} = _support.fs.readPackageJsonFrom(__dirname);
+
+const NEW_COMMAND_TIMEOUT_MS = 60 * 1000;
+const ON_UNEXPECTED_SHUTDOWN_EVENT = 'onUnexpectedShutdown';
+
+class DriverCore {
+  static baseVersion = BASEDRIVER_VER;
+  sessionId = null;
+  opts;
+  initialOpts;
+  caps;
+  originalCaps;
+  helpers = _helpers.default;
+  basePath = _constants.DEFAULT_BASE_PATH;
+  relaxedSecurityEnabled = false;
+  allowInsecure = [];
+  denyInsecure = [];
+  newCommandTimeoutMs = NEW_COMMAND_TIMEOUT_MS;
+  implicitWaitMs = 0;
+  locatorStrategies = [];
+  webLocatorStrategies = [];
+  managedDrivers = [];
+  noCommandTimer = null;
+  _eventHistory = {
+    commands: []
+  };
+  _constraints = _lodash.default.cloneDeep(_desiredCaps.desiredCapabilityConstraints);
+  eventEmitter = new _events.EventEmitter();
+  _log;
+  shutdownUnexpectedly = false;
+  shouldValidateCaps;
+  commandsQueueGuard = new _asyncLock.default();
+  settings = new _deviceSettings.default();
+
+  constructor(opts = {}, shouldValidateCaps = true) {
+    this._log = _support.logger.getLogger(_helpers.default.generateDriverLogPrefix(this));
+    this.opts = opts;
+    this.opts.tmpDir = this.opts.tmpDir || process.env.APPIUM_TMP_DIR || _os.default.tmpdir();
+    this.shouldValidateCaps = shouldValidateCaps;
+    this.initialOpts = _lodash.default.cloneDeep(this.opts);
+    this.sessionId = null;
+  }
+
+  get log() {
+    return this._log;
+  }
+
+  onUnexpectedShutdown(handler) {
+    this.eventEmitter.on(ON_UNEXPECTED_SHUTDOWN_EVENT, handler);
+  }
+
+  get driverData() {
+    return {};
+  }
+
+  get isCommandsQueueEnabled() {
+    return true;
+  }
+
+  get eventHistory() {
+    return _lodash.default.cloneDeep(this._eventHistory);
+  }
+
+  logEvent(eventName) {
+    if (eventName === 'commands') {
+      throw new Error('Cannot log commands directly');
+    }
+
+    if (typeof eventName !== 'string') {
+      throw new Error(`Invalid eventName ${eventName}`);
+    }
+
+    if (!this._eventHistory[eventName]) {
+      this._eventHistory[eventName] = [];
+    }
+
+    const ts = Date.now();
+    const logTime = new Date(ts).toTimeString();
+
+    this._eventHistory[eventName].push(ts);
+
+    this.log.debug(`Event '${eventName}' logged at ${ts} (${logTime})`);
+  }
+
+  async getStatus() {
+    return {};
+  }
+
+  set desiredCapConstraints(constraints) {
+    this._constraints = Object.assign(this._constraints, constraints);
+
+    for (const [, value] of _lodash.default.toPairs(this._constraints)) {
+      if (value && value.presence === true) {
+        value.presence = {
+          allowEmpty: false
+        };
+      }
+    }
+  }
+
+  get desiredCapConstraints() {
+    return this._constraints;
+  }
+
+  sessionExists(sessionId) {
+    if (!sessionId) return false;
+    return sessionId === this.sessionId;
+  }
+
+  driverForSession(sessionId) {
+    return this;
+  }
+
+  logExtraCaps(caps) {
+    let extraCaps = _lodash.default.difference(_lodash.default.keys(caps), _lodash.default.keys(this._constraints));
+
+    if (extraCaps.length) {
+      this.log.warn(`The following capabilities were provided, but are not ` + `recognized by Appium:`);
+
+      for (const cap of extraCaps) {
+        this.log.warn(`  ${cap}`);
+      }
+    }
+  }
+
+  validateDesiredCaps(caps) {
+    if (!this.shouldValidateCaps) {
+      return true;
+    }
+
+    try {
+      (0, _capabilities.validateCaps)(caps, this._constraints);
+    } catch (e) {
+      this.log.errorAndThrow(new _protocol.errors.SessionNotCreatedError(`The desiredCapabilities object was not valid for the ` + `following reason(s): ${e.message}`));
+    }
+
+    this.logExtraCaps(caps);
+    return true;
+  }
+
+  isMjsonwpProtocol() {
+    return this.protocol === _constants.PROTOCOLS.MJSONWP;
+  }
+
+  isW3CProtocol() {
+    return this.protocol === _constants.PROTOCOLS.W3C;
+  }
+
+  setProtocolMJSONWP() {
+    this.protocol = _constants.PROTOCOLS.MJSONWP;
+  }
+
+  setProtocolW3C() {
+    this.protocol = _constants.PROTOCOLS.W3C;
+  }
+
+  isFeatureEnabled(name) {
+    if (this.denyInsecure && _lodash.default.includes(this.denyInsecure, name)) {
+      return false;
+    }
+
+    if (this.allowInsecure && _lodash.default.includes(this.allowInsecure, name)) {
+      return true;
+    }
+
+    if (this.relaxedSecurityEnabled) {
+      return true;
+    }
+
+    return false;
+  }
+
+  ensureFeatureEnabled(name) {
+    if (!this.isFeatureEnabled(name)) {
+      throw new Error(`Potentially insecure feature '${name}' has not been ` + `enabled. If you want to enable this feature and accept ` + `the security ramifications, please do so by following ` + `the documented instructions at https://github.com/appium` + `/appium/blob/master/docs/en/writing-running-appium/security.md`);
+    }
+  }
+
+  validateLocatorStrategy(strategy, webContext = false) {
+    let validStrategies = this.locatorStrategies;
+    this.log.debug(`Valid locator strategies for this request: ${validStrategies.join(', ')}`);
+
+    if (webContext) {
+      validStrategies = validStrategies.concat(this.webLocatorStrategies);
+    }
+
+    if (!_lodash.default.includes(validStrategies, strategy)) {
+      throw new _protocol.errors.InvalidSelectorError(`Locator Strategy '${strategy}' is not supported for this session`);
+    }
+  }
+
+  proxyActive(sessionId) {
+    return false;
+  }
+
+  getProxyAvoidList(sessionId) {
+    return [];
+  }
+
+  canProxy(sessionId) {
+    return false;
+  }
+
+  proxyRouteIsAvoided(sessionId, method, url, body) {
+    for (let avoidSchema of this.getProxyAvoidList(sessionId)) {
+      if (!_lodash.default.isArray(avoidSchema) || avoidSchema.length !== 2) {
+        throw new Error('Proxy avoidance must be a list of pairs');
+      }
+
+      let [avoidMethod, avoidPathRegex] = avoidSchema;
+
+      if (!_lodash.default.includes(['GET', 'POST', 'DELETE'], avoidMethod)) {
+        throw new Error(`Unrecognized proxy avoidance method '${avoidMethod}'`);
+      }
+
+      if (!_lodash.default.isRegExp(avoidPathRegex)) {
+        throw new Error('Proxy avoidance path must be a regular expression');
+      }
+
+      let normalizedUrl = url.replace(new RegExp(`^${_lodash.default.escapeRegExp(this.basePath)}`), '');
+
+      if (avoidMethod === method && avoidPathRegex.test(normalizedUrl)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  addManagedDriver(driver) {
+    this.managedDrivers.push(driver);
+  }
+
+  getManagedDrivers() {
+    return this.managedDrivers;
+  }
+
+  async clearNewCommandTimeout() {
+    if (this.noCommandTimer) {
+      clearTimeout(this.noCommandTimer);
+      this.noCommandTimer = null;
+    }
+  }
+
+}
+
+exports.DriverCore = DriverCore;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/basedriver/core.js"],"names":["version","BASEDRIVER_VER","fs","readPackageJsonFrom","__dirname","NEW_COMMAND_TIMEOUT_MS","ON_UNEXPECTED_SHUTDOWN_EVENT","DriverCore","baseVersion","sessionId","opts","initialOpts","caps","originalCaps","helpers","basePath","DEFAULT_BASE_PATH","relaxedSecurityEnabled","allowInsecure","denyInsecure","newCommandTimeoutMs","implicitWaitMs","locatorStrategies","webLocatorStrategies","managedDrivers","noCommandTimer","_eventHistory","commands","_constraints","_","cloneDeep","desiredCapabilityConstraints","eventEmitter","EventEmitter","_log","shutdownUnexpectedly","shouldValidateCaps","commandsQueueGuard","AsyncLock","settings","DeviceSettings","constructor","logger","getLogger","generateDriverLogPrefix","tmpDir","process","env","APPIUM_TMP_DIR","os","tmpdir","log","onUnexpectedShutdown","handler","on","driverData","isCommandsQueueEnabled","eventHistory","logEvent","eventName","Error","ts","Date","now","logTime","toTimeString","push","debug","getStatus","desiredCapConstraints","constraints","Object","assign","value","toPairs","presence","allowEmpty","sessionExists","driverForSession","logExtraCaps","extraCaps","difference","keys","length","warn","cap","validateDesiredCaps","e","errorAndThrow","errors","SessionNotCreatedError","message","isMjsonwpProtocol","protocol","PROTOCOLS","MJSONWP","isW3CProtocol","W3C","setProtocolMJSONWP","setProtocolW3C","isFeatureEnabled","name","includes","ensureFeatureEnabled","validateLocatorStrategy","strategy","webContext","validStrategies","join","concat","InvalidSelectorError","proxyActive","getProxyAvoidList","canProxy","proxyRouteIsAvoided","method","url","body","avoidSchema","isArray","avoidMethod","avoidPathRegex","isRegExp","normalizedUrl","replace","RegExp","escapeRegExp","test","addManagedDriver","driver","getManagedDrivers","clearNewCommandTimeout","clearTimeout"],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable no-unused-vars */\n/* eslint-disable require-await */\n\nimport { fs, logger, node } from '@appium/support';\nimport AsyncLock from 'async-lock';\nimport { EventEmitter } from 'events';\nimport _ from 'lodash';\nimport os from 'os';\nimport { DEFAULT_BASE_PATH, PROTOCOLS } from '../constants';\nimport { errors } from '../protocol';\nimport { validateCaps } from './capabilities';\nimport { desiredCapabilityConstraints } from './desired-caps';\nimport DeviceSettings from './device-settings';\nimport helpers from './helpers';\n\n// for compat with running tests transpiled and in-place\nconst {version: BASEDRIVER_VER} = fs.readPackageJsonFrom(__dirname);\n\nconst NEW_COMMAND_TIMEOUT_MS = 60 * 1000;\n\nconst ON_UNEXPECTED_SHUTDOWN_EVENT = 'onUnexpectedShutdown';\n/**\n * @implements {Core}\n */\nclass DriverCore {\n\n  /**\n   * Make the basedriver version available so for any driver which inherits from this package, we\n   * know which version of basedriver it inherited from\n   */\n  static baseVersion = BASEDRIVER_VER;\n\n  /**\n  * @type {string?}\n  */\n  sessionId = null;\n\n  /**\n  * @type {DriverOpts & Capabilities}\n  */\n  opts;\n\n  /**\n  * @type {DriverOpts}\n  */\n  initialOpts;\n\n  /**\n  * @type {Capabilities}\n  */\n  caps;\n\n  /**\n  * @type {W3CCapabilities}\n  */\n  originalCaps;\n\n  helpers = helpers;\n\n  /**\n  * basePath is used for several purposes, for example in setting up\n  * proxying to other drivers, since we need to know what the base path\n  * of any incoming request might look like. We set it to the default\n  * initially but it is automatically updated during any actual program\n  * execution by the routeConfiguringFunction, which is necessarily run as\n  * the entrypoint for any Appium server\n  */\n  basePath = DEFAULT_BASE_PATH;\n\n  relaxedSecurityEnabled = false;\n\n  /** @type {string[]} */\n  allowInsecure = [];\n\n  /** @type {string[]} */\n  denyInsecure = [];\n\n  newCommandTimeoutMs = NEW_COMMAND_TIMEOUT_MS;\n\n  implicitWaitMs = 0;\n\n  /** @type {string[]} */\n  locatorStrategies = [];\n\n  /** @type {string[]} */\n  webLocatorStrategies = [];\n\n  /** @type {Driver[]} */\n  managedDrivers = [];\n\n  /** @type {NodeJS.Timeout?} */\n  noCommandTimer = null;\n\n  /** @type {EventHistory} */\n  _eventHistory = {commands: []};\n\n  _constraints = _.cloneDeep(desiredCapabilityConstraints);\n\n  // used to handle driver events\n  /** @type {NodeJS.EventEmitter} */\n  eventEmitter = new EventEmitter();\n\n  /**\n  * @type {AppiumLogger}\n  */\n  _log;\n\n  /**\n  * @protected\n  */\n  shutdownUnexpectedly = false;\n\n  /**\n  * @type {boolean}\n  * @protected\n  */\n  shouldValidateCaps;\n\n  /**\n  * @protected\n  */\n  commandsQueueGuard = new AsyncLock();\n\n  /**\n  * settings should be instantiated by drivers which extend BaseDriver, but\n  * we set it to an empty DeviceSettings instance here to make sure that the\n  * default settings are applied even if an extending driver doesn't utilize\n  * the settings functionality itself\n  */\n  settings = new DeviceSettings();\n\n  constructor (\n    opts = /** @type {DriverOpts} */ ({}),\n    shouldValidateCaps = true,\n  ) {\n    this._log = logger.getLogger(helpers.generateDriverLogPrefix(this));\n\n    // setup state\n    this.opts = opts;\n\n    // use a custom tmp dir to avoid losing data and app when computer is\n    // restarted\n    this.opts.tmpDir =\n      this.opts.tmpDir || process.env.APPIUM_TMP_DIR || os.tmpdir();\n\n    // base-driver internals\n    this.shouldValidateCaps = shouldValidateCaps;\n\n    // keeping track of initial opts\n    this.initialOpts = _.cloneDeep(this.opts);\n\n    this.sessionId = null;\n  }\n\n  get log () {\n    return this._log;\n  }\n\n  /**\n  * Set a callback handler if needed to execute a custom piece of code\n  * when the driver is shut down unexpectedly. Multiple calls to this method\n  * will cause the handler to be executed mutiple times\n  *\n  * @param {(...args: any[]) => void} handler The code to be executed on unexpected shutdown.\n  * The function may accept one argument, which is the actual error instance, which\n  * caused the driver to shut down.\n  */\n  onUnexpectedShutdown (handler) {\n    this.eventEmitter.on(ON_UNEXPECTED_SHUTDOWN_EVENT, handler);\n  }\n\n  /**\n  * This property is used by AppiumDriver to store the data of the\n  * specific driver sessions. This data can be later used to adjust\n  * properties for driver instances running in parallel.\n  * Override it in inherited driver classes if necessary.\n  *\n  * @return {Record<string,unknown>} Driver properties mapping\n  */\n  get driverData () {\n    return {};\n  }\n\n  /**\n  * This property controls the way {#executeCommand} method\n  * handles new driver commands received from the client.\n  * Override it for inherited classes only in special cases.\n  *\n  * @return {boolean} If the returned value is true (default) then all the commands\n  *   received by the particular driver instance are going to be put into the queue,\n  *   so each following command will not be executed until the previous command\n  *   execution is completed. False value disables that queue, so each driver command\n  *   is executed independently and does not wait for anything.\n  */\n  get isCommandsQueueEnabled () {\n    return true;\n  }\n\n  /*\n  * make eventHistory a property and return a cloned object so a consumer can't\n  * inadvertently change data outside of logEvent\n  */\n  get eventHistory () {\n    return _.cloneDeep(this._eventHistory);\n  }\n\n  /**\n  * API method for driver developers to log timings for important events\n  * @param {string} eventName\n  */\n  logEvent (eventName) {\n    if (eventName === 'commands') {\n      throw new Error('Cannot log commands directly');\n    }\n    if (typeof eventName !== 'string') {\n      throw new Error(`Invalid eventName ${eventName}`);\n    }\n    if (!this._eventHistory[eventName]) {\n      this._eventHistory[eventName] = [];\n    }\n    const ts = Date.now();\n    const logTime = new Date(ts).toTimeString();\n    this._eventHistory[eventName].push(ts);\n    this.log.debug(`Event '${eventName}' logged at ${ts} (${logTime})`);\n  }\n\n  /**\n  * Overridden in appium driver, but here so that individual drivers can be\n  * tested with clients that poll\n  */\n  async getStatus () {\n    return {};\n  }\n\n  // we only want subclasses to ever extend the contraints\n  set desiredCapConstraints (constraints) {\n    this._constraints = Object.assign(this._constraints, constraints);\n    // 'presence' means different things in different versions of the validator,\n    // when we say 'true' we mean that it should not be able to be empty\n    for (const [, value] of _.toPairs(this._constraints)) {\n      if (value && value.presence === true) {\n        value.presence = {\n          allowEmpty: false,\n        };\n      }\n    }\n  }\n\n  get desiredCapConstraints () {\n    return this._constraints;\n  }\n\n  /**\n  * method required by MJSONWP in order to determine whether it should\n  * respond with an invalid session response\n  * @param {string} [sessionId]\n  * @returns {boolean}\n  */\n  sessionExists (sessionId) {\n    if (!sessionId) return false; // eslint-disable-line curly\n    return sessionId === this.sessionId;\n  }\n\n  /**\n  * method required by MJSONWP in order to determine if the command should\n  * be proxied directly to the driver\n  * @param {string} sessionId\n  * @returns {this | import('@appium/types').Driver}\n  */\n  driverForSession (sessionId) {\n    return this;\n  }\n\n  /**\n  *\n  * @param {Capabilities} caps\n  */\n  logExtraCaps (caps) {\n    let extraCaps = _.difference(_.keys(caps), _.keys(this._constraints));\n    if (extraCaps.length) {\n      this.log.warn(\n        `The following capabilities were provided, but are not ` +\n          `recognized by Appium:`,\n      );\n      for (const cap of extraCaps) {\n        this.log.warn(`  ${cap}`);\n      }\n    }\n  }\n\n  /**\n  *\n  * @param {Capabilities} caps\n  * @returns {boolean}\n  */\n  validateDesiredCaps (caps) {\n    if (!this.shouldValidateCaps) {\n      return true;\n    }\n\n    try {\n      validateCaps(caps, this._constraints);\n    } catch (e) {\n      this.log.errorAndThrow(\n        new errors.SessionNotCreatedError(\n          `The desiredCapabilities object was not valid for the ` +\n            `following reason(s): ${e.message}`,\n        ),\n      );\n    }\n\n    this.logExtraCaps(caps);\n\n    return true;\n  }\n\n  isMjsonwpProtocol () {\n    return this.protocol === PROTOCOLS.MJSONWP;\n  }\n\n  isW3CProtocol () {\n    return this.protocol === PROTOCOLS.W3C;\n  }\n\n  setProtocolMJSONWP () {\n    this.protocol = PROTOCOLS.MJSONWP;\n  }\n\n  setProtocolW3C () {\n    this.protocol = PROTOCOLS.W3C;\n  }\n\n  /**\n  * Check whether a given feature is enabled via its name\n  *\n  * @param {string} name - name of feature/command\n  *\n  * @returns {Boolean}\n  */\n  isFeatureEnabled (name) {\n    // if we have explicitly denied this feature, return false immediately\n    if (this.denyInsecure && _.includes(this.denyInsecure, name)) {\n      return false;\n    }\n\n    // if we specifically have allowed the feature, return true\n    if (this.allowInsecure && _.includes(this.allowInsecure, name)) {\n      return true;\n    }\n\n    // otherwise, if we've globally allowed insecure features and not denied\n    // this one, return true\n    if (this.relaxedSecurityEnabled) {\n      return true;\n    }\n\n    // if we haven't allowed anything insecure, then reject\n    return false;\n  }\n\n  /**\n  * Assert that a given feature is enabled and throw a helpful error if it's\n  * not\n  *\n  * @param {string} name - name of feature/command\n  */\n  ensureFeatureEnabled (name) {\n    if (!this.isFeatureEnabled(name)) {\n      throw new Error(\n        `Potentially insecure feature '${name}' has not been ` +\n          `enabled. If you want to enable this feature and accept ` +\n          `the security ramifications, please do so by following ` +\n          `the documented instructions at https://github.com/appium` +\n          `/appium/blob/master/docs/en/writing-running-appium/security.md`,\n      );\n    }\n  }\n\n  /**\n  *\n  * @param {string} strategy\n  * @param {boolean} [webContext]\n  */\n  validateLocatorStrategy (strategy, webContext = false) {\n    let validStrategies = this.locatorStrategies;\n    this.log.debug(\n      `Valid locator strategies for this request: ${validStrategies.join(\n        ', ',\n      )}`,\n    );\n\n    if (webContext) {\n      validStrategies = validStrategies.concat(this.webLocatorStrategies);\n    }\n\n    if (!_.includes(validStrategies, strategy)) {\n      throw new errors.InvalidSelectorError(\n        `Locator Strategy '${strategy}' is not supported for this session`,\n      );\n    }\n  }\n\n  /**\n  *\n  * @param {string} [sessionId]\n  * @returns {boolean}\n  */\n  proxyActive (sessionId) {\n    return false;\n  }\n\n  /**\n  *\n  * @param {string} sessionId\n  * @returns {[string, RegExp][]}\n  */\n  getProxyAvoidList (sessionId) {\n    return [];\n  }\n\n  /**\n  *\n  * @param {string} [sessionId]\n  * @returns {boolean}\n  */\n  canProxy (sessionId) {\n    return false;\n  }\n\n  /**\n  * Whether a given command route (expressed as method and url) should not be\n  * proxied according to this driver\n  *\n  * @param {string} sessionId - the current sessionId (in case the driver runs\n  * multiple session ids and requires it). This is not used in this method but\n  * should be made available to overridden methods.\n  * @param {import('@appium/types').HTTPMethod} method - HTTP method of the route\n  * @param {string} url - url of the route\n  * @param {any} [body] - webdriver request body\n  *\n  * @returns {boolean} - whether the route should be avoided\n  */\n  proxyRouteIsAvoided (sessionId, method, url, body) {\n    for (let avoidSchema of this.getProxyAvoidList(sessionId)) {\n      if (!_.isArray(avoidSchema) || avoidSchema.length !== 2) {\n        throw new Error('Proxy avoidance must be a list of pairs');\n      }\n      let [avoidMethod, avoidPathRegex] = avoidSchema;\n      if (!_.includes(['GET', 'POST', 'DELETE'], avoidMethod)) {\n        throw new Error(`Unrecognized proxy avoidance method '${avoidMethod}'`);\n      }\n      if (!_.isRegExp(avoidPathRegex)) {\n        throw new Error('Proxy avoidance path must be a regular expression');\n      }\n      let normalizedUrl = url.replace(\n        new RegExp(`^${_.escapeRegExp(this.basePath)}`),\n        '',\n      );\n      if (avoidMethod === method && avoidPathRegex.test(normalizedUrl)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n  *\n  * @param {Driver} driver\n  */\n  addManagedDriver (driver) {\n    this.managedDrivers.push(driver);\n  }\n\n  getManagedDrivers () {\n    return this.managedDrivers;\n  }\n\n  async clearNewCommandTimeout () {\n    if (this.noCommandTimer) {\n      clearTimeout(this.noCommandTimer);\n      this.noCommandTimer = null;\n    }\n  }\n}\n\nexport {DriverCore};\n\n/**\n * @typedef {import('@appium/types').Capabilities} Capabilities\n * @typedef {import('@appium/types').W3CCapabilities} W3CCapabilities\n * @typedef {import('@appium/types').Driver} Driver\n * @typedef {import('@appium/types').Core} Core\n * @typedef {import('@appium/types').DriverOpts} DriverOpts\n * @typedef {import('@appium/types').EventHistory} EventHistory\n * @typedef {import('@appium/types').AppiumLogger} AppiumLogger\n */\n"]}

package/build/lib/basedriver/desired-caps.d.ts

@@ -0,0 +1,5 @@
+/** @type {import('@appium/types').Constraints} */
+export let desiredCapabilityConstraints: import('@appium/types').Constraints;
+import validator from "validate.js";
+export { validator };
+//# sourceMappingURL=desired-caps.d.ts.map

package/build/lib/basedriver/desired-caps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"desired-caps.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/desired-caps.js"],"names":[],"mappings":"AAIA,kDAAkD;AAClD,yCADW,OAAO,eAAe,EAAE,WAAW,CAmD5C"}

package/build/lib/basedriver/desired-caps.js

@@ -169,7 +169,5 @@ _validate.default.promise = _bluebird.default;
 
 _validate.default.prettify = function prettify(val) {
   return val;
-};require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/basedriver/desired-caps.js"],"names":["desiredCapabilityConstraints","platformName","presence","isString","deviceName","platformVersion","newCommandTimeout","isNumber","automationName","autoLaunch","isBoolean","udid","orientation","inclusion","autoWebview","noReset","fullReset","language","locale","eventTimings","printPageSourceOnFindFailure","validator","validators","value","isNaN","log","warn","includes","isObject","isArray","Array","deprecated","options","key","inclusionCaseInsensitive","option","toLowerCase","toString","promise","B","prettify","val"],"mappings":"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","sourcesContent":["import log from './logger';\nimport validator from 'validate.js';\nimport B from 'bluebird';\n\n\nlet desiredCapabilityConstraints = {\n  platformName: {\n    presence: true,\n    isString: true,\n  },\n  deviceName: {\n    isString: true\n  },\n  platformVersion: {\n    isString: true\n  },\n  newCommandTimeout: {\n    isNumber: true\n  },\n  automationName: {\n    isString: true\n  },\n  autoLaunch: {\n    isBoolean: true\n  },\n  udid: {\n    isString: true\n  },\n  orientation: {\n    inclusion: [\n      'LANDSCAPE',\n      'PORTRAIT'\n    ]\n  },\n  autoWebview: {\n    isBoolean: true\n  },\n  noReset: {\n    isBoolean: true\n  },\n  fullReset: {\n    isBoolean: true\n  },\n  language: {\n    isString: true\n  },\n  locale: {\n    isString: true\n  },\n  eventTimings: {\n    isBoolean: true\n  },\n  printPageSourceOnFindFailure: {\n    isBoolean: true\n  },\n};\n\nvalidator.validators.isString = function isString (value) {\n  if (typeof value === 'string') {\n    return null;\n  }\n\n  if (typeof value === 'undefined') {\n    return null;\n  }\n\n  return 'must be of type string';\n};\nvalidator.validators.isNumber = function isNumber (value) {\n  if (typeof value === 'number') {\n    return null;\n  }\n\n  if (typeof value === 'undefined') {\n    return null;\n  }\n\n  // allow a string value\n  if (typeof value === 'string' && !isNaN(value)) {\n    log.warn('Number capability passed in as string. Functionality may be compromised.');\n    return null;\n  }\n\n  return 'must be of type number';\n};\nvalidator.validators.isBoolean = function isBoolean (value) {\n  if (typeof value === 'boolean') {\n    return null;\n  }\n\n  // allow a string value\n  if (typeof value === 'string' && ['true', 'false', ''].includes(value)) {\n    return null;\n  }\n\n  if (typeof value === 'undefined') {\n    return null;\n  }\n\n  return 'must be of type boolean';\n};\nvalidator.validators.isObject = function isObject (value) {\n  if (typeof value === 'object') {\n    return null;\n  }\n\n  if (typeof value === 'undefined') {\n    return null;\n  }\n\n  return 'must be of type object';\n};\nvalidator.validators.isArray = function isArray (value) {\n  if (Array.isArray(value)) {\n    return null;\n  }\n\n  if (typeof value === 'undefined') {\n    return null;\n  }\n\n  return 'must be of type array';\n};\nvalidator.validators.deprecated = function deprecated (value, options, key) {\n  if (options) {\n    log.warn(`${key} is a deprecated capability`);\n  }\n  return null;\n};\nvalidator.validators.inclusionCaseInsensitive = function inclusionCaseInsensitive (value, options) {\n  if (typeof value === 'undefined') {\n    return null;\n  } else if (typeof value !== 'string') {\n    return 'unrecognised';\n  }\n  for (let option of options) {\n    if (option.toLowerCase() === value.toLowerCase()) {\n      return null;\n    }\n  }\n  return `${value} not part of ${options.toString()}`;\n};\n\nvalidator.promise = B;\nvalidator.prettify = function prettify (val) {\n  return val;\n};\n\n\nexport { desiredCapabilityConstraints, validator };\n"],"file":"lib/basedriver/desired-caps.js","sourceRoot":"../../.."}
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/basedriver/desired-caps.js"],"names":["desiredCapabilityConstraints","platformName","presence","isString","deviceName","platformVersion","newCommandTimeout","isNumber","automationName","autoLaunch","isBoolean","udid","orientation","inclusion","autoWebview","noReset","fullReset","language","locale","eventTimings","printPageSourceOnFindFailure","validator","validators","value","isNaN","log","warn","includes","isObject","isArray","Array","deprecated","options","key","inclusionCaseInsensitive","option","toLowerCase","toString","promise","B","prettify","val"],"mappings":"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","sourcesContent":["import log from './logger';\nimport validator from 'validate.js';\nimport B from 'bluebird';\n\n/** @type {import('@appium/types').Constraints} */\nlet desiredCapabilityConstraints = {\n  platformName: {\n    presence: true,\n    isString: true,\n  },\n  deviceName: {\n    isString: true\n  },\n  platformVersion: {\n    isString: true\n  },\n  newCommandTimeout: {\n    isNumber: true\n  },\n  automationName: {\n    isString: true\n  },\n  autoLaunch: {\n    isBoolean: true\n  },\n  udid: {\n    isString: true\n  },\n  orientation: {\n    inclusion: [\n      'LANDSCAPE',\n      'PORTRAIT'\n    ]\n  },\n  autoWebview: {\n    isBoolean: true\n  },\n  noReset: {\n    isBoolean: true\n  },\n  fullReset: {\n    isBoolean: true\n  },\n  language: {\n    isString: true\n  },\n  locale: {\n    isString: true\n  },\n  eventTimings: {\n    isBoolean: true\n  },\n  printPageSourceOnFindFailure: {\n    isBoolean: true\n  },\n};\n\nvalidator.validators.isString = function isString (value) {\n  if (typeof value === 'string') {\n    return null;\n  }\n\n  if (typeof value === 'undefined') {\n    return null;\n  }\n\n  return 'must be of type string';\n};\nvalidator.validators.isNumber = function isNumber (value) {\n  if (typeof value === 'number') {\n    return null;\n  }\n\n  if (typeof value === 'undefined') {\n    return null;\n  }\n\n  // allow a string value\n  if (typeof value === 'string' && !isNaN(value)) {\n    log.warn('Number capability passed in as string. Functionality may be compromised.');\n    return null;\n  }\n\n  return 'must be of type number';\n};\nvalidator.validators.isBoolean = function isBoolean (value) {\n  if (typeof value === 'boolean') {\n    return null;\n  }\n\n  // allow a string value\n  if (typeof value === 'string' && ['true', 'false', ''].includes(value)) {\n    return null;\n  }\n\n  if (typeof value === 'undefined') {\n    return null;\n  }\n\n  return 'must be of type boolean';\n};\nvalidator.validators.isObject = function isObject (value) {\n  if (typeof value === 'object') {\n    return null;\n  }\n\n  if (typeof value === 'undefined') {\n    return null;\n  }\n\n  return 'must be of type object';\n};\nvalidator.validators.isArray = function isArray (value) {\n  if (Array.isArray(value)) {\n    return null;\n  }\n\n  if (typeof value === 'undefined') {\n    return null;\n  }\n\n  return 'must be of type array';\n};\nvalidator.validators.deprecated = function deprecated (value, options, key) {\n  if (options) {\n    log.warn(`${key} is a deprecated capability`);\n  }\n  return null;\n};\nvalidator.validators.inclusionCaseInsensitive = function inclusionCaseInsensitive (value, options) {\n  if (typeof value === 'undefined') {\n    return null;\n  } else if (typeof value !== 'string') {\n    return 'unrecognised';\n  }\n  for (let option of options) {\n    if (option.toLowerCase() === value.toLowerCase()) {\n      return null;\n    }\n  }\n  return `${value} not part of ${options.toString()}`;\n};\n\nvalidator.promise = B;\nvalidator.prettify = function prettify (val) {\n  return val;\n};\n\n\nexport { desiredCapabilityConstraints, validator };\n"]}

package/build/lib/basedriver/device-settings.d.ts

@@ -0,0 +1,32 @@
+export default DeviceSettings;
+export type IDeviceSettings<T> = import('@appium/types').DeviceSettings<T>;
+/**
+ * @template {Record<string,unknown>} T
+ * @implements {IDeviceSettings<T>}
+ */
+export class DeviceSettings<T extends Record<string, unknown>> implements IDeviceSettings<T> {
+    /**
+     * `onSettingsUpdate` is _required_ if settings will ever be updated; otherwise
+     * an error will occur at runtime.
+     * @param {T} [defaultSettings]
+     * @param {import('@appium/types').SettingsUpdateListener<T>} [onSettingsUpdate]
+     */
+    constructor(defaultSettings?: T | undefined, onSettingsUpdate?: import("@appium/types").SettingsUpdateListener<T> | undefined);
+    /**
+     * @protected
+     * @type {T}
+     */
+    protected _settings: T;
+    /**
+     * @protected
+     * @type {import('@appium/types').SettingsUpdateListener<T>|undefined}
+     */
+    protected _onSettingsUpdate: import('@appium/types').SettingsUpdateListener<T> | undefined;
+    /**
+     * calls updateSettings from implementing driver every time a setting is changed.
+     * @param {T} newSettings
+     */
+    update(newSettings: T): Promise<void>;
+    getSettings(): T;
+}
+//# sourceMappingURL=device-settings.d.ts.map

package/build/lib/basedriver/device-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-settings.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/device-settings.js"],"names":[],"mappings":";iCAmFa,OAAO,eAAe,EAAE,cAAc,CAAC,CAAC,CAAC;AA1EtD;;;GAGG;AACH,0FAFgC,CAAC;IAgB/B;;;;;OAKG;IACH,+HAGC;IArBD;;;OAGG;IACH,qBAFU,CAAC,CAED;IAEV;;;OAGG;IACH,6BAFU,OAAO,eAAe,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAC,SAAS,CAEnD;IAalB;;;OAGG;IACH,oBAFW,CAAC,iBA+BX;IAED,iBAEC;CACF"}

package/build/lib/basedriver/device-settings.js

@@ -20,9 +20,13 @@ var _errors = require("../protocol/errors");
 const MAX_SETTINGS_SIZE = 20 * 1024 * 1024;
 
 class DeviceSettings {
-  constructor(defaultSettings = {}, onSettingsUpdate = null) {
-    this._settings = Object.assign({}, defaultSettings);
-    this.onSettingsUpdate = onSettingsUpdate;
+  _settings;
+  _onSettingsUpdate;
+
+  constructor(defaultSettings, onSettingsUpdate) {
+    this._settings = { ...(defaultSettings !== null && defaultSettings !== void 0 ? defaultSettings : {})
+    };
+    this._onSettingsUpdate = onSettingsUpdate;
   }
 
   async update(newSettings) {
@@ -36,7 +40,15 @@ class DeviceSettings {
       throw new _errors.errors.InvalidArgumentError(`New settings cannot be applied, because the overall ` + `object size exceeds the allowed limit of ${_support.util.toReadableSizeString(MAX_SETTINGS_SIZE)}`);
     }
 
-    for (const prop of _lodash.default.keys(newSettings)) {
+    if (!_lodash.default.isFunction(this._onSettingsUpdate)) {
+      _logger.default.errorAndThrow(`Unable to update settings; ` + `onSettingsUpdate method not found on '${this.constructor.name}'`);
+
+      return;
+    }
+
+    const props = _lodash.default.keys(newSettings);
+
+    for (const prop of props) {
       if (!_lodash.default.isUndefined(this._settings[prop])) {
         if (this._settings[prop] === newSettings[prop]) {
           _logger.default.debug(`The value of '${prop}' setting did not change. Skipping the update for it`);
@@ -45,12 +57,8 @@ class DeviceSettings {
         }
       }
 
-      if (_lodash.default.isFunction(this.onSettingsUpdate)) {
-        await this.onSettingsUpdate(prop, newSettings[prop], this._settings[prop]);
-        this._settings[prop] = newSettings[prop];
-      } else {
-        _logger.default.errorAndThrow(`Unable to update settings; ` + `onSettingsUpdate method not found on '${this.constructor.name}'`);
-      }
+      await this._onSettingsUpdate(prop, newSettings[prop], this._settings[prop]);
+      this._settings[prop] = newSettings[prop];
     }
   }
 
@@ -62,7 +70,5 @@ class DeviceSettings {
 
 exports.DeviceSettings = DeviceSettings;
 var _default = DeviceSettings;
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9iYXNlZHJpdmVyL2RldmljZS1zZXR0aW5ncy5qcyJdLCJuYW1lcyI6WyJNQVhfU0VUVElOR1NfU0laRSIsIkRldmljZVNldHRpbmdzIiwiX3NldHRpbmdzIiwiX29uU2V0dGluZ3NVcGRhdGUiLCJjb25zdHJ1Y3RvciIsImRlZmF1bHRTZXR0aW5ncyIsIm9uU2V0dGluZ3NVcGRhdGUiLCJ1cGRhdGUiLCJuZXdTZXR0aW5ncyIsIl8iLCJpc1BsYWluT2JqZWN0IiwiZXJyb3JzIiwiSW52YWxpZEFyZ3VtZW50RXJyb3IiLCJKU09OIiwic3RyaW5naWZ5Iiwibm9kZSIsImdldE9iamVjdFNpemUiLCJ1dGlsIiwidG9SZWFkYWJsZVNpemVTdHJpbmciLCJpc0Z1bmN0aW9uIiwibG9nIiwiZXJyb3JBbmRUaHJvdyIsIm5hbWUiLCJwcm9wcyIsImtleXMiLCJwcm9wIiwiaXNVbmRlZmluZWQiLCJkZWJ1ZyIsImdldFNldHRpbmdzIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztBQUVBOztBQUNBOztBQUNBOztBQUNBOztBQUVBLE1BQU1BLGlCQUFpQixHQUFHLEtBQUssSUFBTCxHQUFZLElBQXRDOztBQU1BLE1BQU1DLGNBQU4sQ0FBcUI7QUFNbkJDLEVBQUFBLFNBQVM7QUFNVEMsRUFBQUEsaUJBQWlCOztBQVFqQkMsRUFBQUEsV0FBVyxDQUFFQyxlQUFGLEVBQW1CQyxnQkFBbkIsRUFBcUM7QUFDOUMsU0FBS0osU0FBTCxHQUFrQyxFQUFDLElBQUlHLGVBQUosYUFBSUEsZUFBSixjQUFJQSxlQUFKLEdBQXVCLEVBQXZCO0FBQUQsS0FBbEM7QUFDQSxTQUFLRixpQkFBTCxHQUF5QkcsZ0JBQXpCO0FBQ0Q7O0FBTVcsUUFBTkMsTUFBTSxDQUFFQyxXQUFGLEVBQWU7QUFDekIsUUFBSSxDQUFDQyxnQkFBRUMsYUFBRixDQUFnQkYsV0FBaEIsQ0FBTCxFQUFtQztBQUNqQyxZQUFNLElBQUlHLGVBQU9DLG9CQUFYLENBQWlDLHdEQUFELEdBQ25DLEdBQUVDLElBQUksQ0FBQ0MsU0FBTCxDQUFlTixXQUFmLENBQTRCLFVBRDNCLENBQU47QUFFRDs7QUFFRCxRQUFJTyxjQUFLQyxhQUFMLENBQW1CLEVBQUMsR0FBRyxLQUFLZCxTQUFUO0FBQW9CLFNBQUdNO0FBQXZCLEtBQW5CLEtBQTJEUixpQkFBL0QsRUFBa0Y7QUFDaEYsWUFBTSxJQUFJVyxlQUFPQyxvQkFBWCxDQUFpQyxzREFBRCxHQUNuQyw0Q0FBMkNLLGNBQUtDLG9CQUFMLENBQTBCbEIsaUJBQTFCLENBQTZDLEVBRHJGLENBQU47QUFFRDs7QUFFRCxRQUFJLENBQUNTLGdCQUFFVSxVQUFGLENBQWEsS0FBS2hCLGlCQUFsQixDQUFMLEVBQTJDO0FBQ3pDaUIsc0JBQUlDLGFBQUosQ0FBbUIsNkJBQUQsR0FDakIseUNBQXdDLEtBQUtqQixXQUFMLENBQWlCa0IsSUFBSyxHQUQvRDs7QUFFQTtBQUNEOztBQUVELFVBQU1DLEtBQUssR0FBdUNkLGdCQUFFZSxJQUFGLENBQU9oQixXQUFQLENBQWxEOztBQUNBLFNBQUssTUFBTWlCLElBQVgsSUFBbUJGLEtBQW5CLEVBQTBCO0FBQ3hCLFVBQUksQ0FBQ2QsZ0JBQUVpQixXQUFGLENBQWMsS0FBS3hCLFNBQUwsQ0FBZXVCLElBQWYsQ0FBZCxDQUFMLEVBQTBDO0FBQ3hDLFlBQUksS0FBS3ZCLFNBQUwsQ0FBZXVCLElBQWYsTUFBeUJqQixXQUFXLENBQUNpQixJQUFELENBQXhDLEVBQWdEO0FBQzlDTCwwQkFBSU8sS0FBSixDQUFXLGlCQUFnQkYsSUFBSyxzREFBaEM7O0FBQ0E7QUFDRDtBQUNGOztBQUVELFlBQU0sS0FBS3RCLGlCQUFMLENBQXVCc0IsSUFBdkIsRUFBNkJqQixXQUFXLENBQUNpQixJQUFELENBQXhDLEVBQWdELEtBQUt2QixTQUFMLENBQWV1QixJQUFmLENBQWhELENBQU47QUFDQSxXQUFLdkIsU0FBTCxDQUFldUIsSUFBZixJQUF1QmpCLFdBQVcsQ0FBQ2lCLElBQUQsQ0FBbEM7QUFDRDtBQUNGOztBQUVERyxFQUFBQSxXQUFXLEdBQUk7QUFDYixXQUFPLEtBQUsxQixTQUFaO0FBQ0Q7O0FBOURrQjs7O2VBaUVORCxjIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbmltcG9ydCBfIGZyb20gJ2xvZGFzaCc7XG5pbXBvcnQgbG9nIGZyb20gJy4vbG9nZ2VyJztcbmltcG9ydCB7IG5vZGUsIHV0aWwgfSBmcm9tICdAYXBwaXVtL3N1cHBvcnQnO1xuaW1wb3J0IHsgZXJyb3JzIH0gZnJvbSAnLi4vcHJvdG9jb2wvZXJyb3JzJztcblxuY29uc3QgTUFYX1NFVFRJTkdTX1NJWkUgPSAyMCAqIDEwMjQgKiAxMDI0OyAvLyAyMCBNQlxuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZyx1bmtub3duPn0gVFxuICogQGltcGxlbWVudHMge0lEZXZpY2VTZXR0aW5nczxUPn1cbiAqL1xuY2xhc3MgRGV2aWNlU2V0dGluZ3Mge1xuXG4gIC8qKlxuICAgKiBAcHJvdGVjdGVkXG4gICAqIEB0eXBlIHtUfVxuICAgKi9cbiAgX3NldHRpbmdzO1xuXG4gIC8qKlxuICAgKiBAcHJvdGVjdGVkXG4gICAqIEB0eXBlIHtpbXBvcnQoJ0BhcHBpdW0vdHlwZXMnKS5TZXR0aW5nc1VwZGF0ZUxpc3RlbmVyPFQ+fHVuZGVmaW5lZH1cbiAgICovXG4gIF9vblNldHRpbmdzVXBkYXRlO1xuXG4gIC8qKlxuICAgKiBgb25TZXR0aW5nc1VwZGF0ZWAgaXMgX3JlcXVpcmVkXyBpZiBzZXR0aW5ncyB3aWxsIGV2ZXIgYmUgdXBkYXRlZDsgb3RoZXJ3aXNlXG4gICAqIGFuIGVycm9yIHdpbGwgb2NjdXIgYXQgcnVudGltZS5cbiAgICogQHBhcmFtIHtUfSBbZGVmYXVsdFNldHRpbmdzXVxuICAgKiBAcGFyYW0ge2ltcG9ydCgnQGFwcGl1bS90eXBlcycpLlNldHRpbmdzVXBkYXRlTGlzdGVuZXI8VD59IFtvblNldHRpbmdzVXBkYXRlXVxuICAgKi9cbiAgY29uc3RydWN0b3IgKGRlZmF1bHRTZXR0aW5ncywgb25TZXR0aW5nc1VwZGF0ZSkge1xuICAgIHRoaXMuX3NldHRpbmdzID0gLyoqIEB0eXBlIHtUfSAqLyh7Li4uKGRlZmF1bHRTZXR0aW5ncyA/PyB7fSl9KTtcbiAgICB0aGlzLl9vblNldHRpbmdzVXBkYXRlID0gb25TZXR0aW5nc1VwZGF0ZTtcbiAgfVxuXG4gIC8qKlxuICAgKiBjYWxscyB1cGRhdGVTZXR0aW5ncyBmcm9tIGltcGxlbWVudGluZyBkcml2ZXIgZXZlcnkgdGltZSBhIHNldHRpbmcgaXMgY2hhbmdlZC5cbiAgICogQHBhcmFtIHtUfSBuZXdTZXR0aW5nc1xuICAgKi9cbiAgYXN5bmMgdXBkYXRlIChuZXdTZXR0aW5ncykge1xuICAgIGlmICghXy5pc1BsYWluT2JqZWN0KG5ld1NldHRpbmdzKSkge1xuICAgICAgdGhyb3cgbmV3IGVycm9ycy5JbnZhbGlkQXJndW1lbnRFcnJvcihgU2V0dGluZ3MgdXBkYXRlIHNob3VsZCBiZSBjYWxsZWQgd2l0aCB2YWxpZCBKU09OLiBHb3QgYCArXG4gICAgICAgIGAke0pTT04uc3RyaW5naWZ5KG5ld1NldHRpbmdzKX0gaW5zdGVhZGApO1xuICAgIH1cblxuICAgIGlmIChub2RlLmdldE9iamVjdFNpemUoey4uLnRoaXMuX3NldHRpbmdzLCAuLi5uZXdTZXR0aW5nc30pID49IE1BWF9TRVRUSU5HU19TSVpFKSB7XG4gICAgICB0aHJvdyBuZXcgZXJyb3JzLkludmFsaWRBcmd1bWVudEVycm9yKGBOZXcgc2V0dGluZ3MgY2Fubm90IGJlIGFwcGxpZWQsIGJlY2F1c2UgdGhlIG92ZXJhbGwgYCArXG4gICAgICAgIGBvYmplY3Qgc2l6ZSBleGNlZWRzIHRoZSBhbGxvd2VkIGxpbWl0IG9mICR7dXRpbC50b1JlYWRhYmxlU2l6ZVN0cmluZyhNQVhfU0VUVElOR1NfU0laRSl9YCk7XG4gICAgfVxuXG4gICAgaWYgKCFfLmlzRnVuY3Rpb24odGhpcy5fb25TZXR0aW5nc1VwZGF0ZSkpIHtcbiAgICAgIGxvZy5lcnJvckFuZFRocm93KGBVbmFibGUgdG8gdXBkYXRlIHNldHRpbmdzOyBgICtcbiAgICAgIGBvblNldHRpbmdzVXBkYXRlIG1ldGhvZCBub3QgZm91bmQgb24gJyR7dGhpcy5jb25zdHJ1Y3Rvci5uYW1lfSdgKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBjb25zdCBwcm9wcyA9IC8qKiBAdHlwZSB7KGtleW9mIFQgJiBzdHJpbmcpW119ICovKF8ua2V5cyhuZXdTZXR0aW5ncykpO1xuICAgIGZvciAoY29uc3QgcHJvcCBvZiBwcm9wcykge1xuICAgICAgaWYgKCFfLmlzVW5kZWZpbmVkKHRoaXMuX3NldHRpbmdzW3Byb3BdKSkge1xuICAgICAgICBpZiAodGhpcy5fc2V0dGluZ3NbcHJvcF0gPT09IG5ld1NldHRpbmdzW3Byb3BdKSB7XG4gICAgICAgICAgbG9nLmRlYnVnKGBUaGUgdmFsdWUgb2YgJyR7cHJvcH0nIHNldHRpbmcgZGlkIG5vdCBjaGFuZ2UuIFNraXBwaW5nIHRoZSB1cGRhdGUgZm9yIGl0YCk7XG4gICAgICAgICAgY29udGludWU7XG4gICAgICAgIH1cbiAgICAgIH1cbiAgICAgIC8vIHVwZGF0ZSBzZXR0aW5nIG9ubHkgd2hlbiB0aGVyZSBpcyB1cGRhdGVTZXR0aW5ncyBkZWZpbmVkLlxuICAgICAgYXdhaXQgdGhpcy5fb25TZXR0aW5nc1VwZGF0ZShwcm9wLCBuZXdTZXR0aW5nc1twcm9wXSwgdGhpcy5fc2V0dGluZ3NbcHJvcF0pO1xuICAgICAgdGhpcy5fc2V0dGluZ3NbcHJvcF0gPSBuZXdTZXR0aW5nc1twcm9wXTtcbiAgICB9XG4gIH1cblxuICBnZXRTZXR0aW5ncyAoKSB7XG4gICAgcmV0dXJuIHRoaXMuX3NldHRpbmdzO1xuICB9XG59XG5cbmV4cG9ydCBkZWZhdWx0IERldmljZVNldHRpbmdzO1xuZXhwb3J0IHsgRGV2aWNlU2V0dGluZ3MgfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge2ltcG9ydCgnQGFwcGl1bS90eXBlcycpLkRldmljZVNldHRpbmdzPFQ+fSBJRGV2aWNlU2V0dGluZ3NcbiAqL1xuIl19

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

@@ -0,0 +1,83 @@
+/**
+ * @implements {SessionHandler}
+ */
+export class BaseDriverCore extends DriverCore implements SessionHandler {
+    /** @type {Record<string,any>|undefined} */
+    cliArgs: Record<string, any> | undefined;
+    /**
+      * @param {string} cmd
+      * @param  {...any[]} args
+      * @returns {Promise<any>}
+      */
+    executeCommand(cmd: string, ...args: any[][]): Promise<any>;
+    /**
+      *
+      * @param {Error} err
+      */
+    startUnexpectedShutdown(err?: Error): Promise<void>;
+    startNewCommandTimeout(): Promise<void>;
+    /**
+     *
+     * @param {import('@appium/types').AppiumServer} server
+     * @param {string} host
+     * @param {number} port
+     * @param {string} path
+     */
+    assignServer(server: import('@appium/types').AppiumServer, host: string, port: number, path: string): void;
+    server: import("@appium/types").AppiumServer | undefined;
+    serverHost: string | undefined;
+    serverPort: number | undefined;
+    serverPath: string | undefined;
+    reset(): Promise<void>;
+    resetOnUnexpectedShutdown: (() => void) | undefined;
+    /**
+       *
+       * Historically the first two arguments were reserved for JSONWP capabilities.
+       * Appium 2 has dropped the support of these, so now we only accept capability
+       * objects in W3C format and thus allow any of the three arguments to represent
+       * the latter.
+       * @param {W3CCapabilities} w3cCapabilities1
+       * @param {W3CCapabilities} [w3cCapabilities2]
+       * @param {W3CCapabilities} [w3cCapabilities]
+       * @param {DriverData[]} [driverData]
+       * @returns {Promise<[string,object]>}
+       */
+    createSession(w3cCapabilities1: W3CCapabilities, w3cCapabilities2?: W3CCapabilities | undefined, w3cCapabilities?: W3CCapabilities | undefined, driverData?: import("@appium/types").DriverData[] | undefined): Promise<[string, object]>;
+    /**
+      *
+      * @param {string} [sessionId]
+      * @param {DriverData[]} [driverData]
+      * @returns {Promise<void>}
+      */
+    deleteSession(sessionId?: string | undefined, driverData?: import("@appium/types").DriverData[] | undefined): Promise<void>;
+}
+export default BaseDriver;
+export type HTTPMethod = import('@appium/types').HTTPMethod;
+export type Driver = import('@appium/types').Driver;
+export type ExternalDriver = import('@appium/types').ExternalDriver;
+export type Capabilities = import('@appium/types').Capabilities;
+export type W3CCapabilities = import('@appium/types').W3CCapabilities;
+export type DriverData = import('@appium/types').DriverData;
+export type UpdateServerCallback = (app: import('express').Express, httpServer: import('@appium/types').AppiumServer) => import('type-fest').Promisable<void>;
+/**
+ * This is used to extend {@linkcode BaseDriverCore } by the mixins and also external drivers.
+ */
+export type BaseDriverBase<Proto = {}, Static = {}> = import('@appium/types').Class<BaseDriverCore & Proto, BaseDriverStatic & Static>;
+/**
+ * Static properties of `BaseDriver` and optional properties for subclasses.
+ */
+export type BaseDriverStatic<T extends import("@appium/types").ExternalDriver = import("@appium/types").ExternalDriver> = {
+    baseVersion: string;
+    updateServer?: UpdateServerCallback | undefined;
+    newMethodMap?: import("@appium/types").MethodMap<T> | undefined;
+};
+export type SessionHandler = import('@appium/types').SessionHandler<[string, object], void>;
+import { DriverCore } from "./core";
+declare const BaseDriver_base: import("./commands/session").SessionBase;
+/**
+ * This ensures that all of the mixins correctly implement the interface described in {@linkcode Driver}.
+ * @implements {Driver}
+ */
+export class BaseDriver extends BaseDriver_base implements Driver {
+}
+//# sourceMappingURL=driver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/driver.js"],"names":[],"mappings":"AA0BA;;GAEG;AACH;IAEE,2CAA2C;IAC3C,SADW,OAAO,MAAM,EAAC,GAAG,CAAC,GAAC,SAAS,CAC/B;IAMR;;;;QAII;IACJ,oBAJY,MAAM,WACF,GAAG,EAAE,KACP,QAAQ,GAAG,CAAC,CA2EzB;IAED;;;QAGI;IACJ,8BAFY,KAAK,iBAgBhB;IAED,wCAmBC;IAED;;;;;;OAMG;IACH,qBALW,OAAO,eAAe,EAAE,YAAY,QACpC,MAAM,QACN,MAAM,QACN,MAAM,QAOhB;IAJC,yDAAoB;IACpB,+BAAsB;IACtB,+BAAsB;IACtB,+BAAsB;IAOxB,uBA+BC;IAfC,oDAAyC;IAiB3C;;;;;;;;;;;SAWK;IACL,gCANa,eAAe,iKAIb,QAAQ,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC,CAmGtC;IAED;;;;;QAKI;IACJ,8GAFc,QAAQ,IAAI,CAAC,CAc1B;CACF;;yBAWY,OAAO,eAAe,EAAE,UAAU;qBAClC,OAAO,eAAe,EAAE,MAAM;6BAC9B,OAAO,eAAe,EAAE,cAAc;2BACtC,OAAO,eAAe,EAAE,YAAY;8BACpC,OAAO,eAAe,EAAE,eAAe;yBACvC,OAAO,eAAe,EAAE,UAAU;yCAMpC,OAAO,SAAS,EAAE,OAAO,cACzB,OAAO,eAAe,EAAE,YAAY,KAClC,OAAO,WAAW,EAAE,UAAU,CAAC,IAAI,CAAC;;;;sDAOpC,OAAO,eAAe,EAAE,KAAK,CAAC,cAAc,GAAG,KAAK,EAAC,gBAAgB,GAAG,MAAM,CAAC;;;;;iBAO9E,MAAM;;;;6BAMP,OAAO,eAAe,EAAE,cAAc,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAC,IAAI,CAAC;;;AA1C1E;;;GAGG;AACH;CAAiE"}