@appium/base-driver 8.7.2 → 9.0.0

package/build/lib/basedriver/core.js

@@ -1,238 +1,369 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+/* eslint-disable no-unused-vars */
+/* eslint-disable require-await */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 _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);
-
+const support_1 = require("@appium/support");
+const async_lock_1 = __importDefault(require("async-lock"));
+const events_1 = require("events");
+const lodash_1 = __importDefault(require("lodash"));
+const os_1 = __importDefault(require("os"));
+const constants_1 = require("../constants");
+const protocol_1 = require("../protocol");
+const device_settings_1 = __importDefault(require("./device-settings"));
+const helpers_1 = __importDefault(require("./helpers"));
+// for compat with running tests transpiled and in-place
+const { version: BASEDRIVER_VER } = support_1.fs.readPackageJsonFrom(__dirname);
 const NEW_COMMAND_TIMEOUT_MS = 60 * 1000;
 const ON_UNEXPECTED_SHUTDOWN_EVENT = 'onUnexpectedShutdown';
-
+/**
+ * @template {Constraints} [C=BaseDriverCapConstraints]
+ * @implements {Core<C>}
+ */
 class DriverCore {
-  static baseVersion = BASEDRIVER_VER;
-  static executeMethodMap = {};
-  sessionId = null;
-  opts;
-  initialOpts;
-  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: []
-  };
-  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(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 {};
-  }
-
-  sessionExists(sessionId) {
-    if (!sessionId) return false;
-    return sessionId === this.sessionId;
-  }
-
-  driverForSession(sessionId) {
-    return this;
-  }
-
-  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) {
-    this.assertFeatureEnabled(name);
-  }
-
-  assertFeatureEnabled(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)) {
+    /**
+     * @param {DriverOpts<C>} opts
+     * @param {boolean} [shouldValidateCaps]
+     */
+    constructor(opts = /** @type {DriverOpts<C>} */ ({}), shouldValidateCaps = true) {
+        /**
+         * @type {string?}
+         */
+        this.sessionId = null;
+        this.helpers = helpers_1.default;
+        /**
+         * basePath is used for several purposes, for example in setting up
+         * proxying to other drivers, since we need to know what the base path
+         * of any incoming request might look like. We set it to the default
+         * initially but it is automatically updated during any actual program
+         * execution by the routeConfiguringFunction, which is necessarily run as
+         * the entrypoint for any Appium server
+         */
+        this.basePath = constants_1.DEFAULT_BASE_PATH;
+        this.relaxedSecurityEnabled = false;
+        /** @type {string[]} */
+        this.allowInsecure = [];
+        /** @type {string[]} */
+        this.denyInsecure = [];
+        this.newCommandTimeoutMs = NEW_COMMAND_TIMEOUT_MS;
+        this.implicitWaitMs = 0;
+        /** @type {string[]} */
+        this.locatorStrategies = [];
+        /** @type {string[]} */
+        this.webLocatorStrategies = [];
+        /** @type {Driver[]} */
+        this.managedDrivers = [];
+        /** @type {NodeJS.Timeout?} */
+        this.noCommandTimer = null;
+        /** @type {EventHistory} */
+        this._eventHistory = { commands: [] };
+        // used to handle driver events
+        /** @type {NodeJS.EventEmitter} */
+        this.eventEmitter = new events_1.EventEmitter();
+        /**
+         * @protected
+         */
+        this.shutdownUnexpectedly = false;
+        /**
+         * @protected
+         */
+        this.commandsQueueGuard = new async_lock_1.default();
+        /**
+         * settings should be instantiated by drivers which extend BaseDriver, but
+         * we set it to an empty DeviceSettings instance here to make sure that the
+         * default settings are applied even if an extending driver doesn't utilize
+         * the settings functionality itself
+         */
+        this.settings = new device_settings_1.default();
+        this._log = support_1.logger.getLogger(helpers_1.default.generateDriverLogPrefix(this));
+        // setup state
+        this.opts = opts;
+        // use a custom tmp dir to avoid losing data and app when computer is
+        // restarted
+        this.opts.tmpDir = this.opts.tmpDir || process.env.APPIUM_TMP_DIR || os_1.default.tmpdir();
+        // base-driver internals
+        this.shouldValidateCaps = shouldValidateCaps;
+        // keeping track of initial opts
+        this.initialOpts = lodash_1.default.cloneDeep(opts);
+        this.sessionId = null;
+    }
+    get log() {
+        return this._log;
+    }
+    /**
+     * Set a callback handler if needed to execute a custom piece of code
+     * when the driver is shut down unexpectedly. Multiple calls to this method
+     * will cause the handler to be executed mutiple times
+     *
+     * @param {(...args: any[]) => void} handler The code to be executed on unexpected shutdown.
+     * The function may accept one argument, which is the actual error instance, which
+     * caused the driver to shut down.
+     */
+    onUnexpectedShutdown(handler) {
+        this.eventEmitter.on(ON_UNEXPECTED_SHUTDOWN_EVENT, handler);
+    }
+    /**
+     * This property is used by AppiumDriver to store the data of the
+     * specific driver sessions. This data can be later used to adjust
+     * properties for driver instances running in parallel.
+     * Override it in inherited driver classes if necessary.
+     *
+     * @return {Record<string,unknown>} Driver properties mapping
+     */
+    get driverData() {
+        return {};
+    }
+    /**
+     * This property controls the way the `executeCommand` method
+     * handles new driver commands received from the client.
+     * Override it for inherited classes only in special cases.
+     *
+     * @return {boolean} If the returned value is true (default) then all the commands
+     *   received by the particular driver instance are going to be put into the queue,
+     *   so each following command will not be executed until the previous command
+     *   execution is completed. False value disables that queue, so each driver command
+     *   is executed independently and does not wait for anything.
+     */
+    get isCommandsQueueEnabled() {
         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;
-    }
-  }
-
+    }
+    /*
+     * make eventHistory a property and return a cloned object so a consumer can't
+     * inadvertently change data outside of logEvent
+     */
+    get eventHistory() {
+        return lodash_1.default.cloneDeep(this._eventHistory);
+    }
+    /**
+     * API method for driver developers to log timings for important events
+     * @param {string} eventName
+     */
+    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})`);
+    }
+    /**
+     * Overridden in appium driver, but here so that individual drivers can be
+     * tested with clients that poll
+     */
+    async getStatus() {
+        return {};
+    }
+    /**
+     * method required by MJSONWP in order to determine whether it should
+     * respond with an invalid session response
+     * @param {string} [sessionId]
+     * @returns {boolean}
+     */
+    sessionExists(sessionId) {
+        if (!sessionId)
+            return false; // eslint-disable-line curly
+        return sessionId === this.sessionId;
+    }
+    /**
+     * method required by MJSONWP in order to determine if the command should
+     * be proxied directly to the driver
+     * @param {string} sessionId
+     * @returns {Core<C> | null}
+     */
+    driverForSession(sessionId) {
+        return this;
+    }
+    isMjsonwpProtocol() {
+        return this.protocol === constants_1.PROTOCOLS.MJSONWP;
+    }
+    isW3CProtocol() {
+        return this.protocol === constants_1.PROTOCOLS.W3C;
+    }
+    setProtocolMJSONWP() {
+        this.protocol = constants_1.PROTOCOLS.MJSONWP;
+    }
+    setProtocolW3C() {
+        this.protocol = constants_1.PROTOCOLS.W3C;
+    }
+    /**
+     * Check whether a given feature is enabled via its name
+     *
+     * @param {string} name - name of feature/command
+     *
+     * @returns {Boolean}
+     */
+    isFeatureEnabled(name) {
+        // if we have explicitly denied this feature, return false immediately
+        if (this.denyInsecure && lodash_1.default.includes(this.denyInsecure, name)) {
+            return false;
+        }
+        // if we specifically have allowed the feature, return true
+        if (this.allowInsecure && lodash_1.default.includes(this.allowInsecure, name)) {
+            return true;
+        }
+        // otherwise, if we've globally allowed insecure features and not denied
+        // this one, return true
+        if (this.relaxedSecurityEnabled) {
+            return true;
+        }
+        // if we haven't allowed anything insecure, then reject
+        return false;
+    }
+    /**
+     * Assert that a given feature is enabled and throw a helpful error if it's
+     * not
+     *
+     * @param {string} name - name of feature/command
+     * @deprecated
+     */
+    ensureFeatureEnabled(name) {
+        this.assertFeatureEnabled(name);
+    }
+    /**
+     * Assert that a given feature is enabled and throw a helpful error if it's
+     * not
+     *
+     * @param {string} name - name of feature/command
+     */
+    assertFeatureEnabled(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`);
+        }
+    }
+    /**
+     *
+     * @param {string} strategy
+     * @param {boolean} [webContext]
+     */
+    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_1.default.includes(validStrategies, strategy)) {
+            throw new protocol_1.errors.InvalidSelectorError(`Locator Strategy '${strategy}' is not supported for this session`);
+        }
+    }
+    /**
+     *
+     * @param {string} [sessionId]
+     * @returns {boolean}
+     */
+    proxyActive(sessionId) {
+        return false;
+    }
+    /**
+     *
+     * @param {string} sessionId
+     * @returns {import('@appium/types').RouteMatcher[]}
+     */
+    getProxyAvoidList(sessionId) {
+        return [];
+    }
+    /**
+     *
+     * @param {string} [sessionId]
+     * @returns {boolean}
+     */
+    canProxy(sessionId) {
+        return false;
+    }
+    /**
+     * Whether a given command route (expressed as method and url) should not be
+     * proxied according to this driver
+     *
+     * @param {string} sessionId - the current sessionId (in case the driver runs
+     * multiple session ids and requires it). This is not used in this method but
+     * should be made available to overridden methods.
+     * @param {import('@appium/types').HTTPMethod} method - HTTP method of the route
+     * @param {string} url - url of the route
+     * @param {any} [body] - webdriver request body
+     *
+     * @returns {boolean} - whether the route should be avoided
+     */
+    proxyRouteIsAvoided(sessionId, method, url, body) {
+        for (let avoidSchema of this.getProxyAvoidList(sessionId)) {
+            if (!lodash_1.default.isArray(avoidSchema) || avoidSchema.length !== 2) {
+                throw new Error('Proxy avoidance must be a list of pairs');
+            }
+            let [avoidMethod, avoidPathRegex] = avoidSchema;
+            if (!lodash_1.default.includes(['GET', 'POST', 'DELETE'], avoidMethod)) {
+                throw new Error(`Unrecognized proxy avoidance method '${avoidMethod}'`);
+            }
+            if (!lodash_1.default.isRegExp(avoidPathRegex)) {
+                throw new Error('Proxy avoidance path must be a regular expression');
+            }
+            let normalizedUrl = url.replace(new RegExp(`^${lodash_1.default.escapeRegExp(this.basePath)}`), '');
+            if (avoidMethod === method && avoidPathRegex.test(normalizedUrl)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     *
+     * @param {Driver} driver
+     */
+    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,"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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"}
+/**
+ * Make the basedriver version available so for any driver which inherits from this package, we
+ * know which version of basedriver it inherited from
+ */
+DriverCore.baseVersion = BASEDRIVER_VER;
+/** @type {import('@appium/types').ExecuteMethodMap<DriverCore>} */
+DriverCore.executeMethodMap = {};
+/**
+ * @typedef {import('@appium/types').Driver} Driver
+ * @typedef {import('@appium/types').Constraints} Constraints
+ * @typedef {import('@appium/types').ServerArgs} ServerArgs
+ * @typedef {import('@appium/types').EventHistory} EventHistory
+ * @typedef {import('@appium/types').AppiumLogger} AppiumLogger
+ * @typedef {import('@appium/types').StringRecord} StringRecord
+ * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints
+ */
+/**
+ * @template {Constraints} [C=BaseDriverCapConstraints]
+ * @template {StringRecord|void} [Extra=void]
+ * @typedef {import('@appium/types').Capabilities<C, Extra>} Capabilities
+ */
+/**
+ * @template {StringRecord} [T={}]
+ * @typedef {import('@appium/types').W3CCapabilities<T>} W3CCapabilities
+ */
+/**
+ * @template {Constraints} C
+ * @typedef {import('@appium/types').Core<C>} Core
+ */
+/**
+ * @template {Constraints} C
+ * @typedef {import('@appium/types').DriverOpts<C>} DriverOpts
+ */
+//# sourceMappingURL=core.js.map