@appium/base-driver 8.7.1 → 8.7.3

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

@@ -1,15 +1,120 @@
-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 Constraints = import('@appium/types').Constraints;
 export type ExecuteMethodMap = import('@appium/types').ExecuteMethodMap;
 export type ServerArgs = import('@appium/types').ServerArgs;
 export type EventHistory = import('@appium/types').EventHistory;
 export type AppiumLogger = import('@appium/types').AppiumLogger;
+export type StringRecord = import('@appium/types').StringRecord;
+export type BaseDriverCapConstraints = import('@appium/types').BaseDriverCapConstraints;
+export type Capabilities<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}, Extra extends void | import("@appium/types").StringRecord = void> = import('@appium/types').Capabilities<C, Extra>;
+export type W3CCapabilities<T extends import("@appium/types").StringRecord = {}> = import('@appium/types').W3CCapabilities<T>;
+export type Core<C extends Readonly<Record<string, import("@appium/types").Constraint>>> = import('@appium/types').Core<C>;
+export type DriverOpts<C extends Readonly<Record<string, import("@appium/types").Constraint>>> = import('@appium/types').DriverOpts<C>;
 /**
- * @implements {Core}
+ * @template {Constraints} [C=BaseDriverCapConstraints]
+ * @implements {Core<C>}
  */
-export class DriverCore implements Core {
+export class DriverCore<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}> implements Core<C> {
     /**
      * Make the basedriver version available so for any driver which inherits from this package, we
      * know which version of basedriver it inherited from
@@ -17,28 +122,24 @@ export class DriverCore implements Core {
     static baseVersion: any;
     /** @type {ExecuteMethodMap} */
     static executeMethodMap: ExecuteMethodMap;
-    constructor(opts?: import("@appium/types").ServerArgs, shouldValidateCaps?: boolean);
+    /**
+     * @param {DriverOpts<C>} opts
+     * @param {boolean} [shouldValidateCaps]
+     */
+    constructor(opts?: DriverOpts<C>, shouldValidateCaps?: boolean | undefined);
     /**
      * @type {string?}
      */
     sessionId: string | null;
     /**
-     * @type {import('@appium/types').DriverOpts}
+     * @type {import('@appium/types').DriverOpts<C>}
      */
-    opts: import('@appium/types').DriverOpts;
+    opts: import('@appium/types').DriverOpts<C>;
     /**
      * @type {ServerArgs}
      */
     initialOpts: ServerArgs;
-    /**
-     * @type {Capabilities}
-     */
-    caps: Capabilities;
-    /**
-     * @type {W3CCapabilities}
-     */
-    originalCaps: W3CCapabilities;
-    helpers: import("@appium/types").DriverHelpers;
+    helpers: import("@appium/types").DriverHelpers<any>;
     /**
      * basePath is used for several purposes, for example in setting up
      * proxying to other drivers, since we need to know what the base path
@@ -144,9 +245,9 @@ export class DriverCore implements Core {
      * method required by MJSONWP in order to determine if the command should
      * be proxied directly to the driver
      * @param {string} sessionId
-     * @returns {Core | null}
+     * @returns {Core<C> | null}
      */
-    driverForSession(sessionId: string): Core | null;
+    driverForSession(sessionId: string): Core<C> | null;
     isMjsonwpProtocol(): boolean;
     isW3CProtocol(): boolean;
     setProtocolMJSONWP(): void;
@@ -218,7 +319,57 @@ export class DriverCore implements Core {
      * @param {Driver} driver
      */
     addManagedDriver(driver: Driver): void;
-    getManagedDrivers(): import("@appium/types").Driver[];
+    getManagedDrivers(): import("@appium/types").Driver<{
+        readonly platformName: {
+            readonly presence: true;
+            readonly isString: true;
+        };
+        readonly app: {
+            readonly isString: true;
+        };
+        readonly deviceName: {
+            readonly isString: true;
+        };
+        readonly platformVersion: {
+            readonly isString: true;
+        };
+        readonly newCommandTimeout: {
+            readonly isNumber: true;
+        };
+        readonly automationName: {
+            readonly isString: true;
+        };
+        readonly autoLaunch: {
+            readonly isBoolean: true;
+        };
+        readonly udid: {
+            readonly isString: true;
+        };
+        readonly orientation: {
+            readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+        };
+        readonly autoWebview: {
+            readonly isBoolean: true;
+        };
+        readonly noReset: {
+            readonly isBoolean: true;
+        };
+        readonly fullReset: {
+            readonly isBoolean: true;
+        };
+        readonly language: {
+            readonly isString: true;
+        };
+        readonly locale: {
+            readonly isString: true;
+        };
+        readonly eventTimings: {
+            readonly isBoolean: true;
+        };
+        readonly printPageSourceOnFindFailure: {
+            readonly isBoolean: true;
+        };
+    }, import("@appium/types").StringRecord>[];
     clearNewCommandTimeout(): Promise<void>;
 }
 import { EventEmitter } from "events";

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

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/core.js"],"names":[],"mappings":"2BAwaa,OAAO,eAAe,EAAE,YAAY;8BACpC,OAAO,eAAe,EAAE,eAAe;qBACvC,OAAO,eAAe,EAAE,MAAM;mBAC9B,OAAO,eAAe,EAAE,IAAI;+BAC5B,OAAO,eAAe,EAAE,gBAAgB;yBACxC,OAAO,eAAe,EAAE,UAAU;2BAClC,OAAO,eAAe,EAAE,YAAY;2BACpC,OAAO,eAAe,EAAE,YAAY;AA5ZjD;;GAEG;AACH;IACE;;;OAGG;IACH,wBAAoC;IAEpC,+BAA+B;IAC/B,yBADW,gBAAgB,CACE;IAkG7B,qFAiBC;IAjHD;;OAEG;IACH,WAFU,MAAM,QAEC;IAEjB;;OAEG;IACH,MAFU,OAAO,eAAe,EAAE,UAAU,CAEvC;IAEL;;OAEG;IACH,aAFU,UAAU,CAER;IAEZ;;OAEG;IACH,MAFU,YAAY,CAEjB;IAEL;;OAEG;IACH,cAFU,eAAe,CAEZ;IAEb,+CAAkB;IAElB;;;;;;;OAOG;IACH,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;IAG/B,kCAAkC;IAClC,cADW,mBAAmB,CACI;IAElC;;OAEG;IACH,MAFU,YAAY,CAEjB;IAEL;;OAEG;IACH,wCAA6B;IAE7B;;OAEG;IACH,oBAFU,OAAO,CAEE;IAEnB;;OAEG;IACH,wCAAqC;IAErC;;;;;OAKG;IACH,8BAAgC;IAqBhC,gDAEC;IAED;;;;;;;;OAQG;IACH,wCAJqB,GAAG,EAAE,KAAK,IAAI,QAMlC;IAED;;;;;;;OAOG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,sCAEC;IAMD,yDAEC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAgBhB;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,+CAFa,OAAO,CAKnB;IAED;;;;;OAKG;IACH,4BAHW,MAAM,GACJ,IAAI,GAAG,IAAI,CAIvB;IAED,6BAEC;IAED,yBAEC;IAED,2BAEC;IADC,6BAAiC;IAGnC,uBAEC;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,WAuBhB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,QAKhB;IAED;;;;;OAKG;IACH,2BAFW,MAAM,QAYhB;IAED;;;;OAIG;IACH,kCAHW,MAAM,0CAgBhB;IAED;;;;OAIG;IACH,6CAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,OAAO,eAAe,EAAE,YAAY,EAAE,CAIlD;IAED;;;;OAIG;IACH,0CAFa,OAAO,CAInB;IAED;;;;;;;;;;;;OAYG;IACH,+BATW,MAAM,UAGN,OAAO,eAAe,EAAE,UAAU,OAClC,MAAM,SACN,GAAG,GAED,OAAO,CAoBnB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED,sDAEC;IAED,wCAKC;CACF"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/core.js"],"names":[],"mappings":"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"}

package/build/lib/basedriver/core.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -27,6 +25,8 @@ var _deviceSettings = _interopRequireDefault(require("./device-settings"));
 
 var _helpers = _interopRequireDefault(require("./helpers"));
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const {
   version: BASEDRIVER_VER
 } = _support.fs.readPackageJsonFrom(__dirname);
@@ -40,8 +40,6 @@ class DriverCore {
   sessionId = null;
   opts;
   initialOpts;
-  caps;
-  originalCaps;
   helpers = _helpers.default;
   basePath = _constants.DEFAULT_BASE_PATH;
   relaxedSecurityEnabled = false;
@@ -68,7 +66,7 @@ class DriverCore {
     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.initialOpts = _lodash.default.cloneDeep(opts);
     this.sessionId = null;
   }
 
@@ -237,4 +235,4 @@ class DriverCore {
 }
 
 exports.DriverCore = DriverCore;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["version","BASEDRIVER_VER","fs","readPackageJsonFrom","__dirname","NEW_COMMAND_TIMEOUT_MS","ON_UNEXPECTED_SHUTDOWN_EVENT","DriverCore","baseVersion","executeMethodMap","sessionId","opts","initialOpts","caps","originalCaps","helpers","basePath","DEFAULT_BASE_PATH","relaxedSecurityEnabled","allowInsecure","denyInsecure","newCommandTimeoutMs","implicitWaitMs","locatorStrategies","webLocatorStrategies","managedDrivers","noCommandTimer","_eventHistory","commands","eventEmitter","EventEmitter","_log","shutdownUnexpectedly","shouldValidateCaps","commandsQueueGuard","AsyncLock","settings","DeviceSettings","constructor","logger","getLogger","generateDriverLogPrefix","tmpDir","process","env","APPIUM_TMP_DIR","os","tmpdir","_","cloneDeep","log","onUnexpectedShutdown","handler","on","driverData","isCommandsQueueEnabled","eventHistory","logEvent","eventName","Error","ts","Date","now","logTime","toTimeString","push","debug","getStatus","sessionExists","driverForSession","isMjsonwpProtocol","protocol","PROTOCOLS","MJSONWP","isW3CProtocol","W3C","setProtocolMJSONWP","setProtocolW3C","isFeatureEnabled","name","includes","ensureFeatureEnabled","assertFeatureEnabled","validateLocatorStrategy","strategy","webContext","validStrategies","join","concat","errors","InvalidSelectorError","proxyActive","getProxyAvoidList","canProxy","proxyRouteIsAvoided","method","url","body","avoidSchema","isArray","length","avoidMethod","avoidPathRegex","isRegExp","normalizedUrl","replace","RegExp","escapeRegExp","test","addManagedDriver","driver","getManagedDrivers","clearNewCommandTimeout","clearTimeout"],"sources":["../../../lib/basedriver/core.js"],"sourcesContent":["/* eslint-disable no-unused-vars */\n/* eslint-disable require-await */\n\nimport {fs, logger} 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 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   * 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  /** @type {ExecuteMethodMap} */\n  static executeMethodMap = {};\n\n  /**\n   * @type {string?}\n   */\n  sessionId = null;\n\n  /**\n   * @type {import('@appium/types').DriverOpts}\n   */\n  opts;\n\n  /**\n   * @type {ServerArgs}\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  // 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   */\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(opts = /** @type {ServerArgs} */ ({}), shouldValidateCaps = true) {\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 = 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  /**\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 {Core | null}\n   */\n  driverForSession(sessionId) {\n    return this;\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   * @deprecated\n   */\n  ensureFeatureEnabled(name) {\n    this.assertFeatureEnabled(name);\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  assertFeatureEnabled(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(`Valid locator strategies for this request: ${validStrategies.join(', ')}`);\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 {import('@appium/types').RouteMatcher[]}\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(new RegExp(`^${_.escapeRegExp(this.basePath)}`), '');\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').ExecuteMethodMap} ExecuteMethodMap\n * @typedef {import('@appium/types').ServerArgs} ServerArgs\n * @typedef {import('@appium/types').EventHistory} EventHistory\n * @typedef {import('@appium/types').AppiumLogger} AppiumLogger\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["version","BASEDRIVER_VER","fs","readPackageJsonFrom","__dirname","NEW_COMMAND_TIMEOUT_MS","ON_UNEXPECTED_SHUTDOWN_EVENT","DriverCore","baseVersion","executeMethodMap","sessionId","opts","initialOpts","helpers","basePath","DEFAULT_BASE_PATH","relaxedSecurityEnabled","allowInsecure","denyInsecure","newCommandTimeoutMs","implicitWaitMs","locatorStrategies","webLocatorStrategies","managedDrivers","noCommandTimer","_eventHistory","commands","eventEmitter","EventEmitter","_log","shutdownUnexpectedly","shouldValidateCaps","commandsQueueGuard","AsyncLock","settings","DeviceSettings","constructor","logger","getLogger","generateDriverLogPrefix","tmpDir","process","env","APPIUM_TMP_DIR","os","tmpdir","_","cloneDeep","log","onUnexpectedShutdown","handler","on","driverData","isCommandsQueueEnabled","eventHistory","logEvent","eventName","Error","ts","Date","now","logTime","toTimeString","push","debug","getStatus","sessionExists","driverForSession","isMjsonwpProtocol","protocol","PROTOCOLS","MJSONWP","isW3CProtocol","W3C","setProtocolMJSONWP","setProtocolW3C","isFeatureEnabled","name","includes","ensureFeatureEnabled","assertFeatureEnabled","validateLocatorStrategy","strategy","webContext","validStrategies","join","concat","errors","InvalidSelectorError","proxyActive","getProxyAvoidList","canProxy","proxyRouteIsAvoided","method","url","body","avoidSchema","isArray","length","avoidMethod","avoidPathRegex","isRegExp","normalizedUrl","replace","RegExp","escapeRegExp","test","addManagedDriver","driver","getManagedDrivers","clearNewCommandTimeout","clearTimeout"],"sources":["../../../lib/basedriver/core.js"],"sourcesContent":["/* eslint-disable no-unused-vars */\n/* eslint-disable require-await */\n\nimport {fs, logger} 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 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/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @implements {Core<C>}\n */\nclass DriverCore {\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  /** @type {ExecuteMethodMap} */\n  static executeMethodMap = {};\n\n  /**\n   * @type {string?}\n   */\n  sessionId = null;\n\n  /**\n   * @type {import('@appium/types').DriverOpts<C>}\n   */\n  opts;\n\n  /**\n   * @type {ServerArgs}\n   */\n  initialOpts;\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  // 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   */\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  /**\n   * @param {DriverOpts<C>} opts\n   * @param {boolean} [shouldValidateCaps]\n   */\n  constructor(opts = /** @type {DriverOpts<C>} */ ({}), shouldValidateCaps = true) {\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 = 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(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  /**\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 {Core<C> | null}\n   */\n  driverForSession(sessionId) {\n    return this;\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   * @deprecated\n   */\n  ensureFeatureEnabled(name) {\n    this.assertFeatureEnabled(name);\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  assertFeatureEnabled(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(`Valid locator strategies for this request: ${validStrategies.join(', ')}`);\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 {import('@appium/types').RouteMatcher[]}\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(new RegExp(`^${_.escapeRegExp(this.basePath)}`), '');\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').Driver} Driver\n * @typedef {import('@appium/types').Constraints} Constraints\n * @typedef {import('@appium/types').ExecuteMethodMap} ExecuteMethodMap\n * @typedef {import('@appium/types').ServerArgs} ServerArgs\n * @typedef {import('@appium/types').EventHistory} EventHistory\n * @typedef {import('@appium/types').AppiumLogger} AppiumLogger\n * @typedef {import('@appium/types').StringRecord} StringRecord\n * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').Capabilities<C, Extra>} Capabilities\n */\n/**\n * @template {StringRecord} [T={}]\n * @typedef {import('@appium/types').W3CCapabilities<T>} W3CCapabilities\n */\n\n/**\n * @template {Constraints} C\n * @typedef {import('@appium/types').Core<C>} Core\n */\n\n/**\n * @template {Constraints} C\n * @typedef {import('@appium/types').DriverOpts<C>} DriverOpts\n */\n"],"mappings":"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"}

package/build/lib/basedriver/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","names":["version","BASEDRIVER_VER","fs","readPackageJsonFrom","__dirname","NEW_COMMAND_TIMEOUT_MS","ON_UNEXPECTED_SHUTDOWN_EVENT","DriverCore","baseVersion","executeMethodMap","sessionId","opts","initialOpts","helpers","basePath","DEFAULT_BASE_PATH","relaxedSecurityEnabled","allowInsecure","denyInsecure","newCommandTimeoutMs","implicitWaitMs","locatorStrategies","webLocatorStrategies","managedDrivers","noCommandTimer","_eventHistory","commands","eventEmitter","EventEmitter","_log","shutdownUnexpectedly","shouldValidateCaps","commandsQueueGuard","AsyncLock","settings","DeviceSettings","constructor","logger","getLogger","generateDriverLogPrefix","tmpDir","process","env","APPIUM_TMP_DIR","os","tmpdir","_","cloneDeep","log","onUnexpectedShutdown","handler","on","driverData","isCommandsQueueEnabled","eventHistory","logEvent","eventName","Error","ts","Date","now","logTime","toTimeString","push","debug","getStatus","sessionExists","driverForSession","isMjsonwpProtocol","protocol","PROTOCOLS","MJSONWP","isW3CProtocol","W3C","setProtocolMJSONWP","setProtocolW3C","isFeatureEnabled","name","includes","ensureFeatureEnabled","assertFeatureEnabled","validateLocatorStrategy","strategy","webContext","validStrategies","join","concat","errors","InvalidSelectorError","proxyActive","getProxyAvoidList","canProxy","proxyRouteIsAvoided","method","url","body","avoidSchema","isArray","length","avoidMethod","avoidPathRegex","isRegExp","normalizedUrl","replace","RegExp","escapeRegExp","test","addManagedDriver","driver","getManagedDrivers","clearNewCommandTimeout","clearTimeout"],"sources":["../../../lib/basedriver/core.js"],"sourcesContent":["/* eslint-disable no-unused-vars */\n/* eslint-disable require-await */\n\nimport {fs, logger} 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 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/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @implements {Core<C>}\n */\nclass DriverCore {\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  /** @type {ExecuteMethodMap} */\n  static executeMethodMap = {};\n\n  /**\n   * @type {string?}\n   */\n  sessionId = null;\n\n  /**\n   * @type {import('@appium/types').DriverOpts<C>}\n   */\n  opts;\n\n  /**\n   * @type {ServerArgs}\n   */\n  initialOpts;\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  // 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   */\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  /**\n   * @param {DriverOpts<C>} opts\n   * @param {boolean} [shouldValidateCaps]\n   */\n  constructor(opts = /** @type {DriverOpts<C>} */ ({}), shouldValidateCaps = true) {\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 = 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(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  /**\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 {Core<C> | null}\n   */\n  driverForSession(sessionId) {\n    return this;\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   * @deprecated\n   */\n  ensureFeatureEnabled(name) {\n    this.assertFeatureEnabled(name);\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  assertFeatureEnabled(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(`Valid locator strategies for this request: ${validStrategies.join(', ')}`);\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 {import('@appium/types').RouteMatcher[]}\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(new RegExp(`^${_.escapeRegExp(this.basePath)}`), '');\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').Driver} Driver\n * @typedef {import('@appium/types').Constraints} Constraints\n * @typedef {import('@appium/types').ExecuteMethodMap} ExecuteMethodMap\n * @typedef {import('@appium/types').ServerArgs} ServerArgs\n * @typedef {import('@appium/types').EventHistory} EventHistory\n * @typedef {import('@appium/types').AppiumLogger} AppiumLogger\n * @typedef {import('@appium/types').StringRecord} StringRecord\n * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').Capabilities<C, Extra>} Capabilities\n */\n/**\n * @template {StringRecord} [T={}]\n * @typedef {import('@appium/types').W3CCapabilities<T>} W3CCapabilities\n */\n\n/**\n * @template {Constraints} C\n * @typedef {import('@appium/types').Core<C>} Core\n */\n\n/**\n * @template {Constraints} C\n * @typedef {import('@appium/types').DriverOpts<C>} DriverOpts\n */\n"],"mappings":"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"}

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

@@ -1,5 +1,3 @@
-/** @type {import('@appium/types').Constraints} */
-export let desiredCapabilityConstraints: import('@appium/types').Constraints;
 export const validator: _validator.ValidateJS & {
     promise: typeof B;
 };

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

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

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

@@ -1,11 +1,9 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.validator = exports.desiredCapabilityConstraints = void 0;
+exports.validator = void 0;
 
 require("source-map-support/register");
 
@@ -15,57 +13,10 @@ var _validate = _interopRequireDefault(require("validate.js"));
 
 var _bluebird = _interopRequireDefault(require("bluebird"));
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const validator = _validate.default;
 exports.validator = validator;
-let desiredCapabilityConstraints = {
-  platformName: {
-    presence: true,
-    isString: true
-  },
-  deviceName: {
-    isString: true
-  },
-  platformVersion: {
-    isString: true
-  },
-  newCommandTimeout: {
-    isNumber: true
-  },
-  automationName: {
-    isString: true
-  },
-  autoLaunch: {
-    isBoolean: true
-  },
-  udid: {
-    isString: true
-  },
-  orientation: {
-    inclusion: ['LANDSCAPE', 'PORTRAIT']
-  },
-  autoWebview: {
-    isBoolean: true
-  },
-  noReset: {
-    isBoolean: true
-  },
-  fullReset: {
-    isBoolean: true
-  },
-  language: {
-    isString: true
-  },
-  locale: {
-    isString: true
-  },
-  eventTimings: {
-    isBoolean: true
-  },
-  printPageSourceOnFindFailure: {
-    isBoolean: true
-  }
-};
-exports.desiredCapabilityConstraints = desiredCapabilityConstraints;
 
 validator.validators.isString = function isString(value) {
   if (typeof value === 'string') {
@@ -166,4 +117,4 @@ validator.promise = _bluebird.default;
 validator.prettify = function prettify(val) {
   return val;
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["validator","_validator","desiredCapabilityConstraints","platformName","presence","isString","deviceName","platformVersion","newCommandTimeout","isNumber","automationName","autoLaunch","isBoolean","udid","orientation","inclusion","autoWebview","noReset","fullReset","language","locale","eventTimings","printPageSourceOnFindFailure","validators","value","isNaN","Number","log","warn","includes","isObject","isArray","Array","deprecated","options","key","inclusionCaseInsensitive","option","toLowerCase","toString","promise","B","prettify","val"],"sources":["../../../lib/basedriver/desired-caps.js"],"sourcesContent":["import log from './logger';\nimport _validator from 'validate.js';\nimport B from 'bluebird';\n\nconst validator =\n  /** @type {import('validate.js').ValidateJS & {promise: typeof import('bluebird')}} */ (\n    _validator\n  );\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: ['LANDSCAPE', 'PORTRAIT'],\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(Number(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\nexport {desiredCapabilityConstraints, validator};\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"desired-caps.js","names":["validator","_validator","validators","isString","value","isNumber","isNaN","Number","log","warn","isBoolean","includes","isObject","isArray","Array","deprecated","options","key","inclusionCaseInsensitive","option","toLowerCase","toString","promise","B","prettify","val"],"sources":["../../../lib/basedriver/desired-caps.js"],"sourcesContent":["import log from './logger';\nimport _validator from 'validate.js';\nimport B from 'bluebird';\n\nexport const validator =\n  /** @type {import('validate.js').ValidateJS & {promise: typeof import('bluebird')}} */ (\n    _validator\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(Number(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"],"mappings":"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"}

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

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -17,6 +15,8 @@ var _support = require("@appium/support");
 
 var _errors = require("../protocol/errors");
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const MAX_SETTINGS_SIZE = 20 * 1024 * 1024;
 exports.MAX_SETTINGS_SIZE = MAX_SETTINGS_SIZE;
 
@@ -66,4 +66,4 @@ class DeviceSettings {
 exports.DeviceSettings = DeviceSettings;
 var _default = DeviceSettings;
 exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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