appium-remote-debugger 15.3.4 → 15.3.5

package/lib/mixins/message-handlers.ts

@@ -1,8 +1,5 @@
-import { events } from './events';
-import {
-  pageArrayFromDict,
-  appInfoFromDict,
-} from '../utils';
+import {events} from './events';
+import {pageArrayFromDict, appInfoFromDict} from '../utils';
 import _ from 'lodash';
 import {
   setAppIdKey,
@@ -14,9 +11,9 @@ import {
   setConnectedDrivers,
   getSkippedApps,
 } from './property-accessors';
-import type { RemoteDebugger } from '../remote-debugger';
-import type { StringRecord } from '@appium/types';
-import type { AppDict } from '../types';
+import type {RemoteDebugger} from '../remote-debugger';
+import type {StringRecord} from '@appium/types';
+import type {AppDict} from '../types';
 
 /*
  * Generic callbacks used throughout the lifecycle of the Remote Debugger.
@@ -36,7 +33,7 @@ export async function onPageChange(
   this: RemoteDebugger,
   err: Error | null | undefined,
   appIdKey: string,
-  pageDict: StringRecord
+  pageDict: StringRecord,
 ): Promise<void> {
   if (_.isEmpty(pageDict)) {
     return;
@@ -50,14 +47,14 @@ export async function onPageChange(
     if (previousPages && _.isEqual(previousPages, currentPages)) {
       this.log.debug(
         `Received page change notice for app '${appIdKey}' ` +
-        `but the listing has not changed. Ignoring.`
+          `but the listing has not changed. Ignoring.`,
       );
       return;
     }
     // keep track of the page dictionary
     getAppDict(this)[appIdKey].pageArray = currentPages;
     this.log.debug(
-      `Pages changed for ${appIdKey}: ${JSON.stringify(previousPages)} -> ${JSON.stringify(currentPages)}`
+      `Pages changed for ${appIdKey}: ${JSON.stringify(previousPages)} -> ${JSON.stringify(currentPages)}`,
     );
   }
 
@@ -83,7 +80,7 @@ export async function onPageChange(
 export async function onAppConnect(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  dict: StringRecord
+  dict: StringRecord,
 ): Promise<void> {
   const appIdKey = dict.WIRApplicationIdentifierKey;
   this.log.debug(`Notified that new application '${appIdKey}' has connected`);
@@ -103,7 +100,7 @@ export async function onAppConnect(
 export function onAppDisconnect(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  dict: StringRecord
+  dict: StringRecord,
 ): void {
   const appIdKey = dict.WIRApplicationIdentifierKey;
   this.log.debug(`Application '${appIdKey}' disconnected. Removing from app dictionary.`);
@@ -137,7 +134,7 @@ export function onAppDisconnect(
 export async function onAppUpdate(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  dict: StringRecord
+  dict: StringRecord,
 ): Promise<void> {
   this.log.debug(`Notified that an application has been updated`);
   updateAppsWithDict.bind(this)(dict);
@@ -154,7 +151,7 @@ export async function onAppUpdate(
 export function onConnectedDriverList(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  drivers: StringRecord
+  drivers: StringRecord,
 ): void {
   setConnectedDrivers(this, drivers.WIRDriverDictionaryKey);
   this.log.debug(`Received connected driver list: ${JSON.stringify(this.connectedDrivers)}`);
@@ -173,12 +170,14 @@ export function onConnectedDriverList(
 export function onCurrentState(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  state: StringRecord
+  state: StringRecord,
 ): void {
   setCurrentState(this, state.WIRAutomationAvailabilityKey);
   // This state changes when 'Remote Automation' in 'Settings app' > 'Safari' > 'Advanced' > 'Remote Automation' changes
   // WIRAutomationAvailabilityAvailable or WIRAutomationAvailabilityNotAvailable
-  this.log.debug(`Received connected automation availability state: ${JSON.stringify(this.currentState)}`);
+  this.log.debug(
+    `Received connected automation availability state: ${JSON.stringify(this.currentState)}`,
+  );
 }
 
 /**
@@ -192,7 +191,7 @@ export function onCurrentState(
 export async function onConnectedApplicationList(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  apps: StringRecord
+  apps: StringRecord,
 ): Promise<void> {
   this.log.debug(`Received connected applications list: ${_.keys(apps).join(', ')}`);
 
@@ -233,8 +232,10 @@ export function getDebuggerAppKey(this: RemoteDebugger, bundleId: string): strin
     let proxyAppId: string | undefined;
     for (const [key, data] of _.toPairs(getAppDict(this))) {
       if (data.isProxy && data.hostId === appId) {
-        this.log.debug(`Found separate bundleId '${data.bundleId}' ` +
-                  `acting as proxy for '${bundleId}', with app id '${key}'`);
+        this.log.debug(
+          `Found separate bundleId '${data.bundleId}' ` +
+            `acting as proxy for '${bundleId}', with app id '${key}'`,
+        );
         // set the app id... the last one will be used, so just keep re-assigning
         proxyAppId = key;
       }

package/lib/mixins/misc.ts

@@ -1,10 +1,7 @@
-import { checkParams } from '../utils';
-import B, { TimeoutError as BTimeoutError } from 'bluebird';
-import {
-  getAppIdKey,
-  getPageIdKey,
-} from './property-accessors';
-import type { RemoteDebugger } from '../remote-debugger';
+import {checkParams} from '../utils';
+import B, {TimeoutError as BTimeoutError} from 'bluebird';
+import {getAppIdKey, getPageIdKey} from './property-accessors';
+import type {RemoteDebugger} from '../remote-debugger';
 
 const SAFARI_BUNDLE_ID = 'com.apple.mobilesafari';
 const GARBAGE_COLLECT_TIMEOUT_MS = 5000;
@@ -15,7 +12,7 @@ const GARBAGE_COLLECT_TIMEOUT_MS = 5000;
  */
 export async function launchSafari(this: RemoteDebugger): Promise<void> {
   await this.requireRpcClient().send('launchApplication', {
-    bundleId: SAFARI_BUNDLE_ID
+    bundleId: SAFARI_BUNDLE_ID,
   });
 }
 
@@ -28,7 +25,7 @@ export async function launchSafari(this: RemoteDebugger): Promise<void> {
  */
 export async function startTimeline(
   this: RemoteDebugger,
-  fn: import('../types').EventListener
+  fn: import('../types').EventListener,
 ): Promise<any> {
   this.log.debug('Starting to record the timeline');
   this.requireRpcClient().on('Timeline.eventRecorded', fn);
@@ -77,7 +74,7 @@ export async function overrideUserAgent(this: RemoteDebugger, value: string): Pr
  */
 export async function isJavascriptExecutionBlocked(
   this: RemoteDebugger,
-  timeoutMs: number = 1000
+  timeoutMs: number = 1000,
 ): Promise<boolean> {
   try {
     await B.resolve(
@@ -86,7 +83,7 @@ export async function isJavascriptExecutionBlocked(
         returnByValue: true,
         appIdKey: getAppIdKey(this),
         pageIdKey: getPageIdKey(this),
-      })
+      }),
     ).timeout(timeoutMs);
     return false;
   } catch {
@@ -104,7 +101,7 @@ export async function isJavascriptExecutionBlocked(
  */
 export async function garbageCollect(
   this: RemoteDebugger,
-  timeoutMs: number = GARBAGE_COLLECT_TIMEOUT_MS
+  timeoutMs: number = GARBAGE_COLLECT_TIMEOUT_MS,
 ): Promise<void> {
   this.log.debug(`Garbage collecting with ${timeoutMs}ms timeout`);
 
@@ -119,11 +116,11 @@ export async function garbageCollect(
   }
 
   try {
-    await B.resolve(this.requireRpcClient().send(
-      'Heap.gc', {
+    await B.resolve(
+      this.requireRpcClient().send('Heap.gc', {
         appIdKey: getAppIdKey(this),
         pageIdKey: getPageIdKey(this),
-      })
+      }),
     ).timeout(timeoutMs);
     this.log.debug(`Garbage collection successful`);
   } catch (e: any) {

package/lib/mixins/navigate.ts

@@ -1,8 +1,8 @@
-import { checkParams } from '../utils';
-import { events } from './events';
-import { timing, util } from '@appium/support';
+import {checkParams} from '../utils';
+import {events} from './events';
+import {timing, util} from '@appium/support';
 import _ from 'lodash';
-import B, { TimeoutError as BTimeoutError } from 'bluebird';
+import B, {TimeoutError as BTimeoutError} from 'bluebird';
 import {
   getAppIdKey,
   setPageLoading,
@@ -13,8 +13,8 @@ import {
   getPageIdKey,
   setNavigatingToPage,
 } from './property-accessors';
-import type { RemoteDebugger } from '../remote-debugger';
-import type { AppIdKey, PageIdKey } from '../types';
+import type {RemoteDebugger} from '../remote-debugger';
+import type {AppIdKey, PageIdKey} from '../types';
 
 export const DEFAULT_PAGE_READINESS_TIMEOUT_MS = 20 * 1000;
 const PAGE_READINESS_CHECK_INTERVAL_MS = 50;
@@ -25,7 +25,7 @@ const PAGE_READINESS_CHECK_INTERVAL_MS = 50;
 const PAGE_LOAD_STRATEGY = Object.freeze({
   EAGER: 'eager',
   NONE: 'none',
-  NORMAL: 'normal'
+  NORMAL: 'normal',
 });
 
 /**
@@ -78,7 +78,10 @@ export function isPageLoadingCompleted(this: RemoteDebugger, readyState: string)
  * @param startPageLoadTimer - Optional timer instance to use for tracking elapsed time.
  *                             If not provided, a new timer will be created and started.
  */
-export async function waitForDom(this: RemoteDebugger, startPageLoadTimer?: timing.Timer): Promise<void> {
+export async function waitForDom(
+  this: RemoteDebugger,
+  startPageLoadTimer?: timing.Timer,
+): Promise<void> {
   const readinessTimeoutMs = this.pageLoadMs;
   this.log.debug(`Waiting up to ${readinessTimeoutMs}ms for the page to be ready`);
   const timer = startPageLoadTimer ?? new timing.Timer().start();
@@ -86,49 +89,53 @@ export async function waitForDom(this: RemoteDebugger, startPageLoadTimer?: timi
   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 = 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 maxWaitMs = (readinessTimeoutMs - elapsedMs) * 0.95;
-      if (await this.checkPageIsReady(maxWaitMs)) {
-        if (isPageLoading) {
-          this.log.debug(`Page is ready in ${elapsedMs}ms`);
+        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`,
+          );
           isPageLoading = false;
+          return;
         }
-        return;
-      }
-      if (elapsedMs > readinessTimeoutMs) {
-        this.log.info(
-          `Timed out after ${readinessTimeoutMs}ms of waiting for the page readiness. Continuing anyway`
-        );
-        isPageLoading = false;
-        return;
+        retry++;
       }
-      retry++;
-    }
-  })());
-  const cancellationPromise = B.resolve((async () => {
-    try {
-      await getPageLoadDelay(this);
-    } catch {}
-  })());
+    })(),
+  );
+  const cancellationPromise = B.resolve(
+    (async () => {
+      try {
+        await getPageLoadDelay(this);
+      } catch {}
+    })(),
+  );
 
   try {
     await B.any([cancellationPromise, pageReadinessPromise]);
@@ -152,13 +159,12 @@ 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 B.resolve(this.execute(readyCmd)).timeout(actualTimeoutMs);
     this.log.debug(
       JSON.stringify({
         readyState,
         pageLoadStrategy: getPageLoadStartegy(this) ?? PAGE_LOAD_STRATEGY.NORMAL,
-      })
+      }),
     );
     return this.isPageLoadingCompleted(readyState);
   } catch (err: any) {
@@ -194,10 +200,7 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
 
   this.log.debug(`Navigating to new URL: '${url}'`);
   setNavigatingToPage(this, true);
-  await rpcClient.waitForPage(
-    appIdKey as AppIdKey,
-    pageIdKey as PageIdKey
-  );
+  await rpcClient.waitForPage(appIdKey as AppIdKey, pageIdKey as PageIdKey);
   const readinessTimeoutMs = this.pageLoadMs;
   let onPageLoaded: (() => void) | undefined;
   let onPageLoadedTimeout: NodeJS.Timeout | undefined | null;
@@ -212,7 +215,7 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
         isPageLoading = false;
         this.log.info(
           `Timed out after ${start.getDuration().asMilliSeconds.toFixed(0)}ms of waiting ` +
-          `for the ${url} page readiness. Continuing anyway`
+            `for the ${url} page readiness. Continuing anyway`,
         );
       }
       return resolve();
@@ -221,7 +224,9 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
     onPageLoaded = () => {
       if (isPageLoading) {
         isPageLoading = false;
-        this.log.debug(`The page ${url} is ready in ${start.getDuration().asMilliSeconds.toFixed(0)}ms`);
+        this.log.debug(
+          `The page ${url} is ready in ${start.getDuration().asMilliSeconds.toFixed(0)}ms`,
+        );
       }
       if (onPageLoadedTimeout) {
         clearTimeout(onPageLoadedTimeout);
@@ -239,11 +244,13 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
       pageIdKey,
     });
   });
-  const cancellationPromise = B.resolve((async () => {
-    try {
-      await getPageLoadDelay(this);
-    } catch {}
-  })());
+  const cancellationPromise = B.resolve(
+    (async () => {
+      try {
+        await getPageLoadDelay(this);
+      } catch {}
+    })(),
+  );
 
   try {
     await B.any([cancellationPromise, pageReadinessPromise]);

package/lib/mixins/property-accessors.ts

@@ -1,49 +1,54 @@
 /* eslint-disable dot-notation */
-import type { StringRecord } from '@appium/types';
-import type { RemoteDebugger } from '../remote-debugger';
-import type { EventListener } from '../types';
+import type {StringRecord} from '@appium/types';
+import type {RemoteDebugger} from '../remote-debugger';
+import type {EventListener} from '../types';
 
-export function getAppDict(instance: RemoteDebugger): typeof instance['_appDict'] {
+export function getAppDict(instance: RemoteDebugger): (typeof instance)['_appDict'] {
   return instance['_appDict'];
 }
 
-export function getAppIdKey(instance: RemoteDebugger): typeof instance['_appIdKey'] {
+export function getAppIdKey(instance: RemoteDebugger): (typeof instance)['_appIdKey'] {
   return instance['_appIdKey'];
 }
 
-export function setAppIdKey(instance: RemoteDebugger, value: typeof instance['_appIdKey']): void {
+export function setAppIdKey(instance: RemoteDebugger, value: (typeof instance)['_appIdKey']): void {
   instance['_appIdKey'] = value;
 }
 
-export function getRcpClient(instance: RemoteDebugger): typeof instance['_rpcClient'] {
+export function getRcpClient(instance: RemoteDebugger): (typeof instance)['_rpcClient'] {
   return instance['_rpcClient'];
 }
 
-export function getPageIdKey(instance: RemoteDebugger): typeof instance['_pageIdKey'] {
+export function getPageIdKey(instance: RemoteDebugger): (typeof instance)['_pageIdKey'] {
   return instance['_pageIdKey'];
 }
 
-export function setPageIdKey(instance: RemoteDebugger, value: typeof instance['_pageIdKey']): void {
+export function setPageIdKey(
+  instance: RemoteDebugger,
+  value: (typeof instance)['_pageIdKey'],
+): void {
   instance['_pageIdKey'] = value;
 }
 
-export function getIsSafari(instance: RemoteDebugger): typeof instance['_isSafari'] {
+export function getIsSafari(instance: RemoteDebugger): (typeof instance)['_isSafari'] {
   return instance['_isSafari'];
 }
 
-export function getIncludeSafari(instance: RemoteDebugger): typeof instance['_includeSafari'] {
+export function getIncludeSafari(instance: RemoteDebugger): (typeof instance)['_includeSafari'] {
   return instance['_includeSafari'];
 }
 
-export function getBundleId(instance: RemoteDebugger): typeof instance['_bundleId'] {
+export function getBundleId(instance: RemoteDebugger): (typeof instance)['_bundleId'] {
   return instance['_bundleId'];
 }
 
-export function getAdditionalBundleIds(instance: RemoteDebugger): typeof instance['_additionalBundleIds'] {
+export function getAdditionalBundleIds(
+  instance: RemoteDebugger,
+): (typeof instance)['_additionalBundleIds'] {
   return instance['_additionalBundleIds'];
 }
 
-export function getSkippedApps(instance: RemoteDebugger): typeof instance['_skippedApps'] {
+export function getSkippedApps(instance: RemoteDebugger): (typeof instance)['_skippedApps'] {
   return instance['_skippedApps'];
 }
 
@@ -59,38 +64,58 @@ export function setPageLoading(instance: RemoteDebugger, value: boolean): void {
   instance['_pageLoading'] = value;
 }
 
-export function getGarbageCollectOnExecute(instance: RemoteDebugger): typeof instance['_garbageCollectOnExecute'] {
+export function getGarbageCollectOnExecute(
+  instance: RemoteDebugger,
+): (typeof instance)['_garbageCollectOnExecute'] {
   return instance['_garbageCollectOnExecute'];
 }
 
-export function getNavigatingToPage(instance: RemoteDebugger): typeof instance['_navigatingToPage'] {
+export function getNavigatingToPage(
+  instance: RemoteDebugger,
+): (typeof instance)['_navigatingToPage'] {
   return instance['_navigatingToPage'];
 }
 
-export function setNavigatingToPage(instance: RemoteDebugger, value: typeof instance['_navigatingToPage']): void {
+export function setNavigatingToPage(
+  instance: RemoteDebugger,
+  value: (typeof instance)['_navigatingToPage'],
+): void {
   instance['_navigatingToPage'] = value;
 }
 
-export function setCurrentState(instance: RemoteDebugger, value: typeof instance['_currentState']): void {
+export function setCurrentState(
+  instance: RemoteDebugger,
+  value: (typeof instance)['_currentState'],
+): void {
   instance['_currentState'] = value;
 }
 
-export function setConnectedDrivers(instance: RemoteDebugger, value: typeof instance['_connectedDrivers']): void {
+export function setConnectedDrivers(
+  instance: RemoteDebugger,
+  value: (typeof instance)['_connectedDrivers'],
+): void {
   instance['_connectedDrivers'] = value;
 }
 
-export function getPageLoadDelay(instance: RemoteDebugger): typeof instance['_pageLoadDelay'] {
+export function getPageLoadDelay(instance: RemoteDebugger): (typeof instance)['_pageLoadDelay'] {
   return instance['_pageLoadDelay'];
 }
 
-export function setPageLoadDelay(instance: RemoteDebugger, value: typeof instance['_pageLoadDelay']): void {
+export function setPageLoadDelay(
+  instance: RemoteDebugger,
+  value: (typeof instance)['_pageLoadDelay'],
+): void {
   instance['_pageLoadDelay'] = value;
 }
 
-export function getPageLoadStartegy(instance: RemoteDebugger): typeof instance['_pageLoadStrategy'] {
+export function getPageLoadStartegy(
+  instance: RemoteDebugger,
+): (typeof instance)['_pageLoadStrategy'] {
   return instance['_pageLoadStrategy'];
 }
 
-export function getPageReadyTimeout(instance: RemoteDebugger): typeof instance['_pageReadyTimeout'] {
+export function getPageReadyTimeout(
+  instance: RemoteDebugger,
+): (typeof instance)['_pageReadyTimeout'] {
   return instance['_pageReadyTimeout'];
 }

package/lib/mixins/screenshot.ts

@@ -1,9 +1,6 @@
-import {
-  getAppIdKey,
-  getPageIdKey,
-} from './property-accessors';
-import type { RemoteDebugger } from '../remote-debugger';
-import type { Rect } from '@appium/types';
+import {getAppIdKey, getPageIdKey} from './property-accessors';
+import type {RemoteDebugger} from '../remote-debugger';
+import type {Rect} from '@appium/types';
 
 /**
  * Options for capturing a screenshot.
@@ -28,15 +25,17 @@ export interface ScreenshotCaptureOptions {
  */
 export async function captureScreenshot(
   this: RemoteDebugger,
-  opts: ScreenshotCaptureOptions = {}
+  opts: ScreenshotCaptureOptions = {},
 ): Promise<string> {
   const {rect = null, coordinateSystem = 'Viewport'} = opts;
   this.log.debug('Capturing screenshot');
 
-  const arect = rect ?? (await this.executeAtom(
-    'execute_script',
-    ['return {x: 0, y: 0, width: window.innerWidth, height: window.innerHeight}', []]
-  ) as Rect);
+  const arect =
+    rect ??
+    ((await this.executeAtom('execute_script', [
+      'return {x: 0, y: 0, width: window.innerWidth, height: window.innerHeight}',
+      [],
+    ])) as Rect);
   const response = await this.requireRpcClient().send('Page.snapshotRect', {
     ...arect,
     appIdKey: getAppIdKey(this),

package/lib/protocol/index.ts

@@ -1,5 +1,5 @@
-import type { StringRecord } from '@appium/types';
-import type { RemoteCommandOpts, ProtocolCommandOpts } from '../types';
+import type {StringRecord} from '@appium/types';
+import type {RemoteCommandOpts, ProtocolCommandOpts} from '../types';
 
 const OBJECT_GROUP = 'console';
 
@@ -197,7 +197,7 @@ const COMMANDS = {
   'Worker.enable': [],
   'Worker.disable': [],
   'Worker.initialized': ['workerId'],
-  'Worker.sendMessageToWorker': ['workerId', 'message']
+  'Worker.sendMessageToWorker': ['workerId', 'message'],
   //#endregion
 } as const;
 
@@ -219,18 +219,20 @@ export function getProtocolCommand(
   id: string,
   method: string,
   opts: RemoteCommandOpts,
-  direct: boolean = false
+  direct: boolean = false,
 ): ProtocolCommandOpts {
   const paramNames = COMMANDS[method as keyof typeof COMMANDS];
   if (!paramNames) {
     throw new Error(`Unknown command: '${method}'`);
   }
 
-  const params: StringRecord = (paramNames as readonly string[])
-    .reduce(function (acc: StringRecord, name: string) {
-      acc[name] = opts[name];
-      return acc;
-    }, {} as StringRecord);
+  const params: StringRecord = (paramNames as readonly string[]).reduce(function (
+    acc: StringRecord,
+    name: string,
+  ) {
+    acc[name] = opts[name];
+    return acc;
+  }, {} as StringRecord);
   const result: ProtocolCommandOpts = {
     id,
     method,

package/lib/remote-debugger-real-device.ts

@@ -1,17 +1,17 @@
-import { RemoteDebugger } from './remote-debugger';
-import { RpcClientRealDevice } from './rpc';
-import type { RemoteDebuggerRealDeviceOptions } from './types';
+import {RemoteDebugger} from './remote-debugger';
+import {RpcClientRealDevice} from './rpc';
+import type {RemoteDebuggerRealDeviceOptions} from './types';
 
 export class RemoteDebuggerRealDevice extends RemoteDebugger {
   private readonly _udid: string;
 
-  constructor (opts: RemoteDebuggerRealDeviceOptions) {
+  constructor(opts: RemoteDebuggerRealDeviceOptions) {
     super(opts);
     this._udid = opts.udid;
     this._skippedApps = ['lockdownd'];
   }
 
-  override initRpcClient (): void {
+  override initRpcClient(): void {
     this._rpcClient = new RpcClientRealDevice({
       bundleId: this._bundleId,
       platformVersion: this._platformVersion,