appium-xcuitest-driver 10.10.0 → 10.11.0

package/lib/{app-utils.js → app-utils.ts}

@@ -1,43 +1,57 @@
 import _ from 'lodash';
-import path from 'path';
+import path from 'node:path';
 import {plist, fs, util, tempDir, zip, timing} from 'appium/support';
-import log from './logger.js';
+import {log} from './logger';
 import os from 'node:os';
 import {exec} from 'teen_process';
 import B from 'bluebird';
 import {spawn} from 'node:child_process';
 import assert from 'node:assert';
-import { isTvOs } from './utils.js';
+import {isTvOs} from './utils';
+import type {XCUITestDriver, XCUITestDriverOpts} from './driver';
+import type {StringRecord, HTTPHeaders, DownloadAppOptions, PostProcessOptions, PostProcessResult, CachedAppInfo} from '@appium/types';
+import type {Readable} from 'node:stream';
 
-const STRINGSDICT_RESOURCE = '.stringsdict';
-const STRINGS_RESOURCE = '.strings';
 export const SAFARI_BUNDLE_ID = 'com.apple.mobilesafari';
 export const APP_EXT = '.app';
 export const IPA_EXT = '.ipa';
+export const SUPPORTED_EXTENSIONS = [IPA_EXT, APP_EXT];
+const STRINGSDICT_RESOURCE = '.stringsdict';
+const STRINGS_RESOURCE = '.strings';
 const ZIP_EXT = '.zip';
-const SAFARI_OPTS_ALIASES_MAP = /** @type {const} */ ({
+const SAFARI_OPTS_ALIASES_MAP = {
   safariAllowPopups: [
     ['WebKitJavaScriptCanOpenWindowsAutomatically', 'JavaScriptCanOpenWindowsAutomatically'],
-    (x) => Number(Boolean(x)),
+    (x: boolean) => Number(Boolean(x)),
   ],
-  safariIgnoreFraudWarning: [['WarnAboutFraudulentWebsites'], (x) => Number(!x)],
-  safariOpenLinksInBackground: [['OpenLinksInBackground'], (x) => Number(Boolean(x))],
-});
+  safariIgnoreFraudWarning: [['WarnAboutFraudulentWebsites'], (x: boolean) => Number(!x)],
+  safariOpenLinksInBackground: [['OpenLinksInBackground'], (x: boolean) => Number(Boolean(x))],
+} as const;
 const MAX_ARCHIVE_SCAN_DEPTH = 1;
-export const SUPPORTED_EXTENSIONS = [IPA_EXT, APP_EXT];
 const MACOS_RESOURCE_FOLDER = '__MACOSX';
 const SANITIZE_REPLACEMENT = '-';
 const INTEL_ARCH = 'x86_64';
 
+export interface LocalizableStringsOptions {
+  app?: string;
+  language?: string;
+  localizableStringsDir?: string;
+  stringFile?: string;
+  strictMode?: boolean;
+}
+
+export interface UnzipInfo {
+  rootDir: string;
+  archiveSize: number;
+}
+
 /**
  * Verify whether the given application is compatible to the
  * platform where it is going to be installed and tested.
  *
- * @this {XCUITestDriver}
- * @returns {Promise<void>}
- * @throws {Error} If bundle architecture does not match the expected device architecture.
+ * @throws If bundle architecture does not match the expected device architecture.
  */
-export async function verifyApplicationPlatform() {
+export async function verifyApplicationPlatform(this: XCUITestDriver): Promise<void> {
   this.log.debug('Verifying application platform');
 
   if (!this.opts.app) {
@@ -104,37 +118,13 @@ export async function verifyApplicationPlatform() {
   );
 }
 
-/**
- *
- * @param {string} resourcePath
- * @returns {Promise<import('@appium/types').StringRecord>}
- */
-async function readResource(resourcePath) {
-  const data = await plist.parsePlistFile(resourcePath);
-  const result = {};
-  for (const [key, value] of _.toPairs(data)) {
-    result[key] = _.isString(value) ? value : JSON.stringify(value);
-  }
-  return result;
-}
-
-/**
- * @typedef {Object} LocalizableStringsOptions
- * @property {string} [app]
- * @property {string} [language='en']
- * @property {string} [localizableStringsDir]
- * @property {string} [stringFile]
- * @property {boolean} [strictMode]
- */
-
 /**
  * Extracts string resources from an app
- *
- * @this {XCUITestDriver}
- * @param {LocalizableStringsOptions} opts
- * @returns {Promise<import('@appium/types').StringRecord>}
  */
-export async function parseLocalizableStrings(opts = {}) {
+export async function parseLocalizableStrings(
+  this: XCUITestDriver,
+  opts: LocalizableStringsOptions = {}
+): Promise<StringRecord> {
   const {app, language = 'en', localizableStringsDir, stringFile, strictMode} = opts;
   if (!app) {
     const message = `Strings extraction is not supported if 'app' capability is not set`;
@@ -147,21 +137,20 @@ export async function parseLocalizableStrings(opts = {}) {
 
   let bundleRoot = app;
   const isArchive = (await fs.stat(app)).isFile();
-  let tmpRoot;
+  let tmpRoot: string | undefined;
   try {
     if (isArchive) {
       tmpRoot = await tempDir.openDir();
       this.log.info(`Extracting '${app}' into a temporary location to parse its resources`);
       await zip.extractAllTo(app, tmpRoot);
-      const relativeBundleRoot = /** @type {string} */ (_.first(await findApps(tmpRoot, [APP_EXT])));
+      const relativeBundleRoot = _.first(await findApps(tmpRoot, [APP_EXT])) as string;
       this.log.info(`Selecting '${relativeBundleRoot}'`);
       bundleRoot = path.join(tmpRoot, relativeBundleRoot);
     }
 
-    /** @type {string|undefined} */
-    let lprojRoot;
+    let lprojRoot: string | undefined;
     for (const subfolder of [`${language}.lproj`, localizableStringsDir, ''].filter(_.isString)) {
-      lprojRoot = path.resolve(bundleRoot, /** @type {string} */ (subfolder));
+      lprojRoot = path.resolve(bundleRoot, subfolder as string);
       if (await fs.exists(lprojRoot)) {
         break;
       }
@@ -176,9 +165,9 @@ export async function parseLocalizableStrings(opts = {}) {
     }
 
     this.log.info(`Retrieving resource strings from '${lprojRoot}'`);
-    const resourcePaths = [];
+    const resourcePaths: string[] = [];
     if (stringFile) {
-      const dstPath = path.resolve(/** @type {string} */ (lprojRoot), stringFile);
+      const dstPath = path.resolve(lprojRoot, stringFile);
       if (await fs.exists(dstPath)) {
         resourcePaths.push(dstPath);
       } else {
@@ -190,7 +179,7 @@ export async function parseLocalizableStrings(opts = {}) {
       }
     }
 
-    if (_.isEmpty(resourcePaths) && (await fs.exists(lprojRoot))) {
+    if (_.isEmpty(resourcePaths) && lprojRoot && (await fs.exists(lprojRoot))) {
       const resourceFiles = (await fs.readdir(lprojRoot))
         .filter((name) => _.some([STRINGS_RESOURCE, STRINGSDICT_RESOURCE], (x) => name.endsWith(x)))
         .map((name) => path.resolve(lprojRoot, name));
@@ -202,8 +191,8 @@ export async function parseLocalizableStrings(opts = {}) {
       return {};
     }
 
-    const resultStrings = {};
-    const toAbsolutePath = (/** @type {string} */ p) => path.isAbsolute(p) ? p : path.resolve(process.cwd(), p);
+    const resultStrings: StringRecord = {};
+    const toAbsolutePath = (p: string) => path.isAbsolute(p) ? p : path.resolve(process.cwd(), p);
     for (const resourcePath of resourcePaths) {
       if (!util.isSubPath(toAbsolutePath(resourcePath), toAbsolutePath(bundleRoot))) {
         // security precaution
@@ -213,7 +202,7 @@ export async function parseLocalizableStrings(opts = {}) {
         const data = await readResource(resourcePath);
         this.log.debug(`Parsed ${util.pluralize('string', _.keys(data).length, true)} from '${resourcePath}'`);
         _.merge(resultStrings, data);
-      } catch (e) {
+      } catch (e: any) {
         this.log.warn(`Cannot parse '${resourcePath}' resource. Original error: ${e.message}`);
       }
     }
@@ -227,43 +216,13 @@ export async function parseLocalizableStrings(opts = {}) {
   }
 }
 
-/**
- * Check whether the given path on the file system points to the .app bundle root
- *
- * @param {string} appPath Possible .app bundle root
- * @returns {Promise<boolean>} Whether the given path points to an .app bundle
- */
-async function isAppBundle(appPath) {
-  return (
-    _.endsWith(_.toLower(appPath), APP_EXT) &&
-    (await fs.stat(appPath)).isDirectory() &&
-    (await fs.exists(path.join(appPath, 'Info.plist')))
-  );
-}
-
-/**
- * Check whether the given path on the file system points to the .ipa file
- *
- * @param {string} appPath Possible .ipa file
- * @returns {Promise<boolean>} Whether the given path points to an .ipa bundle
- */
-async function isIpaBundle(appPath) {
-  return _.endsWith(_.toLower(appPath), IPA_EXT) && (await fs.stat(appPath)).isFile();
-}
-
-/**
- * @typedef {Object} UnzipInfo
- * @property {string} rootDir
- * @property {number} archiveSize
- */
-
 /**
  * Unzips a ZIP archive on the local file system.
  *
- * @param {string} archivePath Full path to a .zip archive
- * @returns {Promise<UnzipInfo>} temporary folder root where the archive has been extracted
+ * @param archivePath Full path to a .zip archive
+ * @returns temporary folder root where the archive has been extracted
  */
-export async function unzipFile(archivePath) {
+export async function unzipFile(archivePath: string): Promise<UnzipInfo> {
   const useSystemUnzipEnv = process.env.APPIUM_PREFER_SYSTEM_UNZIP;
   const useSystemUnzip =
     _.isEmpty(useSystemUnzipEnv) || !['0', 'false'].includes(_.toLower(useSystemUnzipEnv));
@@ -289,11 +248,8 @@ export async function unzipFile(archivePath) {
  * Uses bdstar tool for this purpose.
  * This allows to optimize the time needed to prepare the app under test
  * to MAX(download, unzip) instead of SUM(download, unzip)
- *
- * @param {import('node:stream').Readable} zipStream
- * @returns {Promise<UnzipInfo>}
  */
-export async function unzipStream(zipStream) {
+export async function unzipStream(zipStream: Readable): Promise<UnzipInfo> {
   const tmpRoot = await tempDir.openDir();
   const bsdtarProcess = spawn(await fs.which('bsdtar'), [
     '-x',
@@ -321,7 +277,7 @@ export async function unzipStream(zipStream) {
         zipStream.unpipe(bsdtarProcess.stdin);
         log.debug(`bsdtar process exited with code ${code}, signal ${signal}`);
         if (code === 0) {
-          resolve();
+          resolve(undefined);
         } else {
           reject(new Error('Is it a valid ZIP archive?'));
         }
@@ -331,7 +287,7 @@ export async function unzipStream(zipStream) {
         reject(e);
       });
     });
-  } catch (err) {
+  } catch (err: any) {
     bsdtarProcess.kill(9);
     await fs.rimraf(tmpRoot);
     throw new Error(`The response data cannot be unzipped: ${err.message}`);
@@ -346,19 +302,150 @@ export async function unzipStream(zipStream) {
 }
 
 /**
- * Used to parse the file name value from response headers
+ * Builds Safari preferences object based on the given session capabilities
  *
- * @param {import('@appium/types').HTTPHeaders} headers
- * @returns {string?}
+ * @param opts
+ * @return
  */
-function parseFileName(headers) {
+export function buildSafariPreferences(opts: XCUITestDriverOpts): StringRecord {
+  const safariSettings = _.cloneDeep(opts?.safariGlobalPreferences ?? {});
+
+  for (const [name, [aliases, valueConverter]] of _.toPairs(SAFARI_OPTS_ALIASES_MAP)) {
+    if (!_.has(opts, name)) {
+      continue;
+    }
+
+    for (const alias of aliases) {
+      safariSettings[alias] = valueConverter((opts as any)[name]);
+    }
+  }
+  return safariSettings;
+}
+
+/**
+ * The callback invoked by configureApp helper
+ * when it is necessary to download the remote application.
+ * We assume the remote file could be anythingm, but only
+ * .zip and .ipa formats are supported.
+ * A .zip archive can contain one or more
+ */
+export async function onDownloadApp(this: XCUITestDriver, opts: DownloadAppOptions): Promise<string> {
+  return this.isRealDevice()
+    ? await downloadIpa.bind(this)(opts.stream, opts.headers)
+    : await unzipApp.bind(this)(opts.stream);
+}
+
+export async function onPostConfigureApp(
+  this: XCUITestDriver,
+  opts: PostProcessOptions
+): Promise<PostProcessResult | false> {
+  // Pick the previously cached entry if its integrity has been preserved
+  const appInfo = _.isPlainObject(opts.cachedAppInfo) ? opts.cachedAppInfo as CachedAppInfo : undefined;
+  const cachedPath = appInfo ? appInfo.fullPath : undefined;
+
+  const shouldUseCachedApp = async () => {
+    if (!appInfo || !cachedPath || !await fs.exists(cachedPath)) {
+      return false;
+    }
+
+    const isCachedPathAFile = (await fs.stat(cachedPath)).isFile();
+    if (isCachedPathAFile) {
+      return await fs.hash(cachedPath) === (appInfo.integrity as any)?.file;
+    }
+    // If the cached path is a folder then it is expected to be previously extracted from
+    // an archive located under appPath whose hash is stored as `cachedAppInfo.packageHash`
+    if (
+      !isCachedPathAFile
+      && opts.cachedAppInfo?.packageHash
+      && opts.appPath
+      && await fs.exists(opts.appPath)
+      && (await fs.stat(opts.appPath)).isFile()
+      && opts.cachedAppInfo.packageHash === await fs.hash(opts.appPath)
+    ) {
+      const nestedItemsCountInCache = (appInfo.integrity as any)?.folder;
+      if (nestedItemsCountInCache !== undefined) {
+        return (await fs.glob('**/*', {cwd: cachedPath})).length >= nestedItemsCountInCache;
+      }
+    }
+
+    return false;
+  };
+
+  if (await shouldUseCachedApp()) {
+    if (!cachedPath) {
+      return false;
+    }
+    this.log.info(`Using '${cachedPath}' which was cached from '${opts.appPath || 'unknown'}'`);
+    return {appPath: cachedPath};
+  }
+
+  if (!opts.appPath) {
+    return false;
+  }
+
+  const isLocalIpa = await isIpaBundle(opts.appPath);
+  const isLocalApp = !isLocalIpa && await isAppBundle(opts.appPath);
+  const isPackageReadyForInstall = isLocalApp || (this.isRealDevice() && isLocalIpa);
+  if (isPackageReadyForInstall) {
+    await this.appInfosCache.put(opts.appPath);
+  }
+  // Only local .app bundles (real device/Simulator)
+  // and .ipa packages for real devices should not be cached
+  if (!opts.isUrl && isPackageReadyForInstall) {
+    return false;
+  }
+  // Cache the app while unpacking the bundle if necessary
+  return {
+    appPath: isPackageReadyForInstall
+      ? opts.appPath
+      : await unzipApp.bind(this)(opts.appPath)
+  };
+}
+
+// Private functions
+async function readResource(resourcePath: string): Promise<StringRecord> {
+  const data = await plist.parsePlistFile(resourcePath);
+  return _.toPairs(data).reduce((result, [key, value]) => {
+    result[key] = _.isString(value) ? value : JSON.stringify(value);
+    return result;
+  }, {} as StringRecord);
+}
+
+/**
+ * Check whether the given path on the file system points to the .app bundle root
+ *
+ * @param appPath Possible .app bundle root
+ * @returns Whether the given path points to an .app bundle
+ */
+async function isAppBundle(appPath: string): Promise<boolean> {
+  return (
+    _.endsWith(_.toLower(appPath), APP_EXT) &&
+    (await fs.stat(appPath)).isDirectory() &&
+    (await fs.exists(path.join(appPath, 'Info.plist')))
+  );
+}
+
+/**
+ * Check whether the given path on the file system points to the .ipa file
+ *
+ * @param appPath Possible .ipa file
+ * @returns Whether the given path points to an .ipa bundle
+ */
+async function isIpaBundle(appPath: string): Promise<boolean> {
+  return _.endsWith(_.toLower(appPath), IPA_EXT) && (await fs.stat(appPath)).isFile();
+}
+
+/**
+ * Used to parse the file name value from response headers
+ */
+function parseFileName(headers: HTTPHeaders): string | null {
   const contentDisposition = headers['content-disposition'];
   if (!_.isString(contentDisposition)) {
     return null;
   }
 
-  if (/^attachment/i.test(/** @type {string} */ (contentDisposition))) {
-    const match = /filename="([^"]+)/i.exec(/** @type {string} */ (contentDisposition));
+  if (/^attachment/i.test(contentDisposition)) {
+    const match = /filename="([^"]+)/i.exec(contentDisposition);
     if (match) {
       return fs.sanitizeName(match[1], {replacement: SANITIZE_REPLACEMENT});
     }
@@ -368,16 +455,11 @@ function parseFileName(headers) {
 
 /**
  * Downloads and verifies remote applications for real devices
- *
- * @this {XCUITestDriver}
- * @param {import('node:stream').Readable} stream
- * @param {import('@appium/types').HTTPHeaders} headers
- * @returns {Promise<string>}
  */
-async function downloadIpa(stream, headers) {
+async function downloadIpa(this: XCUITestDriver, stream: Readable, headers: HTTPHeaders): Promise<string> {
   const timer = new timing.Timer().start();
 
-  const logPerformance = (/** @type {string} */ dstPath, /** @type {number} */ fileSize, /** @type {string} */ action) => {
+  const logPerformance = (dstPath: string, fileSize: number, action: string) => {
     const secondsElapsed = timer.getDuration().asSeconds;
     this.log.info(
       `The remote file (${util.toReadableSizeString(fileSize)}) ` +
@@ -405,7 +487,7 @@ async function downloadIpa(stream, headers) {
       for (const matchedPath of matchedPaths) {
         try {
           await this.appInfosCache.put(matchedPath);
-        } catch (e) {
+        } catch (e: any) {
           this.log.info(e.message);
           continue;
         }
@@ -436,7 +518,7 @@ async function downloadIpa(stream, headers) {
         reject(e);
       });
     });
-  } catch (err) {
+  } catch (err: any) {
     throw new Error(`Cannot fetch the remote file: ${err.message}`);
   }
   const {size} = await fs.stat(ipaPath);
@@ -453,11 +535,11 @@ async function downloadIpa(stream, headers) {
 /**
  * Looks for items with given extensions in the given folder
  *
- * @param {string} appPath Full path to an app bundle
- * @param {Array<string>} appExtensions List of matching item extensions
- * @returns {Promise<string[]>} List of relative paths to matched items
+ * @param appPath Full path to an app bundle
+ * @param appExtensions List of matching item extensions
+ * @returns List of relative paths to matched items
  */
-async function findApps(appPath, appExtensions) {
+async function findApps(appPath: string, appExtensions: string[]): Promise<string[]> {
   const globPattern = `**/*.+(${appExtensions.map((ext) => ext.replace(/^\./, '')).join('|')})`;
   const sortedBundleItems = (
     await fs.glob(globPattern, {
@@ -470,11 +552,11 @@ async function findApps(appPath, appExtensions) {
 /**
  * Moves the application bundle to a newly created temporary folder
  *
- * @param {string} appPath Full path to the .app or .ipa bundle
- * @returns {Promise<string>} The new path to the app bundle.
+ * @param appPath Full path to the .app or .ipa bundle
+ * @returns The new path to the app bundle.
  * The name of the app bundle remains the same
  */
-async function isolateApp(appPath) {
+async function isolateApp(appPath: string): Promise<string> {
   const appFileName = path.basename(appPath);
   if ((await fs.stat(appPath)).isFile()) {
     const isolatedPath = await tempDir.path({
@@ -491,38 +573,20 @@ async function isolateApp(appPath) {
   return isolatedRoot;
 }
 
-/**
- * Builds Safari preferences object based on the given session capabilities
- *
- * @param {import('./driver').XCUITestDriverOpts} opts
- * @return {import('@appium/types').StringRecord}
- */
-export function buildSafariPreferences(opts) {
-  const safariSettings = _.cloneDeep(opts?.safariGlobalPreferences ?? {});
-
-  for (const [name, [aliases, valueConverter]] of _.toPairs(SAFARI_OPTS_ALIASES_MAP)) {
-    if (!_.has(opts, name)) {
-      continue;
-    }
-
-    for (const alias of aliases) {
-      safariSettings[alias] = valueConverter(opts[name]);
-    }
-  }
-  return safariSettings;
-}
-
 /**
  * Unzip the given archive and find a matching .app bundle in it
  *
- * @this {XCUITestDriver}
- * @param {string|import('node:stream').Readable} appPathOrZipStream The path to the archive.
- * @param {number} depth [0] the current nesting depth. App bundles whose nesting level
+ * @param appPathOrZipStream The path to the archive.
+ * @param depth [0] the current nesting depth. App bundles whose nesting level
  * is greater than 1 are not supported.
- * @returns {Promise<string>} Full path to the first matching .app bundle..
+ * @returns Full path to the first matching .app bundle..
  * @throws If no matching .app bundles were found in the provided archive.
  */
-async function unzipApp(appPathOrZipStream, depth = 0) {
+async function unzipApp(
+  this: XCUITestDriver,
+  appPathOrZipStream: string | Readable,
+  depth: number = 0
+): Promise<string> {
   const errMsg = `The archive did not have any matching ${APP_EXT} or ${IPA_EXT} ` +
     `bundles. Please make sure the provided package is valid and contains at least one matching ` +
     `application bundle which is not nested.`;
@@ -531,22 +595,18 @@ async function unzipApp(appPathOrZipStream, depth = 0) {
   }
 
   const timer = new timing.Timer().start();
-  /** @type {string} */
-  let rootDir;
-  /** @type {number} */
-  let archiveSize;
+  let rootDir: string;
+  let archiveSize: number;
   try {
     if (_.isString(appPathOrZipStream)) {
-      ({rootDir, archiveSize} = await unzipFile(/** @type {string} */ (appPathOrZipStream)));
+      ({rootDir, archiveSize} = await unzipFile(appPathOrZipStream));
     } else {
       if (depth > 0) {
         assert.fail('Streaming unzip cannot be invoked for nested archive items');
       }
-      ({rootDir, archiveSize} = await unzipStream(
-        /** @type {import('node:stream').Readable} */ (appPathOrZipStream))
-      );
+      ({rootDir, archiveSize} = await unzipStream(appPathOrZipStream));
     }
-  } catch (e) {
+  } catch (e: any) {
     this.log.debug(e.stack);
     throw new Error(
       `Cannot prepare the application for testing. Original error: ${e.message}`
@@ -564,11 +624,11 @@ async function unzipApp(appPathOrZipStream, depth = 0) {
     this.log.debug(`Approximate decompression speed: ${util.toReadableSizeString(bytesPerSec)}/s`);
   }
 
-  const isCompatibleWithCurrentPlatform = async (/** @type {string} */ appPath) => {
-    let platforms;
+  const isCompatibleWithCurrentPlatform = async (appPath: string) => {
+    let platforms: string[];
     try {
       platforms = await this.appInfosCache.extractAppPlatforms(appPath);
-    } catch (e) {
+    } catch (e: any) {
       this.log.info(e.message);
       return false;
     }
@@ -615,100 +675,10 @@ async function unzipApp(appPathOrZipStream, depth = 0) {
   throw new Error(errMsg);
 }
 
-/**
- * The callback invoked by configureApp helper
- * when it is necessary to download the remote application.
- * We assume the remote file could be anythingm, but only
- * .zip and .ipa formats are supported.
- * A .zip archive can contain one or more
- *
- * @this {XCUITestDriver}
- * @param {import('@appium/types').DownloadAppOptions} opts
- * @returns {Promise<string>}
- */
-export async function onDownloadApp({stream, headers}) {
-  return this.isRealDevice()
-    ? await downloadIpa.bind(this)(stream, headers)
-    : await unzipApp.bind(this)(stream);
-}
-
-/**
- * @this {XCUITestDriver}
- * @param {import('@appium/types').PostProcessOptions} opts
- * @returns {Promise<import('@appium/types').PostProcessResult|false>}
- */
-export async function onPostConfigureApp({cachedAppInfo, isUrl, appPath}) {
-  // Pick the previously cached entry if its integrity has been preserved
-  /** @type {import('@appium/types').CachedAppInfo|undefined} */
-  const appInfo = _.isPlainObject(cachedAppInfo) ? cachedAppInfo : undefined;
-  const cachedPath = appInfo ? /** @type {string} */ (appInfo.fullPath) : undefined;
-
-  const shouldUseCachedApp = async () => {
-    if (!appInfo || !cachedPath || !await fs.exists(cachedPath)) {
-      return false;
-    }
-
-    const isCachedPathAFile = (await fs.stat(cachedPath)).isFile();
-    if (isCachedPathAFile) {
-      return await fs.hash(cachedPath) === /** @type {any} */ (appInfo.integrity)?.file;
-    }
-    // If the cached path is a folder then it is expected to be previously extracted from
-    // an archive located under appPath whose hash is stored as `cachedAppInfo.packageHash`
-    if (
-      !isCachedPathAFile
-      && cachedAppInfo?.packageHash
-      && await fs.exists(/** @type {string} */ (appPath))
-      && (await fs.stat(/** @type {string} */ (appPath))).isFile()
-      && cachedAppInfo.packageHash === await fs.hash(/** @type {string} */ (appPath))
-    ) {
-      /** @type {number|undefined} */
-      const nestedItemsCountInCache = /** @type {any} */ (appInfo.integrity)?.folder;
-      if (nestedItemsCountInCache !== undefined) {
-        return (await fs.glob('**/*', {cwd: cachedPath})).length >= nestedItemsCountInCache;
-      }
-    }
-
-    return false;
-  };
-
-  if (await shouldUseCachedApp()) {
-    this.log.info(`Using '${cachedPath}' which was cached from '${appPath}'`);
-    return {appPath: /** @type {string} */ (cachedPath)};
-  }
-
-  const isLocalIpa = await isIpaBundle(/** @type {string} */(appPath));
-  const isLocalApp = !isLocalIpa && await isAppBundle(/** @type {string} */(appPath));
-  const isPackageReadyForInstall = isLocalApp || (this.isRealDevice() && isLocalIpa);
-  if (isPackageReadyForInstall) {
-    await this.appInfosCache.put(/** @type {string} */(appPath));
-  }
-  // Only local .app bundles (real device/Simulator)
-  // and .ipa packages for real devices should not be cached
-  if (!isUrl && isPackageReadyForInstall) {
-    return false;
-  }
-  // Cache the app while unpacking the bundle if necessary
-  return {
-    appPath: isPackageReadyForInstall
-      ? appPath
-      : await unzipApp.bind(this)(/** @type {string} */(appPath))
-  };
-}
-
-/**
- * @returns {Promise<boolean>}
- */
-async function isRosettaInstalled() {
+async function isRosettaInstalled(): Promise<boolean> {
   return await fs.exists('/Library/Apple/usr/share/rosetta/rosetta');
 }
 
-/**
- * @returns {boolean}
- */
-function isAppleSilicon() {
+function isAppleSilicon(): boolean {
   return os.cpus()[0].model.includes('Apple');
 }
-
-/**
- * @typedef {import('./driver').XCUITestDriver} XCUITestDriver
- */

package/lib/commands/battery.js

@@ -1,5 +1,4 @@
-import log from '../logger.js';
-import { isIos18OrNewer } from '../utils.js';
+import { isIos18OrNewer } from '../utils';
 
 /**
  * Reads the battery information from the device under test.
@@ -22,10 +21,10 @@ export async function mobileGetBatteryInfo() {
         returnRawJson: true,
       });
     } catch (err) {
-      log.error(`Failed to get battery info from DiagnosticsService: ${err.message}`);
+      this.log.error(`Failed to get battery info from DiagnosticsService: ${err.message}`);
     } finally {
       if (remoteXPCConnection) {
-        log.info(`Closing remoteXPC connection for device ${this.device.udid}`);
+        this.log.info(`Closing remoteXPC connection for device ${this.device.udid}`);
         await remoteXPCConnection.close();
       }
     }