@appium/base-driver 10.5.2 → 10.7.0

package/lib/basedriver/capabilities.ts

@@ -5,13 +5,10 @@ import type {
   W3CCapabilities,
   StandardCapabilities,
 } from '@appium/types';
-import type {
-  KeyAsString,
-  MergeExclusive,
-} from 'type-fest';
-import _ from 'lodash';
+import type {KeyAsString, MergeExclusive} from 'type-fest';
 import {validator} from './validation';
 import {util} from '@appium/support';
+import {omit, pickBy} from '../utils';
 import {log} from './logger';
 import {errors} from '../protocol/errors';
 
@@ -39,22 +36,22 @@ export function mergeCaps<
   T extends Constraints,
   U extends Constraints,
   Primary extends Capabilities<T>,
-  Secondary extends Capabilities<U>
+  Secondary extends Capabilities<U>,
 >(
   primary: Primary | undefined = {} as Primary,
-  secondary: Secondary | undefined = {} as Secondary
+  secondary: Secondary | undefined = {} as Secondary,
 ): MergeExclusive<Primary, Secondary> {
-  const result = ({
+  const result = {
     ...primary,
-  }) as MergeExclusive<Primary, Secondary>;
+  } as MergeExclusive<Primary, Secondary>;
 
   for (const [name, value] of Object.entries(secondary)) {
     // Overwriting is not allowed. Primary and secondary must have different properties (w3c rule 4.4)
-    if (!_.isUndefined(primary[name])) {
+    if (primary[name] !== undefined) {
       throw new errors.InvalidArgumentError(
         `property '${name}' should not exist on both primary (${JSON.stringify(
-          primary
-        )}) and secondary (${JSON.stringify(secondary)}) object`
+          primary,
+        )}) and secondary (${JSON.stringify(secondary)}) object`,
       );
     }
     result[name as keyof typeof result] = value;
@@ -69,37 +66,42 @@ export function mergeCaps<
 export function validateCaps<C extends Constraints>(
   caps: Capabilities<C>,
   constraints: C | undefined = {} as C,
-  opts: ValidateCapsOpts | undefined = {}
+  opts: ValidateCapsOpts | undefined = {},
 ): Capabilities<C> {
   const {skipPresenceConstraint} = opts;
 
-  if (!_.isPlainObject(caps)) {
+  if (!util.isPlainObject(caps)) {
     throw new errors.InvalidArgumentError(`must be a JSON object`);
   }
 
   // Remove the 'presence' constraint if we're not checking for it
-  constraints = (
-    _.mapValues(
-      constraints,
-      skipPresenceConstraint
-        ? /** @param {Constraint} constraint */
-          (constraint) => _.omit(constraint, 'presence')
-        : /** @param {Constraint} constraint */
-          (constraint) => {
-            if (constraint.presence === true) {
-              return {..._.omit(constraint, 'presence'), presence: {allowEmpty: false}};
-            }
-            return constraint;
-          }
-    )
+  constraints = Object.fromEntries(
+    Object.entries(constraints ?? {}).map(([key, constraint]) => {
+      if (skipPresenceConstraint) {
+        return [key, omit(constraint as Record<string, unknown>, 'presence')];
+      }
+      if ((constraint as {presence?: unknown}).presence === true) {
+        return [
+          key,
+          {
+            ...omit(constraint as Record<string, unknown>, 'presence'),
+            presence: {allowEmpty: false},
+          },
+        ];
+      }
+      return [key, constraint];
+    }),
   ) as C;
 
-  const validationErrors = validator.validate(_.pickBy(caps, util.hasValue), constraints);
+  const validationErrors = validator.validate(
+    pickBy(caps, (value) => util.hasValue(value)),
+    constraints,
+  );
 
   if (validationErrors) {
     const message: string[] = [];
-    for (const [attribute, reasons] of _.toPairs(validationErrors)) {
-      for (const reason of (reasons as string[])) {
+    for (const [attribute, reasons] of Object.entries(validationErrors)) {
+      for (const reason of reasons as string[]) {
         message.push(`'${attribute}' ${reason}`);
       }
     }
@@ -115,22 +117,20 @@ export function validateCaps<C extends Constraints>(
  * @see https://www.w3.org/TR/webdriver2/#dfn-table-of-standard-capabilities)
  */
 export const STANDARD_CAPS = Object.freeze(
-  new Set(
-    ([
-      'browserName',
-      'browserVersion',
-      'platformName',
-      'acceptInsecureCerts',
-      'pageLoadStrategy',
-      'proxy',
-      'setWindowRect',
-      'timeouts',
-      'strictFileInteractability',
-      'unhandledPromptBehavior',
-      'userAgent',
-      'webSocketUrl',
-    ]) as KeyAsString<StandardCapabilities>[]
-  )
+  new Set([
+    'browserName',
+    'browserVersion',
+    'platformName',
+    'acceptInsecureCerts',
+    'pageLoadStrategy',
+    'proxy',
+    'setWindowRect',
+    'timeouts',
+    'strictFileInteractability',
+    'unhandledPromptBehavior',
+    'userAgent',
+    'webSocketUrl',
+  ] as KeyAsString<StandardCapabilities>[]),
 );
 
 const STANDARD_CAPS_LOWER = new Set([...STANDARD_CAPS].map((cap) => cap.toLowerCase()));
@@ -148,34 +148,40 @@ export function isStandardCap(cap: string): boolean {
  * @see https://www.w3.org/TR/webdriver/#dfn-extension-capabilities
  * @internal
  */
-export function stripAppiumPrefixes<C extends Constraints>(caps: NSCapabilities<C>): Capabilities<C> {
+export function stripAppiumPrefixes<C extends Constraints>(
+  caps: NSCapabilities<C>,
+): Capabilities<C> {
   // split into prefixed and non-prefixed.
   // non-prefixed should be standard caps at this point
-  const [prefixedCaps, nonPrefixedCaps] = _.partition(_.keys(caps), (cap) =>
-    String(cap).startsWith(APPIUM_VENDOR_PREFIX)
-  );
+  const capKeys = Object.keys(caps);
+  const prefixedCaps = capKeys.filter((cap) => String(cap).startsWith(APPIUM_VENDOR_PREFIX));
+  const nonPrefixedCaps = capKeys.filter((cap) => !String(cap).startsWith(APPIUM_VENDOR_PREFIX));
 
   // initialize this with the k/v pairs of the non-prefixed caps
-  const strippedCaps = (_.pick(caps, nonPrefixedCaps)) as Capabilities<C>;
+  const strippedCaps: Record<string, unknown> = Object.fromEntries(
+    nonPrefixedCaps.map((cap) => [cap, caps[cap as keyof typeof caps]]),
+  ) as Capabilities<C>;
   const badPrefixedCaps: string[] = [];
 
   // Strip out the 'appium:' prefix
   for (const prefixedCap of prefixedCaps) {
-    const strippedCapName = prefixedCap.substring(APPIUM_VENDOR_PREFIX.length) as KeyAsString<Capabilities<C>>;
+    const strippedCapName = prefixedCap.substring(APPIUM_VENDOR_PREFIX.length) as KeyAsString<
+      Capabilities<C>
+    >;
 
     // If it's standard capability that was prefixed, add it to an array of incorrectly prefixed capabilities
     if (isStandardCap(strippedCapName)) {
       badPrefixedCaps.push(strippedCapName);
-      if (_.isNil(strippedCaps[strippedCapName])) {
-        strippedCaps[strippedCapName] = caps[prefixedCap];
+      if (strippedCaps[strippedCapName] == null) {
+        strippedCaps[strippedCapName] = caps[prefixedCap as keyof typeof caps];
       } else {
         log.warn(
-          `Ignoring capability '${prefixedCap}=${caps[prefixedCap]}' and ` +
-            `using capability '${strippedCapName}=${strippedCaps[strippedCapName]}'`
+          `Ignoring capability '${prefixedCap}=${caps[prefixedCap as keyof typeof caps]}' and ` +
+            `using capability '${strippedCapName}=${strippedCaps[strippedCapName]}'`,
         );
       }
     } else {
-      strippedCaps[strippedCapName] = caps[prefixedCap];
+      strippedCaps[strippedCapName] = caps[prefixedCap as keyof typeof caps];
     }
   }
 
@@ -183,32 +189,29 @@ export function stripAppiumPrefixes<C extends Constraints>(caps: NSCapabilities<
   if (badPrefixedCaps.length > 0) {
     log.warn(
       `The capabilities ${JSON.stringify(
-        badPrefixedCaps
-      )} are standard capabilities and do not require "appium:" prefix`
+        badPrefixedCaps,
+      )} are standard capabilities and do not require "appium:" prefix`,
     );
   }
-  return strippedCaps;
+  return strippedCaps as Capabilities<C>;
 }
 
 /**
  * Get an array of all the unprefixed caps that are being used in 'alwaysMatch' and all of the 'firstMatch' object
  */
-export function findNonPrefixedCaps<C extends Constraints>(
-  {
-    alwaysMatch = {},
-    firstMatch = []
-  }: W3CCapabilities<C>
-): string[] {
-  return _.chain([alwaysMatch, ...firstMatch])
-    .reduce(
+export function findNonPrefixedCaps<C extends Constraints>({
+  alwaysMatch = {},
+  firstMatch = [],
+}: W3CCapabilities<C>): string[] {
+  return util.uniq(
+    [alwaysMatch, ...firstMatch].reduce<string[]>(
       (unprefixedCaps, caps) => [
         ...unprefixedCaps,
         ...Object.keys(caps).filter((cap) => !cap.includes(':') && !isStandardCap(cap)),
       ],
-      []
-    )
-    .uniq()
-    .value();
+      [],
+    ),
+  );
 }
 
 /**
@@ -218,12 +221,12 @@ export function findNonPrefixedCaps<C extends Constraints>(
 export function parseCaps<C extends Constraints>(
   caps: W3CCapabilities<C>,
   constraints: C | undefined = {} as C,
-  shouldValidateCaps: boolean | undefined = true
+  shouldValidateCaps: boolean | undefined = true,
 ): ParsedCaps<C> {
   // If capabilities request is not an object, return error (#1.1)
-  if (!_.isPlainObject(caps)) {
+  if (!util.isPlainObject(caps)) {
     throw new errors.InvalidArgumentError(
-      'The capabilities argument was not valid for the following reason(s): "capabilities" must be a JSON object.'
+      'The capabilities argument was not valid for the following reason(s): "capabilities" must be a JSON object.',
     );
   }
 
@@ -235,9 +238,9 @@ export function parseCaps<C extends Constraints>(
   } = caps;
 
   // Reject 'firstMatch' argument if it's not an array (#3.2)
-  if (!_.isArray(allFirstMatchCaps)) {
+  if (!Array.isArray(allFirstMatchCaps)) {
     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'
+      'The capabilities.firstMatch argument was not valid for the following reason(s): "capabilities.firstMatch" must be a JSON array or undefined',
     );
   }
 
@@ -246,16 +249,16 @@ export function parseCaps<C extends Constraints>(
   if (allFirstMatchCaps.length === 0) {
     log.warn(
       `The firstMatch array in the given capabilities has no entries. Adding an empty entry for now, ` +
-        `but it will require one or more entries as W3C spec.`
+        `but it will require one or more entries as W3C spec.`,
     );
     allFirstMatchCaps.push({});
   }
 
   // Check for non-prefixed, non-standard capabilities and log warnings if they are found
   const nonPrefixedCaps = findNonPrefixedCaps(caps);
-  if (!_.isEmpty(nonPrefixedCaps)) {
+  if (!util.isEmpty(nonPrefixedCaps)) {
     throw new errors.InvalidArgumentError(
-      `All non-standard capabilities should have a vendor prefix. The following capabilities did not have one: ${nonPrefixedCaps}`
+      `All non-standard capabilities should have a vendor prefix. The following capabilities did not have one: ${nonPrefixedCaps}`,
     );
   }
 
@@ -271,22 +274,24 @@ export function parseCaps<C extends Constraints>(
   }
   // Remove the 'presence' constraint for any keys that are already present in 'requiredCaps'
   // since we know that this constraint has already passed
-  const filteredConstraints = _.omitBy(constraints, (_, key) => key in strippedRequiredCaps) as C;
+  const filteredConstraints = Object.fromEntries(
+    Object.entries(constraints ?? {}).filter(([key]) => !(key in strippedRequiredCaps)),
+  ) as C;
 
   // Validate all of the first match capabilities and return an array with only the valid caps (see spec #5)
   const validationErrors: string[] = [];
-  const validatedFirstMatchCaps = _.compact(
-    strippedAllFirstMatchCaps.map((firstMatchCaps) => {
+  const validatedFirstMatchCaps = strippedAllFirstMatchCaps
+    .map((firstMatchCaps) => {
       try {
         // Validate firstMatch caps
         return shouldValidateCaps
           ? validateCaps(firstMatchCaps, filteredConstraints)
           : firstMatchCaps;
       } catch (e) {
-        validationErrors.push(e.message);
+        validationErrors.push((e as Error).message);
       }
     })
-  ) as Capabilities<C>[];
+    .filter(Boolean) as Capabilities<C>[];
 
   /**
    * Try to merge requiredCaps with first match capabilities, break once it finds its first match
@@ -300,8 +305,8 @@ export function parseCaps<C extends Constraints>(
         break;
       }
     } catch (err) {
-      log.warn(err.message);
-      validationErrors.push(err.message);
+      log.warn((err as Error).message);
+      validationErrors.push((err as Error).message);
     }
   }
 
@@ -318,24 +323,21 @@ export function parseCaps<C extends Constraints>(
 /**
  * Calls parseCaps and just returns the matchedCaps variable
  */
-export function processCapabilities<
-  C extends Constraints,
-  W3CCaps extends W3CCapabilities<C>
->(
+export function processCapabilities<C extends Constraints, W3CCaps extends W3CCapabilities<C>>(
   w3cCaps: W3CCaps,
   constraints: C | undefined = {} as C,
-  shouldValidateCaps: boolean | undefined = true
+  shouldValidateCaps: boolean | undefined = true,
 ): Capabilities<C> {
   const {matchedCaps, validationErrors} = parseCaps(w3cCaps, constraints, shouldValidateCaps);
 
   // If we found an error throw an exception
   if (!util.hasValue(matchedCaps)) {
-    if (_.isArray(w3cCaps.firstMatch) && w3cCaps.firstMatch.length > 1) {
+    if (Array.isArray(w3cCaps.firstMatch) && w3cCaps.firstMatch.length > 1) {
       // If there was more than one 'firstMatch' cap, indicate that we couldn't find a matching capabilities set and show all the errors
       throw new errors.InvalidArgumentError(
         `Could not find matching capabilities from ${JSON.stringify(
-          w3cCaps
-        )}:\n ${validationErrors.join('\n')}`
+          w3cCaps,
+        )}:\n ${validationErrors.join('\n')}`,
       );
     } else {
       // Otherwise, just show the singular error message
@@ -350,23 +352,25 @@ export function processCapabilities<
  * Return a copy of a "bare" (single-level, non-W3C) capabilities object which has taken everything
  * within the 'appium:options' capability and promoted it to the top level.
  */
-export function promoteAppiumOptionsForObject<C extends Constraints>(obj: NSCapabilities<C>): NSCapabilities<C> {
+export function promoteAppiumOptionsForObject<C extends Constraints>(
+  obj: NSCapabilities<C>,
+): NSCapabilities<C> {
   const appiumOptions = obj[PREFIXED_APPIUM_OPTS_CAP];
   if (!appiumOptions) {
     return obj;
   }
 
-  if (!_.isPlainObject(appiumOptions)) {
+  if (!util.isPlainObject(appiumOptions)) {
     throw new errors.SessionNotCreatedError(
-      `The ${PREFIXED_APPIUM_OPTS_CAP} capability must be an object`
+      `The ${PREFIXED_APPIUM_OPTS_CAP} capability must be an object`,
     );
   }
-  if (_.isEmpty(appiumOptions)) {
+  if (util.isEmpty(appiumOptions)) {
     return obj;
   }
 
   log.debug(
-    `Found ${PREFIXED_APPIUM_OPTS_CAP} capability present; will promote items inside to caps`
+    `Found ${PREFIXED_APPIUM_OPTS_CAP} capability present; will promote items inside to caps`,
   );
 
   /**
@@ -374,32 +378,37 @@ export function promoteAppiumOptionsForObject<C extends Constraints>(obj: NSCapa
    */
   const shouldAddVendorPrefix = (capName: string) => !capName.startsWith(APPIUM_VENDOR_PREFIX);
   const verifyIfAcceptable = (capName: string) => {
-    if (!_.isString(capName)) {
+    if (typeof capName !== 'string') {
       throw new errors.SessionNotCreatedError(
-        `Capability names in ${PREFIXED_APPIUM_OPTS_CAP} must be strings. '${capName}' is unexpected`
+        `Capability names in ${PREFIXED_APPIUM_OPTS_CAP} must be strings. '${capName}' is unexpected`,
       );
     }
     if (isStandardCap(capName)) {
       throw new errors.SessionNotCreatedError(
-        `${PREFIXED_APPIUM_OPTS_CAP} must only contain vendor-specific capabilities. '${capName}' is unexpected`
+        `${PREFIXED_APPIUM_OPTS_CAP} must only contain vendor-specific capabilities. '${capName}' is unexpected`,
       );
     }
     return capName;
   };
-  const preprocessedOptions = _(appiumOptions)
-    .mapKeys((value, key: string) => verifyIfAcceptable(key))
-    .mapKeys((value, key: string) => (shouldAddVendorPrefix(key) ? `${APPIUM_VENDOR_PREFIX}${key}` : key))
-    .value();
+  const preprocessedOptions: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(appiumOptions as Record<string, unknown>)) {
+    const verifiedKey = verifyIfAcceptable(key);
+    const finalKey = shouldAddVendorPrefix(verifiedKey)
+      ? `${APPIUM_VENDOR_PREFIX}${verifiedKey}`
+      : verifiedKey;
+    preprocessedOptions[finalKey] = value;
+  }
   // warn if we are going to overwrite any keys on the base caps object
-  const overwrittenKeys = _.intersection(Object.keys(obj), Object.keys(preprocessedOptions));
+  const overwrittenKeys = Object.keys(obj).filter((key) => key in preprocessedOptions);
   if (overwrittenKeys.length > 0) {
     log.warn(
       `Found capabilities inside ${PREFIXED_APPIUM_OPTS_CAP} that will overwrite ` +
-        `capabilities at the top level: ${JSON.stringify(overwrittenKeys)}`
+        `capabilities at the top level: ${JSON.stringify(overwrittenKeys)}`,
     );
   }
-  return _.cloneDeep({
-    ..._.omit(obj, PREFIXED_APPIUM_OPTS_CAP) as NSCapabilities<C>,
+  const restObj = omit(obj, PREFIXED_APPIUM_OPTS_CAP) as NSCapabilities<C>;
+  return structuredClone({
+    ...restObj,
     ...preprocessedOptions,
   });
 }
@@ -408,15 +417,17 @@ export function promoteAppiumOptionsForObject<C extends Constraints>(obj: NSCapa
  * Return a copy of a capabilities object which has taken everything within the 'options'
  * capability and promoted it to the top level.
  */
-export function promoteAppiumOptions<C extends Constraints>(originalCaps: W3CCapabilities<C>): W3CCapabilities<C> {
+export function promoteAppiumOptions<C extends Constraints>(
+  originalCaps: W3CCapabilities<C>,
+): W3CCapabilities<C> {
   const result = {} as W3CCapabilities<C>;
   const {alwaysMatch, firstMatch} = originalCaps;
-  if (_.isPlainObject(alwaysMatch)) {
+  if (util.isPlainObject(alwaysMatch)) {
     result.alwaysMatch = promoteAppiumOptionsForObject(alwaysMatch);
   } else if ('alwaysMatch' in originalCaps) {
     result.alwaysMatch = alwaysMatch;
   }
-  if (_.isArray(firstMatch)) {
+  if (Array.isArray(firstMatch)) {
     result.firstMatch = firstMatch.map(promoteAppiumOptionsForObject);
   } else if ('firstMatch' in originalCaps) {
     result.firstMatch = firstMatch;

package/lib/basedriver/commands/bidi.ts

@@ -1,7 +1,7 @@
+import {util} from '@appium/support';
 import type {Constraints, DriverStatus, IBidiCommands} from '@appium/types';
 import type {BaseDriver} from '../driver';
 import {mixin} from './mixin';
-import _ from 'lodash';
 
 declare module '../driver' {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -36,16 +36,16 @@ const BidiCommands: IBidiCommands = {
 
   async bidiStatus<C extends Constraints>(this: BaseDriver<C>): Promise<DriverStatus> {
     const result = await this.getStatus();
-    if (!_.has(result, 'ready')) {
-      //@ts-ignore This is OK
-      result.ready = true;
-    }
-    if (!_.has(result, 'message')) {
-      //@ts-ignore This is OK
-      result.message = `${this.constructor.name} is ready to accept commands`;
-    }
-    return result as DriverStatus;
-  }
+    const base: Record<string, unknown> = util.isPlainObject(result) ? {...result} : {};
+    return {
+      ...base,
+      ready: 'ready' in base ? (base.ready as boolean) : true,
+      message:
+        'message' in base
+          ? (base.message as string)
+          : `${this.constructor.name} is ready to accept commands`,
+    };
+  },
 };
 
 mixin(BidiCommands);

package/lib/basedriver/commands/event.ts

@@ -1,5 +1,5 @@
-import type {Constraints, IEventCommands} from '@appium/types';
-import _ from 'lodash';
+import type {Constraints, EventHistory, IEventCommands} from '@appium/types';
+import {util} from '@appium/support';
 import type {BaseDriver} from '../driver';
 import {mixin} from './mixin';
 
@@ -16,7 +16,11 @@ const EventCommands: IEventCommands = {
    * separation
    * @param event - the event name
    */
-  async logCustomEvent<C extends Constraints>(this: BaseDriver<C>, vendor: string, event: string) {
+  async logCustomEvent<C extends Constraints>(
+    this: BaseDriver<C>,
+    vendor: string,
+    event: string,
+  ): Promise<void> {
     this.logEvent(`${vendor}:${event}`);
   },
 
@@ -26,23 +30,25 @@ const EventCommands: IEventCommands = {
    * It returns all events if the type is not provided or empty string/array.
    * @returns the event history log object
    */
-  async getLogEvents<C extends Constraints>(this: BaseDriver<C>, type: string | string[]) {
-    if (_.isEmpty(type)) {
+  async getLogEvents<C extends Constraints>(
+    this: BaseDriver<C>,
+    type: string | string[],
+  ): Promise<Partial<EventHistory>> {
+    if (util.isEmpty(type)) {
       return this.eventHistory;
     }
 
-    const typeList = _.castArray(type);
+    const typeList = Array.isArray(type) ? type : [type];
 
-    return _.reduce(
-      this.eventHistory,
-      (acc, eventTimes, eventType) => {
+    return Object.entries(this.eventHistory).reduce<Partial<EventHistory>>(
+      (acc, [eventType, eventTimes]) => {
         if (typeList.includes(eventType)) {
           acc[eventType] = eventTimes;
         }
         return acc;
       },
-      {}
-    );
+      {},
+    ) as Record<string, number>;
   },
 };
 

package/lib/basedriver/commands/execute.ts

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import {util} from '@appium/support';
 import {errors, validateExecuteMethodParams} from '../../protocol';
 import type {
   Constraints,
@@ -17,31 +17,34 @@ declare module '../driver' {
   interface BaseDriver<C extends Constraints> extends IExecuteCommands {}
 }
 
-const ExecuteCommands: IExecuteCommands = {
+const ExecuteCommands = {
   async executeMethod<C extends Constraints>(
     this: BaseDriver<C>,
     script: string,
-    protoArgs: readonly [StringRecord<unknown>] | readonly unknown[]
+    protoArgs: readonly [StringRecord<unknown>] | readonly unknown[],
   ) {
     const Driver = this.constructor as DriverClass<Driver<C>>;
     const commandMetadata = {...Driver.executeMethodMap?.[script]};
     if (!commandMetadata.command) {
-      const availableScripts = _.keys(Driver.executeMethodMap);
-      if (_.isEmpty(availableScripts)) {
+      const availableScripts = Object.keys(Driver.executeMethodMap ?? {});
+      if (util.isEmpty(availableScripts)) {
         throw new errors.UnsupportedOperationError(
           `Unsupported execute method '${script}'. ` +
-          `Make sure the installed ${Driver.name} is up-to-date. ` +
-          `The current driver version does not define any execute methods.`
+            `Make sure the installed ${Driver.name} is up-to-date. ` +
+            `The current driver version does not define any execute methods.`,
         );
       }
-      const {sorted: sortedMatches, suggestion} = rankLevenshteinCandidates(script, availableScripts);
+      const {sorted: sortedMatches, suggestion} = rankLevenshteinCandidates(
+        script,
+        availableScripts,
+      );
       throw new errors.UnsupportedOperationError(
         (suggestion
           ? `Unsupported execute method '${script}', did you mean '${suggestion}'? `
           : `Unsupported execute method '${script}'. `) +
-        `Make sure the installed ${Driver.name} is up-to-date. ` +
-        `Execute methods available in the current driver version are: ` +
-        sortedMatches.join(', ')
+          `Make sure the installed ${Driver.name} is up-to-date. ` +
+          `Execute methods available in the current driver version are: ` +
+          sortedMatches.join(', '),
       );
     }
     const args = validateExecuteMethodParams(protoArgs as any[], commandMetadata.params);
@@ -49,6 +52,6 @@ const ExecuteCommands: IExecuteCommands = {
     const command = this[commandName] as DriverCommand;
     return await command.call(this, ...args);
   },
-};
+} as IExecuteCommands;
 
 mixin(ExecuteCommands);