@appium/base-driver 10.5.2 → 10.7.0

package/lib/basedriver/commands/find.ts

@@ -5,7 +5,6 @@ import type {BaseDriver} from '../driver';
 import {mixin} from './mixin';
 
 declare module '../driver' {
-
   interface BaseDriver<C extends Constraints> extends IFindCommands {}
 }
 
@@ -14,21 +13,21 @@ async function findElOrEls<C extends Constraints>(
   strategy: string,
   selector: string,
   mult: true,
-  context?: any
+  context?: any,
 ): Promise<Element[]>;
 async function findElOrEls<C extends Constraints>(
   this: BaseDriver<C>,
   strategy: string,
   selector: string,
   mult: false,
-  context?: any
+  context?: any,
 ): Promise<Element>;
 async function findElOrEls<C extends Constraints>(
   this: BaseDriver<C>,
   strategy: string,
   selector: string,
   mult: boolean,
-  context?: any
+  context?: any,
 ): Promise<Element[] | Element> {
   throw new errors.NotImplementedError('Not implemented yet for find.');
 }
@@ -38,21 +37,21 @@ async function findElOrElsWithProcessing<C extends Constraints>(
   strategy: string,
   selector: string,
   mult: true,
-  context?: any
+  context?: any,
 ): Promise<Element[]>;
 async function findElOrElsWithProcessing<C extends Constraints>(
   this: BaseDriver<C>,
   strategy: string,
   selector: string,
   mult: false,
-  context?: any
+  context?: any,
 ): Promise<Element>;
 async function findElOrElsWithProcessing<C extends Constraints>(
   this: BaseDriver<C>,
   strategy: string,
   selector: string,
   mult: boolean,
-  context?: any
+  context?: any,
 ): Promise<Element[] | Element> {
   this.validateLocatorStrategy(strategy);
   try {
@@ -61,7 +60,8 @@ async function findElOrElsWithProcessing<C extends Constraints>(
   } catch (err) {
     if (this.opts.printPageSourceOnFindFailure) {
       const src = await this.getPageSource();
-      this.log.debug(`Error finding element${mult ? 's' : ''}: ${err.message}`);
+      const message = err instanceof Error ? err.message : String(err);
+      this.log.debug(`Error finding element${mult ? 's' : ''}: ${message}`);
       this.log.debug(`Page source requested through 'printPageSourceOnFindFailure':`);
       this.log.debug(src);
     }
@@ -71,11 +71,19 @@ async function findElOrElsWithProcessing<C extends Constraints>(
 }
 
 const FindCommands: IFindCommands = {
-  async findElement<C extends Constraints>(this: BaseDriver<C>, strategy, selector) {
+  async findElement<C extends Constraints>(
+    this: BaseDriver<C>,
+    strategy: string,
+    selector: string,
+  ) {
     return await this.findElOrElsWithProcessing(strategy, selector, false);
   },
 
-  async findElements<C extends Constraints>(this: BaseDriver<C>, strategy, selector) {
+  async findElements<C extends Constraints>(
+    this: BaseDriver<C>,
+    strategy: string,
+    selector: string,
+  ) {
     return await this.findElOrElsWithProcessing(strategy, selector, true);
   },
 
@@ -83,7 +91,7 @@ const FindCommands: IFindCommands = {
     this: BaseDriver<C>,
     strategy: string,
     selector: string,
-    elementId: string
+    elementId: string,
   ) {
     return await this.findElOrElsWithProcessing(strategy, selector, false, elementId);
   },
@@ -92,7 +100,7 @@ const FindCommands: IFindCommands = {
     this: BaseDriver<C>,
     strategy: string,
     selector: string,
-    elementId: string
+    elementId: string,
   ) {
     return await this.findElOrElsWithProcessing(strategy, selector, true, elementId);
   },

package/lib/basedriver/commands/log.ts

@@ -1,5 +1,4 @@
 import type {Constraints, Driver, ILogCommands} from '@appium/types';
-import _ from 'lodash';
 import type {BaseDriver} from '../driver';
 import {mixin} from './mixin';
 
@@ -20,10 +19,12 @@ const LogCommands: ILogCommands = {
     this.log.debug(`Retrieving '${String(logType)}' logs`);
 
     if (!(logType in this.supportedLogTypes)) {
-      const logsTypesWithDescriptions = _.mapValues(this.supportedLogTypes, 'description');
+      const logsTypesWithDescriptions = Object.fromEntries(
+        Object.entries(this.supportedLogTypes).map(([key, value]) => [key, value.description]),
+      );
       throw new Error(
         `Unsupported log type '${String(logType)}'. ` +
-          `Supported types: ${JSON.stringify(logsTypesWithDescriptions)}`
+          `Supported types: ${JSON.stringify(logsTypesWithDescriptions)}`,
       );
     }
 

package/lib/basedriver/commands/timeout.ts

@@ -1,5 +1,4 @@
 import {waitForCondition} from 'asyncbox';
-import _ from 'lodash';
 import {util} from '@appium/support';
 import {errors} from '../../protocol';
 import type {BaseDriver} from '../driver';
@@ -14,27 +13,36 @@ declare module '../driver' {
 const MIN_TIMEOUT = 0;
 
 const TimeoutCommands: ITimeoutCommands = {
-  async timeouts<C extends Constraints>(this: BaseDriver<C>, type, ms, script, pageLoad, implicit) {
-    if (type && _.isString(type) && util.hasValue(ms)) {
+  async timeouts<C extends Constraints>(
+    this: BaseDriver<C>,
+    type?: string,
+    ms?: number | string,
+    script?: number,
+    pageLoad?: number,
+    implicit?: number,
+  ) {
+    if (type && typeof type === 'string' && util.hasValue(ms)) {
       // legacy stuff with some Appium-specific additions
       this.log.debug(`Timeout arguments: ${JSON.stringify({type, ms})}}`);
       switch (type) {
         case 'command':
-          return void (await this.newCommandTimeout(ms));
+          return void (await this.newCommandTimeout(this.parseTimeoutArgument(ms)));
         case 'implicit':
-          return void (await this.implicitWaitW3C(ms));
+          return void (await this.implicitWaitW3C(this.parseTimeoutArgument(ms)));
         case 'page load':
-          return void (await this.pageLoadTimeoutW3C(ms));
+          return void (await this.pageLoadTimeoutW3C(this.parseTimeoutArgument(ms)));
         case 'script':
-          return void (await this.scriptTimeoutW3C(ms));
+          return void (await this.scriptTimeoutW3C(this.parseTimeoutArgument(ms)));
         default:
           throw new Error(`'${type}' type is not supported for the timeout API`);
       }
     }
 
     this.log.debug(`W3C timeout argument: ${JSON.stringify({script, pageLoad, implicit})}}`);
-    if ([script, pageLoad, implicit].every(_.isNil)) {
-      throw new errors.InvalidArgumentError('W3C protocol expects any of script, pageLoad or implicit to be set');
+    if ([script, pageLoad, implicit].every((value) => value == null)) {
+      throw new errors.InvalidArgumentError(
+        'W3C protocol expects any of script, pageLoad or implicit to be set',
+      );
     }
     if (util.hasValue(script)) {
       await this.scriptTimeoutW3C(script);
@@ -47,7 +55,7 @@ const TimeoutCommands: ITimeoutCommands = {
     }
   },
 
-  async getTimeouts() {
+  async getTimeouts<C extends Constraints>(this: BaseDriver<C>) {
     return {
       command: this.newCommandTimeoutMs,
       implicit: this.implicitWaitMs,
@@ -82,7 +90,7 @@ const TimeoutCommands: ITimeoutCommands = {
     if (this.managedDrivers?.length) {
       this.log.debug('Setting implicit wait on managed drivers');
       for (const driver of this.managedDrivers) {
-        if (_.isFunction(driver.setImplicitWait)) {
+        if (typeof driver.setImplicitWait === 'function') {
           driver.setImplicitWait(ms);
         }
       }
@@ -95,7 +103,7 @@ const TimeoutCommands: ITimeoutCommands = {
     if (this.managedDrivers?.length) {
       this.log.debug('Setting new command timeout on managed drivers');
       for (const driver of this.managedDrivers) {
-        if (_.isFunction(driver.setNewCommandTimeout)) {
+        if (typeof driver.setNewCommandTimeout === 'function') {
           driver.setNewCommandTimeout(ms);
         }
       }
@@ -104,7 +112,7 @@ const TimeoutCommands: ITimeoutCommands = {
 
   async implicitWaitForCondition<C extends Constraints>(
     this: BaseDriver<C>,
-    condFn: (...args: any[]) => Promise<any>
+    condFn: (...args: any[]) => Promise<any>,
   ) {
     this.log.debug(`Waiting up to ${this.implicitWaitMs} ms for condition`);
     const wrappedCondFn = async (...args: any[]) => {
@@ -122,7 +130,7 @@ const TimeoutCommands: ITimeoutCommands = {
 
   parseTimeoutArgument<C extends Constraints>(this: BaseDriver<C>, ms: number | string) {
     const duration = parseInt(String(ms), 10);
-    if (_.isNaN(duration) || duration < MIN_TIMEOUT) {
+    if (Number.isNaN(duration) || duration < MIN_TIMEOUT) {
       throw new errors.UnknownError(`Invalid timeout value '${ms}'`);
     }
     return duration;

package/lib/basedriver/core.ts

@@ -12,12 +12,9 @@ import type {
   StringRecord,
 } from '@appium/types';
 import AsyncLock from 'async-lock';
-import _ from 'lodash';
+import {util} from '@appium/support';
 import os from 'node:os';
-import {
-  DEFAULT_BASE_PATH,
-  PROTOCOLS,
-} from '../constants';
+import {DEFAULT_BASE_PATH, PROTOCOLS} from '../constants';
 import {errors} from '../protocol';
 import {DeviceSettings} from './device-settings';
 import * as helpers from './helpers';
@@ -31,7 +28,8 @@ const ALL_DRIVERS_MATCH = '*';
 const FEATURE_NAME_SEPARATOR = ':';
 
 export class DriverCore<const C extends Constraints, Settings extends StringRecord = StringRecord>
-  extends ExtensionCore implements Core<C, Settings>
+  extends ExtensionCore
+  implements Core<C, Settings>
 {
   /**
    * Make the basedriver version available so for any driver which inherits from this package, we
@@ -41,7 +39,7 @@ export class DriverCore<const C extends Constraints, Settings extends StringReco
 
   sessionId: string | null;
 
-  sessionCreationTimestampMs: number;
+  sessionCreationTimestampMs!: number;
 
   opts: DriverOpts<C>;
 
@@ -104,7 +102,6 @@ export class DriverCore<const C extends Constraints, Settings extends StringReco
     super();
     this._log = this.log; // TODO: remove references to this._log and use this.log instead
 
-
     // setup state
     this.opts = opts as DriverOpts<C>;
 
@@ -116,7 +113,7 @@ export class DriverCore<const C extends Constraints, Settings extends StringReco
     this.shouldValidateCaps = shouldValidateCaps;
 
     // keeping track of initial opts
-    this.initialOpts = _.cloneDeep(opts);
+    this.initialOpts = structuredClone(opts);
 
     this.sessionId = null;
     this.helpers = helpers;
@@ -166,7 +163,7 @@ export class DriverCore<const C extends Constraints, Settings extends StringReco
    * inadvertently change data outside of logEvent
    */
   get eventHistory() {
-    return _.cloneDeep(this._eventHistory);
+    return structuredClone(this._eventHistory);
   }
 
   /**
@@ -263,7 +260,7 @@ export class DriverCore<const C extends Constraints, Settings extends StringReco
   isFeatureEnabled(name: string): boolean {
     // automationName comparison is case-insensitive,
     // while feature name is case-sensitive
-    const currentAutomationName = _.toLower(this.opts.automationName);
+    const currentAutomationName = String(this.opts.automationName).toLowerCase();
 
     const parseFullName = (fullName: string) => {
       const separatorPos = fullName.indexOf(FEATURE_NAME_SEPARATOR);
@@ -273,27 +270,31 @@ export class DriverCore<const C extends Constraints, Settings extends StringReco
         // but better be safe than sorry
         throw new Error(
           `The full feature name must include both the automation name ` +
-          `'${this.opts.automationName}' or the '${ALL_DRIVERS_MATCH}' ` +
-          `wildcard to apply the feature to all installed drivers, and ` +
-          `the feature name split by a colon. Got '${fullName}' instead`
+            `'${this.opts.automationName}' or the '${ALL_DRIVERS_MATCH}' ` +
+            `wildcard to apply the feature to all installed drivers, and ` +
+            `the feature name split by a colon. Got '${fullName}' instead`,
         );
       }
       return [
-        _.toLower(fullName.substring(0, separatorPos)),
-        fullName.substring(separatorPos + 1)
+        fullName.substring(0, separatorPos).toLowerCase(),
+        fullName.substring(separatorPos + 1),
       ];
     };
     const parseFullNames = (fullNames: string[]) => fullNames.map(parseFullName);
-    const matches = ([automationName, featureName]: [string, string]) =>
-      [currentAutomationName, ALL_DRIVERS_MATCH].includes(automationName) && featureName === name;
+    const matches = (pair: string[]) => {
+      const [automationName, featureName] = pair;
+      return (
+        [currentAutomationName, ALL_DRIVERS_MATCH].includes(automationName) && featureName === name
+      );
+    };
 
     // if we have explicitly denied this feature, return false immediately
-    if (!_.isEmpty(this.denyInsecure) && parseFullNames(this.denyInsecure).some(matches)) {
+    if (!util.isEmpty(this.denyInsecure) && parseFullNames(this.denyInsecure).some(matches)) {
       return false;
     }
 
     // if we specifically have allowed the feature, return true
-    if (!_.isEmpty(this.allowInsecure) && parseFullNames(this.allowInsecure).some(matches)) {
+    if (!util.isEmpty(this.allowInsecure) && parseFullNames(this.allowInsecure).some(matches)) {
       return true;
     }
 
@@ -332,7 +333,7 @@ export class DriverCore<const C extends Constraints, Settings extends StringReco
       validStrategies = validStrategies.concat(this.webLocatorStrategies);
     }
 
-    if (!_.includes(validStrategies, strategy)) {
+    if (!validStrategies.includes(strategy)) {
       throw new errors.InvalidSelectorError(
         `Locator Strategy '${strategy}' is not supported for this session`,
       );
@@ -370,17 +371,17 @@ export class DriverCore<const C extends Constraints, Settings extends StringReco
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   proxyRouteIsAvoided(sessionId: string, method: HTTPMethod, url: string, body?: any): boolean {
     for (const avoidSchema of this.getProxyAvoidList(sessionId)) {
-      if (!_.isArray(avoidSchema) || avoidSchema.length !== 2) {
+      if (!Array.isArray(avoidSchema) || avoidSchema.length !== 2) {
         throw new Error('Proxy avoidance must be a list of pairs');
       }
       const [avoidMethod, avoidPathRegex] = avoidSchema;
-      if (!_.includes(['GET', 'POST', 'DELETE'], avoidMethod)) {
+      if (!['GET', 'POST', 'DELETE'].includes(avoidMethod)) {
         throw new Error(`Unrecognized proxy avoidance method '${avoidMethod}'`);
       }
-      if (!_.isRegExp(avoidPathRegex)) {
+      if (!(avoidPathRegex instanceof RegExp)) {
         throw new Error('Proxy avoidance path must be a regular expression');
       }
-      const normalizedUrl = url.replace(new RegExp(`^${_.escapeRegExp(this.basePath)}`), '');
+      const normalizedUrl = url.replace(new RegExp(`^${util.escapeRegExp(this.basePath)}`), '');
       if (avoidMethod === method && avoidPathRegex.test(normalizedUrl)) {
         return true;
       }
@@ -406,5 +407,4 @@ export class DriverCore<const C extends Constraints, Settings extends StringReco
       this.noCommandTimer = null;
     }
   }
-
 }

package/lib/basedriver/device-settings.ts

@@ -1,6 +1,5 @@
-import _ from 'lodash';
+import {util, node} from '@appium/support';
 import {log} from './logger';
-import {node, util} from '@appium/support';
 import {errors} from '../protocol/errors';
 import type {StringRecord, IDeviceSettings, SettingsUpdateListener} from '@appium/types';
 
@@ -24,7 +23,7 @@ export class DeviceSettings<T extends StringRecord = StringRecord> implements ID
    */
   constructor(
     defaultSettings: T = {} as T,
-    onSettingsUpdate: SettingsUpdateListener<T> = async () => {}
+    onSettingsUpdate: SettingsUpdateListener<T> = async () => {},
   ) {
     this._settings = {...defaultSettings};
     this._onSettingsUpdate = onSettingsUpdate;
@@ -36,32 +35,28 @@ export class DeviceSettings<T extends StringRecord = StringRecord> implements ID
    * @param newSettings - New settings to merge (must be plain object; total size remains bounded).
    */
   async update(newSettings: T): Promise<void> {
-    if (!_.isPlainObject(newSettings)) {
+    if (!util.isPlainObject(newSettings)) {
       throw new errors.InvalidArgumentError(
         `Settings update should be called with valid JSON. Got ` +
-          `${JSON.stringify(newSettings)} instead`
+          `${JSON.stringify(newSettings)} instead`,
       );
     }
 
     if (node.getObjectSize({...this._settings, ...newSettings}) >= MAX_SETTINGS_SIZE) {
       throw new errors.InvalidArgumentError(
         `New settings cannot be applied, because the overall ` +
-          `object size exceeds the allowed limit of ${util.toReadableSizeString(MAX_SETTINGS_SIZE)}`
+          `object size exceeds the allowed limit of ${util.toReadableSizeString(MAX_SETTINGS_SIZE)}`,
       );
     }
 
     for (const prop in newSettings) {
-      if (!_.isUndefined(this._settings[prop])) {
+      if (this._settings[prop] !== undefined) {
         if (this._settings[prop] === newSettings[prop]) {
           log.debug(`The value of '${prop}' setting did not change. Skipping the update for it`);
           continue;
         }
       }
-      await this._onSettingsUpdate(
-        prop as keyof T,
-        newSettings[prop],
-        this._settings[prop]
-      );
+      await this._onSettingsUpdate(prop as keyof T, newSettings[prop], this._settings[prop]);
       this._settings[prop] = newSettings[prop];
     }
   }