@appium/base-driver 10.1.2 → 10.2.1

package/build/lib/basedriver/helpers.js

@@ -10,9 +10,8 @@ exports.duplicateKeys = duplicateKeys;
 exports.parseCapsArray = parseCapsArray;
 exports.generateDriverLogPrefix = generateDriverLogPrefix;
 const lodash_1 = __importDefault(require("lodash"));
-const path_1 = __importDefault(require("path"));
-const url_1 = __importDefault(require("url"));
-const logger_1 = __importDefault(require("./logger"));
+const node_path_1 = __importDefault(require("node:path"));
+const logger_1 = require("./logger");
 const support_1 = require("@appium/support");
 const lru_cache_1 = require("lru-cache");
 const async_lock_1 = __importDefault(require("async-lock"));
@@ -27,13 +26,12 @@ const DEFAULT_REQ_HEADERS = Object.freeze({
     'user-agent': `Appium (BaseDriver v${exports.BASEDRIVER_VER})`,
 });
 const AVG_DOWNLOAD_SPEED_MEASUREMENT_THRESHOLD_SEC = 2;
-/** @type {LRUCache<string, import('@appium/types').CachedAppInfo>} */
 const APPLICATIONS_CACHE = new lru_cache_1.LRUCache({
     max: MAX_CACHED_APPS,
     ttl: CACHED_APPS_MAX_AGE_MS, // expire after 24 hours
     updateAgeOnGet: true,
     dispose: ({ fullPath }, app) => {
-        logger_1.default.info(`The application '${app}' cached at '${fullPath}' has ` +
+        logger_1.log.info(`The application '${app}' cached at '${fullPath}' has ` +
             `expired after ${CACHED_APPS_MAX_AGE_MS}ms`);
         if (fullPath) {
             support_1.fs.rimraf(fullPath);
@@ -50,40 +48,40 @@ process.on('exit', () => {
         return;
     }
     const appPaths = [...APPLICATIONS_CACHE.values()].map(({ fullPath }) => fullPath);
-    logger_1.default.debug(`Performing cleanup of ${appPaths.length} cached ` +
-        support_1.util.pluralize('application', appPaths.length));
+    logger_1.log.debug(`Performing cleanup of ${support_1.util.pluralize('cached application', appPaths.length, true)}`);
     for (const appPath of appPaths) {
+        if (!appPath) {
+            continue;
+        }
         try {
-            // @ts-ignore it's defined
             support_1.fs.rimrafSync(appPath);
         }
         catch (e) {
-            logger_1.default.warn(e.message);
+            logger_1.log.warn(e.message);
         }
     }
 });
 /**
- * Perform initial application package configuration
- * to prepare it for the further consumption by a driver:
- *
- * - Manages caching logic
- * - Downloads the app from a remote URL to the local filesystem
- * - Determines package name
- * - Checks basic requirements on the application package
+ * Performs initial application package configuration so the app is ready for driver use.
+ * Resolves local paths, downloads remote apps (http/https) with optional caching, and
+ * runs optional post-process or custom download hooks.
  *
- * @param {string} app
- * @param {string|string[]|import('@appium/types').ConfigureAppOptions} options
- * @returns {Promise<string>}
+ * @param app - Path to a local app or URL of a downloadable app (http/https).
+ * @param options - Supported extensions and optional hooks. Either a single extension
+ * string, an array of extension strings, or {@link ConfigureAppOptions} (e.g.
+ * `supportedExtensions`, `onPostProcess`, `onDownload`).
+ * @returns Resolved path to the application (local path or path to downloaded/cached app).
+ * @throws {Error} If supported extensions are missing, the app path/URL is invalid, or download fails.
  */
-async function configureApp(app, options = /** @type {import('@appium/types').ConfigureAppOptions} */ ({})) {
+async function configureApp(app, options = {}) {
     if (!lodash_1.default.isString(app)) {
         // immediately shortcircuit if not given an app
         return '';
     }
-    /** @type {string[]} */
     let supportedAppExtensions;
-    const onPostProcess = !lodash_1.default.isString(options) && !lodash_1.default.isArray(options) ? options.onPostProcess : undefined;
-    const onDownload = !lodash_1.default.isString(options) && !lodash_1.default.isArray(options) ? options.onDownload : undefined;
+    const opts = !lodash_1.default.isString(options) && !lodash_1.default.isArray(options) ? options : undefined;
+    const onPostProcess = opts?.onPostProcess;
+    const onDownload = opts?.onDownload;
     if (lodash_1.default.isString(options)) {
         supportedAppExtensions = [options];
     }
@@ -91,18 +89,18 @@ async function configureApp(app, options = /** @type {import('@appium/types').Co
         supportedAppExtensions = options;
     }
     else if (lodash_1.default.isPlainObject(options)) {
-        supportedAppExtensions = options.supportedExtensions;
+        supportedAppExtensions = options.supportedExtensions ?? [];
+    }
+    else {
+        supportedAppExtensions = [];
     }
-    // @ts-ignore this is OK
     if (lodash_1.default.isEmpty(supportedAppExtensions)) {
         throw new Error(`One or more supported app extensions must be provided`);
     }
     let newApp = app;
     const originalAppLink = app;
     let packageHash = null;
-    /** @type {import('axios').AxiosResponse['headers']|undefined} */
     let headers;
-    /** @type {RemoteAppProps} */
     const remoteAppProps = {
         lastModified: null,
         immutable: false,
@@ -111,9 +109,9 @@ async function configureApp(app, options = /** @type {import('@appium/types').Co
     };
     const { protocol, pathname } = parseAppLink(app);
     const isUrl = isSupportedUrl(app);
-    if (!isUrl && !path_1.default.isAbsolute(newApp)) {
-        newApp = path_1.default.resolve(process.cwd(), newApp);
-        logger_1.default.warn(`The current application path '${app}' is not absolute ` +
+    if (!isUrl && !node_path_1.default.isAbsolute(newApp)) {
+        newApp = node_path_1.default.resolve(process.cwd(), newApp);
+        logger_1.log.warn(`The current application path '${app}' is not absolute ` +
             `and has been rewritten to '${newApp}'. Consider using absolute paths rather than relative`);
         app = newApp;
     }
@@ -121,64 +119,68 @@ async function configureApp(app, options = /** @type {import('@appium/types').Co
     return await APPLICATIONS_CACHE_GUARD.acquire(appCacheKey, async () => {
         const cachedAppInfo = APPLICATIONS_CACHE.get(appCacheKey);
         if (cachedAppInfo) {
-            logger_1.default.debug(`Cached app data: ${JSON.stringify(cachedAppInfo, null, 2)}`);
+            logger_1.log.debug(`Cached app data: ${JSON.stringify(cachedAppInfo, null, 2)}`);
         }
         if (isUrl) {
             // Use the app from remote URL
-            logger_1.default.info(`Using downloadable app '${newApp}'`);
-            const reqHeaders = {
-                ...DEFAULT_REQ_HEADERS,
-            };
+            logger_1.log.info(`Using downloadable app '${newApp}'`);
+            const reqHeaders = { ...DEFAULT_REQ_HEADERS };
             if (cachedAppInfo?.etag) {
                 reqHeaders['if-none-match'] = cachedAppInfo.etag;
             }
             else if (cachedAppInfo?.lastModified) {
                 reqHeaders['if-modified-since'] = cachedAppInfo.lastModified.toUTCString();
             }
-            logger_1.default.debug(`Request headers: ${JSON.stringify(reqHeaders)}`);
-            let { headers, stream, status } = await queryAppLink(newApp, reqHeaders);
-            logger_1.default.debug(`Response status: ${status}`);
+            logger_1.log.debug(`Request headers: ${JSON.stringify(reqHeaders)}`);
+            let result = await queryAppLink(newApp, reqHeaders);
+            headers = result.headers;
+            let { stream, status } = result;
+            logger_1.log.debug(`Response status: ${status}`);
             try {
                 if (!lodash_1.default.isEmpty(headers)) {
                     if (headers.etag) {
-                        logger_1.default.debug(`Etag: ${headers.etag}`);
+                        logger_1.log.debug(`Etag: ${headers.etag}`);
                         remoteAppProps.etag = headers.etag;
                     }
                     if (headers['last-modified']) {
-                        logger_1.default.debug(`Last-Modified: ${headers['last-modified']}`);
+                        logger_1.log.debug(`Last-Modified: ${headers['last-modified']}`);
                         remoteAppProps.lastModified = new Date(headers['last-modified']);
                     }
                     if (headers['cache-control']) {
-                        logger_1.default.debug(`Cache-Control: ${headers['cache-control']}`);
-                        remoteAppProps.immutable = /\bimmutable\b/i.test(headers['cache-control']);
-                        const maxAgeMatch = /\bmax-age=(\d+)\b/i.exec(headers['cache-control']);
+                        logger_1.log.debug(`Cache-Control: ${headers['cache-control']}`);
+                        remoteAppProps.immutable = /\bimmutable\b/i.test(String(headers['cache-control']));
+                        const maxAgeMatch = /\bmax-age=(\d+)\b/i.exec(String(headers['cache-control']));
                         if (maxAgeMatch) {
                             remoteAppProps.maxAge = parseInt(maxAgeMatch[1], 10);
                         }
                     }
                 }
                 if (cachedAppInfo && status === HTTP_STATUS_NOT_MODIFIED) {
-                    if (await isAppIntegrityOk(/** @type {string} */ (cachedAppInfo.fullPath), cachedAppInfo.integrity)) {
-                        logger_1.default.info(`Reusing previously downloaded application at '${cachedAppInfo.fullPath}'`);
-                        return verifyAppExtension(/** @type {string} */ (cachedAppInfo.fullPath), supportedAppExtensions);
+                    const cachedPath = cachedAppInfo.fullPath ?? '';
+                    if (cachedPath && (await isAppIntegrityOk(cachedPath, cachedAppInfo.integrity))) {
+                        logger_1.log.info(`Reusing previously downloaded application at '${cachedPath}'`);
+                        return verifyAppExtension(cachedPath, supportedAppExtensions);
                     }
-                    logger_1.default.info(`The application at '${cachedAppInfo.fullPath}' does not exist anymore ` +
+                    logger_1.log.info(`The application at '${cachedAppInfo.fullPath}' does not exist anymore ` +
                         `or its integrity has been damaged. Deleting it from the internal cache`);
                     APPLICATIONS_CACHE.delete(appCacheKey);
                     if (!stream.closed) {
                         stream.destroy();
                     }
-                    ({ stream, headers, status } = await queryAppLink(newApp, { ...DEFAULT_REQ_HEADERS }));
+                    result = await queryAppLink(newApp, { ...DEFAULT_REQ_HEADERS });
+                    stream = result.stream;
+                    headers = result.headers;
+                    status = result.status;
                 }
                 if (onDownload) {
                     newApp = await onDownload({
                         url: originalAppLink,
-                        headers: /** @type {import('@appium/types').HTTPHeaders} */ (lodash_1.default.clone(headers)),
+                        headers: lodash_1.default.clone(headers),
                         stream,
                     });
                 }
                 else {
-                    const fileName = determineFilename(headers, pathname, supportedAppExtensions);
+                    const fileName = determineFilename(headers, pathname ?? '', supportedAppExtensions);
                     newApp = await fetchApp(stream, await support_1.tempDir.path({
                         prefix: fileName,
                         suffix: '',
@@ -193,7 +195,7 @@ async function configureApp(app, options = /** @type {import('@appium/types').Co
         }
         else if (await support_1.fs.exists(newApp)) {
             // Use the local app
-            logger_1.default.info(`Using local app '${newApp}'`);
+            logger_1.log.info(`Using local app '${newApp}'`);
         }
         else {
             let errorMessage = `The application at '${newApp}' does not exist or is not accessible`;
@@ -209,7 +211,6 @@ async function configureApp(app, options = /** @type {import('@appium/types').Co
         if (isPackageAFile) {
             packageHash = await calculateFileIntegrity(newApp);
         }
-        /** @type {(appPathToCache: string) => Promise<string>} */
         const storeAppInCache = async (appPathToCache) => {
             const cachedFullPath = cachedAppInfo?.fullPath;
             if (cachedFullPath && cachedFullPath !== appPathToCache) {
@@ -232,14 +233,14 @@ async function configureApp(app, options = /** @type {import('@appium/types').Co
             return appPathToCache;
         };
         if (lodash_1.default.isFunction(onPostProcess)) {
-            const result = await onPostProcess(
-            /** @type {import('@appium/types').PostProcessOptions<import('axios').AxiosResponseHeaders>} */ ({
+            const postProcessArg = {
                 cachedAppInfo: lodash_1.default.clone(cachedAppInfo),
                 isUrl,
                 originalAppLink,
                 headers: lodash_1.default.clone(headers),
                 appPath: newApp,
-            }));
+            };
+            const result = await onPostProcess(postProcessArg);
             return !result?.appPath || app === result?.appPath || !(await support_1.fs.exists(result?.appPath))
                 ? newApp
                 : await storeAppInCache(result.appPath);
@@ -251,21 +252,23 @@ async function configureApp(app, options = /** @type {import('@appium/types').Co
     });
 }
 /**
- * @param {string} app
- * @returns {boolean}
+ * Returns whether the given string looks like a package or bundle identifier
+ * (e.g. `com.example.app` or `org.company.AnotherApp`).
+ *
+ * @param app - Value to check (e.g. app path or bundle id).
+ * @returns `true` if the value matches a dot-separated identifier pattern.
  */
 function isPackageOrBundle(app) {
     return /^([a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+)+$/.test(app);
 }
 /**
- * Finds all instances 'firstKey' and create a duplicate with the key 'secondKey',
- * Do the same thing in reverse. If we find 'secondKey', create a duplicate with the key 'firstKey'.
+ * Recursively ensures both keys exist with the same value in objects and arrays.
+ * For each object, if `firstKey` exists its value is also set at `secondKey`, and vice versa.
  *
- * This will cause keys to be overwritten if the object contains 'firstKey' and 'secondKey'.
-
- * @param {*} input Any type of input
- * @param {String} firstKey The first key to duplicate
- * @param {String} secondKey The second key to duplicate
+ * @param input - Object, array, or primitive to process (arrays/objects traversed recursively).
+ * @param firstKey - First key name to mirror.
+ * @param secondKey - Second key name to mirror.
+ * @returns A deep copy of `input` with both keys present where objects had either key.
  */
 function duplicateKeys(input, firstKey, secondKey) {
     // If array provided, recursively call on all elements
@@ -275,7 +278,7 @@ function duplicateKeys(input, firstKey, secondKey) {
     // If object, create duplicates for keys and then recursively call on values
     if (lodash_1.default.isPlainObject(input)) {
         const resultObj = {};
-        for (let [key, value] of lodash_1.default.toPairs(input)) {
+        for (const [key, value] of lodash_1.default.toPairs(input)) {
             const recursivelyCalledValue = duplicateKeys(value, firstKey, secondKey);
             if (key === firstKey) {
                 resultObj[secondKey] = recursivelyCalledValue;
@@ -291,11 +294,12 @@ function duplicateKeys(input, firstKey, secondKey) {
     return input;
 }
 /**
- * Takes a capability value and tries to JSON.parse it as an array,
- * and either returns the parsed array or a singleton array.
+ * Normalizes a capability value to a string array. If already an array, returns it;
+ * if a string, parses as JSON array when possible, otherwise returns a single-element array.
  *
- * @param {string|string[]} capValue Capability value
- * @returns {string[]}
+ * @param capValue - Capability value: string (including JSON array like `"[\"a\",\"b\"]"`) or string[].
+ * @returns Array of strings.
+ * @throws {TypeError} If value is not a string/array or JSON parsing fails for array-like input.
  */
 function parseCapsArray(capValue) {
     if (lodash_1.default.isArray(capValue)) {
@@ -312,7 +316,7 @@ function parseCapsArray(capValue) {
         if (lodash_1.default.isString(capValue) && lodash_1.default.startsWith(lodash_1.default.trimStart(capValue), '[')) {
             throw new TypeError(message);
         }
-        logger_1.default.warn(message);
+        logger_1.log.warn(message);
     }
     if (lodash_1.default.isString(capValue)) {
         return [capValue];
@@ -320,36 +324,77 @@ function parseCapsArray(capValue) {
     throw new TypeError(`Expected a string or a valid JSON array; received '${capValue}'`);
 }
 /**
- * Generate a string that uniquely describes driver instance
+ * Builds a short log prefix for a driver instance (e.g. `UiAutomator2@a1b2`).
  *
- * @param {object} obj driver instance
- * @param {string?} [sessionId=null] session identifier (if exists).
- * This parameter is deprecated and is not used.
- * @returns {string}
+ * @param obj - Driver or other object; its constructor name and a short id are used.
+ * @param _sessionId - Deprecated and unused; kept for {@link DriverHelpers} interface compatibility.
+ * @returns Prefix string like `DriverName@xxxx`, or `UnknownDriver@????` if `obj` is null.
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function generateDriverLogPrefix(obj, sessionId = null) {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- DriverHelpers interface
+function generateDriverLogPrefix(obj, _sessionId) {
+    if (!obj) {
+        // This should not happen
+        return 'UnknownDriver@????';
+    }
     return `${obj.constructor.name}@${support_1.node.getObjectId(obj).substring(0, 4)}`;
 }
+function parseAppLink(appLink) {
+    try {
+        return new URL(appLink);
+    }
+    catch {
+        return {};
+    }
+}
+function isEnvOptionEnabled(optionName, defaultValue = null) {
+    const value = process.env[optionName];
+    if (!lodash_1.default.isNull(defaultValue) && lodash_1.default.isEmpty(value)) {
+        return defaultValue;
+    }
+    return !lodash_1.default.isEmpty(value) && !['0', 'false', 'no'].includes(lodash_1.default.toLower(value));
+}
+function isSupportedUrl(app) {
+    try {
+        const { protocol } = parseAppLink(app);
+        return ['http:', 'https:'].includes(protocol ?? '');
+    }
+    catch {
+        return false;
+    }
+}
 /**
- * Sends a HTTP GET query to fetch the app with caching enabled.
- * Follows https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching
- *
- * @param {string} appLink The URL to download an app from
- * @param {import('axios').RawAxiosRequestHeaders} reqHeaders Additional HTTP request headers
- * @returns {Promise<RemoteAppData>}
+ * Transforms the given app link to the cache key.
+ * Necessary to properly cache apps having the same address but different query strings,
+ * e.g. ones stored in S3 using presigned URLs.
  */
+function toCacheKey(app) {
+    if (!isEnvOptionEnabled('APPIUM_APPS_CACHE_IGNORE_URL_QUERY') || !isSupportedUrl(app)) {
+        return app;
+    }
+    try {
+        const parsed = parseAppLink(app);
+        const href = 'href' in parsed ? parsed.href : undefined;
+        const search = 'search' in parsed ? parsed.search : undefined;
+        if (href && search) {
+            return href.replace(search, '');
+        }
+        if (href) {
+            return href;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return app;
+}
 async function queryAppLink(appLink, reqHeaders) {
-    const { href, auth } = url_1.default.parse(appLink);
-    const axiosUrl = auth ? href.replace(`${auth}@`, '') : href;
-    /** @type {import('axios').AxiosBasicCredentials|undefined} */
-    const axiosAuth = auth ? {
-        username: auth.substring(0, auth.indexOf(':')),
-        password: auth.substring(auth.indexOf(':') + 1),
-    } : undefined;
-    /**
-     * @type {import('axios').RawAxiosRequestConfig}
-     */
+    const url = new URL(appLink);
+    // Extract credentials, then remove them from the URL for axios
+    const { username, password } = url;
+    url.username = '';
+    url.password = '';
+    const axiosUrl = url.href;
+    const axiosAuth = username ? { username, password } : undefined;
     const requestOpts = {
         url: axiosUrl,
         auth: axiosAuth,
@@ -360,24 +405,12 @@ async function queryAppLink(appLink, reqHeaders) {
     };
     try {
         const { data: stream, headers, status } = await (0, axios_1.default)(requestOpts);
-        return {
-            stream,
-            headers,
-            status,
-        };
+        return { stream, headers, status };
     }
     catch (err) {
         throw new Error(`Cannot download the app from ${axiosUrl}: ${err.message}`);
     }
 }
-/**
- * Retrieves app payload from the given stream. Also meters the download performance.
- *
- * @param {import('stream').Readable} srcStream The incoming stream
- * @param {string} dstPath The target file path to be written
- * @returns {Promise<string>} The same dstPath
- * @throws {Error} If there was a failure while downloading the file
- */
 async function fetchApp(srcStream, dstPath) {
     const timer = new support_1.timing.Timer().start();
     try {
@@ -385,7 +418,7 @@ async function fetchApp(srcStream, dstPath) {
         srcStream.pipe(writer);
         await new bluebird_1.default((resolve, reject) => {
             srcStream.once('error', reject);
-            writer.once('finish', resolve);
+            writer.once('finish', () => resolve());
             writer.once('error', (e) => {
                 srcStream.unpipe(writer);
                 reject(e);
@@ -397,78 +430,25 @@ async function fetchApp(srcStream, dstPath) {
     }
     const secondsElapsed = timer.getDuration().asSeconds;
     const { size } = await support_1.fs.stat(dstPath);
-    logger_1.default.debug(`The application (${support_1.util.toReadableSizeString(size)}) ` +
+    logger_1.log.debug(`The application (${support_1.util.toReadableSizeString(size)}) ` +
         `has been downloaded to '${dstPath}' in ${secondsElapsed.toFixed(3)}s`);
     // it does not make much sense to approximate the speed for short downloads
     if (secondsElapsed >= AVG_DOWNLOAD_SPEED_MEASUREMENT_THRESHOLD_SEC) {
         const bytesPerSec = Math.floor(size / secondsElapsed);
-        logger_1.default.debug(`Approximate download speed: ${support_1.util.toReadableSizeString(bytesPerSec)}/s`);
+        logger_1.log.debug(`Approximate download speed: ${support_1.util.toReadableSizeString(bytesPerSec)}/s`);
     }
     return dstPath;
 }
-/**
- * Transforms the given app link to the cache key.
- * This is necessary to properly cache apps
- * having the same address, but different query strings,
- * for example ones stored in S3 using presigned URLs.
- *
- * @param {string} app App link.
- * @returns {string} Transformed app link or the original arg if
- * no transformation is needed.
- */
-function toCacheKey(app) {
-    if (!isEnvOptionEnabled('APPIUM_APPS_CACHE_IGNORE_URL_QUERY') || !isSupportedUrl(app)) {
-        return app;
-    }
-    try {
-        const { href, search } = parseAppLink(app);
-        if (href && search) {
-            return href.replace(search, '');
-        }
-        if (href) {
-            return href;
-        }
-    }
-    catch { }
-    return app;
-}
-/**
- * Safely parses the given app link to a URL object
- *
- * @param {string} appLink
- * @returns {URL|import('@appium/types').StringRecord} Parsed URL object
- * or an empty object if the parsing has failed
- */
-function parseAppLink(appLink) {
-    try {
-        return new URL(appLink);
-    }
-    catch {
-        return {};
-    }
-}
-/**
- * Tries to determine the file name of the payload that is going
- * to be downloaded from an URL
- *
- * @param {import('axios').RawAxiosRequestHeaders} headers
- * @param {string} pathname
- * @param {string[]} supportedAppExtensions
- * @returns {string}
- */
 function determineFilename(headers, pathname, supportedAppExtensions) {
-    const basename = support_1.fs.sanitizeName(path_1.default.basename(decodeURIComponent(pathname ?? '')), {
+    const basename = support_1.fs.sanitizeName(node_path_1.default.basename(decodeURIComponent(pathname ?? '')), {
         replacement: SANITIZE_REPLACEMENT,
     });
-    const extname = path_1.default.extname(basename);
-    if (headers['content-disposition'] && /^attachment/i.test(
-    /** @type {string} */ (headers['content-disposition']))) {
-        logger_1.default.debug(`Content-Disposition: ${headers['content-disposition']}`);
-        const match = /filename="([^"]+)/i.exec(/** @type {string} */ (headers['content-disposition']));
+    const extname = node_path_1.default.extname(basename);
+    if (headers['content-disposition'] && /^attachment/i.test(String(headers['content-disposition']))) {
+        logger_1.log.debug(`Content-Disposition: ${headers['content-disposition']}`);
+        const match = /filename="([^"]+)/i.exec(String(headers['content-disposition']));
         if (match) {
-            return support_1.fs.sanitizeName(match[1], {
-                replacement: SANITIZE_REPLACEMENT,
-            });
+            return support_1.fs.sanitizeName(match[1], { replacement: SANITIZE_REPLACEMENT });
         }
     }
     // assign the default file name and the extension if none has been detected
@@ -477,88 +457,26 @@ function determineFilename(headers, pathname, supportedAppExtensions) {
         : DEFAULT_BASENAME;
     let resultingExt = extname;
     if (!supportedAppExtensions.map(lodash_1.default.toLower).includes(lodash_1.default.toLower(resultingExt))) {
-        logger_1.default.info(`The current file extension '${resultingExt}' is not supported. ` +
+        logger_1.log.info(`The current file extension '${resultingExt}' is not supported. ` +
             `Defaulting to '${lodash_1.default.first(supportedAppExtensions)}'`);
-        resultingExt = /** @type {string} */ (lodash_1.default.first(supportedAppExtensions));
+        resultingExt = lodash_1.default.first(supportedAppExtensions);
     }
     return `${resultingName}${resultingExt}`;
 }
-/**
- * Checks whether we can threat the given app link
- * as a URL,
- *
- * @param {string} app
- * @returns {boolean} True if app is a supported URL
- */
-function isSupportedUrl(app) {
-    try {
-        const { protocol } = parseAppLink(app);
-        return ['http:', 'https:'].includes(protocol);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if the given environment option is enabled
- *
- * @param {string} optionName Option name
- * @param {boolean|null} [defaultValue=null] The value to return if the given env value
- * is not set explicitly
- * @returns {boolean} True if the option is enabled
- */
-function isEnvOptionEnabled(optionName, defaultValue = null) {
-    const value = process.env[optionName];
-    if (!lodash_1.default.isNull(defaultValue) && lodash_1.default.isEmpty(value)) {
-        return defaultValue;
-    }
-    return !lodash_1.default.isEmpty(value) && !['0', 'false', 'no'].includes(lodash_1.default.toLower(value));
-}
-/**
- *
- * @param {string} [envVarName]
- * @param {number} defaultValue
- * @returns {number}
- */
-function toNaturalNumber(defaultValue, envVarName) {
-    if (!envVarName || lodash_1.default.isUndefined(process.env[envVarName])) {
-        return defaultValue;
-    }
-    const num = parseInt(`${process.env[envVarName]}`, 10);
-    return num > 0 ? num : defaultValue;
-}
-/**
- * @param {string} app
- * @param {string[]} supportedAppExtensions
- * @returns {string}
- */
 function verifyAppExtension(app, supportedAppExtensions) {
-    if (supportedAppExtensions.map(lodash_1.default.toLower).includes(lodash_1.default.toLower(path_1.default.extname(app)))) {
+    if (supportedAppExtensions.map(lodash_1.default.toLower).includes(lodash_1.default.toLower(node_path_1.default.extname(app)))) {
         return app;
     }
     throw new Error(`New app path '${app}' did not have ` +
         `${support_1.util.pluralize('extension', supportedAppExtensions.length, false)}: ` +
         supportedAppExtensions);
 }
-/**
- * @param {string} folderPath
- * @returns {Promise<number>}
- */
 async function calculateFolderIntegrity(folderPath) {
     return (await support_1.fs.glob('**/*', { cwd: folderPath })).length;
 }
-/**
- * @param {string} filePath
- * @returns {Promise<string>}
- */
 async function calculateFileIntegrity(filePath) {
     return await support_1.fs.hash(filePath);
 }
-/**
- * @param {string} currentPath
- * @param {import('@appium/types').StringRecord} expectedIntegrity
- * @returns {Promise<boolean>}
- */
 async function isAppIntegrityOk(currentPath, expectedIntegrity = {}) {
     if (!(await support_1.fs.exists(currentPath))) {
         return false;
@@ -571,10 +489,17 @@ async function isAppIntegrityOk(currentPath, expectedIntegrity = {}) {
     // more precise, but we don't need to be very precise here and also don't want to
     // overuse RAM and have a performance drop.
     return (await support_1.fs.stat(currentPath)).isDirectory()
-        ? (await calculateFolderIntegrity(currentPath)) >= expectedIntegrity?.folder
+        ? (await calculateFolderIntegrity(currentPath)) >= (expectedIntegrity?.folder ?? 0)
         : (await calculateFileIntegrity(currentPath)) === expectedIntegrity?.file;
 }
-/** @type {import('@appium/types').DriverHelpers} */
+function toNaturalNumber(defaultValue, envVarName) {
+    if (!envVarName || lodash_1.default.isUndefined(process.env[envVarName])) {
+        return defaultValue;
+    }
+    const num = parseInt(`${process.env[envVarName]}`, 10);
+    return num > 0 ? num : defaultValue;
+}
+// #endregion
 exports.default = {
     configureApp,
     isPackageOrBundle,
@@ -582,17 +507,4 @@ exports.default = {
     parseCapsArray,
     generateDriverLogPrefix,
 };
-/**
- * @typedef RemoteAppProps
- * @property {Date?} lastModified
- * @property {boolean} immutable
- * @property {number?} maxAge
- * @property {string?} etag
- */
-/**
- * @typedef RemoteAppData Properties of the remote application (e.g. GET HTTP response) to be downloaded.
- * @property {number} status The HTTP status of the response
- * @property {import('stream').Readable} stream The HTTP response body represented as readable stream
- * @property {import('axios').RawAxiosResponseHeaders | import('axios').AxiosResponseHeaders} headers HTTP response headers
- */
 //# sourceMappingURL=helpers.js.map