@appium/base-driver 10.5.1 → 10.6.0

package/lib/index.js

@@ -1,19 +1,9 @@
-import B from 'bluebird';
-
-try {
-  B.config({
-    cancellation: true,
-  });
-} catch {
-  // sometimes during testing this somehow gets required twice and results in an error about
-  // cancellation not being able to be enabled after promise has been configured
-}
-
 // BaseDriver exports
 export {ExtensionCore} from './basedriver/extension-core';
 import {BaseDriver} from './basedriver/driver';
 export {DriverCore} from './basedriver/core';
 export {DeviceSettings} from './basedriver/device-settings';
+export {AppiumIpc} from './basedriver/ipc';
 
 export {BaseDriver};
 export default BaseDriver;

package/lib/jsonwp-proxy/protocol-converter.ts

@@ -1,5 +1,4 @@
 import type {AppiumLogger, HTTPBody, ProxyResponse} from '@appium/types';
-import _ from 'lodash';
 import {logger, util} from '@appium/support';
 import {duplicateKeys} from '../basedriver/helpers';
 import {MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, PROTOCOLS} from '../constants';
@@ -138,12 +137,12 @@ export class ProtocolConverter {
    * provided in the request, we need to do 3 proxies and combine the result.
    */
   private getTimeoutRequestObjects(body: HTTPBody): Record<string, unknown>[] {
-    if (_.isNil(body)) {
+    if (body == null) {
       return [];
     }
 
     const bodyObj = (util.safeJsonParse(body) as Record<string, unknown>) ?? {};
-    if (this.downstreamProtocol === W3C && _.has(bodyObj, 'ms') && _.has(bodyObj, 'type')) {
+    if (this.downstreamProtocol === W3C && Object.hasOwn(bodyObj, 'ms') && Object.hasOwn(bodyObj, 'type')) {
       const typeToW3C = (x: string) => (x === 'page load' ? 'pageLoad' : x);
       return [
         {
@@ -152,9 +151,9 @@ export class ProtocolConverter {
       ];
     }
 
-    if (this.downstreamProtocol === MJSONWP && (!_.has(bodyObj, 'ms') || !_.has(bodyObj, 'type'))) {
+    if (this.downstreamProtocol === MJSONWP && (!Object.hasOwn(bodyObj, 'ms') || !Object.hasOwn(bodyObj, 'type'))) {
       const typeToJSONWP = (x: string) => (x === 'pageLoad' ? 'page load' : x);
-      return _.toPairs(bodyObj)
+      return Object.entries(bodyObj)
         // Only transform the entry if ms value is a valid positive float number
         .filter((pair) => /^\d+(?:[.,]\d*?)?$/.test(`${pair[1]}`))
         .map((pair) => ({
@@ -206,16 +205,16 @@ export class ProtocolConverter {
     body: HTTPBody
   ): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body);
-    if (_.isPlainObject(bodyObj)) {
+    if (util.isPlainObject(bodyObj)) {
       const obj = bodyObj as Record<string, unknown>;
-      if (this.downstreamProtocol === W3C && _.has(bodyObj, 'name') && !_.has(bodyObj, 'handle')) {
+      if (this.downstreamProtocol === W3C && Object.hasOwn(bodyObj, 'name') && !Object.hasOwn(bodyObj, 'handle')) {
         this.log.debug(`Copied 'name' value '${obj.name}' to 'handle' as per W3C spec`);
         return await this.proxyFunc(url, method, {...obj, handle: obj.name});
       }
       if (
         this.downstreamProtocol === MJSONWP &&
-        _.has(bodyObj, 'handle') &&
-        !_.has(bodyObj, 'name')
+        Object.hasOwn(bodyObj, 'handle') &&
+        !Object.hasOwn(bodyObj, 'name')
       ) {
         this.log.debug(`Copied 'handle' value '${obj.handle}' to 'name' as per JSONWP spec`);
         return await this.proxyFunc(url, method, {...obj, name: obj.handle});
@@ -230,13 +229,13 @@ export class ProtocolConverter {
     body: HTTPBody
   ): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body) as Record<string, unknown> | undefined;
-    if (_.isPlainObject(bodyObj) && (util.hasValue(bodyObj?.text) || util.hasValue(bodyObj?.value))) {
+    if (util.isPlainObject(bodyObj) && (util.hasValue(bodyObj?.text) || util.hasValue(bodyObj?.value))) {
       let {text, value} = bodyObj;
       if (util.hasValue(text) && !util.hasValue(value)) {
-        value = _.isString(text) ? [...text] : _.isArray(text) ? text : [];
+        value = typeof text === 'string' ? [...text] : Array.isArray(text) ? text : [];
         this.log.debug(`Added 'value' property to 'setValue' request body`);
       } else if (!util.hasValue(text) && util.hasValue(value)) {
-        text = _.isArray(value) ? value.join('') : _.isString(value) ? value : '';
+        text = Array.isArray(value) ? value.join('') : typeof value === 'string' ? value : '';
         this.log.debug(`Added 'text' property to 'setValue' request body`);
       }
       return await this.proxyFunc(url, method, {...bodyObj, text, value});
@@ -250,10 +249,10 @@ export class ProtocolConverter {
     body: HTTPBody
   ): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body);
-    if (_.has(bodyObj, 'id') && _.isPlainObject(bodyObj.id)) {
+    if (Object.hasOwn(bodyObj ?? {}, 'id') && util.isPlainObject((bodyObj as Record<string, unknown>).id)) {
       return await this.proxyFunc(url, method, {
         ...(bodyObj as object),
-        id: duplicateKeys(bodyObj.id as object, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY),
+        id: duplicateKeys((bodyObj as Record<string, unknown>).id as object, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY),
       });
     }
     return await this.proxyFunc(url, method, body);
@@ -265,7 +264,7 @@ export class ProtocolConverter {
     body: HTTPBody
   ): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body);
-    if (_.isPlainObject(bodyObj)) {
+    if (util.isPlainObject(bodyObj)) {
       return await this.proxyFunc(
         url,
         method,

package/lib/jsonwp-proxy/proxy-request.ts

@@ -1,19 +1,16 @@
 import axios from 'axios';
-import { CancellationError } from 'bluebird';
-import EventEmitter from 'node:events';
-
-const CANCEL_EVENT = 'cancel';
-const FINISH_EVENT = 'finish';
 
 export class ProxyRequest {
   private readonly _requestConfig: axios.RawAxiosRequestConfig;
-  private readonly _ee: EventEmitter;
-  private _resultPromise: Promise<any> | null;
+  private _resultPromise: Promise<axios.AxiosResponse> | null;
+  private _abortController: AbortController | null;
+  private _cancelled: boolean;
 
   constructor(requestConfig: axios.RawAxiosRequestConfig<any>) {
     this._requestConfig = requestConfig;
-    this._ee = new EventEmitter();
     this._resultPromise = null;
+    this._abortController = null;
+    this._cancelled = false;
   }
 
   async execute(): Promise<axios.AxiosResponse> {
@@ -21,32 +18,35 @@ export class ProxyRequest {
       return await this._resultPromise;
     }
 
+    const abortController = new AbortController();
+    this._abortController = abortController;
+    this._cancelled = false;
+
     try {
-      this._resultPromise = Promise.race([
-        this._makeRacingTimer(),
-        this._makeRequest(),
-      ]);
+      this._resultPromise = this._makeRequest(abortController.signal);
       return await this._resultPromise;
     } finally {
-      this._ee.emit(FINISH_EVENT);
-      this._ee.removeAllListeners();
+      this._abortController = null;
     }
   }
 
   cancel(): void {
-    this._ee.emit(CANCEL_EVENT);
-  }
-
-  private async _makeRequest(): Promise<axios.AxiosResponse> {
-    return await axios(this._requestConfig);
+    this._cancelled = true;
+    this._abortController?.abort();
   }
 
-  private async _makeRacingTimer(): Promise<void> {
-    return await new Promise((resolve, reject) => {
-      this._ee.once(FINISH_EVENT, resolve);
-      this._ee.once(CANCEL_EVENT, () => reject(new CancellationError(
-        'The request has been cancelled'
-      )));
-    });
+  private async _makeRequest(signal: AbortSignal): Promise<axios.AxiosResponse> {
+    try {
+      return await axios({
+        ...this._requestConfig,
+        signal,
+      });
+    } catch (err) {
+      if (this._cancelled && axios.isCancel(err)) {
+        // The request was cancelled; do not propagate the error to callers.
+        return await new Promise<axios.AxiosResponse>(() => {});
+      }
+      throw err;
+    }
   }
 }

package/lib/jsonwp-proxy/proxy.ts

@@ -6,7 +6,6 @@ import type {
   ProxyOptions,
   ProxyResponse,
 } from '@appium/types';
-import _ from 'lodash';
 import {logger, util} from '@appium/support';
 import {getSummaryByCode} from '../jsonwp-status/status';
 import {
@@ -19,6 +18,7 @@ import {
 import {isSessionCommand, routeToCommandName} from '../protocol';
 import {MAX_LOG_BODY_LENGTH, DEFAULT_BASE_PATH, PROTOCOLS} from '../constants';
 import {ProtocolConverter} from './protocol-converter';
+import {omit, pick} from '../utils';
 import {formatResponseValue, ensureW3cResponse} from '../protocol/helpers';
 import http from 'node:http';
 import https from 'node:https';
@@ -69,8 +69,11 @@ export class JWProxy {
   private readonly _log: AppiumLogger | undefined;
 
   constructor(opts: ProxyOptions = {}) {
-    const filteredOpts = _.pick(opts, ALLOWED_OPTS);
-    const options = _.defaults(_.omit(filteredOpts, 'log'), {
+    const filteredOptsWithoutLog = omit(
+      pick(opts as Record<string, unknown>, ALLOWED_OPTS),
+      'log'
+    ) as Omit<ProxyOptions, 'log'>;
+    const options = {
       scheme: 'http',
       server: 'localhost',
       port: 4444,
@@ -78,7 +81,8 @@ export class JWProxy {
       reqBasePath: DEFAULT_BASE_PATH,
       sessionId: null,
       timeout: DEFAULT_REQUEST_TIMEOUT,
-    }) as ProxyOptions & {
+      ...filteredOptsWithoutLog,
+    } as ProxyOptions & {
       scheme: string;
       server: string;
       port: number;
@@ -153,7 +157,7 @@ export class JWProxy {
     const requiresSessionId =
       !commandName || (commandName && isSessionCommand(commandName));
     const proxyPrefix = `${this.scheme}://${this.server}:${this.port}${this.base}`;
-    let proxySuffix = normalizedPathname ? `/${_.trimStart(normalizedPathname, '/')}` : '';
+    let proxySuffix = normalizedPathname ? `/${normalizedPathname.replace(/^\/+/, '')}` : '';
     if (parsedUrl.search) {
       proxySuffix += parsedUrl.search;
     }
@@ -179,7 +183,7 @@ export class JWProxy {
     method = method.toUpperCase();
     const newUrl = this.getUrlForProxy(url, method as HTTPMethod);
     const truncateBody = (content: unknown): string =>
-      _.truncate(_.isString(content) ? content : JSON.stringify(content), {
+      util.truncateString(typeof content === 'string' ? content : JSON.stringify(content), {
         length: MAX_LOG_BODY_LENGTH,
       });
     const reqOpts: RawAxiosRequestConfig = {
@@ -242,7 +246,7 @@ export class JWProxy {
       const {data, status, headers} = await this.request(reqOpts);
       // `data` might be really big
       // Be careful while handling it to avoid memory leaks
-      if (!_.isPlainObject(data)) {
+      if (!util.isPlainObject(data)) {
         // The response should be a valid JSON object
         // If it cannot be coerced to an object then the response is wrong
         throwProxyError(data);
@@ -252,23 +256,15 @@ export class JWProxy {
       const isSessionCreationRequest = url.endsWith('/session') && method === 'POST';
       if (isSessionCreationRequest) {
         if (status === 200) {
-          const value = (data as Record<string, unknown>).value as
-            | Record<string, unknown>
-            | undefined;
-          const raw =
-            (data as Record<string, unknown>).sessionId ?? value?.sessionId;
+          const value = data.value as Record<string, unknown> | undefined;
+          const raw = data.sessionId ?? value?.sessionId;
           this.sessionId =
             typeof raw === 'string' ? raw : raw != null ? String(raw) : null;
         }
-        this.downstreamProtocol = this.getProtocolFromResBody(
-          data as Record<string, unknown>
-        ) ?? this.downstreamProtocol;
+        this.downstreamProtocol = this.getProtocolFromResBody(data) ?? this.downstreamProtocol;
         this.log.info(`Determined the downstream protocol as '${this.downstreamProtocol}'`);
       }
-      if (
-        _.has(data, 'status') &&
-        parseInt((data as Record<string, unknown>).status as string, 10) !== 0
-      ) {
+      if (Object.hasOwn(data, 'status') && parseInt(data.status as string, 10) !== 0) {
         throwProxyError(data);
       }
       return [
@@ -307,10 +303,10 @@ export class JWProxy {
    * Detects the downstream protocol from a response body.
    */
   getProtocolFromResBody(resObj: Record<string, unknown>): Protocol | undefined {
-    if (_.isInteger(resObj.status)) {
+    if (Number.isInteger(resObj.status)) {
       return MJSONWP;
     }
-    if (!_.isUndefined(resObj.value)) {
+    if (resObj.value !== undefined) {
       return W3C;
     }
   }
@@ -363,10 +359,10 @@ export class JWProxy {
       const status = parseInt(resBody.status as string, 10);
       if (!isNaN(status) && status !== 0) {
         let message: unknown = resBody.value;
-        if (_.isPlainObject(message) && _.has(message, 'message')) {
+        if (util.isPlainObject(message) && Object.hasOwn(message, 'message')) {
           message = (message as Record<string, unknown>).message;
         }
-        throw errorFromMJSONWPStatusCode(status, _.isEmpty(message)
+        throw errorFromMJSONWPStatusCode(status, util.isEmpty(message)
           ? getSummaryByCode(status)
           : (message as string | {message: string}));
       }
@@ -374,8 +370,8 @@ export class JWProxy {
       if (response.statusCode < 300) {
         return resBody.value;
       }
-      if (_.isPlainObject(resBody.value) && (resBody.value as Record<string, unknown>).error) {
-        const value = resBody.value as Record<string, unknown>;
+      if (util.isPlainObject(resBody.value) && resBody.value.error) {
+        const value = resBody.value;
         throw errorFromW3CJsonCode(
           value.error as string,
           (value.message as string) ?? '',
@@ -387,7 +383,7 @@ export class JWProxy {
     }
     throw new errors.UnknownError(
       `Did not know what to do with response code '${response.statusCode}' ` +
-        `and response body '${_.truncate(JSON.stringify(resBodyObj), {
+        `and response body '${util.truncateString(JSON.stringify(resBodyObj), {
           length: 300,
         })}'`
     );
@@ -424,16 +420,16 @@ export class JWProxy {
       );
     }
     res.setHeader('content-type', 'application/json; charset=utf-8');
-    if (!_.isPlainObject(resBodyObj)) {
+    if (!util.isPlainObject(resBodyObj)) {
       const error = new errors.UnknownError(
         `The downstream server response with the status code ${statusCode} is not a valid JSON object: ` +
-          _.truncate(`${resBodyObj}`, {length: 300})
+          util.truncateString(`${resBodyObj}`, {length: 300})
       );
       [statusCode, resBodyObj] = getResponseForW3CError(error);
     }
 
     const resBody = resBodyObj as Record<string, unknown>;
-    if (_.has(resBody, 'sessionId')) {
+    if (Object.hasOwn(resBody, 'sessionId')) {
       const reqSessionId = this.getSessionIdFromUrl(req.originalUrl);
       if (reqSessionId) {
         this.log.info(`Replacing sessionId ${resBody.sessionId} with ${reqSessionId}`);
@@ -459,7 +455,10 @@ export class JWProxy {
     try {
       return await req.execute();
     } finally {
-      _.pull(this._activeRequests, req);
+      const reqIndex = this._activeRequests.indexOf(req);
+      if (reqIndex >= 0) {
+        this._activeRequests.splice(reqIndex, 1);
+      }
     }
   }
 
@@ -467,8 +466,8 @@ export class JWProxy {
     // eslint-disable-next-line n/no-deprecated-api -- we need relative URL support
     const parsedUrl = nodeUrl.parse(url || '/');
     if (
-      _.isNil(parsedUrl.href) ||
-      _.isNil(parsedUrl.pathname) ||
+      parsedUrl.href == null ||
+      parsedUrl.pathname == null ||
       (parsedUrl.protocol && !['http:', 'https:'].includes(parsedUrl.protocol))
     ) {
       throw new Error(`Did not know how to proxy the url '${url}'`);
@@ -477,7 +476,7 @@ export class JWProxy {
   }
 
   private _toNormalizedPathname(parsedUrl: nodeUrl.UrlWithStringQuery): string {
-    if (!_.isString(parsedUrl.pathname)) {
+    if (typeof parsedUrl.pathname !== 'string') {
       return '';
     }
     let pathname =
@@ -488,20 +487,20 @@ export class JWProxy {
     // This is needed for the backward compatibility
     // if drivers don't set reqBasePath properly
     if (!this.reqBasePath) {
-      if (match && match.params && _.isArray((match.params as Record<string, unknown>).prefix)) {
+      if (match && match.params && Array.isArray((match.params as Record<string, unknown>).prefix)) {
         pathname = pathname.replace(
           `/${((match.params as Record<string, unknown>).prefix as string[]).join('/')}`,
           ''
         );
-      } else if (_.startsWith(pathname, '/wd/hub')) {
+      } else if (pathname.startsWith('/wd/hub')) {
         pathname = pathname.replace('/wd/hub', '');
       }
     }
     let result = pathname;
     if (match && match.params) {
       const command = (match.params as Record<string, unknown>).command;
-      result = _.isArray(command) ? `/${(command as string[]).join('/')}` : '';
+      result = Array.isArray(command) ? `/${(command as string[]).join('/')}` : '';
     }
-    return _.trimEnd(result, '/');
+    return result.replace(/\/+$/, '');
   }
 }

package/lib/protocol/errors.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import {util, logger} from '@appium/support';
 import {StatusCodes as HTTPStatusCodes} from 'http-status-codes';
 import type {ErrorBiDiCommandResponse, Class} from '@appium/types';
@@ -22,13 +21,13 @@ class BaseError extends Error {
 
   private _formatStack(): void {
     // eslint-disable-next-line no-prototype-builtins
-    if (Error.hasOwnProperty('captureStackTrace') && _.isEmpty(this.stack)) {
+    if (Error.hasOwnProperty('captureStackTrace') && util.isEmpty(this.stack)) {
       Error.captureStackTrace(this, this.constructor);
     }
-    if (!_.isString(this.cause?.stack)) {
+    if (typeof this.cause?.stack !== 'string') {
       return;
     }
-    if (_.isEmpty(this.stack)) {
+    if (util.isEmpty(this.stack)) {
       this.stack = this.cause.stack;
       return;
     }
@@ -77,7 +76,7 @@ export class ProtocolError extends BaseError {
   bidiErrObject(id: string | number): ErrorBiDiCommandResponse {
     // if we don't have an id, the client didn't send one, so we have nothing to send back.
     // send back zero rather than making something up
-    const intId = (_.isInteger(id) ? id : (parseInt(`${id}`, 10) || 0)) as number;
+    const intId = (Number.isInteger(id) ? id : (parseInt(`${id}`, 10) || 0)) as number;
     return {
       id: intId,
       type: 'error',
@@ -957,30 +956,30 @@ export class ProxyRequestError extends BaseError {
   ) {
     const [responseErrorObj, originalMessage] = ProxyRequestError._parseHttpResponse(httpResponseData);
     super(
-      _.isEmpty(message)
+      util.isEmpty(message)
         ? `Proxy request unsuccessful.${originalMessage ? (' ' + originalMessage) : ''}`
         : message,
       cause,
     );
 
     // If the response error is an object and value is an object, it's a W3C error (for JSONWP value is a string)
-    if (_.isPlainObject(responseErrorObj.value) && _.has(responseErrorObj.value, 'error')) {
-      this._w3cError = responseErrorObj.value;
+    if (util.isPlainObject(responseErrorObj.value) && Object.hasOwn(responseErrorObj.value, 'error')) {
+      this._w3cError = responseErrorObj.value as unknown as typeof this._w3cError;
       this._w3cErrorStatus = httpStatus;
-    } else if (_.has(responseErrorObj, 'status')) {
-      this._jwpError = responseErrorObj;
+    } else if (Object.hasOwn(responseErrorObj, 'status')) {
+      this._jwpError = responseErrorObj as typeof this._jwpError;
     }
   }
 
   private static _parseHttpResponse(data: any): [Record<string, any>, string] {
     let responseErrorObj: Record<string, any> = util.safeJsonParse(data);
-    if (!_.isPlainObject(responseErrorObj)) {
+    if (!util.isPlainObject(responseErrorObj)) {
       responseErrorObj = {};
     }
-    let errorMessage: string = _.isString(data) ? data : '';
-    if (_.isString(responseErrorObj.value)) {
+    let errorMessage: string = typeof data === 'string' ? data : '';
+    if (typeof responseErrorObj.value === 'string') {
       errorMessage = responseErrorObj.value;
-    } else if (_.isString(responseErrorObj.value?.message)) {
+    } else if (typeof responseErrorObj.value?.message === 'string') {
       errorMessage = responseErrorObj.value.message;
     }
     return [responseErrorObj, errorMessage];
@@ -991,7 +990,7 @@ export class ProxyRequestError extends BaseError {
       // If it's MJSONWP error, returns actual error cause for request failure based on `jsonwp.status`
       return errorFromMJSONWPStatusCode(this._jwpError.status, this._jwpError.value);
     }
-    if (util.hasValue(this._w3cError) && _.isNumber(this._w3cErrorStatus) && this._w3cErrorStatus >= 300) {
+    if (util.hasValue(this._w3cError) && typeof this._w3cErrorStatus === 'number' && this._w3cErrorStatus >= 300) {
       return errorFromW3CJsonCode(
         this._w3cError.error,
         this._w3cError.message || this.message,
@@ -1007,10 +1006,10 @@ function generateBadParametersMessage(
   paramNames: string[]
 ): string {
   const toArray = function <T> (x: T | T[]): T[] {
-    if (_.isUndefined(x)) {
+    if (x === undefined) {
       return [];
     }
-    if (_.isArray(x)) {
+    if (Array.isArray(x)) {
       return x;
     }
     return [x];
@@ -1018,26 +1017,28 @@ function generateBadParametersMessage(
 
   const requiredParamNames = toArray(paramRequirements.required);
   const actualParamNames = toArray(paramNames);
-  const missingRequiredParamNames = _.difference(requiredParamNames, actualParamNames);
+  const missingRequiredParamNames = requiredParamNames.filter((name) => !actualParamNames.includes(name));
   const resultLines: string[] = [];
   resultLines.push(
-    _.isEmpty(missingRequiredParamNames)
+    util.isEmpty(missingRequiredParamNames)
       ? // This should not happen
         'Some of the provided parameters are not known'
       : `The following required parameter${
           missingRequiredParamNames.length === 1 ? ' is' : 's are'
         } missing: ${JSON.stringify(missingRequiredParamNames)}`,
   );
-  if (!_.isEmpty(requiredParamNames)) {
+  if (!util.isEmpty(requiredParamNames)) {
     resultLines.push(`Known required parameters are: ${JSON.stringify(requiredParamNames)}`);
   }
-  const optionalParamNames = _.difference(toArray(paramRequirements.optional), ['sessionId', 'id']);
-  if (!_.isEmpty(optionalParamNames)) {
+  const optionalParamNames = toArray(paramRequirements.optional).filter(
+    (name): name is string => typeof name === 'string' && !['sessionId', 'id'].includes(name)
+  );
+  if (!util.isEmpty(optionalParamNames)) {
     resultLines.push(`Known optional parameters are: ${JSON.stringify(optionalParamNames)}`);
   }
   resultLines.push(
     `You have provided${
-      _.isEmpty(actualParamNames) ? ' none' : ': ' + JSON.stringify(paramNames)
+      util.isEmpty(actualParamNames) ? ' none' : ': ' + JSON.stringify(paramNames)
     }`,
   );
   return resultLines.join('\n');
@@ -1087,7 +1088,7 @@ export const errors = {
   ProxyRequestError,
 } as const;
 
-const jsonwpErrorCodeMap: Record<string, Class<ProtocolError>> = _.values(errors)
+const jsonwpErrorCodeMap: Record<string, Class<ProtocolError>> = Object.values(errors)
   .reduce((acc: Record<string, Class<ProtocolError>>, ErrorClass: any) => {
     if ('code' in ErrorClass) {
       acc[ErrorClass.code()] = ErrorClass;
@@ -1095,7 +1096,7 @@ const jsonwpErrorCodeMap: Record<string, Class<ProtocolError>> = _.values(errors
     return acc;
   }, {});
 
-const w3cErrorCodeMap: Record<string, Class<ProtocolError>> = _.values(errors)
+const w3cErrorCodeMap: Record<string, Class<ProtocolError>> = Object.values(errors)
   .reduce((acc: Record<string, Class<ProtocolError>>, ErrorClass: any) => {
     if ('error' in ErrorClass) {
       acc[ErrorClass.error()] = ErrorClass;
@@ -1151,7 +1152,7 @@ export function errorFromMJSONWPStatusCode(code: number, value: string | {messag
  * @return The error that is associated with the W3C error string
  */
 export function errorFromW3CJsonCode(signature: string, message: string, stacktrace?: string): ProtocolError {
-  const ErrorClass = w3cErrorCodeMap[_.toLower(signature)] ?? UnknownError;
+  const ErrorClass = w3cErrorCodeMap[signature.toLowerCase()] ?? UnknownError;
   w3cLog.debug(`Matched W3C error code '${signature}' to ${ErrorClass.name}`);
   const resultError = new ErrorClass(message);
   resultError.stacktrace = stacktrace;
@@ -1177,12 +1178,12 @@ export function getResponseForW3CError(err: any): [number, { value: W3CError }]
   ];
 
   // err is ProtocolError
-  if (['error', 'w3cStatus'].every((prop) => _.has(err, prop))) {
+  if (['error', 'w3cStatus'].every((prop) => Object.hasOwn(err, prop))) {
     return protocolErrorToResponse(err);
   }
 
   // err is ProxyRequestError
-  if (_.has(err, 'getActualError') && _.isFunction(err.getActualError)) {
+  if (Object.hasOwn(err, 'getActualError') && typeof err.getActualError === 'function') {
     return protocolErrorToResponse(err.getActualError());
   }
 

package/lib/protocol/helpers.ts

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import {util} from '@appium/support';
 import {duplicateKeys} from '../basedriver/helpers';
 import {MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY} from '../constants';
 
@@ -11,7 +11,7 @@ import {MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY} from '../constants';
  * @returns Either modified value or the same one if nothing has been modified
  */
 export function formatResponseValue(resValue: object | undefined): object | null {
-  if (_.isUndefined(resValue)) {
+  if (resValue === undefined) {
     // convert undefined to null
     return null;
   }
@@ -30,7 +30,11 @@ export function formatResponseValue(resValue: object | undefined): object | null
  * @returns The fixed response body
  */
 export function ensureW3cResponse(responseBody: Record<string, unknown>): Record<string, unknown> {
-  return _.isPlainObject(responseBody)
-    ? (_.omit(responseBody, ['status', 'sessionId']) as Record<string, unknown>)
-    : responseBody;
+  if (!util.isPlainObject(responseBody)) {
+    return responseBody;
+  }
+  const result = {...responseBody};
+  delete result.status;
+  delete result.sessionId;
+  return result;
 }