appium-remote-debugger 15.7.3 → 15.8.1

package/lib/mixins/execute.ts

@@ -4,11 +4,11 @@ import {
   simpleStringify,
   convertJavascriptEvaluationResult,
   RESPONSE_LOG_LENGTH,
+  truncateString,
 } from '../utils';
 import {getScriptForAtom} from '../atoms';
 import {util, timing} from '@appium/support';
 import {retryInterval} from 'asyncbox';
-import _ from 'lodash';
 import {getAppIdKey, getPageIdKey, getGarbageCollectOnExecute} from './property-accessors';
 import type {RemoteDebugger} from '../remote-debugger';
 import type {AppIdKey, PageIdKey} from '../types';
@@ -35,9 +35,7 @@ export async function executeAtom(
   const script = await getScriptForAtom(atom, args, frames);
   const value = await this.execute(script);
   this.log.debug(
-    `Received result for atom '${atom}' execution: ${_.truncate(simpleStringify(value), {
-      length: RESPONSE_LOG_LENGTH,
-    })}`,
+    `Received result for atom '${atom}' execution: ${truncateString(simpleStringify(value), RESPONSE_LOG_LENGTH)}`,
   );
   return value;
 }
@@ -177,7 +175,7 @@ export async function execute(
 
   const rpcClient = this.requireRpcClient(true);
   await rpcClient.waitForPage(appIdKey as AppIdKey, pageIdKey as PageIdKey);
-  this.log.debug(`Sending javascript command: '${_.truncate(command, {length: 50})}'`);
+  this.log.debug(`Sending javascript command: '${truncateString(command, 50)}'`);
   const res = await rpcClient.send('Runtime.evaluate', {
     expression: command,
     returnByValue: true,

package/lib/mixins/message-handlers.ts

@@ -1,6 +1,5 @@
 import {events} from './events';
-import {pageArrayFromDict, appInfoFromDict} from '../utils';
-import _ from 'lodash';
+import {deepEqual, defaults, isEmpty, pageArrayFromDict, appInfoFromDict} from '../utils';
 import {
   setAppIdKey,
   getAppDict,
@@ -35,7 +34,7 @@ export async function onPageChange(
   appIdKey: string,
   pageDict: StringRecord,
 ): Promise<void> {
-  if (_.isEmpty(pageDict)) {
+  if (isEmpty(pageDict)) {
     return;
   }
 
@@ -44,7 +43,7 @@ export async function onPageChange(
   if (getAppDict(this)[appIdKey]) {
     const previousPages = getAppDict(this)[appIdKey].pageArray;
     // we have a pre-existing pageDict
-    if (previousPages && _.isEqual(previousPages, currentPages)) {
+    if (previousPages && deepEqual(previousPages, currentPages)) {
       this.log.debug(
         `Received page change notice for app '${appIdKey}' ` +
           `but the listing has not changed. Ignoring.`,
@@ -116,7 +115,7 @@ export function onAppDisconnect(
     setAppIdKey(this, getDebuggerAppKey.bind(this)(getBundleId(this) as string));
   }
 
-  if (_.isEmpty(getAppDict(this))) {
+  if (isEmpty(getAppDict(this))) {
     // this means we no longer have any apps. what the what?
     this.log.debug('Main app disconnected. Disconnecting altogether.');
     this.emit(events.EVENT_DISCONNECT, true);
@@ -193,12 +192,12 @@ export async function onConnectedApplicationList(
   err: Error | null | undefined,
   apps: StringRecord,
 ): Promise<void> {
-  this.log.debug(`Received connected applications list: ${_.keys(apps).join(', ')}`);
+  this.log.debug(`Received connected applications list: ${Object.keys(apps).join(', ')}`);
 
   // translate the received information into an easier-to-manage
   // hash with app id as key, and app info as value
   const newDict: AppDict = {};
-  for (const dict of _.values(apps)) {
+  for (const dict of Object.values(apps)) {
     const [id, entry] = appInfoFromDict(dict);
     if (getSkippedApps(this).includes(entry.name)) {
       continue;
@@ -206,7 +205,7 @@ export async function onConnectedApplicationList(
     newDict[id] = entry;
   }
   // update the object's list of apps
-  _.defaults(getAppDict(this), newDict);
+  Object.assign(getAppDict(this), defaults(getAppDict(this), newDict));
 }
 
 /**
@@ -220,7 +219,7 @@ export async function onConnectedApplicationList(
  */
 export function getDebuggerAppKey(this: RemoteDebugger, bundleId: string): string | undefined {
   let appId: string | undefined;
-  for (const [key, data] of _.toPairs(getAppDict(this))) {
+  for (const [key, data] of Object.entries(getAppDict(this))) {
     if (data.bundleId === bundleId) {
       appId = key;
       break;
@@ -230,7 +229,7 @@ export function getDebuggerAppKey(this: RemoteDebugger, bundleId: string): strin
   if (appId) {
     this.log.debug(`Found app id key '${appId}' for bundle '${bundleId}'`);
     let proxyAppId: string | undefined;
-    for (const [key, data] of _.toPairs(getAppDict(this))) {
+    for (const [key, data] of Object.entries(getAppDict(this))) {
       if (data.isProxy && data.hostId === appId) {
         this.log.debug(
           `Found separate bundleId '${data.bundleId}' ` +

package/lib/mixins/misc.ts

@@ -1,5 +1,4 @@
-import {checkParams} from '../utils';
-import B, {TimeoutError as BTimeoutError} from 'bluebird';
+import {checkParams, TimeoutError, withTimeout} from '../utils';
 import {getAppIdKey, getPageIdKey} from './property-accessors';
 import type {RemoteDebugger} from '../remote-debugger';
 
@@ -77,14 +76,15 @@ export async function isJavascriptExecutionBlocked(
   timeoutMs: number = 1000,
 ): Promise<boolean> {
   try {
-    await B.resolve(
+    await withTimeout(
       this.requireRpcClient().send('Runtime.evaluate', {
         expression: '1+1;',
         returnByValue: true,
         appIdKey: getAppIdKey(this),
         pageIdKey: getPageIdKey(this),
       }),
-    ).timeout(timeoutMs);
+      timeoutMs,
+    );
     return false;
   } catch {
     return true;
@@ -116,15 +116,16 @@ export async function garbageCollect(
   }
 
   try {
-    await B.resolve(
+    await withTimeout(
       this.requireRpcClient().send('Heap.gc', {
         appIdKey: getAppIdKey(this),
         pageIdKey: getPageIdKey(this),
       }),
-    ).timeout(timeoutMs);
+      timeoutMs,
+    );
     this.log.debug(`Garbage collection successful`);
   } catch (e: any) {
-    if (e instanceof BTimeoutError) {
+    if (e instanceof TimeoutError) {
       this.log.debug(`Garbage collection timed out after ${timeoutMs}ms`);
     } else {
       this.log.debug(`Unable to collect garbage: ${e.message}`);

package/lib/mixins/navigate.ts

@@ -1,8 +1,6 @@
-import {checkParams} from '../utils';
+import {checkParams, delay, TimeoutError, withTimeout} from '../utils';
 import {events} from './events';
 import {timing, util} from '@appium/support';
-import _ from 'lodash';
-import B, {TimeoutError as BTimeoutError} from 'bluebird';
 import {
   getAppIdKey,
   setPageLoading,
@@ -57,7 +55,7 @@ export function cancelPageLoad(this: RemoteDebugger): void {
  *          - 'normal' (default): returns true only when readyState is 'complete'
  */
 export function isPageLoadingCompleted(this: RemoteDebugger, readyState: string): boolean {
-  const pageLoadStrategy = _.toLower(getPageLoadStartegy(this));
+  const pageLoadStrategy = (getPageLoadStartegy(this) ?? '').toLowerCase();
   switch (pageLoadStrategy) {
     case PAGE_LOAD_STRATEGY.EAGER:
       // This could include 'interactive' or 'complete'
@@ -89,60 +87,56 @@ export async function waitForDom(
   let isPageLoading = true;
   setPageLoading(this, true);
   setPageLoadDelay(this, util.cancellableDelay(readinessTimeoutMs));
-  const pageReadinessPromise = B.resolve(
-    (async () => {
-      let retry = 0;
-      while (isPageLoading) {
-        // if we are ready, or we've spend too much time on this
-        const elapsedMs = timer.getDuration().asMilliSeconds;
-        // exponential retry
-        const intervalMs = Math.min(
-          PAGE_READINESS_CHECK_INTERVAL_MS * Math.pow(2, retry),
-          readinessTimeoutMs - elapsedMs,
-        );
-        await B.delay(intervalMs);
-        // we can get this called in the middle of trying to find a new app
-        if (!getAppIdKey(this)) {
-          this.log.debug('Not connected to an application. Ignoring page readiess check');
-          return;
-        }
-        if (!isPageLoading) {
-          return;
-        }
+  const pageReadinessPromise = (async () => {
+    let retry = 0;
+    while (isPageLoading) {
+      // if we are ready, or we've spend too much time on this
+      const elapsedMs = timer.getDuration().asMilliSeconds;
+      // exponential retry
+      const intervalMs = Math.min(
+        PAGE_READINESS_CHECK_INTERVAL_MS * Math.pow(2, retry),
+        readinessTimeoutMs - elapsedMs,
+      );
+      await delay(intervalMs);
+      // we can get this called in the middle of trying to find a new app
+      if (!getAppIdKey(this)) {
+        this.log.debug('Not connected to an application. Ignoring page readiess check');
+        return;
+      }
+      if (!isPageLoading) {
+        return;
+      }
 
-        const maxWaitMs = (readinessTimeoutMs - elapsedMs) * 0.95;
-        if (await this.checkPageIsReady(maxWaitMs)) {
-          if (isPageLoading) {
-            this.log.debug(`Page is ready in ${elapsedMs}ms`);
-            isPageLoading = false;
-          }
-          return;
-        }
-        if (elapsedMs > readinessTimeoutMs) {
-          this.log.info(
-            `Timed out after ${readinessTimeoutMs}ms of waiting for the page readiness. Continuing anyway`,
-          );
+      const maxWaitMs = (readinessTimeoutMs - elapsedMs) * 0.95;
+      if (await this.checkPageIsReady(maxWaitMs)) {
+        if (isPageLoading) {
+          this.log.debug(`Page is ready in ${elapsedMs}ms`);
           isPageLoading = false;
-          return;
         }
-        retry++;
+        return;
       }
-    })(),
-  );
-  const cancellationPromise = B.resolve(
-    (async () => {
-      try {
-        await getPageLoadDelay(this);
-      } catch {}
-    })(),
-  );
+      if (elapsedMs > readinessTimeoutMs) {
+        this.log.info(
+          `Timed out after ${readinessTimeoutMs}ms of waiting for the page readiness. Continuing anyway`,
+        );
+        isPageLoading = false;
+        return;
+      }
+      retry++;
+    }
+  })();
+  const cancellationPromise = (async () => {
+    try {
+      await getPageLoadDelay(this);
+    } catch {}
+  })();
 
   try {
-    await B.any([cancellationPromise, pageReadinessPromise]);
+    await Promise.race([cancellationPromise, pageReadinessPromise]);
   } finally {
     isPageLoading = false;
     setPageLoading(this, false);
-    setPageLoadDelay(this, B.resolve());
+    setPageLoadDelay(this, undefined);
   }
 }
 
@@ -159,7 +153,7 @@ export async function checkPageIsReady(this: RemoteDebugger, timeoutMs?: number)
   const readyCmd = 'document.readyState;';
   const actualTimeoutMs = timeoutMs ?? getPageReadyTimeout(this);
   try {
-    const readyState = await B.resolve(this.execute(readyCmd)).timeout(actualTimeoutMs);
+    const readyState = await withTimeout(this.execute(readyCmd), actualTimeoutMs);
     this.log.debug(
       JSON.stringify({
         readyState,
@@ -168,7 +162,7 @@ export async function checkPageIsReady(this: RemoteDebugger, timeoutMs?: number)
     );
     return this.isPageLoadingCompleted(readyState);
   } catch (err: any) {
-    if (err instanceof BTimeoutError) {
+    if (err instanceof TimeoutError) {
       this.log.debug(`Page readiness check timed out after ${actualTimeoutMs}ms`);
     } else {
       this.log.warn(`Page readiness check has failed. Original error: ${err.message}`);
@@ -210,7 +204,8 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
   let isPageLoading = true;
   const start = new timing.Timer().start();
 
-  const pageReadinessPromise = new B<void>((resolve) => {
+  let pageReadinessResolved = false;
+  const pageReadinessPromise = new Promise<void>((resolve) => {
     onPageLoadedTimeout = setTimeout(() => {
       if (isPageLoading) {
         isPageLoading = false;
@@ -219,6 +214,7 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
             `for the ${url} page readiness. Continuing anyway`,
         );
       }
+      pageReadinessResolved = true;
       return resolve();
     }, readinessTimeoutMs);
 
@@ -233,6 +229,7 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
         clearTimeout(onPageLoadedTimeout);
         onPageLoadedTimeout = null;
       }
+      pageReadinessResolved = true;
       return resolve();
     };
 
@@ -241,28 +238,26 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
 
     // Page.navigate was removed from the WebKit Inspector protocol since iOS 26.4
     // See https://github.com/appium/appium/issues/21976
-    rpcClient.send('Runtime.evaluate', {
+    void rpcClient.send('Runtime.evaluate', {
       expression: `window.location.href = ${JSON.stringify(url)};`,
       appIdKey,
       pageIdKey,
     });
   });
-  const cancellationPromise = B.resolve(
-    (async () => {
-      try {
-        await getPageLoadDelay(this);
-      } catch {}
-    })(),
-  );
+  const cancellationPromise = (async () => {
+    try {
+      await getPageLoadDelay(this);
+    } catch {}
+  })();
 
   try {
-    await B.any([cancellationPromise, pageReadinessPromise]);
+    await Promise.race([cancellationPromise, pageReadinessPromise]);
   } finally {
     setPageLoading(this, false);
     isPageLoading = false;
     setNavigatingToPage(this, false);
-    setPageLoadDelay(this, B.resolve());
-    if (onPageLoadedTimeout && pageReadinessPromise.isFulfilled()) {
+    setPageLoadDelay(this, undefined);
+    if (onPageLoadedTimeout && pageReadinessResolved) {
       clearTimeout(onPageLoadedTimeout);
       onPageLoadedTimeout = null;
     }

package/lib/mixins/property-accessors.ts

@@ -3,26 +3,32 @@ import type {StringRecord} from '@appium/types';
 import type {RemoteDebugger} from '../remote-debugger';
 import type {EventListener} from '../types';
 
+/** Gets the current app dictionary snapshot reference. */
 export function getAppDict(instance: RemoteDebugger): (typeof instance)['_appDict'] {
   return instance['_appDict'];
 }
 
+/** Gets the currently selected application id key. */
 export function getAppIdKey(instance: RemoteDebugger): (typeof instance)['_appIdKey'] {
   return instance['_appIdKey'];
 }
 
+/** Sets the currently selected application id key. */
 export function setAppIdKey(instance: RemoteDebugger, value: (typeof instance)['_appIdKey']): void {
   instance['_appIdKey'] = value;
 }
 
+/** Gets the current RPC client instance. */
 export function getRcpClient(instance: RemoteDebugger): (typeof instance)['_rpcClient'] {
   return instance['_rpcClient'];
 }
 
+/** Gets the currently selected page id key. */
 export function getPageIdKey(instance: RemoteDebugger): (typeof instance)['_pageIdKey'] {
   return instance['_pageIdKey'];
 }
 
+/** Sets the currently selected page id key. */
 export function setPageIdKey(
   instance: RemoteDebugger,
   value: (typeof instance)['_pageIdKey'],
@@ -30,58 +36,70 @@ export function setPageIdKey(
   instance['_pageIdKey'] = value;
 }
 
+/** Gets whether Safari automation mode is enabled. */
 export function getIsSafari(instance: RemoteDebugger): (typeof instance)['_isSafari'] {
   return instance['_isSafari'];
 }
 
+/** Gets whether Safari should be included in app listing. */
 export function getIncludeSafari(instance: RemoteDebugger): (typeof instance)['_includeSafari'] {
   return instance['_includeSafari'];
 }
 
+/** Gets the configured primary bundle identifier. */
 export function getBundleId(instance: RemoteDebugger): (typeof instance)['_bundleId'] {
   return instance['_bundleId'];
 }
 
+/** Gets additional bundle identifiers used for matching apps. */
 export function getAdditionalBundleIds(
   instance: RemoteDebugger,
 ): (typeof instance)['_additionalBundleIds'] {
   return instance['_additionalBundleIds'];
 }
 
+/** Gets bundle identifiers to be ignored during matching. */
 export function getIgnoredBundleIds(
   instance: RemoteDebugger,
 ): (typeof instance)['_ignoredBundleIds'] {
   return instance['_ignoredBundleIds'];
 }
 
+/** Gets the list of apps that were skipped. */
 export function getSkippedApps(instance: RemoteDebugger): (typeof instance)['_skippedApps'] {
   return instance['_skippedApps'];
 }
 
+/** Gets registered client event listeners grouped by event name. */
 export function getClientEventListeners(instance: RemoteDebugger): StringRecord<EventListener[]> {
   return instance['_clientEventListeners'];
 }
 
+/** Gets whether page loading is currently in progress. */
 export function getPageLoading(instance: RemoteDebugger): boolean {
   return instance['_pageLoading'];
 }
 
+/** Sets whether page loading is currently in progress. */
 export function setPageLoading(instance: RemoteDebugger, value: boolean): void {
   instance['_pageLoading'] = value;
 }
 
+/** Gets whether GC should run after JavaScript execution. */
 export function getGarbageCollectOnExecute(
   instance: RemoteDebugger,
 ): (typeof instance)['_garbageCollectOnExecute'] {
   return instance['_garbageCollectOnExecute'];
 }
 
+/** Gets whether a navigation-to-page operation is active. */
 export function getNavigatingToPage(
   instance: RemoteDebugger,
 ): (typeof instance)['_navigatingToPage'] {
   return instance['_navigatingToPage'];
 }
 
+/** Sets whether a navigation-to-page operation is active. */
 export function setNavigatingToPage(
   instance: RemoteDebugger,
   value: (typeof instance)['_navigatingToPage'],
@@ -89,6 +107,7 @@ export function setNavigatingToPage(
   instance['_navigatingToPage'] = value;
 }
 
+/** Sets the current state string reported by the remote debugger. */
 export function setCurrentState(
   instance: RemoteDebugger,
   value: (typeof instance)['_currentState'],
@@ -96,6 +115,7 @@ export function setCurrentState(
   instance['_currentState'] = value;
 }
 
+/** Sets the currently connected driver list. */
 export function setConnectedDrivers(
   instance: RemoteDebugger,
   value: (typeof instance)['_connectedDrivers'],
@@ -103,10 +123,12 @@ export function setConnectedDrivers(
   instance['_connectedDrivers'] = value;
 }
 
+/** Gets the cancellable page-load delay promise. */
 export function getPageLoadDelay(instance: RemoteDebugger): (typeof instance)['_pageLoadDelay'] {
   return instance['_pageLoadDelay'];
 }
 
+/** Sets the cancellable page-load delay promise. */
 export function setPageLoadDelay(
   instance: RemoteDebugger,
   value: (typeof instance)['_pageLoadDelay'],
@@ -114,12 +136,14 @@ export function setPageLoadDelay(
   instance['_pageLoadDelay'] = value;
 }
 
+/** Gets the configured page load strategy. */
 export function getPageLoadStartegy(
   instance: RemoteDebugger,
 ): (typeof instance)['_pageLoadStrategy'] {
   return instance['_pageLoadStrategy'];
 }
 
+/** Gets the configured page readiness timeout in milliseconds. */
 export function getPageReadyTimeout(
   instance: RemoteDebugger,
 ): (typeof instance)['_pageReadyTimeout'] {