appium 2.0.0-beta.43 → 2.0.0-beta.45

package/build/lib/utils.d.ts

@@ -1,21 +1,274 @@
-export type ParsedDriverCaps = {
-    desiredCaps: Capabilities;
+export type StringRecord = import('@appium/types').StringRecord;
+export type BaseDriverCapConstraints = import('@appium/types').BaseDriverCapConstraints;
+export type ParsedDriverCaps<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}, J = any> = {
+    desiredCaps: Capabilities<C>;
     protocol: string;
-    processedJsonwpCapabilities?: any;
-    processedW3CCapabilities?: W3CCapabilities | undefined;
+    processedJsonwpCapabilities?: J | undefined;
+    processedW3CCapabilities?: W3CCapabilities<C, void> | undefined;
 };
-export type InvalidCaps = {
+export type InvalidCaps<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}, J = any> = {
     error: Error;
     protocol: string;
-    desiredCaps?: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumCapabilities & {
-        [x: string]: any;
-    }> | undefined;
-    processedJsonwpCapabilities?: any;
-    processedW3CCapabilities?: W3CCapabilities | undefined;
+    desiredCaps?: Partial<import("@appium/types").ConstraintsToCaps<C> & void> | undefined;
+    processedJsonwpCapabilities?: J | undefined;
+    processedW3CCapabilities?: W3CCapabilities<C, void> | undefined;
 };
-export type W3CCapabilities = import('@appium/types').W3CCapabilities;
-export type Capabilities = import('@appium/types').Capabilities;
-export type AppiumW3CCapabilities = import('@appium/types').AppiumW3CCapabilities;
+export type Capabilities<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}, Extra extends void | import("@appium/types").StringRecord = void> = import('@appium/types').Capabilities<C, Extra>;
+export type W3CCapabilities<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}, Extra extends void | import("@appium/types").StringRecord = void> = import('@appium/types').W3CCapabilities<C, Extra>;
+export type NSCapabilities<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}, Extra extends void | import("@appium/types").StringRecord = void> = import('@appium/types').NSCapabilities<C, Extra>;
+export type ConstraintsToCaps<C extends Readonly<Record<string, import("@appium/types").Constraint>>> = import('@appium/types').ConstraintsToCaps<C>;
+export type StringKeyOf<T> = import('type-fest').StringKeyOf<T>;
+export type Constraints = import('@appium/types').Constraints;
 /**
  * Dumps to value to the console using `info` logger.
  *
@@ -26,20 +279,28 @@ export const inspect: (t1: any) => void;
  * Takes the caps that were provided in the request and translates them
  * into caps that can be used by the inner drivers.
  *
- * @param {any} jsonwpCapabilities
- * @param {W3CCapabilities} w3cCapabilities
- * @param {import('@appium/types').Constraints} constraints
- * @param {import('@appium/types').DefaultCapabilitiesConfig} [defaultCapabilities]
- * @returns {ParsedDriverCaps|InvalidCaps}
+ * @template {Constraints} C
+ * @template [J=any]
+ * @param {J} jsonwpCapabilities
+ * @param {W3CCapabilities<C>} w3cCapabilities
+ * @param {C} constraints
+ * @param {NSCapabilities<C>} [defaultCapabilities]
+ * @returns {ParsedDriverCaps<C,J>|InvalidCaps<C,J>}
  */
-export function parseCapsForInnerDriver(jsonwpCapabilities: any, w3cCapabilities: W3CCapabilities, constraints?: import('@appium/types').Constraints, defaultCapabilities?: import("@appium/types").DefaultCapabilitiesConfig | undefined): ParsedDriverCaps | InvalidCaps;
+export function parseCapsForInnerDriver<C extends Readonly<Record<string, import("@appium/types").Constraint>>, J = any>(jsonwpCapabilities: J, w3cCapabilities: W3CCapabilities<C, void>, constraints?: C, defaultCapabilities?: Partial<import("@appium/types").CapsToNSCaps<import("@appium/types").ConstraintsToCaps<C> & void, "appium">> | undefined): ParsedDriverCaps<C, J> | InvalidCaps<C, J>;
 /**
  * Takes a capabilities objects and prefixes capabilities with `appium:`
- * @param {Capabilities} caps Desired capabilities object
- * @returns {AppiumW3CCapabilities}
+ * @template {Constraints} [C={}]
+ * @param {Capabilities<C>} caps - Desired capabilities object
+ * @returns {NSCapabilities<C>}
  */
-export function insertAppiumPrefixes(caps: Capabilities): AppiumW3CCapabilities;
-export function getPackageVersion(pkgName: any): any;
+export function insertAppiumPrefixes<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {}>(caps: Partial<import("@appium/types").ConstraintsToCaps<C> & void>): Partial<import("@appium/types").CapsToNSCaps<import("@appium/types").ConstraintsToCaps<C> & void, "appium">>;
+/**
+ *
+ * @param {string} pkgName
+ * @returns {string|undefined}
+ */
+export function getPackageVersion(pkgName: string): string | undefined;
 /**
  * Pulls the initial values of Appium settings from the given capabilities argument.
  * Each setting item must satisfy the following format:
@@ -58,9 +319,17 @@ export function getPackageVersion(pkgName: any): any;
  */
 export function pullSettings(caps: any | null): any;
 /**
- *
- * @param {AppiumW3CCapabilities} caps
- * @returns {Capabilities}
+ * @template {Constraints} [C={}]
+ * @param {NSCapabilities<C>} caps
+ * @returns {Capabilities<C>}
+ */
+export function removeAppiumPrefixes<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {}>(caps: Partial<import("@appium/types").CapsToNSCaps<import("@appium/types").ConstraintsToCaps<C> & void, "appium">>): Partial<import("@appium/types").ConstraintsToCaps<C> & void>;
+/**
+ * Adjusts NODE_PATH environment variable,
+ * so drivers and plugins could load their peer dependencies.
+ * Read https://nodejs.org/api/modules.html#loading-from-the-global-folders
+ * for more details.
+ * @returns {void}
  */
-export function removeAppiumPrefixes(caps: AppiumW3CCapabilities): Capabilities;
+export function adjustNodePath(): void;
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/utils.js"],"names":[],"mappings":";iBAiQc,YAAY;cACZ,MAAM;kCACN,GAAG;;;;WAOH,KAAK;cACL,MAAM;;;;kCAEN,GAAG;;;8BAKJ,OAAO,eAAe,EAAE,eAAe;2BACvC,OAAO,eAAe,EAAE,YAAY;oCACpC,OAAO,eAAe,EAAE,qBAAqB;AApQ1D;;;;GAIG;AACH,wCAQE;AAEF;;;;;;;;;GASG;AACH,4DANW,GAAG,mBACH,eAAe,gBACf,OAAO,eAAe,EAAE,WAAW,wFAEjC,gBAAgB,GAAC,WAAW,CAgHxC;AAED;;;;GAIG;AACH,2CAHW,YAAY,GACV,qBAAqB,CAyBjC;AAyBD,qDAGC;AAED;;;;;;;;;;;;;;;GAeG;AACH,oDAgBC;AA5DD;;;;GAIG;AACH,2CAHW,qBAAqB,GACnB,YAAY,CAaxB"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/utils.js"],"names":[],"mappings":"2BA8Sa,OAAO,eAAe,EAAE,YAAY;uCACpC,OAAO,eAAe,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO/C,aAAa,CAAC,CAAC;cACf,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAUN,KAAK;cACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEASP,OAAO,eAAe,EAAE,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEAM9C,OAAO,eAAe,EAAE,eAAe,CAAC,CAAC,EAAE,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEAMjD,OAAO,eAAe,EAAE,cAAc,CAAC,CAAC,EAAE,KAAK,CAAC;wGAKhD,OAAO,eAAe,EAAE,iBAAiB,CAAC,CAAC,CAAC;6BAK5C,OAAO,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;0BAIlC,OAAO,eAAe,EAAE,WAAW;AAlVhD;;;;GAIG;AACH,wCAQE;AAEF;;;;;;;;;;;GAWG;AACH,wYAgHC;AAED;;;;;GAKG;AACH,oSAQC;AAoBD;;;;GAIG;AACH,2CAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAK5B;AAuDD;;;;;;;;;;;;;;;GAeG;AACH,oDAgBC;AAjHD;;;;GAIG;AACH,oSAEC;AAqBD;;;;;;GAMG;AACH,kCAFa,IAAI,CA8ChB"}

package/build/lib/utils.js

@@ -1,10 +1,9 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.adjustNodePath = adjustNodePath;
 exports.getPackageVersion = getPackageVersion;
 exports.insertAppiumPrefixes = insertAppiumPrefixes;
 exports.inspect = void 0;
@@ -22,7 +21,14 @@ var _baseDriver = require("@appium/base-driver");
 
 var _util = require("util");
 
+var _support = require("@appium/support");
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const W3C_APPIUM_PREFIX = 'appium';
+const STANDARD_CAPS_LOWERCASE = new Set([..._baseDriver.STANDARD_CAPS].map(cap => cap.toLowerCase()));
 const isStdoutTTY = process.stdout.isTTY;
 
 const inspect = _lodash.default.flow(_lodash.default.partialRight(_util.inspect, {
@@ -64,7 +70,7 @@ function parseCapsForInnerDriver(jsonwpCapabilities, w3cCapabilities, constraint
       for (const [defaultCapKey, defaultCapValue] of _lodash.default.toPairs(defaultCapabilities)) {
         let isCapAlreadySet = false;
 
-        for (const firstMatchEntry of w3cCapabilities.firstMatch || []) {
+        for (const firstMatchEntry of w3cCapabilities.firstMatch ?? []) {
           if (_lodash.default.isPlainObject(firstMatchEntry) && _lodash.default.has(removeAppiumPrefixes(firstMatchEntry), removeAppiumPrefix(defaultCapKey))) {
             isCapAlreadySet = true;
             break;
@@ -130,32 +136,11 @@ function parseCapsForInnerDriver(jsonwpCapabilities, w3cCapabilities, constraint
 }
 
 function insertAppiumPrefixes(caps) {
-  const STANDARD_CAPS = ['browserName', 'browserVersion', 'platformName', 'acceptInsecureCerts', 'pageLoadStrategy', 'proxy', 'setWindowRect', 'timeouts', 'unhandledPromptBehavior'];
-  let prefixedCaps = {};
-
-  for (let [name, value] of _lodash.default.toPairs(caps)) {
-    if (STANDARD_CAPS.includes(name) || name.includes(':')) {
-      prefixedCaps[name] = value;
-    } else {
-      prefixedCaps[`${W3C_APPIUM_PREFIX}:${name}`] = value;
-    }
-  }
-
-  return prefixedCaps;
+  return _lodash.default.mapKeys(caps, (_, key) => STANDARD_CAPS_LOWERCASE.has(key.toLowerCase()) || key.includes(':') ? key : `${W3C_APPIUM_PREFIX}:${key}`);
 }
 
 function removeAppiumPrefixes(caps) {
-  if (!_lodash.default.isPlainObject(caps)) {
-    return caps;
-  }
-
-  const fixedCaps = {};
-
-  for (let [name, value] of _lodash.default.toPairs(caps)) {
-    fixedCaps[removeAppiumPrefix(name)] = value;
-  }
-
-  return fixedCaps;
+  return _lodash.default.mapKeys(caps, (_, key) => removeAppiumPrefix(key));
 }
 
 function removeAppiumPrefix(key) {
@@ -168,6 +153,54 @@ function getPackageVersion(pkgName) {
   return pkgInfo.version;
 }
 
+function adjustNodePath() {
+  const selfRoot = _support.node.getModuleRootSync('appium', __filename);
+
+  if (!selfRoot || _path.default.dirname(selfRoot).length >= selfRoot.length) {
+    return;
+  }
+
+  const nodeModulesRoot = _path.default.dirname(selfRoot);
+
+  const refreshRequirePaths = () => {
+    try {
+      require('module').Module._initPaths();
+
+      return true;
+    } catch (e) {
+      return false;
+    }
+  };
+
+  if (!process.env.NODE_PATH) {
+    process.env.NODE_PATH = nodeModulesRoot;
+
+    if (refreshRequirePaths()) {
+      process.env.APPIUM_OMIT_PEER_DEPS = '1';
+    } else {
+      delete process.env.NODE_PATH;
+    }
+
+    return;
+  }
+
+  const nodePathParts = process.env.NODE_PATH.split(_path.default.delimiter);
+
+  if (nodePathParts.includes(nodeModulesRoot)) {
+    process.env.APPIUM_OMIT_PEER_DEPS = '1';
+    return;
+  }
+
+  nodePathParts.push(nodeModulesRoot);
+  process.env.NODE_PATH = nodePathParts.join(_path.default.delimiter);
+
+  if (refreshRequirePaths()) {
+    process.env.APPIUM_OMIT_PEER_DEPS = '1';
+  } else {
+    process.env.NODE_PATH = _lodash.default.without(nodePathParts, nodeModulesRoot).join(_path.default.delimiter);
+  }
+}
+
 function pullSettings(caps) {
   if (!_lodash.default.isPlainObject(caps) || _lodash.default.isEmpty(caps)) {
     return {};
@@ -188,4 +221,4 @@ function pullSettings(caps) {
 
   return result;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["W3C_APPIUM_PREFIX","isStdoutTTY","process","stdout","isTTY","inspect","_","flow","partialRight","dump","colors","depth","compact","args","logger","info","parseCapsForInnerDriver","jsonwpCapabilities","w3cCapabilities","constraints","defaultCapabilities","hasW3CCaps","isPlainObject","has","hasJSONWPCaps","desiredCaps","processedW3CCapabilities","processedJsonwpCapabilities","protocol","PROTOCOLS","W3C","error","Error","cloneDeep","isEmpty","defaultCapKey","defaultCapValue","toPairs","isCapAlreadySet","firstMatchEntry","firstMatch","removeAppiumPrefixes","removeAppiumPrefix","alwaysMatch","processCapabilities","message","insertAppiumPrefixes","caps","STANDARD_CAPS","prefixedCaps","name","value","includes","fixedCaps","key","prefix","startsWith","substring","length","getPackageVersion","pkgName","pkgInfo","require","version","pullSettings","result","match","exec"],"sources":["../../lib/utils.js"],"sourcesContent":["import _ from 'lodash';\nimport logger from './logger';\nimport {processCapabilities, PROTOCOLS} from '@appium/base-driver';\nimport {inspect as dump} from 'util';\n\nconst W3C_APPIUM_PREFIX = 'appium';\n\n/**\n *\n * If `stdout` is a TTY, this is `true`.\n *\n * Used for tighter control over log output.\n * @type {boolean}\n */\nconst isStdoutTTY = process.stdout.isTTY;\n\n/**\n * Dumps to value to the console using `info` logger.\n *\n * @todo May want to force color to be `false` if {@link isStdoutTTY} is `false`.\n */\nconst inspect = _.flow(\n  _.partialRight(\n    /** @type {(object: any, options: import('util').InspectOptions) => string} */ (dump),\n    {colors: true, depth: null, compact: !isStdoutTTY}\n  ),\n  (...args) => {\n    logger.info(...args);\n  }\n);\n\n/**\n * Takes the caps that were provided in the request and translates them\n * into caps that can be used by the inner drivers.\n *\n * @param {any} jsonwpCapabilities\n * @param {W3CCapabilities} w3cCapabilities\n * @param {import('@appium/types').Constraints} constraints\n * @param {import('@appium/types').DefaultCapabilitiesConfig} [defaultCapabilities]\n * @returns {ParsedDriverCaps|InvalidCaps}\n */\nfunction parseCapsForInnerDriver(\n  jsonwpCapabilities,\n  w3cCapabilities,\n  constraints = {},\n  defaultCapabilities = {}\n) {\n  // Check if the caller sent JSONWP caps, W3C caps, or both\n  const hasW3CCaps =\n    _.isPlainObject(w3cCapabilities) &&\n    (_.has(w3cCapabilities, 'alwaysMatch') || _.has(w3cCapabilities, 'firstMatch'));\n  const hasJSONWPCaps = _.isPlainObject(jsonwpCapabilities);\n  let desiredCaps = /** @type {ParsedDriverCaps['desiredCaps']} */ ({});\n  /** @type {ParsedDriverCaps['processedW3CCapabilities']} */\n  let processedW3CCapabilities;\n  /** @type {ParsedDriverCaps['processedJsonwpCapabilities']} */\n  let processedJsonwpCapabilities;\n\n  if (!hasW3CCaps) {\n    return /** @type {InvalidCaps} */ ({\n      protocol: PROTOCOLS.W3C,\n      error: new Error('W3C capabilities should be provided'),\n    });\n  }\n\n  const {W3C} = PROTOCOLS;\n  const protocol = W3C;\n\n  // Make sure we don't mutate the original arguments\n  jsonwpCapabilities = _.cloneDeep(jsonwpCapabilities);\n  w3cCapabilities = _.cloneDeep(w3cCapabilities);\n  defaultCapabilities = _.cloneDeep(defaultCapabilities);\n\n  if (!_.isEmpty(defaultCapabilities)) {\n    if (hasW3CCaps) {\n      for (const [defaultCapKey, defaultCapValue] of _.toPairs(defaultCapabilities)) {\n        let isCapAlreadySet = false;\n        // Check if the key is already present in firstMatch entries\n        for (const firstMatchEntry of w3cCapabilities.firstMatch || []) {\n          if (\n            _.isPlainObject(firstMatchEntry) &&\n            _.has(removeAppiumPrefixes(firstMatchEntry), removeAppiumPrefix(defaultCapKey))\n          ) {\n            isCapAlreadySet = true;\n            break;\n          }\n        }\n        // Check if the key is already present in alwaysMatch entries\n        isCapAlreadySet =\n          isCapAlreadySet ||\n          (_.isPlainObject(w3cCapabilities.alwaysMatch) &&\n            _.has(\n              removeAppiumPrefixes(w3cCapabilities.alwaysMatch),\n              removeAppiumPrefix(defaultCapKey)\n            ));\n        if (isCapAlreadySet) {\n          // Skip if the key is already present in the provided caps\n          continue;\n        }\n\n        // Only add the default capability if it is not overridden\n        if (_.isEmpty(w3cCapabilities.firstMatch)) {\n          w3cCapabilities.firstMatch = [{[defaultCapKey]: defaultCapValue}];\n        } else {\n          w3cCapabilities.firstMatch[0][defaultCapKey] = defaultCapValue;\n        }\n      }\n    }\n    if (hasJSONWPCaps) {\n      jsonwpCapabilities = {\n        ...removeAppiumPrefixes(defaultCapabilities),\n        ...jsonwpCapabilities,\n      };\n    }\n  }\n\n  // Get MJSONWP caps\n  if (hasJSONWPCaps) {\n    processedJsonwpCapabilities = {...jsonwpCapabilities};\n  }\n\n  // Get W3C caps\n  if (hasW3CCaps) {\n    // Call the process capabilities algorithm to find matching caps on the W3C\n    // (see: https://github.com/jlipps/simple-wd-spec#processing-capabilities)\n    try {\n      desiredCaps = processCapabilities(w3cCapabilities, constraints, true);\n    } catch (error) {\n      logger.info(`Could not parse W3C capabilities: ${error.message}`);\n      return /** @type {InvalidCaps} */ ({\n        desiredCaps,\n        processedJsonwpCapabilities,\n        processedW3CCapabilities,\n        protocol,\n        error,\n      });\n    }\n\n    // Create a new w3c capabilities payload that contains only the matching caps in `alwaysMatch`\n    processedW3CCapabilities = {\n      alwaysMatch: {...insertAppiumPrefixes(desiredCaps)},\n      firstMatch: [{}],\n    };\n  }\n\n  return /** @type {ParsedDriverCaps} */ ({\n    desiredCaps,\n    processedJsonwpCapabilities,\n    processedW3CCapabilities,\n    protocol,\n  });\n}\n\n/**\n * Takes a capabilities objects and prefixes capabilities with `appium:`\n * @param {Capabilities} caps Desired capabilities object\n * @returns {AppiumW3CCapabilities}\n */\nfunction insertAppiumPrefixes(caps) {\n  // Standard, non-prefixed capabilities (see https://www.w3.org/TR/webdriver/#dfn-table-of-standard-capabilities)\n  const STANDARD_CAPS = [\n    'browserName',\n    'browserVersion',\n    'platformName',\n    'acceptInsecureCerts',\n    'pageLoadStrategy',\n    'proxy',\n    'setWindowRect',\n    'timeouts',\n    'unhandledPromptBehavior',\n  ];\n\n  let prefixedCaps = {};\n  for (let [name, value] of _.toPairs(caps)) {\n    if (STANDARD_CAPS.includes(name) || name.includes(':')) {\n      prefixedCaps[name] = value;\n    } else {\n      prefixedCaps[`${W3C_APPIUM_PREFIX}:${name}`] = value;\n    }\n  }\n  return prefixedCaps;\n}\n\n/**\n *\n * @param {AppiumW3CCapabilities} caps\n * @returns {Capabilities}\n */\nfunction removeAppiumPrefixes(caps) {\n  if (!_.isPlainObject(caps)) {\n    return caps;\n  }\n\n  /** @type {Capabilities} */\n  const fixedCaps = {};\n  for (let [name, value] of _.toPairs(caps)) {\n    fixedCaps[removeAppiumPrefix(name)] = value;\n  }\n  return fixedCaps;\n}\n\nfunction removeAppiumPrefix(key) {\n  const prefix = `${W3C_APPIUM_PREFIX}:`;\n  return _.startsWith(key, prefix) ? key.substring(prefix.length) : key;\n}\n\nfunction getPackageVersion(pkgName) {\n  const pkgInfo = require(`${pkgName}/package.json`) || {};\n  return pkgInfo.version;\n}\n\n/**\n * Pulls the initial values of Appium settings from the given capabilities argument.\n * Each setting item must satisfy the following format:\n * `setting[setting_name]: setting_value`\n * The capabilities argument itself gets mutated, so it does not contain parsed\n * settings anymore to avoid further parsing issues.\n * Check\n * https://github.com/appium/appium/blob/master/docs/en/advanced-concepts/settings.md\n * for more details on the available settings.\n *\n * @param {?Object} caps - Capabilities dictionary. It is mutated if\n * one or more settings have been pulled from it\n * @return {Object} - An empty dictionary if the given caps contains no\n * setting items or a dictionary containing parsed Appium setting names along with\n * their values.\n */\nfunction pullSettings(caps) {\n  if (!_.isPlainObject(caps) || _.isEmpty(caps)) {\n    return {};\n  }\n\n  const result = {};\n  for (const [key, value] of _.toPairs(caps)) {\n    const match = /\\bsettings\\[(\\S+)\\]$/.exec(key);\n    if (!match) {\n      continue;\n    }\n\n    result[match[1]] = value;\n    delete caps[key];\n  }\n  return result;\n}\n\nexport {\n  inspect,\n  parseCapsForInnerDriver,\n  insertAppiumPrefixes,\n  getPackageVersion,\n  pullSettings,\n  removeAppiumPrefixes,\n};\n\n/**\n * @todo protocol is more specific\n * @typedef ParsedDriverCaps\n * @property {Capabilities} desiredCaps\n * @property {string} protocol\n * @property {any} [processedJsonwpCapabilities]\n * @property {W3CCapabilities} [processedW3CCapabilities]\n */\n\n/**\n * @todo protocol is more specific\n * @typedef InvalidCaps\n * @property {Error} error\n * @property {string} protocol\n * @property {Capabilities} [desiredCaps]\n * @property {any} [processedJsonwpCapabilities]\n * @property {W3CCapabilities} [processedW3CCapabilities]\n */\n\n/**\n * @typedef {import('@appium/types').W3CCapabilities} W3CCapabilities\n * @typedef {import('@appium/types').Capabilities} Capabilities\n * @typedef {import('@appium/types').AppiumW3CCapabilities} AppiumW3CCapabilities\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["W3C_APPIUM_PREFIX","STANDARD_CAPS_LOWERCASE","Set","STANDARD_CAPS","map","cap","toLowerCase","isStdoutTTY","process","stdout","isTTY","inspect","_","flow","partialRight","dump","colors","depth","compact","args","logger","info","parseCapsForInnerDriver","jsonwpCapabilities","w3cCapabilities","constraints","defaultCapabilities","hasW3CCaps","isPlainObject","has","hasJSONWPCaps","desiredCaps","processedW3CCapabilities","processedJsonwpCapabilities","protocol","PROTOCOLS","W3C","error","Error","cloneDeep","isEmpty","defaultCapKey","defaultCapValue","toPairs","isCapAlreadySet","firstMatchEntry","firstMatch","removeAppiumPrefixes","removeAppiumPrefix","alwaysMatch","processCapabilities","message","insertAppiumPrefixes","caps","mapKeys","key","includes","prefix","startsWith","substring","length","getPackageVersion","pkgName","pkgInfo","require","version","adjustNodePath","selfRoot","node","getModuleRootSync","__filename","path","dirname","nodeModulesRoot","refreshRequirePaths","Module","_initPaths","e","env","NODE_PATH","APPIUM_OMIT_PEER_DEPS","nodePathParts","split","delimiter","push","join","without","pullSettings","result","value","match","exec"],"sources":["../../lib/utils.js"],"sourcesContent":["import _ from 'lodash';\nimport logger from './logger';\nimport {processCapabilities, PROTOCOLS, STANDARD_CAPS} from '@appium/base-driver';\nimport {inspect as dump} from 'util';\nimport {node} from '@appium/support';\nimport path from 'path';\n\nconst W3C_APPIUM_PREFIX = 'appium';\nconst STANDARD_CAPS_LOWERCASE = new Set([...STANDARD_CAPS].map((cap) => cap.toLowerCase()));\n\n/**\n *\n * If `stdout` is a TTY, this is `true`.\n *\n * Used for tighter control over log output.\n * @type {boolean}\n */\nconst isStdoutTTY = process.stdout.isTTY;\n\n/**\n * Dumps to value to the console using `info` logger.\n *\n * @todo May want to force color to be `false` if {@link isStdoutTTY} is `false`.\n */\nconst inspect = _.flow(\n  _.partialRight(\n    /** @type {(object: any, options: import('util').InspectOptions) => string} */ (dump),\n    {colors: true, depth: null, compact: !isStdoutTTY}\n  ),\n  (...args) => {\n    logger.info(...args);\n  }\n);\n\n/**\n * Takes the caps that were provided in the request and translates them\n * into caps that can be used by the inner drivers.\n *\n * @template {Constraints} C\n * @template [J=any]\n * @param {J} jsonwpCapabilities\n * @param {W3CCapabilities<C>} w3cCapabilities\n * @param {C} constraints\n * @param {NSCapabilities<C>} [defaultCapabilities]\n * @returns {ParsedDriverCaps<C,J>|InvalidCaps<C,J>}\n */\nfunction parseCapsForInnerDriver(\n  jsonwpCapabilities,\n  w3cCapabilities,\n  constraints = /** @type {C} */ ({}),\n  defaultCapabilities = {}\n) {\n  // Check if the caller sent JSONWP caps, W3C caps, or both\n  const hasW3CCaps =\n    _.isPlainObject(w3cCapabilities) &&\n    (_.has(w3cCapabilities, 'alwaysMatch') || _.has(w3cCapabilities, 'firstMatch'));\n  const hasJSONWPCaps = _.isPlainObject(jsonwpCapabilities);\n  let desiredCaps = /** @type {ParsedDriverCaps<C>['desiredCaps']} */ ({});\n  /** @type {ParsedDriverCaps<C>['processedW3CCapabilities']} */\n  let processedW3CCapabilities;\n  /** @type {ParsedDriverCaps<C>['processedJsonwpCapabilities']} */\n  let processedJsonwpCapabilities;\n\n  if (!hasW3CCaps) {\n    return /** @type {InvalidCaps<C>} */ ({\n      protocol: PROTOCOLS.W3C,\n      error: new Error('W3C capabilities should be provided'),\n    });\n  }\n\n  const {W3C} = PROTOCOLS;\n  const protocol = W3C;\n\n  // Make sure we don't mutate the original arguments\n  jsonwpCapabilities = _.cloneDeep(jsonwpCapabilities);\n  w3cCapabilities = _.cloneDeep(w3cCapabilities);\n  defaultCapabilities = _.cloneDeep(defaultCapabilities);\n\n  if (!_.isEmpty(defaultCapabilities)) {\n    if (hasW3CCaps) {\n      for (const [defaultCapKey, defaultCapValue] of _.toPairs(defaultCapabilities)) {\n        let isCapAlreadySet = false;\n        // Check if the key is already present in firstMatch entries\n        for (const firstMatchEntry of w3cCapabilities.firstMatch ?? []) {\n          if (\n            _.isPlainObject(firstMatchEntry) &&\n            _.has(removeAppiumPrefixes(firstMatchEntry), removeAppiumPrefix(defaultCapKey))\n          ) {\n            isCapAlreadySet = true;\n            break;\n          }\n        }\n        // Check if the key is already present in alwaysMatch entries\n        isCapAlreadySet =\n          isCapAlreadySet ||\n          (_.isPlainObject(w3cCapabilities.alwaysMatch) &&\n            _.has(\n              removeAppiumPrefixes(w3cCapabilities.alwaysMatch),\n              removeAppiumPrefix(defaultCapKey)\n            ));\n        if (isCapAlreadySet) {\n          // Skip if the key is already present in the provided caps\n          continue;\n        }\n\n        // Only add the default capability if it is not overridden\n        if (_.isEmpty(w3cCapabilities.firstMatch)) {\n          w3cCapabilities.firstMatch = /** @type {W3CCapabilities<C>['firstMatch']} */ ([\n            {[defaultCapKey]: defaultCapValue},\n          ]);\n        } else {\n          w3cCapabilities.firstMatch[0][defaultCapKey] = defaultCapValue;\n        }\n      }\n    }\n    if (hasJSONWPCaps) {\n      jsonwpCapabilities = {\n        ...removeAppiumPrefixes(defaultCapabilities),\n        ...jsonwpCapabilities,\n      };\n    }\n  }\n\n  // Get MJSONWP caps\n  if (hasJSONWPCaps) {\n    processedJsonwpCapabilities = {...jsonwpCapabilities};\n  }\n\n  // Get W3C caps\n  if (hasW3CCaps) {\n    // Call the process capabilities algorithm to find matching caps on the W3C\n    // (see: https://github.com/jlipps/simple-wd-spec#processing-capabilities)\n    try {\n      desiredCaps = processCapabilities(w3cCapabilities, constraints, true);\n    } catch (error) {\n      logger.info(`Could not parse W3C capabilities: ${error.message}`);\n      return /** @type {InvalidCaps<C,J>} */ ({\n        desiredCaps,\n        processedJsonwpCapabilities,\n        processedW3CCapabilities,\n        protocol,\n        error,\n      });\n    }\n\n    // Create a new w3c capabilities payload that contains only the matching caps in `alwaysMatch`\n    processedW3CCapabilities = {\n      alwaysMatch: {...insertAppiumPrefixes(desiredCaps)},\n      firstMatch: [{}],\n    };\n  }\n\n  return /** @type {ParsedDriverCaps<C,J>} */ ({\n    desiredCaps,\n    processedJsonwpCapabilities,\n    processedW3CCapabilities,\n    protocol,\n  });\n}\n\n/**\n * Takes a capabilities objects and prefixes capabilities with `appium:`\n * @template {Constraints} [C={}]\n * @param {Capabilities<C>} caps - Desired capabilities object\n * @returns {NSCapabilities<C>}\n */\nfunction insertAppiumPrefixes(caps) {\n  return /** @type {NSCapabilities<C>} */ (\n    _.mapKeys(caps, (_, key) =>\n      STANDARD_CAPS_LOWERCASE.has(key.toLowerCase()) || key.includes(':')\n        ? key\n        : `${W3C_APPIUM_PREFIX}:${key}`\n    )\n  );\n}\n\n/**\n * @template {Constraints} [C={}]\n * @param {NSCapabilities<C>} caps\n * @returns {Capabilities<C>}\n */\nfunction removeAppiumPrefixes(caps) {\n  return /** @type {Capabilities<C>} */ (_.mapKeys(caps, (_, key) => removeAppiumPrefix(key)));\n}\n\n/**\n * @param {string} key\n * @returns {string}\n */\nfunction removeAppiumPrefix(key) {\n  const prefix = `${W3C_APPIUM_PREFIX}:`;\n  return _.startsWith(key, prefix) ? key.substring(prefix.length) : key;\n}\n\n/**\n *\n * @param {string} pkgName\n * @returns {string|undefined}\n */\nfunction getPackageVersion(pkgName) {\n  const pkgInfo = require(`${pkgName}/package.json`) || {};\n  return pkgInfo.version;\n}\n\n/**\n * Adjusts NODE_PATH environment variable,\n * so drivers and plugins could load their peer dependencies.\n * Read https://nodejs.org/api/modules.html#loading-from-the-global-folders\n * for more details.\n * @returns {void}\n */\nfunction adjustNodePath() {\n  const selfRoot = node.getModuleRootSync('appium', __filename);\n  if (!selfRoot || path.dirname(selfRoot).length >= selfRoot.length) {\n    return;\n  }\n  const nodeModulesRoot = path.dirname(selfRoot);\n\n  const refreshRequirePaths = () => {\n    try {\n      // ! This hack allows us to avoid modification of import\n      // ! statements in client modules. It uses a private API though,\n      // ! so it could break (maybe, eventually).\n      // See https://gist.github.com/branneman/8048520#7-the-hack\n      // @ts-ignore\n      require('module').Module._initPaths();\n      return true;\n    } catch (e) {\n      return false;\n    }\n  };\n\n  if (!process.env.NODE_PATH) {\n    process.env.NODE_PATH = nodeModulesRoot;\n    if (refreshRequirePaths()) {\n      process.env.APPIUM_OMIT_PEER_DEPS = '1';\n    } else {\n      delete process.env.NODE_PATH;\n    }\n    return;\n  }\n\n  const nodePathParts = process.env.NODE_PATH.split(path.delimiter);\n  if (nodePathParts.includes(nodeModulesRoot)) {\n    process.env.APPIUM_OMIT_PEER_DEPS = '1';\n    return;\n  }\n\n  nodePathParts.push(nodeModulesRoot);\n  process.env.NODE_PATH = nodePathParts.join(path.delimiter);\n  if (refreshRequirePaths()) {\n    process.env.APPIUM_OMIT_PEER_DEPS = '1';\n  } else {\n    process.env.NODE_PATH = _.without(nodePathParts, nodeModulesRoot).join(path.delimiter);\n  }\n}\n\n/**\n * Pulls the initial values of Appium settings from the given capabilities argument.\n * Each setting item must satisfy the following format:\n * `setting[setting_name]: setting_value`\n * The capabilities argument itself gets mutated, so it does not contain parsed\n * settings anymore to avoid further parsing issues.\n * Check\n * https://github.com/appium/appium/blob/master/docs/en/advanced-concepts/settings.md\n * for more details on the available settings.\n *\n * @param {?Object} caps - Capabilities dictionary. It is mutated if\n * one or more settings have been pulled from it\n * @return {Object} - An empty dictionary if the given caps contains no\n * setting items or a dictionary containing parsed Appium setting names along with\n * their values.\n */\nfunction pullSettings(caps) {\n  if (!_.isPlainObject(caps) || _.isEmpty(caps)) {\n    return {};\n  }\n\n  const result = {};\n  for (const [key, value] of _.toPairs(caps)) {\n    const match = /\\bsettings\\[(\\S+)\\]$/.exec(key);\n    if (!match) {\n      continue;\n    }\n\n    result[match[1]] = value;\n    delete caps[key];\n  }\n  return result;\n}\n\nexport {\n  inspect,\n  parseCapsForInnerDriver,\n  insertAppiumPrefixes,\n  getPackageVersion,\n  pullSettings,\n  removeAppiumPrefixes,\n  adjustNodePath,\n};\n\n/**\n * @typedef {import('@appium/types').StringRecord} StringRecord\n * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template [J=any]\n * @typedef ParsedDriverCaps\n * @property {Capabilities<C>} desiredCaps\n * @property {string} protocol\n * @property {J} [processedJsonwpCapabilities]\n * @property {W3CCapabilities<C>} [processedW3CCapabilities]\n */\n\n/**\n * @todo protocol is more specific\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template [J=any]\n * @typedef InvalidCaps\n * @property {Error} error\n * @property {string} protocol\n * @property {Capabilities<C>} [desiredCaps]\n * @property {J} [processedJsonwpCapabilities]\n * @property {W3CCapabilities<C>} [processedW3CCapabilities]\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').Capabilities<C, Extra>} Capabilities\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').W3CCapabilities<C, Extra>} W3CCapabilities\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').NSCapabilities<C, Extra>} NSCapabilities\n */\n\n/**\n * @template {Constraints} C\n * @typedef {import('@appium/types').ConstraintsToCaps<C>} ConstraintsToCaps\n */\n\n/**\n * @template T\n * @typedef {import('type-fest').StringKeyOf<T>} StringKeyOf\n */\n\n/**\n * @typedef {import('@appium/types').Constraints} Constraints\n */\n"],"mappings":"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"}

package/build/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["W3C_APPIUM_PREFIX","STANDARD_CAPS_LOWERCASE","Set","STANDARD_CAPS","map","cap","toLowerCase","isStdoutTTY","process","stdout","isTTY","inspect","_","flow","partialRight","dump","colors","depth","compact","args","logger","info","parseCapsForInnerDriver","jsonwpCapabilities","w3cCapabilities","constraints","defaultCapabilities","hasW3CCaps","isPlainObject","has","hasJSONWPCaps","desiredCaps","processedW3CCapabilities","processedJsonwpCapabilities","protocol","PROTOCOLS","W3C","error","Error","cloneDeep","isEmpty","defaultCapKey","defaultCapValue","toPairs","isCapAlreadySet","firstMatchEntry","firstMatch","removeAppiumPrefixes","removeAppiumPrefix","alwaysMatch","processCapabilities","message","insertAppiumPrefixes","caps","mapKeys","key","includes","prefix","startsWith","substring","length","getPackageVersion","pkgName","pkgInfo","require","version","adjustNodePath","selfRoot","node","getModuleRootSync","__filename","path","dirname","nodeModulesRoot","refreshRequirePaths","Module","_initPaths","e","env","NODE_PATH","APPIUM_OMIT_PEER_DEPS","nodePathParts","split","delimiter","push","join","without","pullSettings","result","value","match","exec"],"sources":["../../lib/utils.js"],"sourcesContent":["import _ from 'lodash';\nimport logger from './logger';\nimport {processCapabilities, PROTOCOLS, STANDARD_CAPS} from '@appium/base-driver';\nimport {inspect as dump} from 'util';\nimport {node} from '@appium/support';\nimport path from 'path';\n\nconst W3C_APPIUM_PREFIX = 'appium';\nconst STANDARD_CAPS_LOWERCASE = new Set([...STANDARD_CAPS].map((cap) => cap.toLowerCase()));\n\n/**\n *\n * If `stdout` is a TTY, this is `true`.\n *\n * Used for tighter control over log output.\n * @type {boolean}\n */\nconst isStdoutTTY = process.stdout.isTTY;\n\n/**\n * Dumps to value to the console using `info` logger.\n *\n * @todo May want to force color to be `false` if {@link isStdoutTTY} is `false`.\n */\nconst inspect = _.flow(\n  _.partialRight(\n    /** @type {(object: any, options: import('util').InspectOptions) => string} */ (dump),\n    {colors: true, depth: null, compact: !isStdoutTTY}\n  ),\n  (...args) => {\n    logger.info(...args);\n  }\n);\n\n/**\n * Takes the caps that were provided in the request and translates them\n * into caps that can be used by the inner drivers.\n *\n * @template {Constraints} C\n * @template [J=any]\n * @param {J} jsonwpCapabilities\n * @param {W3CCapabilities<C>} w3cCapabilities\n * @param {C} constraints\n * @param {NSCapabilities<C>} [defaultCapabilities]\n * @returns {ParsedDriverCaps<C,J>|InvalidCaps<C,J>}\n */\nfunction parseCapsForInnerDriver(\n  jsonwpCapabilities,\n  w3cCapabilities,\n  constraints = /** @type {C} */ ({}),\n  defaultCapabilities = {}\n) {\n  // Check if the caller sent JSONWP caps, W3C caps, or both\n  const hasW3CCaps =\n    _.isPlainObject(w3cCapabilities) &&\n    (_.has(w3cCapabilities, 'alwaysMatch') || _.has(w3cCapabilities, 'firstMatch'));\n  const hasJSONWPCaps = _.isPlainObject(jsonwpCapabilities);\n  let desiredCaps = /** @type {ParsedDriverCaps<C>['desiredCaps']} */ ({});\n  /** @type {ParsedDriverCaps<C>['processedW3CCapabilities']} */\n  let processedW3CCapabilities;\n  /** @type {ParsedDriverCaps<C>['processedJsonwpCapabilities']} */\n  let processedJsonwpCapabilities;\n\n  if (!hasW3CCaps) {\n    return /** @type {InvalidCaps<C>} */ ({\n      protocol: PROTOCOLS.W3C,\n      error: new Error('W3C capabilities should be provided'),\n    });\n  }\n\n  const {W3C} = PROTOCOLS;\n  const protocol = W3C;\n\n  // Make sure we don't mutate the original arguments\n  jsonwpCapabilities = _.cloneDeep(jsonwpCapabilities);\n  w3cCapabilities = _.cloneDeep(w3cCapabilities);\n  defaultCapabilities = _.cloneDeep(defaultCapabilities);\n\n  if (!_.isEmpty(defaultCapabilities)) {\n    if (hasW3CCaps) {\n      for (const [defaultCapKey, defaultCapValue] of _.toPairs(defaultCapabilities)) {\n        let isCapAlreadySet = false;\n        // Check if the key is already present in firstMatch entries\n        for (const firstMatchEntry of w3cCapabilities.firstMatch ?? []) {\n          if (\n            _.isPlainObject(firstMatchEntry) &&\n            _.has(removeAppiumPrefixes(firstMatchEntry), removeAppiumPrefix(defaultCapKey))\n          ) {\n            isCapAlreadySet = true;\n            break;\n          }\n        }\n        // Check if the key is already present in alwaysMatch entries\n        isCapAlreadySet =\n          isCapAlreadySet ||\n          (_.isPlainObject(w3cCapabilities.alwaysMatch) &&\n            _.has(\n              removeAppiumPrefixes(w3cCapabilities.alwaysMatch),\n              removeAppiumPrefix(defaultCapKey)\n            ));\n        if (isCapAlreadySet) {\n          // Skip if the key is already present in the provided caps\n          continue;\n        }\n\n        // Only add the default capability if it is not overridden\n        if (_.isEmpty(w3cCapabilities.firstMatch)) {\n          w3cCapabilities.firstMatch = /** @type {W3CCapabilities<C>['firstMatch']} */ ([\n            {[defaultCapKey]: defaultCapValue},\n          ]);\n        } else {\n          w3cCapabilities.firstMatch[0][defaultCapKey] = defaultCapValue;\n        }\n      }\n    }\n    if (hasJSONWPCaps) {\n      jsonwpCapabilities = {\n        ...removeAppiumPrefixes(defaultCapabilities),\n        ...jsonwpCapabilities,\n      };\n    }\n  }\n\n  // Get MJSONWP caps\n  if (hasJSONWPCaps) {\n    processedJsonwpCapabilities = {...jsonwpCapabilities};\n  }\n\n  // Get W3C caps\n  if (hasW3CCaps) {\n    // Call the process capabilities algorithm to find matching caps on the W3C\n    // (see: https://github.com/jlipps/simple-wd-spec#processing-capabilities)\n    try {\n      desiredCaps = processCapabilities(w3cCapabilities, constraints, true);\n    } catch (error) {\n      logger.info(`Could not parse W3C capabilities: ${error.message}`);\n      return /** @type {InvalidCaps<C,J>} */ ({\n        desiredCaps,\n        processedJsonwpCapabilities,\n        processedW3CCapabilities,\n        protocol,\n        error,\n      });\n    }\n\n    // Create a new w3c capabilities payload that contains only the matching caps in `alwaysMatch`\n    processedW3CCapabilities = {\n      alwaysMatch: {...insertAppiumPrefixes(desiredCaps)},\n      firstMatch: [{}],\n    };\n  }\n\n  return /** @type {ParsedDriverCaps<C,J>} */ ({\n    desiredCaps,\n    processedJsonwpCapabilities,\n    processedW3CCapabilities,\n    protocol,\n  });\n}\n\n/**\n * Takes a capabilities objects and prefixes capabilities with `appium:`\n * @template {Constraints} [C={}]\n * @param {Capabilities<C>} caps - Desired capabilities object\n * @returns {NSCapabilities<C>}\n */\nfunction insertAppiumPrefixes(caps) {\n  return /** @type {NSCapabilities<C>} */ (\n    _.mapKeys(caps, (_, key) =>\n      STANDARD_CAPS_LOWERCASE.has(key.toLowerCase()) || key.includes(':')\n        ? key\n        : `${W3C_APPIUM_PREFIX}:${key}`\n    )\n  );\n}\n\n/**\n * @template {Constraints} [C={}]\n * @param {NSCapabilities<C>} caps\n * @returns {Capabilities<C>}\n */\nfunction removeAppiumPrefixes(caps) {\n  return /** @type {Capabilities<C>} */ (_.mapKeys(caps, (_, key) => removeAppiumPrefix(key)));\n}\n\n/**\n * @param {string} key\n * @returns {string}\n */\nfunction removeAppiumPrefix(key) {\n  const prefix = `${W3C_APPIUM_PREFIX}:`;\n  return _.startsWith(key, prefix) ? key.substring(prefix.length) : key;\n}\n\n/**\n *\n * @param {string} pkgName\n * @returns {string|undefined}\n */\nfunction getPackageVersion(pkgName) {\n  const pkgInfo = require(`${pkgName}/package.json`) || {};\n  return pkgInfo.version;\n}\n\n/**\n * Adjusts NODE_PATH environment variable,\n * so drivers and plugins could load their peer dependencies.\n * Read https://nodejs.org/api/modules.html#loading-from-the-global-folders\n * for more details.\n * @returns {void}\n */\nfunction adjustNodePath() {\n  const selfRoot = node.getModuleRootSync('appium', __filename);\n  if (!selfRoot || path.dirname(selfRoot).length >= selfRoot.length) {\n    return;\n  }\n  const nodeModulesRoot = path.dirname(selfRoot);\n\n  const refreshRequirePaths = () => {\n    try {\n      // ! This hack allows us to avoid modification of import\n      // ! statements in client modules. It uses a private API though,\n      // ! so it could break (maybe, eventually).\n      // See https://gist.github.com/branneman/8048520#7-the-hack\n      // @ts-ignore\n      require('module').Module._initPaths();\n      return true;\n    } catch (e) {\n      return false;\n    }\n  };\n\n  if (!process.env.NODE_PATH) {\n    process.env.NODE_PATH = nodeModulesRoot;\n    if (refreshRequirePaths()) {\n      process.env.APPIUM_OMIT_PEER_DEPS = '1';\n    } else {\n      delete process.env.NODE_PATH;\n    }\n    return;\n  }\n\n  const nodePathParts = process.env.NODE_PATH.split(path.delimiter);\n  if (nodePathParts.includes(nodeModulesRoot)) {\n    process.env.APPIUM_OMIT_PEER_DEPS = '1';\n    return;\n  }\n\n  nodePathParts.push(nodeModulesRoot);\n  process.env.NODE_PATH = nodePathParts.join(path.delimiter);\n  if (refreshRequirePaths()) {\n    process.env.APPIUM_OMIT_PEER_DEPS = '1';\n  } else {\n    process.env.NODE_PATH = _.without(nodePathParts, nodeModulesRoot).join(path.delimiter);\n  }\n}\n\n/**\n * Pulls the initial values of Appium settings from the given capabilities argument.\n * Each setting item must satisfy the following format:\n * `setting[setting_name]: setting_value`\n * The capabilities argument itself gets mutated, so it does not contain parsed\n * settings anymore to avoid further parsing issues.\n * Check\n * https://github.com/appium/appium/blob/master/docs/en/advanced-concepts/settings.md\n * for more details on the available settings.\n *\n * @param {?Object} caps - Capabilities dictionary. It is mutated if\n * one or more settings have been pulled from it\n * @return {Object} - An empty dictionary if the given caps contains no\n * setting items or a dictionary containing parsed Appium setting names along with\n * their values.\n */\nfunction pullSettings(caps) {\n  if (!_.isPlainObject(caps) || _.isEmpty(caps)) {\n    return {};\n  }\n\n  const result = {};\n  for (const [key, value] of _.toPairs(caps)) {\n    const match = /\\bsettings\\[(\\S+)\\]$/.exec(key);\n    if (!match) {\n      continue;\n    }\n\n    result[match[1]] = value;\n    delete caps[key];\n  }\n  return result;\n}\n\nexport {\n  inspect,\n  parseCapsForInnerDriver,\n  insertAppiumPrefixes,\n  getPackageVersion,\n  pullSettings,\n  removeAppiumPrefixes,\n  adjustNodePath,\n};\n\n/**\n * @typedef {import('@appium/types').StringRecord} StringRecord\n * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template [J=any]\n * @typedef ParsedDriverCaps\n * @property {Capabilities<C>} desiredCaps\n * @property {string} protocol\n * @property {J} [processedJsonwpCapabilities]\n * @property {W3CCapabilities<C>} [processedW3CCapabilities]\n */\n\n/**\n * @todo protocol is more specific\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template [J=any]\n * @typedef InvalidCaps\n * @property {Error} error\n * @property {string} protocol\n * @property {Capabilities<C>} [desiredCaps]\n * @property {J} [processedJsonwpCapabilities]\n * @property {W3CCapabilities<C>} [processedW3CCapabilities]\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').Capabilities<C, Extra>} Capabilities\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').W3CCapabilities<C, Extra>} W3CCapabilities\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').NSCapabilities<C, Extra>} NSCapabilities\n */\n\n/**\n * @template {Constraints} C\n * @typedef {import('@appium/types').ConstraintsToCaps<C>} ConstraintsToCaps\n */\n\n/**\n * @template T\n * @typedef {import('type-fest').StringKeyOf<T>} StringKeyOf\n */\n\n/**\n * @typedef {import('@appium/types').Constraints} Constraints\n */\n"],"mappings":"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"}