@appium/base-driver 8.6.0 → 8.7.1

package/build/lib/basedriver/commands/execute.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {SessionBase} Base
+ * @returns {ExecuteBase}
+ */
+export function ExecuteMixin(Base: SessionBase): ExecuteBase;
+export type IExecuteCommands = import('@appium/types').ExecuteCommands;
+export type Driver = import('@appium/types').Driver;
+export type DriverClass = import('@appium/types').DriverClass;
+export type SessionBase = import('./session').SessionBase;
+export type ExecuteBase = import('../driver').BaseDriverBase<import('@appium/types').TimeoutCommands & import('@appium/types').EventCommands & import('@appium/types').FindCommands & import('@appium/types').LogCommands & import('@appium/types').SettingsCommands & import('@appium/types').SessionCommands & IExecuteCommands>;
+//# sourceMappingURL=execute.d.ts.map

package/build/lib/basedriver/commands/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../../lib/basedriver/commands/execute.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,mCAHW,WAAW,GACT,WAAW,CAmDvB;+BAGY,OAAO,eAAe,EAAE,eAAe;qBACvC,OAAO,eAAe,EAAE,MAAM;0BAC9B,OAAO,eAAe,EAAE,WAAW;0BACnC,OAAO,WAAW,EAAE,WAAW;0BAC/B,OAAO,WAAW,EAAE,cAAc,CAAC,OAAO,eAAe,EAAE,eAAe,GAAG,OAAO,eAAe,EAAE,aAAa,GAAG,OAAO,eAAe,EAAE,YAAY,GAAG,OAAO,eAAe,EAAE,WAAW,GAAG,OAAO,eAAe,EAAE,gBAAgB,GAAG,OAAO,eAAe,EAAE,eAAe,GAAG,gBAAgB,CAAC"}

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

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExecuteMixin = ExecuteMixin;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _protocol = require("../../protocol");
+
+function ExecuteMixin(Base) {
+  class ExecuteCommands extends Base {
+    async executeMethod(script, protoArgs) {
+      if (!protoArgs || !_lodash.default.isArray(protoArgs) || protoArgs.length > 1) {
+        throw new _protocol.errors.InvalidArgumentError(`Did not get correct format of arguments for execute method. Expected zero or one ` + `arguments to execute script and instead received: ${JSON.stringify(protoArgs)}`);
+      }
+
+      let args = protoArgs[0] ?? {};
+
+      if (!_lodash.default.isPlainObject(args)) {
+        throw new _protocol.errors.InvalidArgumentError(`Did not receive an appropriate execute method parameters object. It needs to be ` + `deserializable as a plain JS object`);
+      }
+
+      const Driver = this.constructor;
+
+      const availableScripts = _lodash.default.keys(Driver.executeMethodMap);
+
+      const commandMetadata = Driver.executeMethodMap[script];
+
+      if (!commandMetadata) {
+        throw new _protocol.errors.UnsupportedOperationError(`Unsupported execute method '${script}'. Available methods ` + `are: ${availableScripts.join(', ')}`);
+      }
+
+      let argsToApply = [];
+
+      if (!commandMetadata.params) {
+        commandMetadata.params = {
+          required: [],
+          optional: []
+        };
+      } else {
+        var _commandMetadata$para, _commandMetadata$para2;
+
+        (_commandMetadata$para = commandMetadata.params).required ?? (_commandMetadata$para.required = []);
+        (_commandMetadata$para2 = commandMetadata.params).optional ?? (_commandMetadata$para2.optional = []);
+        (0, _protocol.checkParams)(commandMetadata.params, args, null);
+      }
+
+      argsToApply = (0, _protocol.makeArgs)({}, args, commandMetadata.params, null);
+      return await this[Driver.executeMethodMap[script].command](...argsToApply);
+    }
+
+  }
+
+  return ExecuteCommands;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/basedriver/commands/index.d.ts

@@ -3,6 +3,6 @@
  * Returns a `BaseDriver` class.
  * @param {BaseDriverBase} Base
  */
-export function createBaseDriverClass(Base: BaseDriverBase): import("./session").SessionBase;
+export function createBaseDriverClass(Base: BaseDriverBase): import("./execute").ExecuteBase;
 export type BaseDriverBase<T = {}> = import('../driver').BaseDriverBase<T>;
 //# sourceMappingURL=index.d.ts.map

package/build/lib/basedriver/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../lib/basedriver/commands/index.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,4CAFW,cAAc,mCAUxB;qCAIY,OAAO,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../lib/basedriver/commands/index.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,4CAFW,cAAc,mCAWxB;qCAIY,OAAO,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC"}

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

@@ -19,6 +19,8 @@ var _settings = require("./settings");
 
 var _timeout = require("./timeout");
 
+var _execute = require("./execute");
+
 function createBaseDriverClass(Base) {
   const WithTimeoutCommands = (0, _timeout.TimeoutMixin)(Base);
   const WithEventCommands = (0, _event.EventMixin)(WithTimeoutCommands);
@@ -26,6 +28,7 @@ function createBaseDriverClass(Base) {
   const WithLogCommands = (0, _log.LogMixin)(WithFindCommands);
   const WithSettingsCommands = (0, _settings.SettingsMixin)(WithLogCommands);
   const WithSessionCommands = (0, _session.SessionMixin)(WithSettingsCommands);
-  return WithSessionCommands;
+  const WithExecuteCommands = (0, _execute.ExecuteMixin)(WithSessionCommands);
+  return WithExecuteCommands;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -2,6 +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 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;
@@ -14,6 +15,8 @@ export class DriverCore implements Core {
      * know which version of basedriver it inherited from
      */
     static baseVersion: any;
+    /** @type {ExecuteMethodMap} */
+    static executeMethodMap: ExecuteMethodMap;
     constructor(opts?: import("@appium/types").ServerArgs, shouldValidateCaps?: boolean);
     /**
      * @type {string?}
@@ -187,9 +190,9 @@ export class DriverCore implements Core {
     /**
      *
      * @param {string} sessionId
-     * @returns {[string, RegExp][]}
+     * @returns {import('@appium/types').RouteMatcher[]}
      */
-    getProxyAvoidList(sessionId: string): [string, RegExp][];
+    getProxyAvoidList(sessionId: string): import('@appium/types').RouteMatcher[];
     /**
      *
      * @param {string} [sessionId]

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

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/core.js"],"names":[],"mappings":"2BAqaa,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;AAxZjD;;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;;;;;;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,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"}
+{"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"}

package/build/lib/basedriver/core.js

@@ -36,6 +36,7 @@ const ON_UNEXPECTED_SHUTDOWN_EVENT = 'onUnexpectedShutdown';
 
 class DriverCore {
   static baseVersion = BASEDRIVER_VER;
+  static executeMethodMap = {};
   sessionId = null;
   opts;
   initialOpts;
@@ -236,4 +237,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","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  /**\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 {[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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"}
+//# 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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"}

package/build/lib/express/server.d.ts

@@ -45,6 +45,7 @@ export type ConfigureHttpOpts = {
 export type ServerOpts = {
     routeConfiguringFunction: RouteConfiguringFunction;
     port: number;
+    cliArgs: import('@appium/types').ServerArgs;
     hostname?: string | undefined;
     allowCors?: boolean | undefined;
     basePath?: string | undefined;

package/build/lib/express/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../lib/express/server.js"],"names":[],"mappings":";;;;;;;gBA6Qc,OAAO,MAAM,EAAE,MAAM;;;;UACrB,MAAM;;;;sBACN,MAAM;;;;;;2BAKP,OAAO,eAAe,EAAE,YAAY;iCACpC,OAAO,eAAe,EAAE,kBAAkB;wBAC1C,OAAO,eAAe,EAAE,SAAS;;;;;;;;gBAMhC,OAAO,MAAM,EAAE,MAAM;;;;qBACZ,GAAG,KAAK,IAAI;;;;sBACrB,MAAM;;;;;;8BAMN,wBAAwB;UACxB,MAAM;;;;;;;;;;;6CAYT,OAAO,SAAS,EAAE,OAAO,sDAEvB,IAAI;;;;;;;;;;;;SAaH,OAAO,SAAS,EAAE,OAAO;eACzB,wBAAwB;;;;;AAjStC;;;;GAIG;AACH,6BAHW,UAAU,GACR,QAAQ,YAAY,CAAC,CAqDjC;AAED;;;GAGG;AACH,0FAFW,mBAAmB,QA+C7B;AAsGD;;;;GAIG;AACH,4CAHW,MAAM,GACJ,MAAM,CAkBlB"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../lib/express/server.js"],"names":[],"mappings":";;;;;;;gBA8Qc,OAAO,MAAM,EAAE,MAAM;;;;UACrB,MAAM;;;;sBACN,MAAM;;;;;;2BAKP,OAAO,eAAe,EAAE,YAAY;iCACpC,OAAO,eAAe,EAAE,kBAAkB;wBAC1C,OAAO,eAAe,EAAE,SAAS;;;;;;;;gBAMhC,OAAO,MAAM,EAAE,MAAM;;;;qBACZ,GAAG,KAAK,IAAI;;;;sBACrB,MAAM;;;;;;8BAMN,wBAAwB;UACxB,MAAM;aACN,OAAO,eAAe,EAAE,UAAU;;;;;;;;;;;6CAYrC,OAAO,SAAS,EAAE,OAAO,sDAEvB,IAAI;;;;;;;;;;;;SAaH,OAAO,SAAS,EAAE,OAAO;eACzB,wBAAwB;;;;;AAnStC;;;;GAIG;AACH,6BAHW,UAAU,GACR,QAAQ,YAAY,CAAC,CAsDjC;AAED;;;GAGG;AACH,0FAFW,mBAAmB,QA+C7B;AAsGD;;;;GAIG;AACH,4CAHW,MAAM,GACJ,MAAM,CAkBlB"}

package/build/lib/express/server.js

@@ -50,6 +50,7 @@ async function server(opts) {
     routeConfiguringFunction,
     port,
     hostname,
+    cliArgs,
     allowCors = true,
     basePath = _constants.DEFAULT_BASE_PATH,
     extraMethodMap = {},
@@ -76,7 +77,7 @@ async function server(opts) {
       });
 
       for (const updater of serverUpdaters) {
-        await updater(app, appiumServer);
+        await updater(app, appiumServer, cliArgs);
       }
 
       app.all('*', _middleware.catch404Handler);
@@ -231,4 +232,4 @@ function normalizeBasePath(basePath) {
 
   return basePath;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["KEEP_ALIVE_TIMEOUT_MS","server","opts","routeConfiguringFunction","port","hostname","allowCors","basePath","DEFAULT_BASE_PATH","extraMethodMap","serverUpdaters","keepAliveTimeout","app","express","httpServer","http","createServer","B","resolve","reject","appiumServer","configureHttp","configureServer","addRoutes","updater","all","catch404Handler","startServer","err","normalizeBasePath","use","endLogFormatter","favicon","path","STATIC_DIR","static","produceError","produceCrash","allowCrossDomain","allowCrossDomainAsyncExecute","handleIdempotency","fixPythonContentType","defaultToJSONContentType","bodyParser","urlencoded","extended","methodOverride","catchAllHandler","json","limit","startLogFormatter","welcome","guineaPig","guineaPigScrollable","guineaPigAppBanner","serverState","notifier","EventEmitter","closed","addWebSocketHandler","removeWebSocketHandler","removeAllWebSocketHandlers","getWebSocketHandlers","close","bind","emit","log","info","on","code","error","socket","setTimeout","destroy","_openReqCount","once","removeListener","req","res","connection","start","promisify","listen","context","startPromise","headersTimeout","_","isString","Error","replace"],"sources":["../../../lib/express/server.js"],"sourcesContent":["import _ from 'lodash';\nimport path from 'path';\nimport express from 'express';\nimport http from 'http';\nimport favicon from 'serve-favicon';\nimport bodyParser from 'body-parser';\nimport methodOverride from 'method-override';\nimport log from './logger';\nimport {startLogFormatter, endLogFormatter} from './express-logging';\nimport {\n  allowCrossDomain,\n  fixPythonContentType,\n  defaultToJSONContentType,\n  catchAllHandler,\n  allowCrossDomainAsyncExecute,\n  handleIdempotency,\n  catch404Handler,\n} from './middleware';\nimport {guineaPig, guineaPigScrollable, guineaPigAppBanner, welcome, STATIC_DIR} from './static';\nimport {produceError, produceCrash} from './crash';\nimport {\n  addWebSocketHandler,\n  removeWebSocketHandler,\n  removeAllWebSocketHandlers,\n  getWebSocketHandlers,\n} from './websocket';\nimport B from 'bluebird';\nimport {DEFAULT_BASE_PATH} from '../constants';\nimport {EventEmitter} from 'events';\n\nconst KEEP_ALIVE_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes\n\n/**\n *\n * @param {ServerOpts} opts\n * @returns {Promise<AppiumServer>}\n */\nasync function server(opts) {\n  const {\n    routeConfiguringFunction,\n    port,\n    hostname,\n    allowCors = true,\n    basePath = DEFAULT_BASE_PATH,\n    extraMethodMap = {},\n    serverUpdaters = [],\n    keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS,\n  } = opts;\n\n  // create the actual http server\n  const app = express();\n  const httpServer = http.createServer(app);\n  return await new B(async (resolve, reject) => {\n    // we put an async function as the promise constructor because we want some things to happen in\n    // serial (application of plugin updates, for example). But we still need to use a promise here\n    // because some elements of server start failure only happen in httpServer listeners. So the\n    // way we resolve it is to use an async function here but to wrap all the inner logic in\n    // try/catch so any errors can be passed to reject.\n    try {\n      const appiumServer = configureHttp({\n        httpServer,\n        reject,\n        keepAliveTimeout,\n      });\n      configureServer({\n        app,\n        addRoutes: routeConfiguringFunction,\n        allowCors,\n        basePath,\n        extraMethodMap,\n      });\n      // allow extensions to update the app and http server objects\n      for (const updater of serverUpdaters) {\n        await updater(app, appiumServer);\n      }\n\n      // once all configurations and updaters have been applied, make sure to set up a catchall\n      // handler so that anything unknown 404s. But do this after everything else since we don't\n      // want to block extensions' ability to add routes if they want.\n      app.all('*', catch404Handler);\n\n      await startServer({httpServer, hostname, port, keepAliveTimeout});\n\n      resolve(appiumServer);\n    } catch (err) {\n      reject(err);\n    }\n  });\n}\n\n/**\n * Sets up some Express middleware and stuff\n * @param {ConfigureServerOpts} opts\n */\nfunction configureServer({\n  app,\n  addRoutes,\n  allowCors = true,\n  basePath = DEFAULT_BASE_PATH,\n  extraMethodMap = {},\n}) {\n  basePath = normalizeBasePath(basePath);\n\n  app.use(endLogFormatter);\n\n  // set up static assets\n  app.use(favicon(path.resolve(STATIC_DIR, 'favicon.ico')));\n  app.use(express.static(STATIC_DIR));\n\n  // crash routes, for testing\n  app.use(`${basePath}/produce_error`, produceError);\n  app.use(`${basePath}/crash`, produceCrash);\n\n  // add middlewares\n  if (allowCors) {\n    app.use(allowCrossDomain);\n  } else {\n    app.use(allowCrossDomainAsyncExecute(basePath));\n  }\n  app.use(handleIdempotency);\n  app.use(fixPythonContentType(basePath));\n  app.use(defaultToJSONContentType);\n  app.use(bodyParser.urlencoded({extended: true}));\n  app.use(methodOverride());\n  app.use(catchAllHandler);\n\n  // make sure appium never fails because of a file size upload limit\n  app.use(bodyParser.json({limit: '1gb'}));\n\n  // set up start logging (which depends on bodyParser doing its thing)\n  app.use(startLogFormatter);\n\n  addRoutes(app, {basePath, extraMethodMap});\n\n  // dynamic routes for testing, etc.\n  app.all('/welcome', welcome);\n  app.all('/test/guinea-pig', guineaPig);\n  app.all('/test/guinea-pig-scrollable', guineaPigScrollable);\n  app.all('/test/guinea-pig-app-banner', guineaPigAppBanner);\n}\n\n/**\n * Monkeypatches the `http.Server` instance and returns a {@linkcode AppiumServer}.\n * This function _mutates_ the `httpServer` parameter.\n * @param {ConfigureHttpOpts} opts\n * @returns {AppiumServer}\n */\nfunction configureHttp({httpServer, reject, keepAliveTimeout}) {\n  const serverState = {\n    notifier: new EventEmitter(),\n    closed: false,\n  };\n  // TS does not love monkeypatching.\n  const appiumServer = /** @type {AppiumServer} */ (/** @type {unknown} */ (httpServer));\n  appiumServer.addWebSocketHandler = addWebSocketHandler;\n  appiumServer.removeWebSocketHandler = removeWebSocketHandler;\n  appiumServer.removeAllWebSocketHandlers = removeAllWebSocketHandlers;\n  appiumServer.getWebSocketHandlers = getWebSocketHandlers;\n\n  // http.Server.close() only stops new connections, but we need to wait until\n  // all connections are closed and the `close` event is emitted\n  const close = appiumServer.close.bind(appiumServer);\n  appiumServer.close = async () =>\n    await new B((resolve, reject) => {\n      // https://github.com/nodejs/node-v0.x-archive/issues/9066#issuecomment-124210576\n      serverState.closed = true;\n      serverState.notifier.emit('shutdown');\n      log.info('Waiting until the server is closed');\n      httpServer.on('close', () => {\n        log.info('Received server close event');\n        resolve();\n      });\n      close((err) => {\n        if (err) reject(err); // eslint-disable-line curly\n      });\n    });\n\n  appiumServer.on(\n    'error',\n    /** @param {NodeJS.ErrnoException} err */ (err) => {\n      if (err.code === 'EADDRNOTAVAIL') {\n        log.error(\n          'Could not start REST http interface listener. ' + 'Requested address is not available.'\n        );\n      } else {\n        log.error(\n          'Could not start REST http interface listener. The requested ' +\n            'port may already be in use. Please make sure there is no ' +\n            'other instance of this server running already.'\n        );\n      }\n      reject(err);\n    }\n  );\n\n  appiumServer.on(\n    'connection',\n    /** @param {AppiumServerSocket} socket */ (socket) => {\n      socket.setTimeout(keepAliveTimeout);\n      socket.on('error', reject);\n\n      function destroy() {\n        socket.destroy();\n      }\n      socket._openReqCount = 0;\n      socket.once('close', () => serverState.notifier.removeListener('shutdown', destroy));\n      serverState.notifier.once('shutdown', destroy);\n    }\n  );\n\n  appiumServer.on('request', function (req, res) {\n    const socket = /** @type {AppiumServerSocket} */ (req.connection || req.socket);\n    socket._openReqCount++;\n    res.on('finish', function () {\n      socket._openReqCount--;\n      if (serverState.closed && socket._openReqCount === 0) {\n        socket.destroy();\n      }\n    });\n  });\n\n  return appiumServer;\n}\n\n/**\n * Starts an {@linkcode AppiumServer}\n * @param {StartServerOpts} opts\n * @returns {Promise<void>}\n */\nasync function startServer({httpServer, port, hostname, keepAliveTimeout}) {\n  // If the hostname is omitted, the server will accept\n  // connections on any IP address\n  /** @type {(port: number, hostname?: string) => B<http.Server>} */\n  const start = B.promisify(httpServer.listen, {context: httpServer});\n  const startPromise = start(port, hostname);\n  httpServer.keepAliveTimeout = keepAliveTimeout;\n  // headers timeout must be greater than keepAliveTimeout\n  httpServer.headersTimeout = keepAliveTimeout + 5 * 1000;\n  await startPromise;\n}\n\n/**\n * Normalize base path string\n * @param {string} basePath\n * @returns {string}\n */\nfunction normalizeBasePath(basePath) {\n  if (!_.isString(basePath)) {\n    throw new Error(`Invalid path prefix ${basePath}`);\n  }\n\n  // ensure the path prefix does not end in '/', since our method map\n  // starts all paths with '/'\n  basePath = basePath.replace(/\\/$/, '');\n\n  // likewise, ensure the path prefix does always START with /, unless the path\n  // is empty meaning no base path at all\n  if (basePath !== '' && basePath[0] !== '/') {\n    basePath = `/${basePath}`;\n  }\n\n  return basePath;\n}\n\nexport {server, configureServer, normalizeBasePath};\n\n/**\n * Options for {@linkcode startServer}.\n * @typedef StartServerOpts\n * @property {import('http').Server} httpServer - HTTP server instance\n * @property {number} port - Port to run on\n * @property {number} keepAliveTimeout - Keep-alive timeout in milliseconds\n * @property {string} [hostname] - Optional hostname\n */\n\n/**\n * @typedef {import('@appium/types').AppiumServer} AppiumServer\n * @typedef {import('@appium/types').AppiumServerSocket} AppiumServerSocket\n * @typedef {import('@appium/types').MethodMap} MethodMap\n */\n\n/**\n * Options for {@linkcode configureHttp}\n * @typedef ConfigureHttpOpts\n * @property {import('http').Server} httpServer - HTTP server instance\n * @property {(error?: any) => void} reject - Rejection function from `Promise` constructor\n * @property {number} keepAliveTimeout - Keep-alive timeout in milliseconds\n */\n\n/**\n * Options for {@linkcode server}\n * @typedef ServerOpts\n * @property {RouteConfiguringFunction} routeConfiguringFunction\n * @property {number} port\n * @property {string} [hostname]\n * @property {boolean} [allowCors]\n * @property {string} [basePath]\n * @property {MethodMap} [extraMethodMap]\n * @property {import('@appium/types').UpdateServerCallback[]} [serverUpdaters]\n * @property {number} [keepAliveTimeout]\n */\n\n/**\n * A function which configures routes\n * @callback RouteConfiguringFunction\n * @param {import('express').Express} app\n * @param {RouteConfiguringFunctionOpts} [opts]\n * @returns {void}\n */\n\n/**\n * Options for a {@linkcode RouteConfiguringFunction}\n * @typedef RouteConfiguringFunctionOpts\n * @property {string} [basePath]\n * @property {MethodMap} [extraMethodMap]\n */\n\n/**\n * Options for {@linkcode configureServer}\n * @typedef ConfigureServerOpts\n * @property {import('express').Express} app\n * @property {RouteConfiguringFunction} addRoutes\n * @property {boolean} [allowCors]\n * @property {string} [basePath]\n * @property {MethodMap} [extraMethodMap]\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["KEEP_ALIVE_TIMEOUT_MS","server","opts","routeConfiguringFunction","port","hostname","cliArgs","allowCors","basePath","DEFAULT_BASE_PATH","extraMethodMap","serverUpdaters","keepAliveTimeout","app","express","httpServer","http","createServer","B","resolve","reject","appiumServer","configureHttp","configureServer","addRoutes","updater","all","catch404Handler","startServer","err","normalizeBasePath","use","endLogFormatter","favicon","path","STATIC_DIR","static","produceError","produceCrash","allowCrossDomain","allowCrossDomainAsyncExecute","handleIdempotency","fixPythonContentType","defaultToJSONContentType","bodyParser","urlencoded","extended","methodOverride","catchAllHandler","json","limit","startLogFormatter","welcome","guineaPig","guineaPigScrollable","guineaPigAppBanner","serverState","notifier","EventEmitter","closed","addWebSocketHandler","removeWebSocketHandler","removeAllWebSocketHandlers","getWebSocketHandlers","close","bind","emit","log","info","on","code","error","socket","setTimeout","destroy","_openReqCount","once","removeListener","req","res","connection","start","promisify","listen","context","startPromise","headersTimeout","_","isString","Error","replace"],"sources":["../../../lib/express/server.js"],"sourcesContent":["import _ from 'lodash';\nimport path from 'path';\nimport express from 'express';\nimport http from 'http';\nimport favicon from 'serve-favicon';\nimport bodyParser from 'body-parser';\nimport methodOverride from 'method-override';\nimport log from './logger';\nimport {startLogFormatter, endLogFormatter} from './express-logging';\nimport {\n  allowCrossDomain,\n  fixPythonContentType,\n  defaultToJSONContentType,\n  catchAllHandler,\n  allowCrossDomainAsyncExecute,\n  handleIdempotency,\n  catch404Handler,\n} from './middleware';\nimport {guineaPig, guineaPigScrollable, guineaPigAppBanner, welcome, STATIC_DIR} from './static';\nimport {produceError, produceCrash} from './crash';\nimport {\n  addWebSocketHandler,\n  removeWebSocketHandler,\n  removeAllWebSocketHandlers,\n  getWebSocketHandlers,\n} from './websocket';\nimport B from 'bluebird';\nimport {DEFAULT_BASE_PATH} from '../constants';\nimport {EventEmitter} from 'events';\n\nconst KEEP_ALIVE_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes\n\n/**\n *\n * @param {ServerOpts} opts\n * @returns {Promise<AppiumServer>}\n */\nasync function server(opts) {\n  const {\n    routeConfiguringFunction,\n    port,\n    hostname,\n    cliArgs,\n    allowCors = true,\n    basePath = DEFAULT_BASE_PATH,\n    extraMethodMap = {},\n    serverUpdaters = [],\n    keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS,\n  } = opts;\n\n  // create the actual http server\n  const app = express();\n  const httpServer = http.createServer(app);\n  return await new B(async (resolve, reject) => {\n    // we put an async function as the promise constructor because we want some things to happen in\n    // serial (application of plugin updates, for example). But we still need to use a promise here\n    // because some elements of server start failure only happen in httpServer listeners. So the\n    // way we resolve it is to use an async function here but to wrap all the inner logic in\n    // try/catch so any errors can be passed to reject.\n    try {\n      const appiumServer = configureHttp({\n        httpServer,\n        reject,\n        keepAliveTimeout,\n      });\n      configureServer({\n        app,\n        addRoutes: routeConfiguringFunction,\n        allowCors,\n        basePath,\n        extraMethodMap,\n      });\n      // allow extensions to update the app and http server objects\n      for (const updater of serverUpdaters) {\n        await updater(app, appiumServer, cliArgs);\n      }\n\n      // once all configurations and updaters have been applied, make sure to set up a catchall\n      // handler so that anything unknown 404s. But do this after everything else since we don't\n      // want to block extensions' ability to add routes if they want.\n      app.all('*', catch404Handler);\n\n      await startServer({httpServer, hostname, port, keepAliveTimeout});\n\n      resolve(appiumServer);\n    } catch (err) {\n      reject(err);\n    }\n  });\n}\n\n/**\n * Sets up some Express middleware and stuff\n * @param {ConfigureServerOpts} opts\n */\nfunction configureServer({\n  app,\n  addRoutes,\n  allowCors = true,\n  basePath = DEFAULT_BASE_PATH,\n  extraMethodMap = {},\n}) {\n  basePath = normalizeBasePath(basePath);\n\n  app.use(endLogFormatter);\n\n  // set up static assets\n  app.use(favicon(path.resolve(STATIC_DIR, 'favicon.ico')));\n  app.use(express.static(STATIC_DIR));\n\n  // crash routes, for testing\n  app.use(`${basePath}/produce_error`, produceError);\n  app.use(`${basePath}/crash`, produceCrash);\n\n  // add middlewares\n  if (allowCors) {\n    app.use(allowCrossDomain);\n  } else {\n    app.use(allowCrossDomainAsyncExecute(basePath));\n  }\n  app.use(handleIdempotency);\n  app.use(fixPythonContentType(basePath));\n  app.use(defaultToJSONContentType);\n  app.use(bodyParser.urlencoded({extended: true}));\n  app.use(methodOverride());\n  app.use(catchAllHandler);\n\n  // make sure appium never fails because of a file size upload limit\n  app.use(bodyParser.json({limit: '1gb'}));\n\n  // set up start logging (which depends on bodyParser doing its thing)\n  app.use(startLogFormatter);\n\n  addRoutes(app, {basePath, extraMethodMap});\n\n  // dynamic routes for testing, etc.\n  app.all('/welcome', welcome);\n  app.all('/test/guinea-pig', guineaPig);\n  app.all('/test/guinea-pig-scrollable', guineaPigScrollable);\n  app.all('/test/guinea-pig-app-banner', guineaPigAppBanner);\n}\n\n/**\n * Monkeypatches the `http.Server` instance and returns a {@linkcode AppiumServer}.\n * This function _mutates_ the `httpServer` parameter.\n * @param {ConfigureHttpOpts} opts\n * @returns {AppiumServer}\n */\nfunction configureHttp({httpServer, reject, keepAliveTimeout}) {\n  const serverState = {\n    notifier: new EventEmitter(),\n    closed: false,\n  };\n  // TS does not love monkeypatching.\n  const appiumServer = /** @type {AppiumServer} */ (/** @type {unknown} */ (httpServer));\n  appiumServer.addWebSocketHandler = addWebSocketHandler;\n  appiumServer.removeWebSocketHandler = removeWebSocketHandler;\n  appiumServer.removeAllWebSocketHandlers = removeAllWebSocketHandlers;\n  appiumServer.getWebSocketHandlers = getWebSocketHandlers;\n\n  // http.Server.close() only stops new connections, but we need to wait until\n  // all connections are closed and the `close` event is emitted\n  const close = appiumServer.close.bind(appiumServer);\n  appiumServer.close = async () =>\n    await new B((resolve, reject) => {\n      // https://github.com/nodejs/node-v0.x-archive/issues/9066#issuecomment-124210576\n      serverState.closed = true;\n      serverState.notifier.emit('shutdown');\n      log.info('Waiting until the server is closed');\n      httpServer.on('close', () => {\n        log.info('Received server close event');\n        resolve();\n      });\n      close((err) => {\n        if (err) reject(err); // eslint-disable-line curly\n      });\n    });\n\n  appiumServer.on(\n    'error',\n    /** @param {NodeJS.ErrnoException} err */ (err) => {\n      if (err.code === 'EADDRNOTAVAIL') {\n        log.error(\n          'Could not start REST http interface listener. ' + 'Requested address is not available.'\n        );\n      } else {\n        log.error(\n          'Could not start REST http interface listener. The requested ' +\n            'port may already be in use. Please make sure there is no ' +\n            'other instance of this server running already.'\n        );\n      }\n      reject(err);\n    }\n  );\n\n  appiumServer.on(\n    'connection',\n    /** @param {AppiumServerSocket} socket */ (socket) => {\n      socket.setTimeout(keepAliveTimeout);\n      socket.on('error', reject);\n\n      function destroy() {\n        socket.destroy();\n      }\n      socket._openReqCount = 0;\n      socket.once('close', () => serverState.notifier.removeListener('shutdown', destroy));\n      serverState.notifier.once('shutdown', destroy);\n    }\n  );\n\n  appiumServer.on('request', function (req, res) {\n    const socket = /** @type {AppiumServerSocket} */ (req.connection || req.socket);\n    socket._openReqCount++;\n    res.on('finish', function () {\n      socket._openReqCount--;\n      if (serverState.closed && socket._openReqCount === 0) {\n        socket.destroy();\n      }\n    });\n  });\n\n  return appiumServer;\n}\n\n/**\n * Starts an {@linkcode AppiumServer}\n * @param {StartServerOpts} opts\n * @returns {Promise<void>}\n */\nasync function startServer({httpServer, port, hostname, keepAliveTimeout}) {\n  // If the hostname is omitted, the server will accept\n  // connections on any IP address\n  /** @type {(port: number, hostname?: string) => B<http.Server>} */\n  const start = B.promisify(httpServer.listen, {context: httpServer});\n  const startPromise = start(port, hostname);\n  httpServer.keepAliveTimeout = keepAliveTimeout;\n  // headers timeout must be greater than keepAliveTimeout\n  httpServer.headersTimeout = keepAliveTimeout + 5 * 1000;\n  await startPromise;\n}\n\n/**\n * Normalize base path string\n * @param {string} basePath\n * @returns {string}\n */\nfunction normalizeBasePath(basePath) {\n  if (!_.isString(basePath)) {\n    throw new Error(`Invalid path prefix ${basePath}`);\n  }\n\n  // ensure the path prefix does not end in '/', since our method map\n  // starts all paths with '/'\n  basePath = basePath.replace(/\\/$/, '');\n\n  // likewise, ensure the path prefix does always START with /, unless the path\n  // is empty meaning no base path at all\n  if (basePath !== '' && basePath[0] !== '/') {\n    basePath = `/${basePath}`;\n  }\n\n  return basePath;\n}\n\nexport {server, configureServer, normalizeBasePath};\n\n/**\n * Options for {@linkcode startServer}.\n * @typedef StartServerOpts\n * @property {import('http').Server} httpServer - HTTP server instance\n * @property {number} port - Port to run on\n * @property {number} keepAliveTimeout - Keep-alive timeout in milliseconds\n * @property {string} [hostname] - Optional hostname\n */\n\n/**\n * @typedef {import('@appium/types').AppiumServer} AppiumServer\n * @typedef {import('@appium/types').AppiumServerSocket} AppiumServerSocket\n * @typedef {import('@appium/types').MethodMap} MethodMap\n */\n\n/**\n * Options for {@linkcode configureHttp}\n * @typedef ConfigureHttpOpts\n * @property {import('http').Server} httpServer - HTTP server instance\n * @property {(error?: any) => void} reject - Rejection function from `Promise` constructor\n * @property {number} keepAliveTimeout - Keep-alive timeout in milliseconds\n */\n\n/**\n * Options for {@linkcode server}\n * @typedef ServerOpts\n * @property {RouteConfiguringFunction} routeConfiguringFunction\n * @property {number} port\n * @property {import('@appium/types').ServerArgs} cliArgs\n * @property {string} [hostname]\n * @property {boolean} [allowCors]\n * @property {string} [basePath]\n * @property {MethodMap} [extraMethodMap]\n * @property {import('@appium/types').UpdateServerCallback[]} [serverUpdaters]\n * @property {number} [keepAliveTimeout]\n */\n\n/**\n * A function which configures routes\n * @callback RouteConfiguringFunction\n * @param {import('express').Express} app\n * @param {RouteConfiguringFunctionOpts} [opts]\n * @returns {void}\n */\n\n/**\n * Options for a {@linkcode RouteConfiguringFunction}\n * @typedef RouteConfiguringFunctionOpts\n * @property {string} [basePath]\n * @property {MethodMap} [extraMethodMap]\n */\n\n/**\n * Options for {@linkcode configureServer}\n * @typedef ConfigureServerOpts\n * @property {import('express').Express} app\n * @property {RouteConfiguringFunction} addRoutes\n * @property {boolean} [allowCors]\n * @property {string} [basePath]\n * @property {MethodMap} [extraMethodMap]\n */\n"],"mappings":"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"}

package/build/lib/index.d.ts

@@ -7,6 +7,7 @@ export { errorFromMJSONWPStatusCode as errorFromCode } from "./protocol";
 export { STATIC_DIR } from "./express/static";
 export { JWProxy } from "./jsonwp-proxy/proxy";
 export { DEFAULT_WS_PATHNAME_PREFIX } from "./express/websocket";
+export type ServerOpts = import('./express/server').ServerOpts;
 import { BaseDriver } from "./basedriver/driver";
 export { DEFAULT_BASE_PATH, PROTOCOLS } from "./constants";
 export { server, normalizeBasePath } from "./express/server";

package/build/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.js"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.js"],"names":[],"mappings":";;;;;;;;;yBAyCa,OAAO,kBAAkB,EAAE,UAAU"}

package/build/lib/index.js

@@ -172,4 +172,4 @@ _bluebird.default.config({
 
 var _default = _driver.BaseDriver;
 exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJCIiwiY29uZmlnIiwiY2FuY2VsbGF0aW9uIiwiQmFzZURyaXZlciJdLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9pbmRleC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgQiBmcm9tICdibHVlYmlyZCc7XG5cbkIuY29uZmlnKHtcbiAgY2FuY2VsbGF0aW9uOiB0cnVlLFxufSk7XG5cbi8vIEJhc2VEcml2ZXIgZXhwb3J0c1xuaW1wb3J0IHtCYXNlRHJpdmVyfSBmcm9tICcuL2Jhc2Vkcml2ZXIvZHJpdmVyJztcbmV4cG9ydCB7RHJpdmVyQ29yZX0gZnJvbSAnLi9iYXNlZHJpdmVyL2NvcmUnO1xuZXhwb3J0IHtEZXZpY2VTZXR0aW5nc30gZnJvbSAnLi9iYXNlZHJpdmVyL2RldmljZS1zZXR0aW5ncyc7XG5cbmV4cG9ydCB7QmFzZURyaXZlcn07XG5leHBvcnQgZGVmYXVsdCBCYXNlRHJpdmVyO1xuXG4vLyBNSlNPTldQIGV4cG9ydHNcbmV4cG9ydCAqIGZyb20gJy4vcHJvdG9jb2wnO1xuZXhwb3J0IHtlcnJvckZyb21NSlNPTldQU3RhdHVzQ29kZSBhcyBlcnJvckZyb21Db2RlfSBmcm9tICcuL3Byb3RvY29sJztcbmV4cG9ydCB7REVGQVVMVF9CQVNFX1BBVEgsIFBST1RPQ09MU30gZnJvbSAnLi9jb25zdGFudHMnO1xuXG4vLyBFeHByZXNzIGV4cG9ydHNcbmV4cG9ydCB7U1RBVElDX0RJUn0gZnJvbSAnLi9leHByZXNzL3N0YXRpYyc7XG5leHBvcnQge3NlcnZlciwgbm9ybWFsaXplQmFzZVBhdGh9IGZyb20gJy4vZXhwcmVzcy9zZXJ2ZXInO1xuXG4vLyBqc29ud3AtcHJveHkgZXhwb3J0c1xuZXhwb3J0IHtKV1Byb3h5fSBmcm9tICcuL2pzb253cC1wcm94eS9wcm94eSc7XG5cbi8vIGpzb253cC1zdGF0dXMgZXhwb3J0c1xuZXhwb3J0IHtnZXRTdW1tYXJ5QnlDb2RlLCBjb2RlcyBhcyBzdGF0dXNDb2Rlc30gZnJvbSAnLi9qc29ud3Atc3RhdHVzL3N0YXR1cyc7XG5cbi8vIFczQyBjYXBhYmlsaXRpZXMgcGFyc2VyXG5leHBvcnQge1xuICBQUkVGSVhFRF9BUFBJVU1fT1BUU19DQVAsXG4gIHByb2Nlc3NDYXBhYmlsaXRpZXMsXG4gIGlzU3RhbmRhcmRDYXAsXG4gIHZhbGlkYXRlQ2Fwcyxcbn0gZnJvbSAnLi9iYXNlZHJpdmVyL2NhcGFiaWxpdGllcyc7XG5cbi8vIFdlYiBzb2NrZXQgaGVscGVyc1xuZXhwb3J0IHtERUZBVUxUX1dTX1BBVEhOQU1FX1BSRUZJWH0gZnJvbSAnLi9leHByZXNzL3dlYnNvY2tldCc7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOztBQU9BOztBQUNBOztBQUNBOztBQU1BOztBQUFBO0VBQUE7RUFBQTtFQUFBO0VBQUE7SUFBQTtJQUFBO01BQUE7SUFBQTtFQUFBO0FBQUE7O0FBRUE7O0FBR0E7O0FBQ0E7O0FBR0E7O0FBR0E7O0FBR0E7O0FBUUE7O0FBcENBQSxpQkFBQSxDQUFFQyxNQUFGLENBQVM7RUFDUEMsWUFBWSxFQUFFO0FBRFAsQ0FBVDs7ZUFVZUMsa0IifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/protocol/index.d.ts

@@ -1,6 +1,8 @@
 import { routeConfiguringFunction } from "./protocol";
 import { errors } from "./errors";
 import { isErrorType } from "./errors";
+import { makeArgs } from "./protocol";
+import { checkParams } from "./protocol";
 import { errorFromMJSONWPStatusCode } from "./errors";
 import { errorFromW3CJsonCode } from "./errors";
 import { ALL_COMMANDS } from "./routes";
@@ -12,5 +14,5 @@ import { determineProtocol } from "./protocol";
 import { CREATE_SESSION_COMMAND } from "./protocol";
 import { DELETE_SESSION_COMMAND } from "./protocol";
 import { GET_STATUS_COMMAND } from "./protocol";
-export { routeConfiguringFunction, errors, isErrorType, errorFromMJSONWPStatusCode, errorFromW3CJsonCode, ALL_COMMANDS, METHOD_MAP, routeToCommandName, NO_SESSION_ID_COMMANDS, isSessionCommand, determineProtocol, CREATE_SESSION_COMMAND, DELETE_SESSION_COMMAND, GET_STATUS_COMMAND };
+export { routeConfiguringFunction, errors, isErrorType, makeArgs, checkParams, errorFromMJSONWPStatusCode, errorFromW3CJsonCode, ALL_COMMANDS, METHOD_MAP, routeToCommandName, NO_SESSION_ID_COMMANDS, isSessionCommand, determineProtocol, CREATE_SESSION_COMMAND, DELETE_SESSION_COMMAND, GET_STATUS_COMMAND };
 //# sourceMappingURL=index.d.ts.map

package/build/lib/protocol/index.js

@@ -39,6 +39,12 @@ Object.defineProperty(exports, "NO_SESSION_ID_COMMANDS", {
     return _routes.NO_SESSION_ID_COMMANDS;
   }
 });
+Object.defineProperty(exports, "checkParams", {
+  enumerable: true,
+  get: function () {
+    return _protocol.checkParams;
+  }
+});
 Object.defineProperty(exports, "determineProtocol", {
   enumerable: true,
   get: function () {
@@ -75,6 +81,12 @@ Object.defineProperty(exports, "isSessionCommand", {
     return _protocol.isSessionCommand;
   }
 });
+Object.defineProperty(exports, "makeArgs", {
+  enumerable: true,
+  get: function () {
+    return _protocol.makeArgs;
+  }
+});
 Object.defineProperty(exports, "routeConfiguringFunction", {
   enumerable: true,
   get: function () {
@@ -95,4 +107,4 @@ var _protocol = require("./protocol");
 var _routes = require("./routes");
 
 var _errors = require("./errors");
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vbGliL3Byb3RvY29sL2luZGV4LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIGlzU2Vzc2lvbkNvbW1hbmQsXG4gIHJvdXRlQ29uZmlndXJpbmdGdW5jdGlvbixcbiAgZGV0ZXJtaW5lUHJvdG9jb2wsXG4gIENSRUFURV9TRVNTSU9OX0NPTU1BTkQsXG4gIERFTEVURV9TRVNTSU9OX0NPTU1BTkQsXG4gIEdFVF9TVEFUVVNfQ09NTUFORCxcbn0gZnJvbSAnLi9wcm90b2NvbCc7XG5pbXBvcnQge05PX1NFU1NJT05fSURfQ09NTUFORFMsIEFMTF9DT01NQU5EUywgTUVUSE9EX01BUCwgcm91dGVUb0NvbW1hbmROYW1lfSBmcm9tICcuL3JvdXRlcyc7XG5pbXBvcnQge2Vycm9ycywgaXNFcnJvclR5cGUsIGVycm9yRnJvbU1KU09OV1BTdGF0dXNDb2RlLCBlcnJvckZyb21XM0NKc29uQ29kZX0gZnJvbSAnLi9lcnJvcnMnO1xuXG5leHBvcnQge1xuICByb3V0ZUNvbmZpZ3VyaW5nRnVuY3Rpb24sXG4gIGVycm9ycyxcbiAgaXNFcnJvclR5cGUsXG4gIGVycm9yRnJvbU1KU09OV1BTdGF0dXNDb2RlLFxuICBlcnJvckZyb21XM0NKc29uQ29kZSxcbiAgQUxMX0NPTU1BTkRTLFxuICBNRVRIT0RfTUFQLFxuICByb3V0ZVRvQ29tbWFuZE5hbWUsXG4gIE5PX1NFU1NJT05fSURfQ09NTUFORFMsXG4gIGlzU2Vzc2lvbkNvbW1hbmQsXG4gIGRldGVybWluZVByb3RvY29sLFxuICBDUkVBVEVfU0VTU0lPTl9DT01NQU5ELFxuICBERUxFVEVfU0VTU0lPTl9DT01NQU5ELFxuICBHRVRfU1RBVFVTX0NPTU1BTkQsXG59O1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOztBQVFBOztBQUNBIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vbGliL3Byb3RvY29sL2luZGV4LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIGlzU2Vzc2lvbkNvbW1hbmQsXG4gIHJvdXRlQ29uZmlndXJpbmdGdW5jdGlvbixcbiAgZGV0ZXJtaW5lUHJvdG9jb2wsXG4gIENSRUFURV9TRVNTSU9OX0NPTU1BTkQsXG4gIERFTEVURV9TRVNTSU9OX0NPTU1BTkQsXG4gIEdFVF9TVEFUVVNfQ09NTUFORCxcbiAgbWFrZUFyZ3MsXG4gIGNoZWNrUGFyYW1zLFxufSBmcm9tICcuL3Byb3RvY29sJztcbmltcG9ydCB7Tk9fU0VTU0lPTl9JRF9DT01NQU5EUywgQUxMX0NPTU1BTkRTLCBNRVRIT0RfTUFQLCByb3V0ZVRvQ29tbWFuZE5hbWV9IGZyb20gJy4vcm91dGVzJztcbmltcG9ydCB7ZXJyb3JzLCBpc0Vycm9yVHlwZSwgZXJyb3JGcm9tTUpTT05XUFN0YXR1c0NvZGUsIGVycm9yRnJvbVczQ0pzb25Db2RlfSBmcm9tICcuL2Vycm9ycyc7XG5cbmV4cG9ydCB7XG4gIHJvdXRlQ29uZmlndXJpbmdGdW5jdGlvbixcbiAgZXJyb3JzLFxuICBpc0Vycm9yVHlwZSxcbiAgbWFrZUFyZ3MsXG4gIGNoZWNrUGFyYW1zLFxuICBlcnJvckZyb21NSlNPTldQU3RhdHVzQ29kZSxcbiAgZXJyb3JGcm9tVzNDSnNvbkNvZGUsXG4gIEFMTF9DT01NQU5EUyxcbiAgTUVUSE9EX01BUCxcbiAgcm91dGVUb0NvbW1hbmROYW1lLFxuICBOT19TRVNTSU9OX0lEX0NPTU1BTkRTLFxuICBpc1Nlc3Npb25Db21tYW5kLFxuICBkZXRlcm1pbmVQcm90b2NvbCxcbiAgQ1JFQVRFX1NFU1NJT05fQ09NTUFORCxcbiAgREVMRVRFX1NFU1NJT05fQ09NTUFORCxcbiAgR0VUX1NUQVRVU19DT01NQU5ELFxufTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTs7QUFVQTs7QUFDQSJ9

package/build/lib/protocol/protocol.d.ts

@@ -1,3 +1,5 @@
+export function checkParams(paramSets: any, jsonObj: any, protocol: any): void;
+export function makeArgs(requestParams: any, jsonObj: any, payloadParams: any, protocol: any): any;
 /**
  *
  * @param {import('@appium/types').Core} driver

package/build/lib/protocol/protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../lib/protocol/protocol.js"],"names":[],"mappings":"AAsNA;;;;GAIG;AACH,iDAHW,OAAO,eAAe,EAAE,IAAI,GAC1B,OAAO,mBAAmB,EAAE,wBAAwB,CAoChE;AAtND,wDAEC;AAwaD,qFAmBC;AAhdD,kEAEC;AAND,qDAA+C;AAC/C,qDAA+C;AAC/C,6CAAuC"}
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../lib/protocol/protocol.js"],"names":[],"mappings":"AAgGA,+EA2DC;AASD,mGAgDC;AAED;;;;GAIG;AACH,iDAHW,OAAO,eAAe,EAAE,IAAI,GAC1B,OAAO,mBAAmB,EAAE,wBAAwB,CAoChE;AAtND,wDAEC;AAwaD,qFAmBC;AAhdD,kEAEC;AAND,qDAA+C;AAC/C,qDAA+C;AAC/C,6CAAuC"}