@appium/base-driver 10.5.1 → 10.6.0

package/lib/basedriver/validation.ts

@@ -1,6 +1,6 @@
 import type {Constraint} from '@appium/types';
+import {util} from '@appium/support';
 import {log} from './logger';
-import _ from 'lodash';
 
 export class Validator {
   private readonly _validators: Record<
@@ -8,27 +8,27 @@ export class Validator {
     (value: any, options?: any, key?: string) => string | null
   > = {
     isString: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || _.isNil(options)) {
+      if (value === undefined || options == null) {
         return null;
       }
 
-      if (_.isString(value)) {
+      if (typeof value === 'string') {
         return options ? null : 'must not be of type string';
       }
 
       return options ? 'must be of type string' : null;
     },
     isNumber: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || _.isNil(options)) {
+      if (value === undefined || options == null) {
         return null;
       }
 
-      if (_.isNumber(value)) {
+      if (typeof value === 'number') {
         return options ? null : 'must not be of type number';
       }
 
       // allow a string value
-      if (options && _.isString(value) && !isNaN(Number(value))) {
+      if (options && typeof value === 'string' && !isNaN(Number(value))) {
         log.warn('Number capability passed in as string. Functionality may be compromised.');
         return null;
       }
@@ -36,45 +36,45 @@ export class Validator {
       return options ? 'must be of type number' : null;
     },
     isBoolean: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || _.isNil(options)) {
+      if (value === undefined || options == null) {
         return null;
       }
 
-      if (_.isBoolean(value)) {
+      if (typeof value === 'boolean') {
         return options ? null : 'must not be of type boolean';
       }
 
       // allow a string value
-      if (options && _.isString(value) && ['true', 'false', ''].includes(value)) {
+      if (options && typeof value === 'string' && ['true', 'false', ''].includes(value)) {
         return null;
       }
 
       return options ? 'must be of type boolean' : null;
     },
     isObject: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || _.isNil(options)) {
+      if (value === undefined || options == null) {
         return null;
       }
 
-      if (_.isPlainObject(value)) {
+      if (util.isPlainObject(value)) {
         return options ? null : 'must not be a plain object';
       }
 
       return options ? 'must be a plain object' : null;
     },
     isArray: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || _.isNil(options)) {
+      if (value === undefined || options == null) {
         return null;
       }
 
-      if (_.isArray(value)) {
+      if (Array.isArray(value)) {
         return options ? null : 'must not be of type array';
       }
 
       return options ? 'must be of type array' : null;
     },
     deprecated: (value: any, options?: any, key?: string): string | null => {
-      if (!_.isUndefined(value) && options) {
+      if (value !== undefined && options) {
         log.warn(
           `The '${key}' capability has been deprecated and must not be used anymore. ` +
           `Please check the driver documentation for possible alternatives.`
@@ -83,32 +83,32 @@ export class Validator {
       return null;
     },
     inclusion: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || !options) {
+      if (value === undefined || !options) {
         return null;
       }
-      const optionsArr = _.isArray(options) ? options : [options];
+      const optionsArr = Array.isArray(options) ? options : [options];
       if (optionsArr.some((opt) => opt === value)) {
         return null;
       }
       return `must be contained by ${JSON.stringify(optionsArr)}`;
     },
     inclusionCaseInsensitive: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || !options) {
+      if (value === undefined || !options) {
         return null;
       }
-      const optionsArr = _.isArray(options) ? options : [options];
-      if (optionsArr.some((opt) => _.toLower(opt) === _.toLower(value))) {
+      const optionsArr = Array.isArray(options) ? options : [options];
+      if (optionsArr.some((opt) => String(opt).toLowerCase() === String(value).toLowerCase())) {
         return null;
       }
       return `must be contained by ${JSON.stringify(optionsArr)}`;
     },
     presence: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) && options) {
+      if (value === undefined && options) {
         return 'is required to be present';
       }
       if (
         !options?.allowEmpty &&
-        ((!_.isUndefined(value) && _.isEmpty(value)) || (_.isString(value) && !_.trim(value)))
+        ((value !== undefined && util.isEmpty(value)) || (typeof value === 'string' && !value.trim()))
       ) {
         return 'must not be empty or blank';
       }
@@ -118,15 +118,15 @@ export class Validator {
 
   validate(values: Record<string, any>, constraints: Record<string, Constraint>): Record<string, string[]> | null {
     const result: Record<string, string[]> = {};
-    for (const [key, constraint] of _.toPairs(constraints)) {
+    for (const [key, constraint] of Object.entries(constraints)) {
       const value = values[key];
-      for (const [validatorName, options] of _.toPairs(constraint)) {
+      for (const [validatorName, options] of Object.entries(constraint)) {
         if (!(validatorName in this._validators)) {
           continue;
         }
 
-        const validationError = this._validators[validatorName](value, options, key);
-        if (_.isNil(validationError)) {
+        const validationError = this._validators[validatorName as keyof Constraint](value, options, key);
+        if (validationError == null) {
           continue;
         }
 
@@ -137,7 +137,7 @@ export class Validator {
         }
       }
     }
-    return _.isEmpty(result) ? null : result;
+    return util.isEmpty(result) ? null : result;
   }
 
 }

package/lib/express/express-logging.ts

@@ -1,10 +1,9 @@
-import _ from 'lodash';
+import {util, logger} from '@appium/support';
 import '@colors/colors';
 import morgan from 'morgan';
 import type {Request, RequestHandler, Response} from 'express';
 import {log} from './logger';
 import {MAX_LOG_BODY_LENGTH} from '../constants';
-import {logger} from '@appium/support';
 
 /**
  * Morgan middleware that logs when the HTTP response finishes.
@@ -32,8 +31,8 @@ function startLogFormatterHandler(tokens: unknown, req: Request, res: Response):
   let reqBody = '';
   if (req.body) {
     try {
-      reqBody = _.truncate(
-        _.isString(req.body) ? req.body : JSON.stringify(req.body),
+      reqBody = util.truncateString(
+        typeof req.body === 'string' ? req.body : JSON.stringify(req.body),
         {length: MAX_LOG_BODY_LENGTH}
       );
     } catch {

package/lib/express/idempotency.ts

@@ -1,6 +1,6 @@
 import {log} from './logger';
 import {LRUCache} from 'lru-cache';
-import _ from 'lodash';
+import {util} from '@appium/support';
 import {EventEmitter} from 'node:events';
 import type {Request, Response, NextFunction} from 'express';
 
@@ -34,12 +34,12 @@ export async function handleIdempotency(
   next: NextFunction
 ): Promise<void> {
   const keyOrArr = req.headers[IDEMPOTENCY_KEY_HEADER];
-  if (_.isEmpty(keyOrArr) || !keyOrArr) {
+  if (util.isEmpty(keyOrArr) || !keyOrArr) {
     next();
     return;
   }
 
-  const key = _.isArray(keyOrArr) ? keyOrArr[0] : keyOrArr;
+  const key = Array.isArray(keyOrArr) ? keyOrArr[0] : keyOrArr;
 
   log.updateAsyncContext({idempotencyKey: key});
 

package/lib/express/middleware.ts

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import {util} from '@appium/support';
 import type {NextFunction, Request, RequestHandler, Response} from 'express';
 import type {IncomingMessage} from 'node:http';
 import type {Duplex} from 'node:stream';
@@ -6,7 +6,6 @@ import {log} from './logger';
 import {errors} from '../protocol';
 export {handleIdempotency} from './idempotency';
 import {match} from 'path-to-regexp';
-import {util} from '@appium/support';
 import {calcSignature} from '../helpers/session';
 import {getResponseForW3CError} from '../protocol/errors';
 import type {StringRecord, WSServer} from '@appium/types';
@@ -46,7 +45,7 @@ export function allowCrossDomainAsyncExecute(basePath: string): RequestHandler {
     next: NextFunction
   ): void {
     const receiveAsyncResponseRegExp = new RegExp(
-      `${_.escapeRegExp(basePath)}/session/[a-f0-9-]+/(appium/)?receive_async_response`
+      `${util.escapeRegExp(basePath)}/session/[a-f0-9-]+/(appium/)?receive_async_response`
     );
     if (!receiveAsyncResponseRegExp.test(req.url)) {
       next();
@@ -73,7 +72,7 @@ export function handleLogContext(req: Request, _res: Response, next: NextFunctio
     {
       requestId,
       ...sessionInfo,
-      isSensitive: ['true', '1', 'yes'].includes(_.toLower(isSensitiveHeaderValue)),
+      isSensitive: ['true', '1', 'yes'].includes(String(isSensitiveHeaderValue ?? '').toLowerCase()),
     },
     true
   );
@@ -110,7 +109,7 @@ export function tryHandleWebSocketUpgrade(
   head: Buffer,
   webSocketsMapping: StringRecord<WSServer>
 ): boolean {
-  if (_.toLower(req.headers?.upgrade) !== 'websocket') {
+  if (String(req.headers?.upgrade ?? '').toLowerCase() !== 'websocket') {
     return false;
   }
 
@@ -120,7 +119,7 @@ export function tryHandleWebSocketUpgrade(
   } catch {
     currentPathname = req.url ?? '';
   }
-  for (const [pathname, wsServer] of _.toPairs(webSocketsMapping)) {
+  for (const [pathname, wsServer] of Object.entries(webSocketsMapping)) {
     if (match(pathname)(currentPathname)) {
       wsServer.handleUpgrade(req, socket, head, (ws) => {
         wsServer.emit('connection', ws, req);
@@ -182,6 +181,5 @@ export function catch404Handler(req: Request, res: Response): void {
 
 function fetchHeaderValue(req: Request, name: string): string | undefined {
   const value = req.headers[name];
-  return _.isArray(value) ? value[0] : (value as string | undefined);
+  return Array.isArray(value) ? value[0] : (value as string | undefined);
 }
-

package/lib/express/server.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import path from 'node:path';
 import express from 'express';
 import type {Express, RequestHandler} from 'express';
@@ -34,7 +33,6 @@ import {
   removeAllWebSocketHandlers,
   getWebSocketHandlers,
 } from './websocket';
-import B from 'bluebird';
 import {DEFAULT_BASE_PATH} from '../constants';
 import {fs, timing} from '@appium/support';
 import type {
@@ -123,51 +121,51 @@ export async function server(opts: ServerOpts): Promise<AppiumServer> {
   const app = express();
   const httpServer = await createServer(app, cliArgs);
 
-  return await new B<AppiumServer>(async (resolve, reject) => {
-    // we put an async function as the promise constructor because we want some things to happen in
-    // serial (application of plugin updates, for example). But we still need to use a promise here
-    // because some elements of server start failure only happen in httpServer listeners. So the
-    // way we resolve it is to use an async function here but to wrap all the inner logic in
-    // try/catch so any errors can be passed to reject.
-    try {
-      const appiumServer = configureHttp({
-        httpServer,
-        reject,
-        keepAliveTimeout,
-        gracefulShutdownTimeout: cliArgs.shutdownTimeout,
-      });
-      const useLegacyUpgradeHandler = !hasShouldUpgradeCallback(httpServer);
-      configureServer({
-        app,
-        addRoutes: routeConfiguringFunction,
-        allowCors,
-        basePath,
-        extraMethodMap,
-        webSocketsMapping: appiumServer.webSocketsMapping,
-        useLegacyUpgradeHandler,
-      });
-      // allow extensions to update the app and http server objects
-      for (const updater of serverUpdaters) {
-        await updater(app, appiumServer, cliArgs);
-      }
-
-      // once all configurations and updaters have been applied, make sure to set up a catchall
-      // handler so that anything unknown 404s. But do this after everything else since we don't
-      // want to block extensions' ability to add routes if they want.
-      app.all('/*all', catch404Handler);
-
-      await startServer({
-        httpServer,
-        hostname,
-        port,
-        keepAliveTimeout,
-        requestTimeout,
-      });
+  return await new Promise<AppiumServer>((resolve, reject) => {
+    // we use a promise here because some elements of server start failure only happen in
+    // httpServer listeners. The async IIFE runs setup serially (e.g. plugin updates) while
+    // configureHttp can still reject via the listener registered below.
+    void (async () => {
+      try {
+        const appiumServer = configureHttp({
+          httpServer,
+          reject,
+          keepAliveTimeout,
+          gracefulShutdownTimeout: cliArgs.shutdownTimeout,
+        });
+        const useLegacyUpgradeHandler = !hasShouldUpgradeCallback(httpServer);
+        configureServer({
+          app,
+          addRoutes: routeConfiguringFunction,
+          allowCors,
+          basePath,
+          extraMethodMap,
+          webSocketsMapping: appiumServer.webSocketsMapping,
+          useLegacyUpgradeHandler,
+        });
+        // allow extensions to update the app and http server objects
+        for (const updater of serverUpdaters) {
+          await updater(app, appiumServer, cliArgs);
+        }
 
-      resolve(appiumServer);
-    } catch (err) {
-      reject(err);
-    }
+        // once all configurations and updaters have been applied, make sure to set up a catchall
+        // handler so that anything unknown 404s. But do this after everything else since we don't
+        // want to block extensions' ability to add routes if they want.
+        app.all('/*all', catch404Handler);
+
+        await startServer({
+          httpServer,
+          hostname,
+          port,
+          keepAliveTimeout,
+          requestTimeout,
+        });
+
+        resolve(appiumServer);
+      } catch (err) {
+        reject(err);
+      }
+    })();
   });
 }
 
@@ -237,7 +235,7 @@ export function configureServer({
  * @returns Normalized base path
  */
 export function normalizeBasePath(basePath: string): string {
-  if (!_.isString(basePath)) {
+  if (typeof basePath !== 'string') {
     throw new Error(`Invalid path prefix ${basePath}`);
   }
 
@@ -268,19 +266,18 @@ async function createServer(
   }
 
   const certKey = [sslCertificatePath, sslKeyPath];
-  const zipped = _.zip(
-    await B.all(certKey.map((p) => fs.exists(p))),
-    ['certificate', 'key'],
-    certKey
-  ) as [boolean, string, string][];
-  for (const [exists, desc, p] of zipped) {
+  const [certExists, keyExists] = await Promise.all(certKey.map((p) => fs.exists(p)));
+  for (const [exists, desc, p] of [
+    [certExists, 'certificate', sslCertificatePath],
+    [keyExists, 'key', sslKeyPath],
+  ]) {
     if (!exists) {
       throw new Error(
         `The provided SSL ${desc} at '${p}' does not exist or is not accessible`
       );
     }
   }
-  const [cert, key] = await B.all(
+  const [cert, key] = await Promise.all(
     certKey.map((p) => fs.readFile(p, 'utf8'))
   ) as [string, string];
   log.debug('Enabling TLS/SPDY on the server using the provided certificate');
@@ -333,7 +330,7 @@ function configureHttp({
   if (hasShouldUpgradeCallback(httpServer)) {
     // shouldUpgradeCallback only returns a boolean to indicate if the upgrade should proceed
     (appiumServer as unknown as {shouldUpgradeCallback?: (req: http.IncomingMessage) => boolean}).shouldUpgradeCallback = (req) =>
-      _.toLower(req.headers?.upgrade) === 'websocket';
+      String(req.headers?.upgrade ?? '').toLowerCase() === 'websocket';
     appiumServer.on('upgrade', (req, socket, head) => {
       if (!tryHandleWebSocketUpgrade(req, socket, head, appiumServer.webSocketsMapping)) {
         socket.destroy();
@@ -345,7 +342,7 @@ function configureHttp({
   // all connections are closed and the `close` event is emitted
   const originalClose = appiumServer.close.bind(appiumServer);
   appiumServer.close = async () =>
-    await new B<void>((_resolve, _reject) => {
+    await new Promise<void>((_resolve, _reject) => {
       log.info('Closing Appium HTTP server');
       const timer = new timing.Timer().start();
       const onTimeout = setTimeout(() => {
@@ -405,12 +402,21 @@ async function startServer({
   requestTimeout,
 }: StartServerOpts): Promise<void> {
   // If the hostname is omitted, the server will accept connections on any IP address
-  const start = B.promisify(httpServer.listen, {
-    context: httpServer,
-  }) as (port: number, hostname?: string) => B<HttpServer>;
-  const startPromise = start(port, hostname);
+  const startPromise = new Promise<void>((resolve, reject) => {
+    const onError = (err: Error) => {
+      httpServer.removeListener('listening', onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      httpServer.removeListener('error', onError);
+      resolve();
+    };
+    httpServer.once('error', onError);
+    httpServer.once('listening', onListening);
+    httpServer.listen(port, hostname);
+  });
   httpServer.keepAliveTimeout = keepAliveTimeout;
-  if (_.isInteger(requestTimeout)) {
+  if (Number.isInteger(requestTimeout)) {
     httpServer.requestTimeout = Number(requestTimeout);
   }
   // headers timeout must be greater than keepAliveTimeout

package/lib/express/static.ts

@@ -1,13 +1,11 @@
 import path from 'node:path';
 import {log} from './logger';
-import _ from 'lodash';
 import {fs} from '@appium/support';
-import B from 'bluebird';
+import {sleep} from 'asyncbox';
 import type {Request, Response} from 'express';
+import {compileLodashTemplate} from '../utils';
 
-export const STATIC_DIR = _.isNull(path.resolve(__dirname).match(/build[/\\]lib[/\\]express$/))
-  ? path.resolve(__dirname, '..', '..', 'static')
-  : path.resolve(__dirname, '..', '..', '..', 'static');
+export const STATIC_DIR = resolveStaticDir();
 
 type TemplateParams = Record<string, unknown>;
 
@@ -56,7 +54,7 @@ async function guineaPigTemplate(
   log.debug(`Sending guinea pig response with params: ${JSON.stringify(params)}`);
   if (delay) {
     log.debug(`Waiting ${delay}ms before responding`);
-    await B.delay(delay);
+    await sleep(delay);
   }
   res.set('content-type', 'text/html');
   res.cookie('guineacookie1', 'i am a cookie value', {path: '/'});
@@ -73,5 +71,15 @@ async function getTemplate(
   templateName: string
 ): Promise<(params: TemplateParams) => string> {
   const content = await fs.readFile(path.resolve(STATIC_DIR, 'test', templateName));
-  return _.template(content.toString()) as (params: TemplateParams) => string;
+  return compileLodashTemplate(content.toString());
+}
+
+function resolveStaticDir(): string {
+  const fromDir = __dirname;
+  const parts = path.resolve(fromDir).split(path.sep);
+  const baseDriverIndex = parts.indexOf('base-driver');
+  if (baseDriverIndex < 0) {
+    throw new Error(`Could not find the module root folder in the path: ${fromDir}`);
+  }
+  return path.join(parts.slice(0, baseDriverIndex + 1).join(path.sep), 'static');
 }

package/lib/express/websocket.ts

@@ -1,5 +1,4 @@
-import _ from 'lodash';
-import B from 'bluebird';
+import {util} from '@appium/support';
 import type {AppiumServer, WSServer} from '@appium/types';
 
 export const DEFAULT_WS_PATHNAME_PREFIX = '/ws';
@@ -24,9 +23,9 @@ export async function getWebSocketHandlers(
   this: AppiumServer,
   keysFilter: string | null = null
 ): Promise<Record<string, WSServer>> {
-  return _.toPairs(this.webSocketsMapping).reduce<Record<string, WSServer>>(
+  return Object.entries(this.webSocketsMapping).reduce<Record<string, WSServer>>(
     (acc, [pathname, wsServer]) => {
-      if (!_.isString(keysFilter) || pathname.includes(keysFilter)) {
+      if (typeof keysFilter !== 'string' || pathname.includes(keysFilter)) {
         acc[pathname] = wsServer;
       }
       return acc;
@@ -67,15 +66,14 @@ export async function removeWebSocketHandler(
  * @see AppiumServerExtension.removeAllWebSocketHandlers
  */
 export async function removeAllWebSocketHandlers(this: AppiumServer): Promise<boolean> {
-  if (_.isEmpty(this.webSocketsMapping)) {
+  if (util.isEmpty(this.webSocketsMapping)) {
     return false;
   }
 
-  return _.some(
-    await B.all(
-      _.keys(this.webSocketsMapping).map((pathname) =>
-        this.removeWebSocketHandler(pathname)
-      )
+  const results = await Promise.all(
+    Object.keys(this.webSocketsMapping).map((pathname) =>
+      this.removeWebSocketHandler(pathname)
     )
   );
+  return results.some(Boolean);
 }

package/lib/helpers/capabilities.ts

@@ -1,28 +1,28 @@
 import type {Constraints, W3CCapabilities, Capabilities, AppiumLogger} from '@appium/types';
-import _ from 'lodash';
+import {util} from '@appium/support';
 
 /**
  * Determine whether the given argument is valid
  * W3C capabilities instance.
  */
 export function isW3cCaps(caps: unknown): caps is W3CCapabilities<Constraints> {
-  if (!_.isPlainObject(caps)) {
+  if (!util.isPlainObject(caps)) {
     return false;
   }
 
   const c = caps as Record<string, unknown>;
   const isFirstMatchValid = () =>
-    _.isArray(c.firstMatch) &&
-    !_.isEmpty(c.firstMatch) &&
-    _.every(c.firstMatch, _.isPlainObject);
-  const isAlwaysMatchValid = () => _.isPlainObject(c.alwaysMatch);
-  if (_.has(c, 'firstMatch') && _.has(c, 'alwaysMatch')) {
+    Array.isArray(c.firstMatch) &&
+    !util.isEmpty(c.firstMatch) &&
+    c.firstMatch.every((item) => util.isPlainObject(item));
+  const isAlwaysMatchValid = () => util.isPlainObject(c.alwaysMatch);
+  if (Object.hasOwn(c, 'firstMatch') && Object.hasOwn(c, 'alwaysMatch')) {
     return isFirstMatchValid() && isAlwaysMatchValid();
   }
-  if (_.has(c, 'firstMatch')) {
+  if (Object.hasOwn(c, 'firstMatch')) {
     return isFirstMatchValid();
   }
-  if (_.has(c, 'alwaysMatch')) {
+  if (Object.hasOwn(c, 'alwaysMatch')) {
     return isAlwaysMatchValid();
   }
   return false;
@@ -36,16 +36,18 @@ export function fixCaps<C extends Constraints>(
   desiredCapConstraints: C,
   log: AppiumLogger
 ): Capabilities<C> {
-  const caps = _.clone(oldCaps) as Record<string, unknown>;
+  const caps = {...oldCaps} as Record<string, unknown>;
 
   const logCastWarning = (prefix: string) => log.warn(`${prefix}. This may cause unexpected behavior`);
 
   // boolean capabilities can be passed in as strings 'false' and 'true'
   // which we want to translate into boolean values
-  const booleanCaps = _.keys(_.pickBy(desiredCapConstraints, (k) => k.isBoolean === true));
+  const booleanCaps = Object.keys(desiredCapConstraints).filter(
+    (key) => desiredCapConstraints[key as keyof C]?.isBoolean === true
+  );
   for (const cap of booleanCaps) {
     const value = oldCaps[cap];
-    if (!_.isString(value)) {
+    if (typeof value !== 'string') {
       continue;
     }
 
@@ -59,10 +61,12 @@ export function fixCaps<C extends Constraints>(
   }
 
   // int capabilities are often sent in as strings by frameworks
-  const intCaps = _.keys(_.pickBy(desiredCapConstraints, (k) => k.isNumber === true));
+  const intCaps = Object.keys(desiredCapConstraints).filter(
+    (key) => desiredCapConstraints[key as keyof C]?.isNumber === true
+  );
   for (const cap of intCaps) {
     const value = oldCaps[cap];
-    if (!_.isString(value)) {
+    if (typeof value !== 'string') {
       continue;
     }
 

package/lib/helpers/extension-command-name.ts

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import {util} from '@appium/support';
 import type {Constraints, Driver, DriverClass} from '@appium/types';
 import type {BaseDriver} from '../basedriver/driver';
 
@@ -16,7 +16,7 @@ export function resolveExecuteExtensionName<C extends Constraints>(
   const Driver = this.constructor as DriverClass<Driver<C>>;
   const methodMap = Driver.executeMethodMap;
 
-  if (methodMap && _.isPlainObject(methodMap) && commandName in methodMap) {
+  if (methodMap && util.isPlainObject(methodMap) && commandName in methodMap) {
     const command = methodMap[commandName]?.command;
     if (typeof command === 'string') {
       return command;

package/lib/helpers/levenshtein-match.ts

@@ -1,6 +1,5 @@
 import type {StringRecord} from '@appium/types';
 import {distance} from 'fastest-levenshtein';
-import _ from 'lodash';
 
 /**
  * Inclusive maximum Levenshtein edit distance for offering a "did you mean" hint.
@@ -39,10 +38,8 @@ export function rankLevenshteinCandidates(
       }
       return acc;
     }, {});
-  const sortedDistanceKeys = _.keys(matchesMap).sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
-  const sorted = _.flatten(
-    sortedDistanceKeys.map((k) => (matchesMap[k] ?? []).sort()),
-  );
+  const sortedDistanceKeys = Object.keys(matchesMap).sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+  const sorted = sortedDistanceKeys.flatMap((k) => (matchesMap[k] ?? []).sort());
 
   const best = sorted[0];
   const firstDistanceKey = sortedDistanceKeys[0];