appium-remote-debugger 15.7.3 → 15.8.0

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'] {

package/lib/remote-debugger.ts

@@ -10,50 +10,16 @@ import * as cookieMixins from './mixins/cookies';
 import * as screenshotMixins from './mixins/screenshot';
 import * as eventMixins from './mixins/events';
 import * as miscellaneousMixins from './mixins/misc';
-import _ from 'lodash';
+import {util} from '@appium/support';
 import type {RemoteDebuggerOptions, AppDict, EventListener, PageIdKey, AppIdKey} from './types';
 import type {AppiumLogger, StringRecord} from '@appium/types';
 import type {RpcClient} from './rpc/rpc-client';
-import type B from 'bluebird';
 
 export const REMOTE_DEBUGGER_PORT = 27753;
 const PAGE_READY_TIMEOUT_MS = 5000;
 const {version: MODULE_VERSION} = getModuleProperties();
 
 export class RemoteDebugger extends EventEmitter {
-  protected _skippedApps: string[];
-  protected _clientEventListeners: StringRecord<EventListener[]>;
-  protected _appDict: AppDict;
-  protected _appIdKey?: AppIdKey;
-  protected _pageIdKey?: PageIdKey;
-  protected _connectedDrivers?: StringRecord[];
-  protected _currentState?: string;
-  protected _pageLoadDelay?: B<void>;
-  protected _rpcClient: RpcClient | null;
-  protected _pageLoading: boolean;
-  protected _navigatingToPage: boolean;
-  protected _allowNavigationWithoutReload: boolean;
-  protected _pageLoadMs?: number;
-  protected readonly _pageLoadStrategy?: string;
-  protected readonly _log: AppiumLogger;
-  protected readonly _bundleId?: string;
-  protected readonly _additionalBundleIds?: string[];
-  protected readonly _ignoredBundleIds?: string[];
-  protected readonly _platformVersion?: string;
-  protected readonly _isSafari: boolean;
-  protected readonly _includeSafari: boolean;
-  protected readonly _garbageCollectOnExecute: boolean;
-  protected readonly _host?: string;
-  protected readonly _port?: number;
-  protected readonly _socketPath?: string;
-  protected readonly _remoteDebugProxy?: any;
-  protected readonly _pageReadyTimeout: number;
-  protected readonly _logAllCommunication: boolean;
-  protected readonly _logAllCommunicationHexDump: boolean;
-  protected readonly _socketChunkSize?: number;
-  protected readonly _webInspectorMaxFrameLength?: number;
-  protected readonly _fullPageInitialization?: boolean;
-
   // events
   static readonly EVENT_PAGE_CHANGE: string;
   static readonly EVENT_DISCONNECT: string;
@@ -90,7 +56,7 @@ export class RemoteDebugger extends EventEmitter {
   garbageCollect = miscellaneousMixins.garbageCollect;
   isJavascriptExecutionBlocked = miscellaneousMixins.isJavascriptExecutionBlocked;
 
-  // Callbacks
+  // callbacks
   onPageChange = messageHandlerMixins.onPageChange;
   onConnectedApplicationList = messageHandlerMixins.onConnectedApplicationList;
   onAppConnect = messageHandlerMixins.onAppConnect;
@@ -100,6 +66,39 @@ export class RemoteDebugger extends EventEmitter {
   onCurrentState = messageHandlerMixins.onCurrentState;
   frameDetached = navigationMixins.frameDetached;
 
+  protected _skippedApps: string[];
+  protected _clientEventListeners: StringRecord<EventListener[]>;
+  protected _appDict: AppDict;
+  protected _appIdKey?: AppIdKey;
+  protected _pageIdKey?: PageIdKey;
+  protected _connectedDrivers?: StringRecord[];
+  protected _currentState?: string;
+  protected _pageLoadDelay?: ReturnType<typeof util.cancellableDelay>;
+  protected _rpcClient: RpcClient | null;
+  protected _pageLoading: boolean;
+  protected _navigatingToPage: boolean;
+  protected _allowNavigationWithoutReload: boolean;
+  protected _pageLoadMs?: number;
+  protected readonly _pageLoadStrategy?: string;
+  protected readonly _log: AppiumLogger;
+  protected readonly _bundleId?: string;
+  protected readonly _additionalBundleIds?: string[];
+  protected readonly _ignoredBundleIds?: string[];
+  protected readonly _platformVersion?: string;
+  protected readonly _isSafari: boolean;
+  protected readonly _includeSafari: boolean;
+  protected readonly _garbageCollectOnExecute: boolean;
+  protected readonly _host?: string;
+  protected readonly _port?: number;
+  protected readonly _socketPath?: string;
+  protected readonly _remoteDebugProxy?: any;
+  protected readonly _pageReadyTimeout: number;
+  protected readonly _logAllCommunication: boolean;
+  protected readonly _logAllCommunicationHexDump: boolean;
+  protected readonly _socketChunkSize?: number;
+  protected readonly _webInspectorMaxFrameLength?: number;
+  protected readonly _fullPageInitialization?: boolean;
+
   constructor(opts: RemoteDebuggerOptions = {}) {
     super();
 
@@ -146,13 +145,12 @@ export class RemoteDebugger extends EventEmitter {
     this._remoteDebugProxy = remoteDebugProxy;
     this._pageReadyTimeout = pageReadyTimeout;
 
-    this._logAllCommunication = _.isNil(logAllCommunication)
-      ? !!logFullResponse
-      : !!logAllCommunication;
+    this._logAllCommunication =
+      logAllCommunication == null ? !!logFullResponse : !!logAllCommunication;
     this._logAllCommunicationHexDump = logAllCommunicationHexDump;
     this._socketChunkSize = socketChunkSize;
 
-    if (_.isInteger(webInspectorMaxFrameLength)) {
+    if (Number.isInteger(webInspectorMaxFrameLength)) {
       this._webInspectorMaxFrameLength = webInspectorMaxFrameLength;
     }
 
@@ -168,6 +166,41 @@ export class RemoteDebugger extends EventEmitter {
     return this._log;
   }
 
+  get isConnected(): boolean {
+    return !!this._rpcClient?.isConnected;
+  }
+
+  // Only use this getter to read the appDict value.
+  // Any changes to it don't mutate the original property
+  // because the getter always returns the copy of it
+  get appDict(): AppDict {
+    return structuredClone(this._appDict);
+  }
+
+  get allowNavigationWithoutReload(): boolean {
+    return !!this._allowNavigationWithoutReload;
+  }
+
+  get currentState(): string | undefined {
+    return this._currentState;
+  }
+
+  get connectedDrivers(): StringRecord[] | undefined {
+    return this._connectedDrivers;
+  }
+
+  get pageLoadMs(): number {
+    return this._pageLoadMs ?? navigationMixins.DEFAULT_PAGE_READINESS_TIMEOUT_MS;
+  }
+
+  set allowNavigationWithoutReload(allow: boolean) {
+    this._allowNavigationWithoutReload = allow;
+  }
+
+  set pageLoadMs(value: number) {
+    this._pageLoadMs = value;
+  }
+
   requireRpcClient(checkConnected: boolean = false): RpcClient {
     if (!this._rpcClient) {
       throw new Error(`rpcClient is undefined. Has 'initRpcClient' been called before?`);
@@ -228,44 +261,9 @@ export class RemoteDebugger extends EventEmitter {
       pageLoadTimeoutMs: this._pageLoadMs,
     });
   }
-
-  get isConnected(): boolean {
-    return !!this._rpcClient?.isConnected;
-  }
-
-  // Only use this getter to read the appDict value.
-  // Any changes to it don't mutate the original property
-  // because the getter always returns the copy of it
-  get appDict(): AppDict {
-    return _.cloneDeep(this._appDict);
-  }
-
-  set allowNavigationWithoutReload(allow: boolean) {
-    this._allowNavigationWithoutReload = allow;
-  }
-
-  get allowNavigationWithoutReload(): boolean {
-    return !!this._allowNavigationWithoutReload;
-  }
-
-  get currentState(): string | undefined {
-    return this._currentState;
-  }
-
-  get connectedDrivers(): StringRecord[] | undefined {
-    return this._connectedDrivers;
-  }
-
-  get pageLoadMs(): number {
-    return this._pageLoadMs ?? navigationMixins.DEFAULT_PAGE_READINESS_TIMEOUT_MS;
-  }
-
-  set pageLoadMs(value: number) {
-    this._pageLoadMs = value;
-  }
 }
 
-for (const [name, event] of _.toPairs(eventMixins.events)) {
+for (const [name, event] of Object.entries(eventMixins.events)) {
   RemoteDebugger[name] = event;
 }