@appium/base-driver 8.7.1 → 8.7.3

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

@@ -1,69 +1,234 @@
-export type W3CCapabilities = import('@appium/types').W3CCapabilities;
+/**
+ * Standard, non-prefixed capabilities
+ * @see https://www.w3.org/TR/webdriver/#dfn-table-of-standard-capabilities)
+ */
+export const STANDARD_CAPS: Readonly<Set<keyof import("@wdio/types/build/Capabilities").Capabilities>>;
 export type Constraints = import('@appium/types').Constraints;
-export type Capabilities = import('@appium/types').Capabilities;
+export type Constraint = import('@appium/types').Constraint;
+export type StringRecord = import('@appium/types').StringRecord;
+export type BaseDriverCapConstraints = import('@appium/types').BaseDriverCapConstraints;
 export type ValidateCapsOpts = {
     /**
      * - if true, skip the presence constraint
      */
     skipPresenceConstraint?: boolean | undefined;
 };
+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 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>;
 /**
- *
- * @param {W3CCapabilities} caps
- * @param {Constraints} [constraints]
+ * Parse capabilities
+ * @template {Constraints} [C={}]
+ * @param {import('@appium/types').W3CCapabilities<C>} caps
+ * @param {C} [constraints]
  * @param {boolean} [shouldValidateCaps]
- * @returns
+ * @see https://www.w3.org/TR/webdriver/#processing-capabilities
  */
-export function parseCaps(caps: W3CCapabilities, constraints?: import("@appium/types").Constraints | undefined, shouldValidateCaps?: boolean | undefined): {
-    requiredCaps: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumW3CCapabilities & {
-        [x: `${string}:${string}`]: any;
-    }>;
-    allFirstMatchCaps: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumW3CCapabilities & {
-        [x: `${string}:${string}`]: any;
-    }>[];
-    validatedFirstMatchCaps: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumCapabilities & {
-        [x: string]: any;
-    }>[];
-    matchedCaps: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumCapabilities & {
-        [x: string]: any;
-    }> | null;
-    validationErrors: any[];
+export function parseCaps<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {}>(caps: import("@appium/types").W3CCapabilities<C, void>, constraints?: C | undefined, shouldValidateCaps?: boolean | undefined): {
+    requiredCaps: {};
+    allFirstMatchCaps: Partial<import("@appium/types").CapsToNSCaps<import("@appium/types").ConstraintsToCaps<C> & void, "appium">>[] | {}[];
+    validatedFirstMatchCaps: Partial<import("@appium/types").ConstraintsToCaps<C> & void>[];
+    matchedCaps: import("type-fest").Simplify<(import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>> extends infer T ? { [Key in keyof T as import("type-fest/source/enforce-optional").RequiredFilter<import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>>, Key>]: (import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>>)[Key]; } : never) & (import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>> extends infer T_1 ? { [Key_1 in keyof T_1 as import("type-fest/source/enforce-optional").OptionalFilter<import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>>, Key_1>]?: Exclude<(import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<{}> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<C> & void>>>)[Key_1], undefined> | undefined; } : never)> | null;
+    validationErrors: string[];
 };
 /**
- *
- * @param {W3CCapabilities} w3cCaps
- * @param {Constraints} [constraints]
+ * @template {Constraints} C
+ * @param {import('@appium/types').W3CCapabilities<C>} w3cCaps
+ * @param {C} [constraints]
  * @param {boolean} [shouldValidateCaps]
- * @returns {Capabilities}
+ * @returns {import('@appium/types').Capabilities<C>}
  */
-export function processCapabilities(w3cCaps: W3CCapabilities, constraints?: import("@appium/types").Constraints | undefined, shouldValidateCaps?: boolean | undefined): Capabilities;
+export function processCapabilities<C extends Readonly<Record<string, import("@appium/types").Constraint>>>(w3cCaps: import("@appium/types").W3CCapabilities<C, void>, constraints?: C | undefined, shouldValidateCaps?: boolean | undefined): Partial<import("@appium/types").ConstraintsToCaps<C> & void>;
 /**
- *
- * @param {Capabilities} caps
- * @param {Constraints} [constraints]
+ * @template {Constraints} [C={}]
+ * @param {Capabilities<C>} caps
+ * @param {C} [constraints]
  * @param {ValidateCapsOpts} [opts]
- * @returns {Capabilities}
+ * @returns {Capabilities<C>}
  */
-export function validateCaps(caps: Capabilities, constraints?: import("@appium/types").Constraints | undefined, opts?: ValidateCapsOpts | undefined): Capabilities;
+export function validateCaps<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {}>(caps: Partial<import("@appium/types").ConstraintsToCaps<C> & void>, constraints?: C | undefined, opts?: ValidateCapsOpts | undefined): Partial<import("@appium/types").ConstraintsToCaps<C> & void>;
 /**
- * @param {Capabilities} [primary]
- * @param {Capabilities} [secondary]
- * @returns {Capabilities}
+ * Takes primary caps object and merges it into a secondary caps object.
+ * @template {Constraints} [T={}]
+ * @template {Constraints} [U={}]
+ * @param {Capabilities<T>} [primary]
+ * @param {Capabilities<U>} [secondary]
+ * @returns {import('type-fest').Merge<Capabilities<T>, Capabilities<U>>}
+ * @see https://www.w3.org/TR/webdriver/#dfn-merging-capabilities)
  */
-export function mergeCaps(primary?: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumCapabilities & {
-    [x: string]: any;
-}> | undefined, secondary?: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumCapabilities & {
-    [x: string]: any;
-}> | undefined): Capabilities;
+export function mergeCaps<T extends Readonly<Record<string, import("@appium/types").Constraint>> = {}, U extends Readonly<Record<string, import("@appium/types").Constraint>> = {}>(primary?: Partial<import("@appium/types").ConstraintsToCaps<T> & void> | undefined, secondary?: Partial<import("@appium/types").ConstraintsToCaps<U> & void> | undefined): import("type-fest").Simplify<(import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>> extends infer T_1 ? { [Key in keyof T_1 as import("type-fest/source/enforce-optional").RequiredFilter<import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>>, Key>]: (import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>>)[Key]; } : never) & (import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>> extends infer T_2 ? { [Key_1 in keyof T_2 as import("type-fest/source/enforce-optional").OptionalFilter<import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>>, Key_1>]?: Exclude<(import("type-fest/source/merge").SimpleMerge<import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").PickIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>> & import("type-fest/source/merge").SimpleMerge<import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<T> & void>>, import("type-fest").OmitIndexSignature<Partial<import("@appium/types").ConstraintsToCaps<U> & void>>>)[Key_1], undefined> | undefined; } : never)>;
 export const APPIUM_VENDOR_PREFIX: "appium:";
 export const APPIUM_OPTS_CAP: "options";
 /**
  * Get an array of all the unprefixed caps that are being used in 'alwaysMatch' and all of the 'firstMatch' object
- * @param {Object} caps A capabilities object
+ * @template {Constraints} [C={}]
+ * @param {import('@appium/types').W3CCapabilities<C>} caps A capabilities object
+ */
+export function findNonPrefixedCaps<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {}>({ alwaysMatch, firstMatch }: import("@appium/types").W3CCapabilities<C, void>): string[];
+/**
+ * @param {string} cap
+ * @returns {boolean}
+ */
+export function isStandardCap(cap: string): boolean;
+/**
+ * If the 'appium:' prefix was provided and it's a valid capability, strip out the prefix
+ * @template {Constraints} [C={}]
+ * @param {import('@appium/types').NSCapabilities<C>} caps
+ * @see https://www.w3.org/TR/webdriver/#dfn-extension-capabilities
+ * @internal
+ * @returns {import('@appium/types').Capabilities<C>}
  */
-export function findNonPrefixedCaps({ alwaysMatch, firstMatch }: any): string[];
-export function isStandardCap(cap: any): boolean;
-export function stripAppiumPrefixes(caps: any): void;
+export function stripAppiumPrefixes<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>;
 /**
  * Return a copy of a capabilities object which has taken everything within the 'options'
  * capability and promoted it to the top level. Note that this function is assumed to be run after

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

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/capabilities.js"],"names":[],"mappings":"8BAiWa,OAAO,eAAe,EAAE,eAAe;0BACvC,OAAO,eAAe,EAAE,WAAW;2BACnC,OAAO,eAAe,EAAE,YAAY;;;;;;;AAtMjD;;;;;;GAMG;AACH,gCALW,eAAe;;;;;;;;;;;;;;EA0GzB;AAGD;;;;;;GAMG;AACH,6CALW,eAAe,4GAGb,YAAY,CAqBxB;AAhQD;;;;;;GAMG;AACH,mCALW,YAAY,uGAGV,YAAY,CAkCxB;AA/DD;;;;GAIG;AACH;;;;iBAFa,YAAY,CAkBxB;AA3BD,6CAAuC;AACvC,wCAAkC;AAkIlC;;;GAGG;AACH,gFAWC;AA9DD,iDAKC;AAID,qDAoCC;AA+JD;;;;;;;;;;GAUG;AACH,mDAHW,MAAM,GACL,MAAM,CA+BjB;AAtUD,8CAA6E"}
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/capabilities.js"],"names":[],"mappings":"AA2FA;;;GAGG;AACH,uGAcE;0BA2RW,OAAO,eAAe,EAAE,WAAW;yBACnC,OAAO,eAAe,EAAE,UAAU;2BAClC,OAAO,eAAe,EAAE,YAAY;uCACpC,OAAO,eAAe,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEAWhD,OAAO,eAAe,EAAE,cAAc,CAAC,CAAC,EAAE,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEAMhD,OAAO,eAAe,EAAE,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEAM9C,OAAO,eAAe,EAAE,eAAe,CAAC,CAAC,EAAE,KAAK,CAAC;AAhO9D;;;;;;;GAOG;AACH;;;;;;EAmGC;AAGD;;;;;;GAMG;AACH,4SAuBC;AApSD;;;;;;GAMG;AACH,8SAwCC;AA7ED;;;;;;;;GAQG;AACH,kmHAkBC;AA/BD,6CAAuC;AACvC,wCAAkC;AAuKlC;;;;GAIG;AACH,0MAWC;AA/ED;;;GAGG;AACH,mCAHW,MAAM,GACJ,OAAO,CAInB;AAED;;;;;;;GAOG;AACH,mSA6CC;AAkKD;;;;;;;;;;GAUG;AACH,mDAHW,MAAM,GACL,MAAM,CA8BjB;AA7WD,8CAA6E"}

package/build/lib/basedriver/capabilities.js

@@ -1,11 +1,9 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PREFIXED_APPIUM_OPTS_CAP = exports.APPIUM_VENDOR_PREFIX = exports.APPIUM_OPTS_CAP = void 0;
+exports.STANDARD_CAPS = exports.PREFIXED_APPIUM_OPTS_CAP = exports.APPIUM_VENDOR_PREFIX = exports.APPIUM_OPTS_CAP = void 0;
 exports.findNonPrefixedCaps = findNonPrefixedCaps;
 exports.isStandardCap = isStandardCap;
 exports.mergeCaps = mergeCaps;
@@ -27,6 +25,8 @@ var _logger = _interopRequireDefault(require("./logger"));
 
 var _errors = require("../protocol/errors");
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const APPIUM_VENDOR_PREFIX = 'appium:';
 exports.APPIUM_VENDOR_PREFIX = APPIUM_VENDOR_PREFIX;
 const APPIUM_OPTS_CAP = 'options';
@@ -35,7 +35,8 @@ const PREFIXED_APPIUM_OPTS_CAP = `${APPIUM_VENDOR_PREFIX}${APPIUM_OPTS_CAP}`;
 exports.PREFIXED_APPIUM_OPTS_CAP = PREFIXED_APPIUM_OPTS_CAP;
 
 function mergeCaps(primary = {}, secondary = {}) {
-  let result = Object.assign({}, primary);
+  let result = { ...primary
+  };
 
   for (let [name, value] of _lodash.default.toPairs(secondary)) {
     if (!_lodash.default.isUndefined(primary[name])) {
@@ -57,15 +58,19 @@ function validateCaps(caps, constraints = {}, opts = {}) {
     throw new _errors.errors.InvalidArgumentError(`must be a JSON object`);
   }
 
-  constraints = _lodash.default.cloneDeep(constraints);
-
-  if (skipPresenceConstraint) {
-    for (let key of _lodash.default.keys(constraints)) {
-      delete constraints[key].presence;
+  constraints = _lodash.default.mapValues(constraints, skipPresenceConstraint ? constraint => _lodash.default.omit(constraint, 'presence') : constraint => {
+    if (constraint.presence === true) {
+      return { ..._lodash.default.omit(constraint, 'presence'),
+        presence: {
+          allowEmpty: false
+        }
+      };
     }
-  }
 
-  let validationErrors = _desiredCaps.validator.validate(_lodash.default.pickBy(caps, _support.util.hasValue), constraints, {
+    return constraint;
+  });
+
+  const validationErrors = _desiredCaps.validator.validate(_lodash.default.pickBy(caps, _support.util.hasValue), constraints, {
     fullMessages: false
   });
 
@@ -84,40 +89,42 @@ function validateCaps(caps, constraints = {}, opts = {}) {
   return caps;
 }
 
-const STANDARD_CAPS = ['browserName', 'browserVersion', 'platformName', 'acceptInsecureCerts', 'pageLoadStrategy', 'proxy', 'setWindowRect', 'timeouts', 'unhandledPromptBehavior'];
+const STANDARD_CAPS = Object.freeze(new Set(['browserName', 'browserVersion', 'platformName', 'acceptInsecureCerts', 'pageLoadStrategy', 'proxy', 'setWindowRect', 'timeouts', 'unhandledPromptBehavior']));
+exports.STANDARD_CAPS = STANDARD_CAPS;
+const STANDARD_CAPS_LOWER = new Set([...STANDARD_CAPS].map(cap => cap.toLowerCase()));
 
 function isStandardCap(cap) {
-  return !!_lodash.default.find(STANDARD_CAPS, standardCap => standardCap.toLowerCase() === `${cap}`.toLowerCase());
+  return STANDARD_CAPS_LOWER.has(cap.toLowerCase());
 }
 
 function stripAppiumPrefixes(caps) {
-  const prefix = 'appium:';
+  const [prefixedCaps, nonPrefixedCaps] = _lodash.default.partition(_lodash.default.keys(caps), cap => String(cap).startsWith(APPIUM_VENDOR_PREFIX));
 
-  const prefixedCaps = _lodash.default.filter(_lodash.default.keys(caps), cap => `${cap}`.startsWith(prefix));
+  let strippedCaps = _lodash.default.pick(caps, nonPrefixedCaps);
 
   const badPrefixedCaps = [];
 
   for (let prefixedCap of prefixedCaps) {
-    const strippedCapName = prefixedCap.substr(prefix.length);
+    const strippedCapName = prefixedCap.substring(APPIUM_VENDOR_PREFIX.length);
 
     if (isStandardCap(strippedCapName)) {
       badPrefixedCaps.push(strippedCapName);
 
-      if (_lodash.default.isNil(caps[strippedCapName])) {
-        caps[strippedCapName] = caps[prefixedCap];
+      if (_lodash.default.isNil(strippedCaps[strippedCapName])) {
+        strippedCaps[strippedCapName] = caps[prefixedCap];
       } else {
-        _logger.default.warn(`Ignoring capability '${prefixedCap}=${caps[prefixedCap]}' and ` + `using capability '${strippedCapName}=${caps[strippedCapName]}'`);
+        _logger.default.warn(`Ignoring capability '${prefixedCap}=${caps[prefixedCap]}' and ` + `using capability '${strippedCapName}=${strippedCaps[strippedCapName]}'`);
       }
     } else {
-      caps[strippedCapName] = caps[prefixedCap];
+      strippedCaps[strippedCapName] = caps[prefixedCap];
     }
-
-    delete caps[prefixedCap];
   }
 
   if (badPrefixedCaps.length > 0) {
     _logger.default.warn(`The capabilities ${JSON.stringify(badPrefixedCaps)} are standard capabilities and do not require "appium:" prefix`);
   }
+
+  return strippedCaps;
 }
 
 function findNonPrefixedCaps({
@@ -153,32 +160,20 @@ function parseCaps(caps, constraints = {}, shouldValidateCaps = true) {
     throw new _errors.errors.InvalidArgumentError(`All non-standard capabilities should have a vendor prefix. The following capabilities did not have one: ${nonPrefixedCaps}`);
   }
 
-  stripAppiumPrefixes(requiredCaps);
-
-  for (let firstMatchCaps of allFirstMatchCaps) {
-    stripAppiumPrefixes(firstMatchCaps);
-  }
+  let strippedRequiredCaps = stripAppiumPrefixes(requiredCaps);
+  let strippedAllFirstMatchCaps = allFirstMatchCaps.map(stripAppiumPrefixes);
 
   if (shouldValidateCaps) {
-    requiredCaps = validateCaps(requiredCaps, constraints, {
+    strippedRequiredCaps = validateCaps(strippedRequiredCaps, constraints, {
       skipPresenceConstraint: true
     });
   }
 
-  let filteredConstraints = { ...constraints
-  };
-
-  let requiredCapsKeys = _lodash.default.keys(requiredCaps);
-
-  for (let key of _lodash.default.keys(filteredConstraints)) {
-    if (requiredCapsKeys.includes(key)) {
-      delete filteredConstraints[key];
-    }
-  }
+  const filteredConstraints = _lodash.default.omitBy(constraints, (_, key) => key in strippedRequiredCaps);
 
   let validationErrors = [];
 
-  let validatedFirstMatchCaps = _lodash.default.compact(allFirstMatchCaps.map(firstMatchCaps => {
+  let validatedFirstMatchCaps = _lodash.default.compact(strippedAllFirstMatchCaps.map(firstMatchCaps => {
     try {
       return shouldValidateCaps ? validateCaps(firstMatchCaps, filteredConstraints) : firstMatchCaps;
     } catch (e) {
@@ -190,7 +185,7 @@ function parseCaps(caps, constraints = {}, shouldValidateCaps = true) {
 
   for (let firstMatchCaps of validatedFirstMatchCaps) {
     try {
-      matchedCaps = mergeCaps(requiredCaps, firstMatchCaps);
+      matchedCaps = mergeCaps(strippedRequiredCaps, firstMatchCaps);
 
       if (matchedCaps) {
         break;
@@ -241,18 +236,18 @@ function promoteAppiumOptions(originalCaps) {
     throw new _errors.errors.SessionNotCreatedError(`The ${APPIUM_OPTS_CAP} capability must be an object`);
   }
 
-  stripAppiumPrefixes(appiumOptions);
+  const strippedAppiumOptions = stripAppiumPrefixes(appiumOptions);
 
-  const overwrittenKeys = _lodash.default.intersection(Object.keys(caps), Object.keys(appiumOptions));
+  const overwrittenKeys = _lodash.default.intersection(Object.keys(caps), Object.keys(strippedAppiumOptions));
 
   if (overwrittenKeys.length > 0) {
     _logger.default.warn(`Found capabilities inside ${PREFIXED_APPIUM_OPTS_CAP} that will overwrite ` + `capabilities at the top level: ${JSON.stringify(overwrittenKeys)}`);
   }
 
   caps = { ...caps,
-    ...appiumOptions
+    ...strippedAppiumOptions
   };
   delete caps[APPIUM_OPTS_CAP];
   return caps;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["APPIUM_VENDOR_PREFIX","APPIUM_OPTS_CAP","PREFIXED_APPIUM_OPTS_CAP","mergeCaps","primary","secondary","result","Object","assign","name","value","_","toPairs","isUndefined","errors","InvalidArgumentError","JSON","stringify","validateCaps","caps","constraints","opts","skipPresenceConstraint","isPlainObject","cloneDeep","key","keys","presence","validationErrors","validator","validate","pickBy","util","hasValue","fullMessages","message","attribute","reasons","reason","push","join","STANDARD_CAPS","isStandardCap","cap","find","standardCap","toLowerCase","stripAppiumPrefixes","prefix","prefixedCaps","filter","startsWith","badPrefixedCaps","prefixedCap","strippedCapName","substr","length","isNil","log","warn","findNonPrefixedCaps","alwaysMatch","firstMatch","chain","reduce","unprefixedCaps","includes","uniq","parseCaps","shouldValidateCaps","requiredCaps","allFirstMatchCaps","isArray","nonPrefixedCaps","isEmpty","firstMatchCaps","filteredConstraints","requiredCapsKeys","validatedFirstMatchCaps","compact","map","e","matchedCaps","err","processCapabilities","w3cCaps","promoteAppiumOptions","originalCaps","appiumOptions","SessionNotCreatedError","overwrittenKeys","intersection"],"sources":["../../../lib/basedriver/capabilities.js"],"sourcesContent":["// @ts-check\n\nimport _ from 'lodash';\nimport {validator} from './desired-caps';\nimport {util} from '@appium/support';\nimport log from './logger';\nimport {errors} from '../protocol/errors';\n\nconst APPIUM_VENDOR_PREFIX = 'appium:';\nconst APPIUM_OPTS_CAP = 'options';\nconst PREFIXED_APPIUM_OPTS_CAP = `${APPIUM_VENDOR_PREFIX}${APPIUM_OPTS_CAP}`;\n\n// Takes primary caps object and merges it into a secondary caps object.\n// (see https://www.w3.org/TR/webdriver/#dfn-merging-capabilities)\n/**\n * @param {Capabilities} [primary]\n * @param {Capabilities} [secondary]\n * @returns {Capabilities}\n */\nfunction mergeCaps(primary = {}, secondary = {}) {\n  let result = Object.assign({}, primary);\n\n  for (let [name, value] of _.toPairs(secondary)) {\n    // Overwriting is not allowed. Primary and secondary must have different properties (w3c rule 4.4)\n    if (!_.isUndefined(primary[name])) {\n      throw new errors.InvalidArgumentError(\n        `property '${name}' should not exist on both primary (${JSON.stringify(\n          primary\n        )}) and secondary (${JSON.stringify(secondary)}) object`\n      );\n    }\n    result[name] = value;\n  }\n\n  return result;\n}\n\n// Validates caps against a set of constraints\n/**\n *\n * @param {Capabilities} caps\n * @param {Constraints} [constraints]\n * @param {ValidateCapsOpts} [opts]\n * @returns {Capabilities}\n */\nfunction validateCaps(caps, constraints = {}, opts = {}) {\n  let {skipPresenceConstraint} = opts;\n\n  if (!_.isPlainObject(caps)) {\n    throw new errors.InvalidArgumentError(`must be a JSON object`);\n  }\n\n  constraints = _.cloneDeep(constraints); // Defensive copy\n\n  if (skipPresenceConstraint) {\n    // Remove the 'presence' constraint if we're not checking for it\n    for (let key of _.keys(constraints)) {\n      delete constraints[key].presence;\n    }\n  }\n\n  let validationErrors = validator.validate(_.pickBy(caps, util.hasValue), constraints, {\n    fullMessages: false,\n  });\n\n  if (validationErrors) {\n    let message = [];\n    for (let [attribute, reasons] of _.toPairs(validationErrors)) {\n      for (let reason of reasons) {\n        message.push(`'${attribute}' ${reason}`);\n      }\n    }\n    throw new errors.InvalidArgumentError(message.join('; '));\n  }\n\n  // Return caps\n  return caps;\n}\n\n// Standard, non-prefixed capabilities (see https://www.w3.org/TR/webdriver/#dfn-table-of-standard-capabilities)\nconst STANDARD_CAPS = [\n  'browserName',\n  'browserVersion',\n  'platformName',\n  'acceptInsecureCerts',\n  'pageLoadStrategy',\n  'proxy',\n  'setWindowRect',\n  'timeouts',\n  'unhandledPromptBehavior',\n];\n\nfunction isStandardCap(cap) {\n  return !!_.find(\n    STANDARD_CAPS,\n    (standardCap) => standardCap.toLowerCase() === `${cap}`.toLowerCase()\n  );\n}\n\n// If the 'appium:' prefix was provided and it's a valid capability, strip out the prefix (see https://www.w3.org/TR/webdriver/#dfn-extension-capabilities)\n// (NOTE: Method is destructive and mutates contents of caps)\nfunction stripAppiumPrefixes(caps) {\n  const prefix = 'appium:';\n  const prefixedCaps = _.filter(_.keys(caps), (cap) => `${cap}`.startsWith(prefix));\n  const badPrefixedCaps = [];\n\n  // Strip out the 'appium:' prefix\n  for (let prefixedCap of prefixedCaps) {\n    const strippedCapName = prefixedCap.substr(prefix.length);\n\n    // If it's standard capability that was prefixed, add it to an array of incorrectly prefixed capabilities\n    if (isStandardCap(strippedCapName)) {\n      badPrefixedCaps.push(strippedCapName);\n      if (_.isNil(caps[strippedCapName])) {\n        caps[strippedCapName] = caps[prefixedCap];\n      } else {\n        log.warn(\n          `Ignoring capability '${prefixedCap}=${caps[prefixedCap]}' and ` +\n            `using capability '${strippedCapName}=${caps[strippedCapName]}'`\n        );\n      }\n    } else {\n      caps[strippedCapName] = caps[prefixedCap];\n    }\n\n    // Strip out the prefix\n    delete caps[prefixedCap];\n  }\n\n  // If we found standard caps that were incorrectly prefixed, throw an exception (e.g.: don't accept 'appium:platformName', only accept just 'platformName')\n  if (badPrefixedCaps.length > 0) {\n    log.warn(\n      `The capabilities ${JSON.stringify(\n        badPrefixedCaps\n      )} are standard capabilities and do not require \"appium:\" prefix`\n    );\n  }\n}\n\n/**\n * Get an array of all the unprefixed caps that are being used in 'alwaysMatch' and all of the 'firstMatch' object\n * @param {Object} caps A capabilities object\n */\nfunction findNonPrefixedCaps({alwaysMatch = {}, firstMatch = []}) {\n  return _.chain([alwaysMatch, ...firstMatch])\n    .reduce(\n      (unprefixedCaps, caps) => [\n        ...unprefixedCaps,\n        ...Object.keys(caps).filter((cap) => !cap.includes(':') && !isStandardCap(cap)),\n      ],\n      []\n    )\n    .uniq()\n    .value();\n}\n\n// Parse capabilities (based on https://www.w3.org/TR/webdriver/#processing-capabilities)\n/**\n *\n * @param {W3CCapabilities} caps\n * @param {Constraints} [constraints]\n * @param {boolean} [shouldValidateCaps]\n * @returns\n */\nfunction parseCaps(caps, constraints = {}, shouldValidateCaps = true) {\n  // If capabilities request is not an object, return error (#1.1)\n  if (!_.isPlainObject(caps)) {\n    throw new errors.InvalidArgumentError(\n      'The capabilities argument was not valid for the following reason(s): \"capabilities\" must be a JSON object.'\n    );\n  }\n\n  // Let 'requiredCaps' be property named 'alwaysMatch' from capabilities request (#2)\n  // and 'allFirstMatchCaps' be property named 'firstMatch' from capabilities request (#3)\n  let {\n    alwaysMatch: requiredCaps = {}, // If 'requiredCaps' is undefined, set it to an empty JSON object (#2.1)\n    firstMatch: allFirstMatchCaps = [{}], // If 'firstMatch' is undefined set it to a singleton list with one empty object (#3.1)\n  } = caps;\n\n  // Reject 'firstMatch' argument if it's not an array (#3.2)\n  if (!_.isArray(allFirstMatchCaps)) {\n    throw new errors.InvalidArgumentError(\n      'The capabilities.firstMatch argument was not valid for the following reason(s): \"capabilities.firstMatch\" must be a JSON array or undefined'\n    );\n  }\n\n  // If an empty array as provided, we'll be forgiving and make it an array of one empty object\n  // In the future, reject 'firstMatch' argument if its array did not have one or more entries (#3.2)\n  if (allFirstMatchCaps.length === 0) {\n    log.warn(\n      `The firstMatch array in the given capabilities has no entries. Adding an empty entry fo rnow, ` +\n        `but it will require one or more entries as W3C spec.`\n    );\n    allFirstMatchCaps.push({});\n  }\n\n  // Check for non-prefixed, non-standard capabilities and log warnings if they are found\n  let nonPrefixedCaps = findNonPrefixedCaps(caps);\n  if (!_.isEmpty(nonPrefixedCaps)) {\n    throw new errors.InvalidArgumentError(\n      `All non-standard capabilities should have a vendor prefix. The following capabilities did not have one: ${nonPrefixedCaps}`\n    );\n  }\n\n  // Strip out the 'appium:' prefix from all\n  stripAppiumPrefixes(requiredCaps);\n  for (let firstMatchCaps of allFirstMatchCaps) {\n    stripAppiumPrefixes(firstMatchCaps);\n  }\n\n  // Validate the requiredCaps. But don't validate 'presence' because if that constraint fails on 'alwaysMatch' it could still pass on one of the 'firstMatch' keys\n  if (shouldValidateCaps) {\n    requiredCaps = validateCaps(requiredCaps, constraints, {\n      skipPresenceConstraint: true,\n    });\n  }\n\n  // Remove the 'presence' constraint for any keys that are already present in 'requiredCaps'\n  // since we know that this constraint has already passed\n  let filteredConstraints = {...constraints};\n  let requiredCapsKeys = _.keys(requiredCaps);\n  for (let key of _.keys(filteredConstraints)) {\n    if (requiredCapsKeys.includes(key)) {\n      delete filteredConstraints[key];\n    }\n  }\n\n  // Validate all of the first match capabilities and return an array with only the valid caps (see spec #5)\n  let validationErrors = [];\n  /** @type {Capabilities[]} */\n  let validatedFirstMatchCaps = _.compact(\n    allFirstMatchCaps.map((firstMatchCaps) => {\n      try {\n        // Validate firstMatch caps\n        return shouldValidateCaps\n          ? validateCaps(firstMatchCaps, filteredConstraints)\n          : firstMatchCaps;\n      } catch (e) {\n        validationErrors.push(e.message);\n      }\n    })\n  );\n\n  // Try to merge requiredCaps with first match capabilities, break once it finds its first match (see spec #6)\n  let matchedCaps = null;\n  for (let firstMatchCaps of validatedFirstMatchCaps) {\n    try {\n      matchedCaps = mergeCaps(requiredCaps, firstMatchCaps);\n      if (matchedCaps) {\n        break;\n      }\n    } catch (err) {\n      log.warn(err.message);\n      validationErrors.push(err.message);\n    }\n  }\n\n  // Returns variables for testing purposes\n  return {\n    requiredCaps,\n    allFirstMatchCaps,\n    validatedFirstMatchCaps,\n    matchedCaps,\n    validationErrors,\n  };\n}\n\n// Calls parseCaps and just returns the matchedCaps variable\n/**\n *\n * @param {W3CCapabilities} w3cCaps\n * @param {Constraints} [constraints]\n * @param {boolean} [shouldValidateCaps]\n * @returns {Capabilities}\n */\nfunction processCapabilities(w3cCaps, constraints = {}, shouldValidateCaps = true) {\n  const {matchedCaps, validationErrors} = parseCaps(w3cCaps, constraints, shouldValidateCaps);\n\n  // If we found an error throw an exception\n  if (!util.hasValue(matchedCaps)) {\n    if (_.isArray(w3cCaps.firstMatch) && w3cCaps.firstMatch.length > 1) {\n      // If there was more than one 'firstMatch' cap, indicate that we couldn't find a matching capabilities set and show all the errors\n      throw new errors.InvalidArgumentError(\n        `Could not find matching capabilities from ${JSON.stringify(\n          w3cCaps\n        )}:\\n ${validationErrors.join('\\n')}`\n      );\n    } else {\n      // Otherwise, just show the singular error message\n      throw new errors.InvalidArgumentError(validationErrors[0]);\n    }\n  }\n\n  return matchedCaps ?? {};\n}\n\n/**\n * Return a copy of a capabilities object which has taken everything within the 'options'\n * capability and promoted it to the top level. Note that this function is assumed to be run after\n * all vendor prefixes have already been stripped from the top level. So we are dealing with e.g.\n * 'options' and not 'appium:options' at this point. Any prefixes _inside_ the 'options' capability\n * will themselves be stripped. This is designed as an internal function, not one to operate on\n * user-constructed capabilities.\n *\n * @param {object} originalCaps - the capabilities to analyze and promote from 'options'\n * @return {object!} - the capabilities with 'options' promoted if necessary\n */\nfunction promoteAppiumOptions(originalCaps) {\n  const appiumOptions = originalCaps[APPIUM_OPTS_CAP];\n  if (!appiumOptions) {\n    return originalCaps;\n  }\n\n  let caps = _.cloneDeep(originalCaps);\n  if (!_.isPlainObject(appiumOptions)) {\n    throw new errors.SessionNotCreatedError(`The ${APPIUM_OPTS_CAP} capability must be an object`);\n  }\n\n  // first get rid of any prefixes inside appium:options\n  stripAppiumPrefixes(appiumOptions);\n\n  // warn if we are going to overwrite any keys on the base caps object\n  const overwrittenKeys = _.intersection(Object.keys(caps), Object.keys(appiumOptions));\n  if (overwrittenKeys.length > 0) {\n    log.warn(\n      `Found capabilities inside ${PREFIXED_APPIUM_OPTS_CAP} that will overwrite ` +\n        `capabilities at the top level: ${JSON.stringify(overwrittenKeys)}`\n    );\n  }\n\n  // now just apply them to the main caps object\n  caps = {...caps, ...appiumOptions};\n\n  // and remove all traces of the options cap\n  delete caps[APPIUM_OPTS_CAP];\n  return caps;\n}\n\nexport {\n  parseCaps,\n  processCapabilities,\n  validateCaps,\n  mergeCaps,\n  APPIUM_VENDOR_PREFIX,\n  APPIUM_OPTS_CAP,\n  findNonPrefixedCaps,\n  isStandardCap,\n  stripAppiumPrefixes,\n  promoteAppiumOptions,\n  PREFIXED_APPIUM_OPTS_CAP,\n};\n\n/**\n * @typedef {import('@appium/types').W3CCapabilities} W3CCapabilities\n * @typedef {import('@appium/types').Constraints} Constraints\n * @typedef {import('@appium/types').Capabilities} Capabilities\n */\n\n/**\n * @typedef ValidateCapsOpts\n * @property {boolean} [skipPresenceConstraint] - if true, skip the presence constraint\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["APPIUM_VENDOR_PREFIX","APPIUM_OPTS_CAP","PREFIXED_APPIUM_OPTS_CAP","mergeCaps","primary","secondary","result","name","value","_","toPairs","isUndefined","errors","InvalidArgumentError","JSON","stringify","validateCaps","caps","constraints","opts","skipPresenceConstraint","isPlainObject","mapValues","constraint","omit","presence","allowEmpty","validationErrors","validator","validate","pickBy","util","hasValue","fullMessages","message","attribute","reasons","reason","push","join","STANDARD_CAPS","Object","freeze","Set","STANDARD_CAPS_LOWER","map","cap","toLowerCase","isStandardCap","has","stripAppiumPrefixes","prefixedCaps","nonPrefixedCaps","partition","keys","String","startsWith","strippedCaps","pick","badPrefixedCaps","prefixedCap","strippedCapName","substring","length","isNil","log","warn","findNonPrefixedCaps","alwaysMatch","firstMatch","chain","reduce","unprefixedCaps","filter","includes","uniq","parseCaps","shouldValidateCaps","requiredCaps","allFirstMatchCaps","isArray","isEmpty","strippedRequiredCaps","strippedAllFirstMatchCaps","filteredConstraints","omitBy","key","validatedFirstMatchCaps","compact","firstMatchCaps","e","matchedCaps","err","processCapabilities","w3cCaps","promoteAppiumOptions","originalCaps","appiumOptions","cloneDeep","SessionNotCreatedError","strippedAppiumOptions","overwrittenKeys","intersection"],"sources":["../../../lib/basedriver/capabilities.js"],"sourcesContent":["// @ts-check\n\nimport _ from 'lodash';\nimport {validator} from './desired-caps';\nimport {util} from '@appium/support';\nimport log from './logger';\nimport {errors} from '../protocol/errors';\n\nconst APPIUM_VENDOR_PREFIX = 'appium:';\nconst APPIUM_OPTS_CAP = 'options';\nconst PREFIXED_APPIUM_OPTS_CAP = `${APPIUM_VENDOR_PREFIX}${APPIUM_OPTS_CAP}`;\n\n/**\n * Takes primary caps object and merges it into a secondary caps object.\n * @template {Constraints} [T={}]\n * @template {Constraints} [U={}]\n * @param {Capabilities<T>} [primary]\n * @param {Capabilities<U>} [secondary]\n * @returns {import('type-fest').Merge<Capabilities<T>, Capabilities<U>>}\n * @see https://www.w3.org/TR/webdriver/#dfn-merging-capabilities)\n */\nfunction mergeCaps(primary = {}, secondary = {}) {\n  let result = /** @type {import('type-fest').Merge<Capabilities<T>, Capabilities<U>>} */ ({\n    ...primary,\n  });\n\n  for (let [name, value] of /** @type {[keyof typeof secondary, any]} */ (_.toPairs(secondary))) {\n    // Overwriting is not allowed. Primary and secondary must have different properties (w3c rule 4.4)\n    if (!_.isUndefined(primary[name])) {\n      throw new errors.InvalidArgumentError(\n        `property '${name}' should not exist on both primary (${JSON.stringify(\n          primary\n        )}) and secondary (${JSON.stringify(secondary)}) object`\n      );\n    }\n    result[/** @type {keyof typeof result} */ (name)] = value;\n  }\n\n  return result;\n}\n\n// Validates caps against a set of constraints\n/**\n * @template {Constraints} [C={}]\n * @param {Capabilities<C>} caps\n * @param {C} [constraints]\n * @param {ValidateCapsOpts} [opts]\n * @returns {Capabilities<C>}\n */\nfunction validateCaps(caps, constraints = /** @type {C} */ ({}), opts = {}) {\n  let {skipPresenceConstraint} = opts;\n\n  if (!_.isPlainObject(caps)) {\n    throw new errors.InvalidArgumentError(`must be a JSON object`);\n  }\n\n  // Remove the 'presence' constraint if we're not checking for it\n  constraints = /** @type {C} */ (\n    _.mapValues(\n      constraints,\n      skipPresenceConstraint\n        ? /** @param {Constraint} constraint */\n          (constraint) => _.omit(constraint, 'presence')\n        : /** @param {Constraint} constraint */\n          (constraint) => {\n            if (constraint.presence === true) {\n              return {..._.omit(constraint, 'presence'), presence: {allowEmpty: false}};\n            }\n            return constraint;\n          }\n    )\n  );\n\n  const validationErrors = validator.validate(_.pickBy(caps, util.hasValue), constraints, {\n    fullMessages: false,\n  });\n\n  if (validationErrors) {\n    let message = [];\n    for (let [attribute, reasons] of _.toPairs(validationErrors)) {\n      for (let reason of reasons) {\n        message.push(`'${attribute}' ${reason}`);\n      }\n    }\n    throw new errors.InvalidArgumentError(message.join('; '));\n  }\n\n  // Return caps\n  return caps;\n}\n\n/**\n * Standard, non-prefixed capabilities\n * @see https://www.w3.org/TR/webdriver/#dfn-table-of-standard-capabilities)\n */\nexport const STANDARD_CAPS = Object.freeze(\n  new Set(\n    /** @type {import('type-fest').StringKeyOf<import('@appium/types').StandardCapabilities>[]} */ ([\n      'browserName',\n      'browserVersion',\n      'platformName',\n      'acceptInsecureCerts',\n      'pageLoadStrategy',\n      'proxy',\n      'setWindowRect',\n      'timeouts',\n      'unhandledPromptBehavior',\n    ])\n  )\n);\n\nconst STANDARD_CAPS_LOWER = new Set([...STANDARD_CAPS].map((cap) => cap.toLowerCase()));\n\n/**\n * @param {string} cap\n * @returns {boolean}\n */\nfunction isStandardCap(cap) {\n  return STANDARD_CAPS_LOWER.has(cap.toLowerCase());\n}\n\n/**\n * If the 'appium:' prefix was provided and it's a valid capability, strip out the prefix\n * @template {Constraints} [C={}]\n * @param {import('@appium/types').NSCapabilities<C>} caps\n * @see https://www.w3.org/TR/webdriver/#dfn-extension-capabilities\n * @internal\n * @returns {import('@appium/types').Capabilities<C>}\n */\nfunction stripAppiumPrefixes(caps) {\n  // split into prefixed and non-prefixed.\n  // non-prefixed should be standard caps at this point\n  const [prefixedCaps, nonPrefixedCaps] = _.partition(_.keys(caps), (cap) =>\n    String(cap).startsWith(APPIUM_VENDOR_PREFIX)\n  );\n\n  // initialize this with the k/v pairs of the non-prefixed caps\n  let strippedCaps = /** @type {import('@appium/types').Capabilities<C>} */ (\n    _.pick(caps, nonPrefixedCaps)\n  );\n  const badPrefixedCaps = [];\n\n  // Strip out the 'appium:' prefix\n  for (let prefixedCap of prefixedCaps) {\n    const strippedCapName =\n      /** @type {import('type-fest').StringKeyOf<import('@appium/types').Capabilities<C>>} */ (\n        prefixedCap.substring(APPIUM_VENDOR_PREFIX.length)\n      );\n\n    // If it's standard capability that was prefixed, add it to an array of incorrectly prefixed capabilities\n    if (isStandardCap(strippedCapName)) {\n      badPrefixedCaps.push(strippedCapName);\n      if (_.isNil(strippedCaps[strippedCapName])) {\n        strippedCaps[strippedCapName] = caps[prefixedCap];\n      } else {\n        log.warn(\n          `Ignoring capability '${prefixedCap}=${caps[prefixedCap]}' and ` +\n            `using capability '${strippedCapName}=${strippedCaps[strippedCapName]}'`\n        );\n      }\n    } else {\n      strippedCaps[strippedCapName] = caps[prefixedCap];\n    }\n  }\n\n  // If we found standard caps that were incorrectly prefixed, throw an exception (e.g.: don't accept 'appium:platformName', only accept just 'platformName')\n  if (badPrefixedCaps.length > 0) {\n    log.warn(\n      `The capabilities ${JSON.stringify(\n        badPrefixedCaps\n      )} are standard capabilities and do not require \"appium:\" prefix`\n    );\n  }\n  return strippedCaps;\n}\n\n/**\n * Get an array of all the unprefixed caps that are being used in 'alwaysMatch' and all of the 'firstMatch' object\n * @template {Constraints} [C={}]\n * @param {import('@appium/types').W3CCapabilities<C>} caps A capabilities object\n */\nfunction findNonPrefixedCaps({alwaysMatch = {}, firstMatch = []}) {\n  return _.chain([alwaysMatch, ...firstMatch])\n    .reduce(\n      (unprefixedCaps, caps) => [\n        ...unprefixedCaps,\n        ...Object.keys(caps).filter((cap) => !cap.includes(':') && !isStandardCap(cap)),\n      ],\n      []\n    )\n    .uniq()\n    .value();\n}\n\n/**\n * Parse capabilities\n * @template {Constraints} [C={}]\n * @param {import('@appium/types').W3CCapabilities<C>} caps\n * @param {C} [constraints]\n * @param {boolean} [shouldValidateCaps]\n * @see https://www.w3.org/TR/webdriver/#processing-capabilities\n */\nfunction parseCaps(caps, constraints = /** @type {C} */ ({}), shouldValidateCaps = true) {\n  // If capabilities request is not an object, return error (#1.1)\n  if (!_.isPlainObject(caps)) {\n    throw new errors.InvalidArgumentError(\n      'The capabilities argument was not valid for the following reason(s): \"capabilities\" must be a JSON object.'\n    );\n  }\n\n  // Let 'requiredCaps' be property named 'alwaysMatch' from capabilities request (#2)\n  // and 'allFirstMatchCaps' be property named 'firstMatch' from capabilities request (#3)\n  let {\n    alwaysMatch: requiredCaps = {}, // If 'requiredCaps' is undefined, set it to an empty JSON object (#2.1)\n    firstMatch: allFirstMatchCaps = [{}], // If 'firstMatch' is undefined set it to a singleton list with one empty object (#3.1)\n  } = caps;\n\n  // Reject 'firstMatch' argument if it's not an array (#3.2)\n  if (!_.isArray(allFirstMatchCaps)) {\n    throw new errors.InvalidArgumentError(\n      'The capabilities.firstMatch argument was not valid for the following reason(s): \"capabilities.firstMatch\" must be a JSON array or undefined'\n    );\n  }\n\n  // If an empty array as provided, we'll be forgiving and make it an array of one empty object\n  // In the future, reject 'firstMatch' argument if its array did not have one or more entries (#3.2)\n  if (allFirstMatchCaps.length === 0) {\n    log.warn(\n      `The firstMatch array in the given capabilities has no entries. Adding an empty entry fo rnow, ` +\n        `but it will require one or more entries as W3C spec.`\n    );\n    allFirstMatchCaps.push({});\n  }\n\n  // Check for non-prefixed, non-standard capabilities and log warnings if they are found\n  let nonPrefixedCaps = findNonPrefixedCaps(caps);\n  if (!_.isEmpty(nonPrefixedCaps)) {\n    throw new errors.InvalidArgumentError(\n      `All non-standard capabilities should have a vendor prefix. The following capabilities did not have one: ${nonPrefixedCaps}`\n    );\n  }\n\n  // Strip out the 'appium:' prefix from all\n  let strippedRequiredCaps = stripAppiumPrefixes(requiredCaps);\n  let strippedAllFirstMatchCaps = allFirstMatchCaps.map(stripAppiumPrefixes);\n\n  // Validate the requiredCaps. But don't validate 'presence' because if that constraint fails on 'alwaysMatch' it could still pass on one of the 'firstMatch' keys\n  if (shouldValidateCaps) {\n    strippedRequiredCaps = validateCaps(strippedRequiredCaps, constraints, {\n      skipPresenceConstraint: true,\n    });\n  }\n  // Remove the 'presence' constraint for any keys that are already present in 'requiredCaps'\n  // since we know that this constraint has already passed\n  const filteredConstraints = /** @type {C} */ (\n    _.omitBy(constraints, (_, key) => key in strippedRequiredCaps)\n  );\n\n  // Validate all of the first match capabilities and return an array with only the valid caps (see spec #5)\n  /** @type {string[]} */\n  let validationErrors = [];\n  let validatedFirstMatchCaps = _.compact(\n    strippedAllFirstMatchCaps.map(\n      /**\n       * @param {import('@appium/types').Capabilities<C>} firstMatchCaps\n       */\n      (firstMatchCaps) => {\n        try {\n          // Validate firstMatch caps\n          return shouldValidateCaps\n            ? validateCaps(firstMatchCaps, filteredConstraints)\n            : firstMatchCaps;\n        } catch (e) {\n          validationErrors.push(e.message);\n        }\n      }\n    )\n  );\n\n  // Try to merge requiredCaps with first match capabilities, break once it finds its first match (see spec #6)\n  let matchedCaps = null;\n  for (let firstMatchCaps of validatedFirstMatchCaps) {\n    try {\n      matchedCaps = mergeCaps(strippedRequiredCaps, firstMatchCaps);\n      if (matchedCaps) {\n        break;\n      }\n    } catch (err) {\n      log.warn(err.message);\n      validationErrors.push(err.message);\n    }\n  }\n\n  // Returns variables for testing purposes\n  return {\n    requiredCaps,\n    allFirstMatchCaps,\n    validatedFirstMatchCaps,\n    matchedCaps,\n    validationErrors,\n  };\n}\n\n// Calls parseCaps and just returns the matchedCaps variable\n/**\n * @template {Constraints} C\n * @param {import('@appium/types').W3CCapabilities<C>} w3cCaps\n * @param {C} [constraints]\n * @param {boolean} [shouldValidateCaps]\n * @returns {import('@appium/types').Capabilities<C>}\n */\nfunction processCapabilities(\n  w3cCaps,\n  constraints = /** @type {C} */ ({}),\n  shouldValidateCaps = true\n) {\n  const {matchedCaps, validationErrors} = parseCaps(w3cCaps, constraints, shouldValidateCaps);\n\n  // If we found an error throw an exception\n  if (!util.hasValue(matchedCaps)) {\n    if (_.isArray(w3cCaps.firstMatch) && w3cCaps.firstMatch.length > 1) {\n      // If there was more than one 'firstMatch' cap, indicate that we couldn't find a matching capabilities set and show all the errors\n      throw new errors.InvalidArgumentError(\n        `Could not find matching capabilities from ${JSON.stringify(\n          w3cCaps\n        )}:\\n ${validationErrors.join('\\n')}`\n      );\n    } else {\n      // Otherwise, just show the singular error message\n      throw new errors.InvalidArgumentError(validationErrors[0]);\n    }\n  }\n\n  return /** @type {Capabilities<C>} */ (matchedCaps ?? {});\n}\n\n/**\n * Return a copy of a capabilities object which has taken everything within the 'options'\n * capability and promoted it to the top level. Note that this function is assumed to be run after\n * all vendor prefixes have already been stripped from the top level. So we are dealing with e.g.\n * 'options' and not 'appium:options' at this point. Any prefixes _inside_ the 'options' capability\n * will themselves be stripped. This is designed as an internal function, not one to operate on\n * user-constructed capabilities.\n *\n * @param {object} originalCaps - the capabilities to analyze and promote from 'options'\n * @return {object!} - the capabilities with 'options' promoted if necessary\n */\nfunction promoteAppiumOptions(originalCaps) {\n  const appiumOptions = originalCaps[APPIUM_OPTS_CAP];\n  if (!appiumOptions) {\n    return originalCaps;\n  }\n\n  let caps = _.cloneDeep(originalCaps);\n  if (!_.isPlainObject(appiumOptions)) {\n    throw new errors.SessionNotCreatedError(`The ${APPIUM_OPTS_CAP} capability must be an object`);\n  }\n\n  // first get rid of any prefixes inside appium:options\n  const strippedAppiumOptions = stripAppiumPrefixes(appiumOptions);\n  // warn if we are going to overwrite any keys on the base caps object\n  const overwrittenKeys = _.intersection(Object.keys(caps), Object.keys(strippedAppiumOptions));\n  if (overwrittenKeys.length > 0) {\n    log.warn(\n      `Found capabilities inside ${PREFIXED_APPIUM_OPTS_CAP} that will overwrite ` +\n        `capabilities at the top level: ${JSON.stringify(overwrittenKeys)}`\n    );\n  }\n\n  // now just apply them to the main caps object\n  caps = {...caps, ...strippedAppiumOptions};\n\n  // and remove all traces of the options cap\n  delete caps[APPIUM_OPTS_CAP];\n  return caps;\n}\n\nexport {\n  parseCaps,\n  processCapabilities,\n  validateCaps,\n  mergeCaps,\n  APPIUM_VENDOR_PREFIX,\n  APPIUM_OPTS_CAP,\n  findNonPrefixedCaps,\n  isStandardCap,\n  stripAppiumPrefixes,\n  promoteAppiumOptions,\n  PREFIXED_APPIUM_OPTS_CAP,\n};\n\n/**\n * @typedef {import('@appium/types').Constraints} Constraints\n * @typedef {import('@appium/types').Constraint} Constraint\n * @typedef {import('@appium/types').StringRecord} StringRecord\n * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints\n */\n\n/**\n * @typedef ValidateCapsOpts\n * @property {boolean} [skipPresenceConstraint] - if true, skip the presence constraint\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=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"],"mappings":"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"}