appium-adb 14.0.4 → 14.0.6

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [14.0.6](https://github.com/appium/appium-adb/compare/v14.0.5...v14.0.6) (2025-12-05)
+
+### Miscellaneous Chores
+
+* Migrate apk-utils and device-settings to typescript ([#844](https://github.com/appium/appium-adb/issues/844)) ([d5bd207](https://github.com/appium/appium-adb/commit/d5bd20751e1f69b1f54db173241d42a55ffb596c))
+
+## [14.0.5](https://github.com/appium/appium-adb/compare/v14.0.4...v14.0.5) (2025-12-04)
+
+### Miscellaneous Chores
+
+* Migrate app commands to typescript ([#843](https://github.com/appium/appium-adb/issues/843)) ([8993e7c](https://github.com/appium/appium-adb/commit/8993e7c5fcbabda3796b8246ecac39046bf6fe3f))
+
 ## [14.0.4](https://github.com/appium/appium-adb/compare/v14.0.3...v14.0.4) (2025-12-04)
 
 ### Miscellaneous Chores

package/build/lib/tools/apk-utils.d.ts

@@ -1,122 +1,99 @@
+import type { ADB } from '../adb.js';
+import type { UninstallOptions, ShellExecOptions, CachingOptions, InstallOptions, InstallOrUpgradeOptions, InstallOrUpgradeResult, ApkStrings, AppInfo, InstallState, StringRecord } from './types.js';
+export declare const REMOTE_CACHE_ROOT = "/data/local/tmp/appium_cache";
 /**
  * Uninstall the given package from the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the package to be uninstalled.
- * @param {import('./types').UninstallOptions} [options={}] - The set of uninstall options.
- * @return {Promise<boolean>} True if the package was found on the device and
+ * @param pkg - The name of the package to be uninstalled.
+ * @param options - The set of uninstall options.
+ * @returns True if the package was found on the device and
  *                   successfully uninstalled.
  */
-export function uninstallApk(this: import("../adb.js").ADB, pkg: string, options?: import("./types").UninstallOptions): Promise<boolean>;
+export declare function uninstallApk(this: ADB, pkg: string, options?: UninstallOptions): Promise<boolean>;
 /**
  * Install the package after it was pushed to the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} apkPathOnDevice - The full path to the package on the device file system.
- * @param {import('./types').ShellExecOptions} [opts={}] Additional exec options.
- * @throws {error} If there was a failure during application install.
+ * @param apkPathOnDevice - The full path to the package on the device file system.
+ * @param opts - Additional exec options.
+ * @throws If there was a failure during application install.
  */
-export function installFromDevicePath(this: import("../adb.js").ADB, apkPathOnDevice: string, opts?: import("./types").ShellExecOptions): Promise<void>;
+export declare function installFromDevicePath(this: ADB, apkPathOnDevice: string, opts?: ShellExecOptions): Promise<void>;
 /**
  * Caches the given APK at a remote location to speed up further APK deployments.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} apkPath - Full path to the apk on the local FS
- * @param {import('./types').CachingOptions} [options={}] - Caching options
- * @returns {Promise<string>} - Full path to the cached apk on the remote file system
- * @throws {Error} if there was a failure while caching the app
+ * @param apkPath - Full path to the apk on the local FS
+ * @param options - Caching options
+ * @returns Full path to the cached apk on the remote file system
+ * @throws if there was a failure while caching the app
  */
-export function cacheApk(this: import("../adb.js").ADB, apkPath: string, options?: import("./types").CachingOptions): Promise<string>;
-export class cacheApk {
-    /**
-     * Caches the given APK at a remote location to speed up further APK deployments.
-     *
-     * @this {import('../adb.js').ADB}
-     * @param {string} apkPath - Full path to the apk on the local FS
-     * @param {import('./types').CachingOptions} [options={}] - Caching options
-     * @returns {Promise<string>} - Full path to the cached apk on the remote file system
-     * @throws {Error} if there was a failure while caching the app
-     */
-    constructor(this: import("../adb.js").ADB, apkPath: string, options?: import("./types").CachingOptions);
-    _areExtendedLsOptionsSupported: boolean | undefined;
-    remoteAppsCache: LRUCache<string, string, unknown>;
-}
+export declare function cacheApk(this: ADB, apkPath: string, options?: CachingOptions): Promise<string>;
 /**
  * Install the package from the local file system.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appPath - The full path to the local package.
- * @param {import('./types').InstallOptions} [options={}] - The set of installation options.
- * @throws {Error} If an unexpected error happens during install.
+ * @param appPath - The full path to the local package.
+ * @param options - The set of installation options.
+ * @throws If an unexpected error happens during install.
  */
-export function install(this: import("../adb.js").ADB, appPath: string, options?: import("./types").InstallOptions): Promise<void>;
+export declare function install(this: ADB, appPath: string, options?: InstallOptions): Promise<void>;
 /**
  * Retrieves the current installation state of the particular application
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appPath - Full path to the application
- * @param {string?} [pkg=null] - Package identifier. If omitted then the script will
+ * @param appPath - Full path to the application
+ * @param pkg - Package identifier. If omitted then the script will
  * try to extract it on its own
- * @returns {Promise<import('./types').InstallState>} One of `APP_INSTALL_STATE` constants
+ * @returns One of `APP_INSTALL_STATE` constants
  */
-export function getApplicationInstallState(this: import("../adb.js").ADB, appPath: string, pkg?: string | null): Promise<import("./types").InstallState>;
+export declare function getApplicationInstallState(this: ADB, appPath: string, pkg?: string | null): Promise<InstallState>;
 /**
  * Install the package from the local file system or upgrade it if an older
  * version of the same package is already installed.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appPath - The full path to the local package.
- * @param {string?} [pkg=null] - The name of the installed package. The method will
+ * @param appPath - The full path to the local package.
+ * @param pkg - The name of the installed package. The method will
  * perform faster if it is set.
- * @param {import('./types').InstallOrUpgradeOptions} [options={}] - Set of install options.
- * @throws {Error} If an unexpected error happens during install.
- * @returns {Promise<import('./types').InstallOrUpgradeResult>}
+ * @param options - Set of install options.
+ * @throws If an unexpected error happens during install.
  */
-export function installOrUpgrade(this: import("../adb.js").ADB, appPath: string, pkg?: string | null, options?: import("./types").InstallOrUpgradeOptions): Promise<import("./types").InstallOrUpgradeResult>;
+export declare function installOrUpgrade(this: ADB, appPath: string, pkg?: string | null, options?: InstallOrUpgradeOptions): Promise<InstallOrUpgradeResult>;
 /**
  * Extract string resources from the given package on local file system.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appPath - The full path to the .apk(s) package.
- * @param {string?} [language=null] - The name of the language to extract the resources for.
+ * @param appPath - The full path to the .apk(s) package.
+ * @param language - The name of the language to extract the resources for.
  * The default language is used if this equals to `null`
- * @param {string?} [outRoot=null] - The name of the destination folder on the local file system to
+ * @param outRoot - The name of the destination folder on the local file system to
  * store the extracted file to. If not provided then the `localPath` property in the returned object
  * will be undefined.
- * @return {Promise<import('./types').ApkStrings>}
  */
-export function extractStringsFromApk(this: import("../adb.js").ADB, appPath: string, language?: string | null, outRoot?: string | null): Promise<import("./types").ApkStrings>;
+export declare function extractStringsFromApk(this: ADB, appPath: string, language?: string | null, outRoot?: string | null): Promise<ApkStrings>;
 /**
  * Get the package info from local apk file.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appPath - The full path to existing .apk(s) package on the local
+ * @param appPath - The full path to existing .apk(s) package on the local
  *                           file system.
- * @return {Promise<import('./types').AppInfo|{}>} The parsed application information.
+ * @returns The parsed application information.
  */
-export function getApkInfo(this: import("../adb.js").ADB, appPath: string): Promise<import("./types").AppInfo | {}>;
+export declare function getApkInfo(this: ADB, appPath: string): Promise<AppInfo | {}>;
 /**
  * Parses apk strings from aapt2 tool output
  *
- * @param {string} rawOutput The actual tool output
- * @param {string} configMarker The config marker. Usually
+ * @param rawOutput The actual tool output
+ * @param configMarker The config marker. Usually
  * a language abbreviation or an empty string for the default one
- * @returns {Object} Strings ids to values mapping. Plural
+ * @returns Strings ids to values mapping. Plural
  * values are represented as arrays. If no config found for the
  * given marker then an empty mapping is returned.
  */
-export function parseAapt2Strings(rawOutput: string, configMarker: string): any;
+export declare function parseAapt2Strings(rawOutput: string, configMarker: string): StringRecord;
 /**
  * Parses apk strings from aapt tool output
  *
- * @param {string} rawOutput The actual tool output
- * @param {string} configMarker The config marker. Usually
+ * @param rawOutput The actual tool output
+ * @param configMarker The config marker. Usually
  * a language abbreviation or `(default)`
- * @returns {Object} Strings ids to values mapping. Plural
+ * @returns Strings ids to values mapping. Plural
  * values are represented as arrays. If no config found for the
  * given marker then an empty mapping is returned.
  */
-export function parseAaptStrings(rawOutput: string, configMarker: string): any;
-export const REMOTE_CACHE_ROOT: "/data/local/tmp/appium_cache";
-import { LRUCache } from 'lru-cache';
+export declare function parseAaptStrings(rawOutput: string, configMarker: string): StringRecord;
 //# sourceMappingURL=apk-utils.d.ts.map

package/build/lib/tools/apk-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apk-utils.d.ts","sourceRoot":"","sources":["../../../lib/tools/apk-utils.js"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AACH,iEALW,MAAM,YACN,OAAO,SAAS,EAAE,gBAAgB,GACjC,OAAO,CAAC,OAAO,CAAC,CA8B3B;AAED;;;;;;;GAOG;AACH,sFAJW,MAAM,SACN,OAAO,SAAS,EAAE,gBAAgB,iBAQ5C;AAED;;;;;;;;GAQG;AACH,iEALW,MAAM,YACN,OAAO,SAAS,EAAE,cAAc,GAC9B,OAAO,CAAC,MAAM,CAAC,CA+E3B;;IArFD;;;;;;;;OAQG;IACH,oDALW,MAAM,YACN,OAAO,SAAS,EAAE,cAAc,EAgF1C;IA3DK,oDAA2C;IAmC7C,mDAEE;;AAwBN;;;;;;;GAOG;AACH,gEAJW,MAAM,YACN,OAAO,SAAS,EAAE,cAAc,iBAmG1C;AAED;;;;;;;;GAQG;AACH,mFALW,MAAM,QACN,MAAM,OAAC,GAEL,OAAO,CAAC,OAAO,SAAS,EAAE,YAAY,CAAC,CAiEnD;AAED;;;;;;;;;;;GAWG;AACH,yEAPW,MAAM,QACN,MAAM,OAAC,YAEP,OAAO,SAAS,EAAE,uBAAuB,GAEvC,OAAO,CAAC,OAAO,SAAS,EAAE,sBAAsB,CAAC,CAyE7D;AAED;;;;;;;;;;;GAWG;AACH,8EARW,MAAM,aACN,MAAM,OAAC,YAEP,MAAM,OAAC,GAGN,OAAO,CAAC,OAAO,SAAS,EAAE,UAAU,CAAC,CAqEhD;AAED;;;;;;;GAOG;AACH,mEAJW,MAAM,GAEL,OAAO,CAAC,OAAO,SAAS,EAAE,OAAO,GAAC,EAAE,CAAC,CAsBhD;AAiCD;;;;;;;;;GASG;AACH,6CAPW,MAAM,gBACN,MAAM,OA8GhB;AAED;;;;;;;;;GASG;AACH,4CAPW,MAAM,gBACN,MAAM,OA0EhB;AAvuBD,gCAAiC,8BAA8B,CAAC;yBAFvC,WAAW"}
+{"version":3,"file":"apk-utils.d.ts","sourceRoot":"","sources":["../../../lib/tools/apk-utils.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,uBAAuB,EACvB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,YAAY,EACZ,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,iBAAiB,iCAAiC,CAAC;AAEhE;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,OAAO,CAAC,CA4B5G;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAE,IAAI,EAAE,GAAG,EAAE,eAAe,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAK3H;AAED;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CA8EzG;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkGtG;AAED;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,GAAG,IAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CA8D9H;AAED;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,GAAG,IAAW,EAAE,OAAO,GAAE,uBAA4B,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAwErK;AAED;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,GAAG,EACT,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAM,GAAG,IAAW,EAC9B,OAAO,GAAE,MAAM,GAAG,IAAW,GAC5B,OAAO,CAAC,UAAU,CAAC,CAiErB;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,EAAE,CAAC,CAqBnF;AAiCD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,YAAY,CAwGxF;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,YAAY,CAoEvF"}

package/build/lib/tools/apk-utils.js

@@ -60,10 +60,9 @@ exports.REMOTE_CACHE_ROOT = '/data/local/tmp/appium_cache';
 /**
  * Uninstall the given package from the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the package to be uninstalled.
- * @param {import('./types').UninstallOptions} [options={}] - The set of uninstall options.
- * @return {Promise<boolean>} True if the package was found on the device and
+ * @param pkg - The name of the package to be uninstalled.
+ * @param options - The set of uninstall options.
+ * @returns True if the package was found on the device and
  *                   successfully uninstalled.
  */
 async function uninstallApk(pkg, options = {}) {
@@ -83,7 +82,8 @@ async function uninstallApk(pkg, options = {}) {
         stdout = (await this.adbExec(cmd, { timeout: options.timeout })).trim();
     }
     catch (e) {
-        throw new Error(`Unable to uninstall APK. Original error: ${e.message}`);
+        const err = e;
+        throw new Error(`Unable to uninstall APK. Original error: ${err.message}`);
     }
     logger_js_1.log.debug(`'adb ${cmd.join(' ')}' command output: ${stdout}`);
     if (stdout.includes('Success')) {
@@ -96,13 +96,12 @@ async function uninstallApk(pkg, options = {}) {
 /**
  * Install the package after it was pushed to the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} apkPathOnDevice - The full path to the package on the device file system.
- * @param {import('./types').ShellExecOptions} [opts={}] Additional exec options.
- * @throws {error} If there was a failure during application install.
+ * @param apkPathOnDevice - The full path to the package on the device file system.
+ * @param opts - Additional exec options.
+ * @throws If there was a failure during application install.
  */
 async function installFromDevicePath(apkPathOnDevice, opts = {}) {
-    const stdout = /** @type {string} */ (await this.shell(['pm', 'install', '-r', apkPathOnDevice], opts));
+    const stdout = await this.shell(['pm', 'install', '-r', apkPathOnDevice], opts);
     if (stdout.includes('Failure')) {
         throw new Error(`Remote install failed: ${stdout}`);
     }
@@ -110,11 +109,10 @@ async function installFromDevicePath(apkPathOnDevice, opts = {}) {
 /**
  * Caches the given APK at a remote location to speed up further APK deployments.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} apkPath - Full path to the apk on the local FS
- * @param {import('./types').CachingOptions} [options={}] - Caching options
- * @returns {Promise<string>} - Full path to the cached apk on the remote file system
- * @throws {Error} if there was a failure while caching the app
+ * @param apkPath - Full path to the apk on the local FS
+ * @param options - Caching options
+ * @returns Full path to the cached apk on the remote file system
+ * @throws if there was a failure while caching the app
  */
 async function cacheApk(apkPath, options = {}) {
     const appHash = await support_1.fs.hash(apkPath);
@@ -146,7 +144,8 @@ async function cacheApk(apkPath, options = {}) {
             .filter(Boolean)));
     }
     catch (e) {
-        logger_js_1.log.debug(`Got an error '${e.message.trim()}' while getting the list of files in the cache. ` +
+        const err = e;
+        logger_js_1.log.debug(`Got an error '${err.message.trim()}' while getting the list of files in the cache. ` +
             `Assuming the cache does not exist yet`);
         await this.shell(['mkdir', '-p', exports.REMOTE_CACHE_ROOT]);
     }
@@ -170,27 +169,28 @@ async function cacheApk(apkPath, options = {}) {
     }
     if (!this.remoteAppsCache) {
         this.remoteAppsCache = new lru_cache_1.LRUCache({
-            max: /** @type {number} */ (this.remoteAppsCacheLimit),
+            max: this.remoteAppsCacheLimit,
         });
     }
     // Cleanup the invalid entries from the cache
     lodash_1.default.difference([...this.remoteAppsCache.keys()], remoteCachedFiles.map(toHash))
-        .forEach((hash) => ( /** @type {LRUCache} */(this.remoteAppsCache)).delete(hash));
+        .forEach((hash) => this.remoteAppsCache.delete(hash));
     // Bump the cache record for the recently cached item
     this.remoteAppsCache.set(appHash, remotePath);
     // If the remote cache exceeds this.remoteAppsCacheLimit, remove the least recently used entries
     const entriesToCleanup = remoteCachedFiles
         .map((x) => path_1.default.posix.join(exports.REMOTE_CACHE_ROOT, x))
-        .filter((x) => !( /** @type {LRUCache} */(this.remoteAppsCache)).has(toHash(x)))
-        .slice(( /** @type {number} */(this.remoteAppsCacheLimit)) - [...this.remoteAppsCache.keys()].length);
+        .filter((x) => !this.remoteAppsCache.has(toHash(x)))
+        .slice(this.remoteAppsCacheLimit - [...this.remoteAppsCache.keys()].length);
     if (!lodash_1.default.isEmpty(entriesToCleanup)) {
         try {
             await this.shell(['rm', '-f', ...entriesToCleanup]);
             logger_js_1.log.debug(`Deleted ${entriesToCleanup.length} expired application cache entries`);
         }
         catch (e) {
+            const err = e;
             logger_js_1.log.warn(`Cannot delete ${entriesToCleanup.length} expired application cache entries. ` +
-                `Original error: ${e.message}`);
+                `Original error: ${err.message}`);
         }
     }
     return remotePath;
@@ -198,10 +198,9 @@ async function cacheApk(apkPath, options = {}) {
 /**
  * Install the package from the local file system.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appPath - The full path to the local package.
- * @param {import('./types').InstallOptions} [options={}] - The set of installation options.
- * @throws {Error} If an unexpected error happens during install.
+ * @param appPath - The full path to the local package.
+ * @param options - The set of installation options.
+ * @throws If an unexpected error happens during install.
  */
 async function install(appPath, options = {}) {
     if (appPath.endsWith(helpers_js_1.APKS_EXTENSION)) {
@@ -230,7 +229,7 @@ async function install(appPath, options = {}) {
     ];
     let performAppInstall = async () => await this.adbExec(installCmd, installOpts);
     // this.remoteAppsCacheLimit <= 0 means no caching should be applied
-    let shouldCacheApp = ( /** @type {number} */(this.remoteAppsCacheLimit)) > 0;
+    let shouldCacheApp = this.remoteAppsCacheLimit > 0;
     if (shouldCacheApp) {
         shouldCacheApp = !(await this.isStreamedInstallSupported());
         if (!shouldCacheApp) {
@@ -269,15 +268,16 @@ async function install(appPath, options = {}) {
             };
         }
         catch (e) {
-            logger_js_1.log.debug(e);
-            logger_js_1.log.warn(`There was a failure while caching '${appPath}': ${e.message}`);
+            const err = e;
+            logger_js_1.log.debug(err);
+            logger_js_1.log.warn(`There was a failure while caching '${appPath}': ${err.message}`);
             logger_js_1.log.warn('Falling back to the default installation procedure');
             await clearCache();
         }
     }
     try {
         const timer = new support_1.timing.Timer().start();
-        const output = /** @type {string} */ (await performAppInstall());
+        const output = await performAppInstall();
         logger_js_1.log.info(`The installation of '${path_1.default.basename(appPath)}' took ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
         const truncatedOutput = (!lodash_1.default.isString(output) || output.length <= 300) ?
             output : `${output.substring(0, 150)}...${output.substring(output.length - 150)}`;
@@ -292,10 +292,11 @@ async function install(appPath, options = {}) {
         }
     }
     catch (err) {
+        const error = err;
         // on some systems this will throw an error if the app already
         // exists
-        if (!err.message.includes('INSTALL_FAILED_ALREADY_EXISTS')) {
-            throw err;
+        if (!error.message.includes('INSTALL_FAILED_ALREADY_EXISTS')) {
+            throw error;
         }
         logger_js_1.log.debug(`Application '${appPath}' already installed. Continuing.`);
     }
@@ -303,18 +304,16 @@ async function install(appPath, options = {}) {
 /**
  * Retrieves the current installation state of the particular application
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appPath - Full path to the application
- * @param {string?} [pkg=null] - Package identifier. If omitted then the script will
+ * @param appPath - Full path to the application
+ * @param pkg - Package identifier. If omitted then the script will
  * try to extract it on its own
- * @returns {Promise<import('./types').InstallState>} One of `APP_INSTALL_STATE` constants
+ * @returns One of `APP_INSTALL_STATE` constants
  */
 async function getApplicationInstallState(appPath, pkg = null) {
     let apkInfo = null;
     if (!pkg) {
-        apkInfo = await this.getApkInfo(appPath);
-        // @ts-ignore We are ok if this prop does not exist
-        pkg = apkInfo.name;
+        apkInfo = (await this.getApkInfo(appPath));
+        pkg = apkInfo?.name;
     }
     if (!pkg) {
         logger_js_1.log.warn(`Cannot read the package name of '${appPath}'`);
@@ -327,10 +326,10 @@ async function getApplicationInstallState(appPath, pkg = null) {
     }
     const pkgVersionName = semver.valid(semver.coerce(pkgVersionNameStr));
     if (!apkInfo) {
-        apkInfo = await this.getApkInfo(appPath);
+        apkInfo = (await this.getApkInfo(appPath));
     }
     // @ts-ignore We validate the values below
-    const { versionCode: apkVersionCode, versionName: apkVersionNameStr } = apkInfo;
+    const { versionCode: apkVersionCode, versionName: apkVersionNameStr } = apkInfo || {};
     const apkVersionName = semver.valid(semver.coerce(apkVersionNameStr));
     if (!lodash_1.default.isInteger(apkVersionCode) || !lodash_1.default.isInteger(pkgVersionCode)) {
         logger_js_1.log.warn(`Cannot read version codes of '${appPath}' and/or '${pkg}'`);
@@ -340,7 +339,7 @@ async function getApplicationInstallState(appPath, pkg = null) {
         }
     }
     if (lodash_1.default.isInteger(apkVersionCode) && lodash_1.default.isInteger(pkgVersionCode)) {
-        if (( /** @type {number} */(pkgVersionCode)) > apkVersionCode) {
+        if (pkgVersionCode > apkVersionCode) {
             logger_js_1.log.debug(`The version code of the installed '${pkg}' is greater than the application version code (${pkgVersionCode} > ${apkVersionCode})`);
             return this.APP_INSTALL_STATE.NEWER_VERSION_INSTALLED;
         }
@@ -371,13 +370,11 @@ async function getApplicationInstallState(appPath, pkg = null) {
  * Install the package from the local file system or upgrade it if an older
  * version of the same package is already installed.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appPath - The full path to the local package.
- * @param {string?} [pkg=null] - The name of the installed package. The method will
+ * @param appPath - The full path to the local package.
+ * @param pkg - The name of the installed package. The method will
  * perform faster if it is set.
- * @param {import('./types').InstallOrUpgradeOptions} [options={}] - Set of install options.
- * @throws {Error} If an unexpected error happens during install.
- * @returns {Promise<import('./types').InstallOrUpgradeResult>}
+ * @param options - Set of install options.
+ * @throws If an unexpected error happens during install.
  */
 async function installOrUpgrade(appPath, pkg = null, options = {}) {
     if (!pkg) {
@@ -394,7 +391,7 @@ async function installOrUpgrade(appPath, pkg = null, options = {}) {
     const appState = await this.getApplicationInstallState(appPath, pkg);
     let wasUninstalled = false;
     const uninstallPackage = async () => {
-        if (!await this.uninstallApk(/** @type {string} */ (pkg), { skipInstallCheck: true })) {
+        if (!await this.uninstallApk(pkg, { skipInstallCheck: true })) {
             throw new Error(`'${pkg}' package cannot be uninstalled`);
         }
         wasUninstalled = true;
@@ -438,7 +435,8 @@ async function installOrUpgrade(appPath, pkg = null, options = {}) {
         await this.install(appPath, { ...options, replace: true });
     }
     catch (err) {
-        logger_js_1.log.warn(`Cannot install/upgrade '${pkg}' because of '${err.message}'. Trying full reinstall`);
+        const error = err;
+        logger_js_1.log.warn(`Cannot install/upgrade '${pkg}' because of '${error.message}'. Trying full reinstall`);
         await uninstallPackage();
         await this.install(appPath, { ...options, replace: false });
     }
@@ -450,14 +448,12 @@ async function installOrUpgrade(appPath, pkg = null, options = {}) {
 /**
  * Extract string resources from the given package on local file system.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appPath - The full path to the .apk(s) package.
- * @param {string?} [language=null] - The name of the language to extract the resources for.
+ * @param appPath - The full path to the .apk(s) package.
+ * @param language - The name of the language to extract the resources for.
  * The default language is used if this equals to `null`
- * @param {string?} [outRoot=null] - The name of the destination folder on the local file system to
+ * @param outRoot - The name of the destination folder on the local file system to
  * store the extracted file to. If not provided then the `localPath` property in the returned object
  * will be undefined.
- * @return {Promise<import('./types').ApkStrings>}
  */
 async function extractStringsFromApk(appPath, language = null, outRoot = null) {
     logger_js_1.log.debug(`Extracting strings from for language: ${language || 'default'}`);
@@ -470,35 +466,37 @@ async function extractStringsFromApk(appPath, language = null, outRoot = null) {
     try {
         await this.initAapt();
         configMarker = await formatConfigMarker(async () => {
-            const { stdout } = await (0, teen_process_1.exec)(( /** @type {import('./types').StringRecord} */(this.binaries)).aapt, [
+            const { stdout } = await (0, teen_process_1.exec)(this.binaries.aapt, [
                 'd', 'configurations', appPath,
             ]);
             return lodash_1.default.uniq(stdout.split(os_1.default.EOL));
         }, language, '(default)');
-        const { stdout } = await (0, teen_process_1.exec)(( /** @type {import('./types').StringRecord} */(this.binaries)).aapt, [
+        const { stdout } = await (0, teen_process_1.exec)(this.binaries.aapt, [
             'd', '--values', 'resources', appPath,
         ]);
         apkStrings = parseAaptStrings(stdout, configMarker);
     }
     catch (e) {
+        const err = e;
         logger_js_1.log.debug('Cannot extract resources using aapt. Trying aapt2. ' +
-            `Original error: ${e.stderr || e.message}`);
+            `Original error: ${err.stderr || err.message}`);
         await this.initAapt2();
         configMarker = await formatConfigMarker(async () => {
-            const { stdout } = await (0, teen_process_1.exec)(( /** @type {import('./types').StringRecord} */(this.binaries)).aapt2, [
+            const { stdout } = await (0, teen_process_1.exec)(this.binaries.aapt2, [
                 'd', 'configurations', appPath,
             ]);
             return lodash_1.default.uniq(stdout.split(os_1.default.EOL));
         }, language, '');
         try {
-            const { stdout } = await (0, teen_process_1.exec)(( /** @type {import('./types').StringRecord} */(this.binaries)).aapt2, [
+            const { stdout } = await (0, teen_process_1.exec)(this.binaries.aapt2, [
                 'd', 'resources', appPath,
             ]);
             apkStrings = parseAapt2Strings(stdout, configMarker);
         }
         catch (e) {
+            const error = e;
             throw new Error(`Cannot extract resources from '${originalAppPath}'. ` +
-                `Original error: ${e.message}`);
+                `Original error: ${error.message}`);
         }
     }
     if (lodash_1.default.isEmpty(apkStrings)) {
@@ -520,10 +518,9 @@ async function extractStringsFromApk(appPath, language = null, outRoot = null) {
 /**
  * Get the package info from local apk file.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appPath - The full path to existing .apk(s) package on the local
+ * @param appPath - The full path to existing .apk(s) package on the local
  *                           file system.
- * @return {Promise<import('./types').AppInfo|{}>} The parsed application information.
+ * @returns The parsed application information.
  */
 async function getApkInfo(appPath) {
     if (!await support_1.fs.exists(appPath)) {
@@ -541,7 +538,8 @@ async function getApkInfo(appPath) {
         };
     }
     catch (e) {
-        logger_js_1.log.warn(`Error '${e.message}' while getting badging info`);
+        const err = e;
+        logger_js_1.log.warn(`Error '${err.message}' while getting badging info`);
     }
     return {};
 }
@@ -550,11 +548,11 @@ async function getApkInfo(appPath) {
  * Formats the config marker, which is then passed to parse.. methods
  * to make it compatible with resource formats generated by aapt(2) tool
  *
- * @param {Function} configsGetter The function whose result is a list
+ * @param configsGetter The function whose result is a list
  * of apk configs
- * @param {string?} desiredMarker The desired config marker value
- * @param {string} defaultMarker The default config marker value
- * @return {Promise<string>} The formatted config marker
+ * @param desiredMarker The desired config marker value
+ * @param defaultMarker The default config marker value
+ * @returns The formatted config marker
  */
 async function formatConfigMarker(configsGetter, desiredMarker, defaultMarker) {
     let configMarker = desiredMarker || defaultMarker;
@@ -578,10 +576,10 @@ async function formatConfigMarker(configsGetter, desiredMarker, defaultMarker) {
 /**
  * Parses apk strings from aapt2 tool output
  *
- * @param {string} rawOutput The actual tool output
- * @param {string} configMarker The config marker. Usually
+ * @param rawOutput The actual tool output
+ * @param configMarker The config marker. Usually
  * a language abbreviation or an empty string for the default one
- * @returns {Object} Strings ids to values mapping. Plural
+ * @returns Strings ids to values mapping. Plural
  * values are represented as arrays. If no config found for the
  * given marker then an empty mapping is returned.
  */
@@ -669,7 +667,7 @@ function parseAapt2Strings(rawOutput, configMarker) {
                     lineIndex = idx;
                     if (lodash_1.default.isString(content)) {
                         apkStrings[currentResourceId] = [
-                            ...(apkStrings[currentResourceId] || []),
+                            ...(Array.isArray(apkStrings[currentResourceId]) ? apkStrings[currentResourceId] : []),
                             content,
                         ];
                     }
@@ -691,10 +689,10 @@ function parseAapt2Strings(rawOutput, configMarker) {
 /**
  * Parses apk strings from aapt tool output
  *
- * @param {string} rawOutput The actual tool output
- * @param {string} configMarker The config marker. Usually
+ * @param rawOutput The actual tool output
+ * @param configMarker The config marker. Usually
  * a language abbreviation or `(default)`
- * @returns {Object} Strings ids to values mapping. Plural
+ * @returns Strings ids to values mapping. Plural
  * values are represented as arrays. If no config found for the
  * given marker then an empty mapping is returned.
  */
@@ -752,7 +750,7 @@ function parseAaptStrings(rawOutput, configMarker) {
             const match = quotedStringPattern.exec(trimmedLine);
             if (match) {
                 apkStrings[currentResourceId] = [
-                    ...(apkStrings[currentResourceId] || []),
+                    ...(Array.isArray(apkStrings[currentResourceId]) ? apkStrings[currentResourceId] : []),
                     normalizeStringMatch(match[0]),
                 ];
             }