@appium/base-driver 8.5.2 → 8.5.5

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

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

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

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

package/build/lib/basedriver/core.js

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

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

@@ -1,5 +1,8 @@
 /** @type {import('@appium/types').Constraints} */
 export let desiredCapabilityConstraints: import('@appium/types').Constraints;
-import validator from "validate.js";
-export { validator };
+export const validator: _validator.ValidateJS & {
+    promise: typeof B;
+};
+import _validator from "validate.js";
+import B from "bluebird";
 //# sourceMappingURL=desired-caps.d.ts.map

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":"AAIA,kDAAkD;AAClD,yCADW,OAAO,eAAe,EAAE,WAAW,CAmD5C"}
+{"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"}