@appium/base-driver 8.3.1 → 8.4.2

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

@@ -0,0 +1,80 @@
+export type W3CCapabilities = import('@appium/types').W3CCapabilities;
+export type Constraints = import('@appium/types').Constraints;
+export type Capabilities = import('@appium/types').Capabilities;
+export type ValidateCapsOpts = {
+    /**
+     * - if true, skip the presence constraint
+     */
+    skipPresenceConstraint?: boolean | undefined;
+};
+/**
+ *
+ * @param {W3CCapabilities} caps
+ * @param {Constraints} [constraints]
+ * @param {boolean} [shouldValidateCaps]
+ * @returns
+ */
+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[];
+};
+/**
+ *
+ * @param {W3CCapabilities} w3cCaps
+ * @param {Constraints} [constraints]
+ * @param {boolean} [shouldValidateCaps]
+ * @returns {Capabilities}
+ */
+export function processCapabilities(w3cCaps: W3CCapabilities, constraints?: import("@appium/types").Constraints | undefined, shouldValidateCaps?: boolean | undefined): Capabilities;
+/**
+ *
+ * @param {Capabilities} caps
+ * @param {Constraints} [constraints]
+ * @param {ValidateCapsOpts} [opts]
+ * @returns {Capabilities}
+ */
+export function validateCaps(caps: Capabilities, constraints?: import("@appium/types").Constraints | undefined, opts?: ValidateCapsOpts | undefined): Capabilities;
+/**
+ * @param {Capabilities} [primary]
+ * @param {Capabilities} [secondary]
+ * @returns {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 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
+ */
+export function findNonPrefixedCaps({ alwaysMatch, firstMatch }: any): string[];
+export function isStandardCap(cap: any): boolean;
+export function stripAppiumPrefixes(caps: any): 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
+ * all vendor prefixes have already been stripped from the top level. So we are dealing with e.g.
+ * 'options' and not 'appium:options' at this point. Any prefixes _inside_ the 'options' capability
+ * will themselves be stripped. This is designed as an internal function, not one to operate on
+ * user-constructed capabilities.
+ *
+ * @param {object} originalCaps - the capabilities to analyze and promote from 'options'
+ * @return {object!} - the capabilities with 'options' promoted if necessary
+ */
+export function promoteAppiumOptions(originalCaps: object): object;
+export const PREFIXED_APPIUM_OPTS_CAP: string;
+//# sourceMappingURL=capabilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/capabilities.js"],"names":[],"mappings":"8BAiTa,OAAO,eAAe,EAAE,eAAe;0BACvC,OAAO,eAAe,EAAE,WAAW;2BACnC,OAAO,eAAe,EAAE,YAAY;;;;;;;AArKjD;;;;;;GAMG;AACH,gCALW,eAAe;;;;;;;;;;;;;;EAuFzB;AAGD;;;;;;GAMG;AACH,6CALW,eAAe,4GAGb,YAAY,CAiBxB;AA9ND;;;;;;GAMG;AACH,mCALW,YAAY,uGAGV,YAAY,CAmCxB;AA5DD;;;;GAIG;AACH;;;;iBAFa,YAAY,CAcxB;AAvBD,6CAAuC;AACvC,wCAAkC;AAsHlC;;;GAGG;AACH,gFAQC;AAlDD,iDAEC;AAID,qDA8BC;AAqID;;;;;;;;;;GAUG;AACH,mDAHW,MAAM,GACL,MAAM,CA6BjB;AA9RD,8CAA6E"}

package/build/lib/basedriver/capabilities.js

@@ -124,7 +124,7 @@ function findNonPrefixedCaps({
   alwaysMatch = {},
   firstMatch = []
 }) {
-  return _lodash.default.chain([alwaysMatch, ...firstMatch]).reduce((unprefixedCaps, caps) => [...unprefixedCaps, ...(0, _lodash.default)(caps).keys().filter(cap => !cap.includes(':') && !isStandardCap(cap))], []).uniq().value();
+  return _lodash.default.chain([alwaysMatch, ...firstMatch]).reduce((unprefixedCaps, caps) => [...unprefixedCaps, ...Object.keys(caps).filter(cap => !cap.includes(':') && !isStandardCap(cap))], []).uniq().value();
 }
 
 function parseCaps(caps, constraints = {}, shouldValidateCaps = true) {
@@ -177,14 +177,15 @@ function parseCaps(caps, constraints = {}, shouldValidateCaps = true) {
   }
 
   let validationErrors = [];
-  let validatedFirstMatchCaps = allFirstMatchCaps.map(firstMatchCaps => {
+
+  let validatedFirstMatchCaps = _lodash.default.compact(allFirstMatchCaps.map(firstMatchCaps => {
     try {
       return shouldValidateCaps ? validateCaps(firstMatchCaps, filteredConstraints) : firstMatchCaps;
     } catch (e) {
       validationErrors.push(e.message);
-      return null;
     }
-  }).filter(caps => !_lodash.default.isNull(caps));
+  }));
+
   let matchedCaps = null;
 
   for (let firstMatchCaps of validatedFirstMatchCaps) {
@@ -210,21 +211,21 @@ function parseCaps(caps, constraints = {}, shouldValidateCaps = true) {
   };
 }
 
-function processCapabilities(caps, constraints = {}, shouldValidateCaps = true) {
+function processCapabilities(w3cCaps, constraints = {}, shouldValidateCaps = true) {
   const {
     matchedCaps,
     validationErrors
-  } = parseCaps(caps, constraints, shouldValidateCaps);
+  } = parseCaps(w3cCaps, constraints, shouldValidateCaps);
 
   if (!_support.util.hasValue(matchedCaps)) {
-    if (_lodash.default.isArray(caps.firstMatch) && caps.firstMatch.length > 1) {
-      throw new _errors.errors.InvalidArgumentError(`Could not find matching capabilities from ${JSON.stringify(caps)}:\n ${validationErrors.join('\n')}`);
+    if (_lodash.default.isArray(w3cCaps.firstMatch) && w3cCaps.firstMatch.length > 1) {
+      throw new _errors.errors.InvalidArgumentError(`Could not find matching capabilities from ${JSON.stringify(w3cCaps)}:\n ${validationErrors.join('\n')}`);
     } else {
       throw new _errors.errors.InvalidArgumentError(validationErrors[0]);
     }
   }
 
-  return matchedCaps;
+  return matchedCaps !== null && matchedCaps !== void 0 ? matchedCaps : {};
 }
 
 function promoteAppiumOptions(originalCaps) {
@@ -254,4 +255,4 @@ function promoteAppiumOptions(originalCaps) {
   delete caps[APPIUM_OPTS_CAP];
   return caps;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/basedriver/capabilities.js"],"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","map","e","isNull","matchedCaps","err","processCapabilities","promoteAppiumOptions","originalCaps","appiumOptions","SessionNotCreatedError","overwrittenKeys","intersection"],"mappings":"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","sourcesContent":["import _ 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)\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(`property '${name}' should not exist on both primary (${JSON.stringify(primary)}) and secondary (${JSON.stringify(secondary)}) object`);\n    }\n    result[name] = value;\n  }\n\n  return result;\n}\n\n// Validates caps against a set of constraints\nfunction validateCaps (caps, constraints = {}, opts = {}) {\n\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),\n                                              constraints,\n                                              {fullMessages: false});\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(STANDARD_CAPS, (standardCap) => standardCap.toLowerCase() === `${cap}`.toLowerCase());\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(`Ignoring capability '${prefixedCap}=${caps[prefixedCap]}' and ` +\n          `using capability '${strippedCapName}=${caps[strippedCapName]}'`);\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(`The capabilities ${JSON.stringify(badPrefixedCaps)} are standard capabilities and do not require \"appium:\" prefix`);\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((unprefixedCaps, caps) => [\n      ...unprefixedCaps,\n      ..._(caps).keys().filter((cap) => !cap.includes(':') && !isStandardCap(cap)),\n    ], [])\n    .uniq()\n    .value();\n}\n\n// Parse capabilities (based on https://www.w3.org/TR/webdriver/#processing-capabilities)\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('The capabilities argument was not valid for the following reason(s): \"capabilities\" must be a JSON object.');\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('The capabilities.firstMatch argument was not valid for the following reason(s): \"capabilities.firstMatch\" must be a JSON array or undefined');\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(`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    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(`All non-standard capabilities should have a vendor prefix. The following capabilities did not have one: ${nonPrefixedCaps}`);\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, {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  let validatedFirstMatchCaps = allFirstMatchCaps.map((firstMatchCaps) => {\n    try {\n      // Validate firstMatch caps\n      return shouldValidateCaps ? validateCaps(firstMatchCaps, filteredConstraints) : firstMatchCaps;\n    } catch (e) {\n      validationErrors.push(e.message);\n      return null;\n    }\n  }).filter((caps) => !_.isNull(caps));\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 {requiredCaps, allFirstMatchCaps, validatedFirstMatchCaps, matchedCaps, validationErrors};\n}\n\n// Calls parseCaps and just returns the matchedCaps variable\nfunction processCapabilities (caps, constraints = {}, shouldValidateCaps = true) {\n  const {matchedCaps, validationErrors} = parseCaps(caps, constraints, shouldValidateCaps);\n\n  // If we found an error throw an exception\n  if (!util.hasValue(matchedCaps)) {\n    if (_.isArray(caps.firstMatch) && caps.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(`Could not find matching capabilities from ${JSON.stringify(caps)}:\\n ${validationErrors.join('\\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(`Found capabilities inside ${PREFIXED_APPIUM_OPTS_CAP} that will overwrite ` +\n             `capabilities at the top level: ${JSON.stringify(overwrittenKeys)}`);\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\n\nexport {\n  parseCaps, processCapabilities, validateCaps, mergeCaps, APPIUM_VENDOR_PREFIX, APPIUM_OPTS_CAP,\n  findNonPrefixedCaps, isStandardCap, stripAppiumPrefixes, promoteAppiumOptions, PREFIXED_APPIUM_OPTS_CAP,\n};\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/basedriver/capabilities.js"],"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"],"mappings":"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","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(`property '${name}' should not exist on both primary (${JSON.stringify(primary)}) and secondary (${JSON.stringify(secondary)}) object`);\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\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),\n                                              constraints,\n                                              {fullMessages: false});\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(STANDARD_CAPS, (standardCap) => standardCap.toLowerCase() === `${cap}`.toLowerCase());\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(`Ignoring capability '${prefixedCap}=${caps[prefixedCap]}' and ` +\n          `using capability '${strippedCapName}=${caps[strippedCapName]}'`);\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(`The capabilities ${JSON.stringify(badPrefixedCaps)} are standard capabilities and do not require \"appium:\" prefix`);\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((unprefixedCaps, caps) => [\n      ...unprefixedCaps,\n      ...Object.keys(caps).filter((cap) => !cap.includes(':') && !isStandardCap(cap)),\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('The capabilities argument was not valid for the following reason(s): \"capabilities\" must be a JSON object.');\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('The capabilities.firstMatch argument was not valid for the following reason(s): \"capabilities.firstMatch\" must be a JSON array or undefined');\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(`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    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(`All non-standard capabilities should have a vendor prefix. The following capabilities did not have one: ${nonPrefixedCaps}`);\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, {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(allFirstMatchCaps.map((firstMatchCaps) => {\n    try {\n      // Validate firstMatch caps\n      return shouldValidateCaps ? validateCaps(firstMatchCaps, filteredConstraints) : firstMatchCaps;\n    } catch (e) {\n      validationErrors.push(e.message);\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 {requiredCaps, allFirstMatchCaps, validatedFirstMatchCaps, matchedCaps, validationErrors};\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(`Could not find matching capabilities from ${JSON.stringify(w3cCaps)}:\\n ${validationErrors.join('\\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(`Found capabilities inside ${PREFIXED_APPIUM_OPTS_CAP} that will overwrite ` +\n             `capabilities at the top level: ${JSON.stringify(overwrittenKeys)}`);\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\n\nexport {\n  parseCaps, processCapabilities, validateCaps, mergeCaps, APPIUM_VENDOR_PREFIX, APPIUM_OPTS_CAP,\n  findNonPrefixedCaps, isStandardCap, stripAppiumPrefixes, promoteAppiumOptions, 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"]}

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

@@ -0,0 +1,9 @@
+/**
+ * @param {TimeoutBase} Base
+ * @returns {EventBase}
+ */
+export function EventMixin(Base: TimeoutBase): EventBase;
+export type IEventCommands = import('@appium/types').EventCommands;
+export type TimeoutBase = import('./timeout').TimeoutBase;
+export type EventBase = import('../driver').BaseDriverBase<import('@appium/types').TimeoutCommands & IEventCommands>;
+//# sourceMappingURL=event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../../../lib/basedriver/commands/event.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,iCAHW,WAAW,GACT,SAAS,CA6CrB;6BAGY,OAAO,eAAe,EAAE,aAAa;0BACrC,OAAO,WAAW,EAAE,WAAW;wBAC/B,OAAO,WAAW,EAAE,cAAc,CAAC,OAAO,eAAe,EAAE,eAAe,GAAG,cAAc,CAAC"}

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

@@ -5,36 +5,36 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.EventMixin = EventMixin;
 
 require("source-map-support/register");
 
 var _lodash = _interopRequireDefault(require("lodash"));
 
-const commands = {};
+function EventMixin(Base) {
+  class EventCommands extends Base {
+    async logCustomEvent(vendor, event) {
+      this.logEvent(`${vendor}:${event}`);
+    }
 
-commands.logCustomEvent = function (vendor, event) {
-  this.logEvent(`${vendor}:${event}`);
-};
+    async getLogEvents(type) {
+      if (_lodash.default.isEmpty(type)) {
+        return this.eventHistory;
+      }
 
-commands.getLogEvents = function (type = null) {
-  if (_lodash.default.isEmpty(type)) {
-    return this._eventHistory;
-  }
+      const typeList = _lodash.default.castArray(type);
 
-  if (!_lodash.default.isArray(type)) {
-    type = [type];
-  }
+      return _lodash.default.reduce(this.eventHistory, (acc, eventTimes, eventType) => {
+        if (typeList.includes(eventType)) {
+          acc[eventType] = eventTimes;
+        }
 
-  return _lodash.default.reduce(this._eventHistory, (acc, eventTimes, eventType) => {
-    if (type.includes(eventType)) {
-      acc[eventType] = eventTimes;
+        return acc;
+      }, {});
     }
 
-    return acc;
-  }, {});
-};
+  }
 
-var _default = commands;
-exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+  return EventCommands;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {EventBase} Base
+ * @returns {FindBase}
+ */
+export function FindMixin(Base: EventBase): FindBase;
+export type Element = import('@appium/types').Element;
+export type IFindCommands = import('@appium/types').FindCommands;
+export type EventBase = import('./event').EventBase;
+export type FindBase = import('../driver').BaseDriverBase<import('@appium/types').TimeoutCommands & import('@appium/types').EventCommands & IFindCommands>;
+//# sourceMappingURL=find.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../../../lib/basedriver/commands/find.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,gCAHW,SAAS,GACP,QAAQ,CAoGpB;sBAGY,OAAO,eAAe,EAAE,OAAO;4BAC/B,OAAO,eAAe,EAAE,YAAY;wBACpC,OAAO,SAAS,EAAE,SAAS;uBAC3B,OAAO,WAAW,EAAE,cAAc,CAAC,OAAO,eAAe,EAAE,eAAe,GAAG,OAAO,eAAe,EAAE,aAAa,GAAG,aAAa,CAAC"}

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

@@ -3,50 +3,57 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.helpers = exports.default = exports.commands = void 0;
+exports.FindMixin = FindMixin;
 
 require("source-map-support/register");
 
-const commands = {},
-      helpers = {},
-      extensions = {};
-exports.helpers = helpers;
-exports.commands = commands;
-
-helpers.findElOrElsWithProcessing = async function findElOrElsWithProcessing(strategy, selector, mult, context) {
-  this.validateLocatorStrategy(strategy);
-
-  try {
-    return await this.findElOrEls(strategy, selector, mult, context);
-  } catch (err) {
-    if (this.opts.printPageSourceOnFindFailure) {
-      const src = await this.getPageSource();
-      this.log.debug(`Error finding element${mult ? 's' : ''}: ${err.message}`);
-      this.log.debug(`Page source requested through 'printPageSourceOnFindFailure':`);
-      this.log.debug(src);
+var _protocol = require("../../protocol");
+
+function FindMixin(Base) {
+  class FindCommands extends Base {
+    async findElement(strategy, selector) {
+      return await this.findElOrElsWithProcessing(strategy, selector, false);
     }
 
-    throw err;
-  }
-};
+    async findElements(strategy, selector) {
+      return await this.findElOrElsWithProcessing(strategy, selector, true);
+    }
 
-commands.findElement = async function findElement(strategy, selector) {
-  return await this.findElOrElsWithProcessing(strategy, selector, false);
-};
+    async findElementFromElement(strategy, selector, elementId) {
+      return await this.findElOrElsWithProcessing(strategy, selector, false, elementId);
+    }
 
-commands.findElements = async function findElements(strategy, selector) {
-  return await this.findElOrElsWithProcessing(strategy, selector, true);
-};
+    async findElementsFromElement(strategy, selector, elementId) {
+      return await this.findElOrElsWithProcessing(strategy, selector, true, elementId);
+    }
 
-commands.findElementFromElement = async function findElementFromElement(strategy, selector, elementId) {
-  return await this.findElOrElsWithProcessing(strategy, selector, false, elementId);
-};
+    async findElOrEls(strategy, selector, mult, context) {
+      throw new _protocol.errors.NotImplementedError('Not implemented yet for find.');
+    }
 
-commands.findElementsFromElement = async function findElementsFromElement(strategy, selector, elementId) {
-  return await this.findElOrElsWithProcessing(strategy, selector, true, elementId);
-};
+    async getPageSource() {
+      throw new _protocol.errors.NotImplementedError('Not implemented yet for find.');
+    }
+
+    async findElOrElsWithProcessing(strategy, selector, mult, context) {
+      this.validateLocatorStrategy(strategy);
+
+      try {
+        return await this.findElOrEls(strategy, selector, mult, context);
+      } catch (err) {
+        if (this.opts.printPageSourceOnFindFailure) {
+          const src = await this.getPageSource();
+          this.log.debug(`Error finding element${mult ? 's' : ''}: ${err.message}`);
+          this.log.debug(`Page source requested through 'printPageSourceOnFindFailure':`);
+          this.log.debug(src);
+        }
+
+        throw err;
+      }
+    }
+
+  }
 
-Object.assign(extensions, commands, helpers);
-var _default = extensions;
-exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+  return FindCommands;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,8 @@
+/**
+ * Applies all the mixins to the `BaseDriverBase` class.
+ * Returns a `BaseDriver` class.
+ * @param {BaseDriverBase} Base
+ */
+export function createBaseDriverClass(Base: BaseDriverBase): import("./session").SessionBase;
+export type BaseDriverBase<T = {}> = import('../driver').BaseDriverBase<T>;
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,28 +1,31 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.createBaseDriverClass = createBaseDriverClass;
 
 require("source-map-support/register");
 
-var _session = _interopRequireDefault(require("./session"));
+var _event = require("./event");
 
-var _settings = _interopRequireDefault(require("./settings"));
+var _find = require("./find");
 
-var _timeout = _interopRequireDefault(require("./timeout"));
+var _log = require("./log");
 
-var _find = _interopRequireDefault(require("./find"));
+var _session = require("./session");
 
-var _log = _interopRequireDefault(require("./log"));
+var _settings = require("./settings");
 
-var _event = _interopRequireDefault(require("./event"));
+var _timeout = require("./timeout");
 
-let commands = {};
-Object.assign(commands, _session.default, _settings.default, _timeout.default, _find.default, _log.default, _event.default);
-var _default = commands;
-exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9iYXNlZHJpdmVyL2NvbW1hbmRzL2luZGV4LmpzIl0sIm5hbWVzIjpbImNvbW1hbmRzIiwiT2JqZWN0IiwiYXNzaWduIiwic2Vzc2lvbkNtZHMiLCJzZXR0aW5nc0NtZHMiLCJ0aW1lb3V0Q21kcyIsImZpbmRDbWRzIiwibG9nQ21kcyIsImV2ZW50Q21kcyJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFBQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFHQSxJQUFJQSxRQUFRLEdBQUcsRUFBZjtBQUVBQyxNQUFNLENBQUNDLE1BQVAsQ0FDRUYsUUFERixFQUVFRyxnQkFGRixFQUdFQyxpQkFIRixFQUlFQyxnQkFKRixFQUtFQyxhQUxGLEVBTUVDLFlBTkYsRUFPRUMsY0FQRjtlQVdlUixRIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHNlc3Npb25DbWRzIGZyb20gJy4vc2Vzc2lvbic7XG5pbXBvcnQgc2V0dGluZ3NDbWRzIGZyb20gJy4vc2V0dGluZ3MnO1xuaW1wb3J0IHRpbWVvdXRDbWRzIGZyb20gJy4vdGltZW91dCc7XG5pbXBvcnQgZmluZENtZHMgZnJvbSAnLi9maW5kJztcbmltcG9ydCBsb2dDbWRzIGZyb20gJy4vbG9nJztcbmltcG9ydCBldmVudENtZHMgZnJvbSAnLi9ldmVudCc7XG5cblxubGV0IGNvbW1hbmRzID0ge307XG5cbk9iamVjdC5hc3NpZ24oXG4gIGNvbW1hbmRzLFxuICBzZXNzaW9uQ21kcyxcbiAgc2V0dGluZ3NDbWRzLFxuICB0aW1lb3V0Q21kcyxcbiAgZmluZENtZHMsXG4gIGxvZ0NtZHMsXG4gIGV2ZW50Q21kcyxcbiAgLy8gYWRkIG90aGVyIGNvbW1hbmQgdHlwZXMgaGVyZVxuKTtcblxuZXhwb3J0IGRlZmF1bHQgY29tbWFuZHM7XG4iXX0=
+function createBaseDriverClass(Base) {
+  const WithTimeoutCommands = (0, _timeout.TimeoutMixin)(Base);
+  const WithEventCommands = (0, _event.EventMixin)(WithTimeoutCommands);
+  const WithFindCommands = (0, _find.FindMixin)(WithEventCommands);
+  const WithLogCommands = (0, _log.LogMixin)(WithFindCommands);
+  const WithSettingsCommands = (0, _settings.SettingsMixin)(WithLogCommands);
+  const WithSessionCommands = (0, _session.SessionMixin)(WithSettingsCommands);
+  return WithSessionCommands;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {FindBase} Base
+ * @returns {LogBase}
+ */
+export function LogMixin(Base: FindBase): LogBase;
+export type ILogCommands = import('@appium/types').LogCommands;
+export type Driver = import('@appium/types').Driver;
+export type FindBase = import('./find').FindBase;
+export type LogBase = import('../driver').BaseDriverBase<import('@appium/types').TimeoutCommands & import('@appium/types').EventCommands & import('@appium/types').FindCommands & ILogCommands>;
+export type LogType<T> = import('@appium/types').LogType<T>;
+//# sourceMappingURL=log.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../../lib/basedriver/commands/log.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,+BAHW,QAAQ,GACN,OAAO,CA2CnB;2BAIY,OAAO,eAAe,EAAE,WAAW;qBACnC,OAAO,eAAe,EAAE,MAAM;uBAC9B,OAAO,QAAQ,EAAE,QAAQ;sBACzB,OAAO,WAAW,EAAE,cAAc,CAAC,OAAO,eAAe,EAAE,eAAe,GAAG,OAAO,eAAe,EAAE,aAAa,GAAG,OAAO,eAAe,EAAE,YAAY,GAAG,YAAY,CAAC;yBAKzK,OAAO,eAAe,EAAE,OAAO,CAAC,CAAC,CAAC"}