appium-adb 14.0.4 → 14.0.6

package/build/lib/tools/app-commands.js

@@ -40,7 +40,7 @@ const support_1 = require("@appium/support");
 const logger_js_1 = require("../logger.js");
 const asyncbox_1 = require("asyncbox");
 const node_path_1 = __importDefault(require("node:path"));
-/** @type {import('./types').StringRecord<import('./types').InstallState>} */
+// Constants
 exports.APP_INSTALL_STATE = {
     UNKNOWN: 'unknown',
     NOT_INSTALLED: 'notInstalled',
@@ -57,13 +57,13 @@ const MIN_API_LEVEL_WITH_PERMS_SUPPORT = 23;
 const RESOLVER_ACTIVITY_NAME = 'android/com.android.internal.app.ResolverActivity';
 const MAIN_ACTION = 'android.intent.action.MAIN';
 const LAUNCHER_CATEGORY = 'android.intent.category.LAUNCHER';
+// Public methods
 /**
  * Verify whether the given argument is a
  * valid class name.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} classString - The actual class name to be verified.
- * @return {boolean} The result of Regexp.exec operation
+ * @param classString - The actual class name to be verified.
+ * @returns The result of Regexp.exec operation
  * or _null_ if no matches are found.
  */
 function isValidClass(classString) {
@@ -75,10 +75,9 @@ function isValidClass(classString) {
  * given package. It is expected the package is already installed on
  * the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The target package identifier
- * @param {import('./types').ResolveActivityOptions} opts
- * @return {Promise<string>} Fully qualified name of the launchable activity
+ * @param pkg - The target package identifier
+ * @param opts - Options for resolving the activity
+ * @returns Fully qualified name of the launchable activity
  * @throws {Error} If there was an error while resolving the activity name
  */
 async function resolveLaunchableActivity(pkg, opts = {}) {
@@ -97,10 +96,10 @@ async function resolveLaunchableActivity(pkg, opts = {}) {
         try {
             const tmpApp = await this.pullApk(pkg, tmpRoot);
             const { apkActivity } = await this.packageAndLaunchActivityFromManifest(tmpApp);
-            return /** @type {string} */ (apkActivity);
+            return apkActivity;
         }
         catch (e) {
-            const err = /** @type {Error} */ (e);
+            const err = e;
             logger_js_1.log.debug(err.stack);
             logger_js_1.log.warn(`Unable to resolve the launchable activity of '${pkg}'. ` +
                 `The very first match of the dumpsys output is going to be used. ` +
@@ -123,30 +122,28 @@ async function resolveLaunchableActivity(pkg, opts = {}) {
 }
 /**
  * Forcefully stops the app and puts it in the "stopped" state.
- * Android treats a “stopped” app as if it was never launched since boot:
+ * Android treats a "stopped" app as if it was never launched since boot:
  * - It cannot receive broadcast intents (except for explicit ones).
  * - Scheduled jobs, alarms, and services are cancelled.
- * - The app won’t restart until the user explicitly launches it again.
- * It’s the same as when a user swipes an app away from Settings → Apps → Force Stop.
+ * - The app won't restart until the user explicitly launches it again.
+ * It's the same as when a user swipes an app away from Settings → Apps → Force Stop.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be stopped.
- * @return {Promise<string>} The output of the corresponding adb command.
+ * @param pkg - The package name to be stopped.
+ * @returns The output of the corresponding adb command.
  */
 async function forceStop(pkg) {
     return await this.shell(['am', 'force-stop', pkg]);
 }
 /**
- * Gracefully kills the app’s process, similar to how Android would do it
+ * Gracefully kills the app's process, similar to how Android would do it
  * automatically when low on memory.
- * It only kills the process, without changing the app’s “stopped” state.
+ * It only kills the process, without changing the app's "stopped" state.
  * Background services or broadcast receivers may restart soon after,
  * if they are still scheduled or registered.
  * No data or state (like alarms, jobs, etc.) are cleared.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be stopped.
- * @return {Promise<string>} The output of the corresponding adb command.
+ * @param pkg - The package name to be stopped.
+ * @returns The output of the corresponding adb command.
  */
 async function killPackage(pkg) {
     return await this.shell(['am', 'kill', pkg]);
@@ -155,9 +152,8 @@ async function killPackage(pkg) {
  * Clear the user data of the particular application on the device
  * under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be cleared.
- * @return {Promise<string>} The output of the corresponding adb command.
+ * @param pkg - The package name to be cleared.
+ * @returns The output of the corresponding adb command.
  */
 async function clear(pkg) {
     return await this.shell(['pm', 'clear', pkg]);
@@ -167,9 +163,8 @@ async function clear(pkg) {
  * This method is only useful on Android 6.0+ and for applications
  * that support components-based permissions setting.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string} [apk] - The path to the actual apk file.
+ * @param pkg - The package name to be processed.
+ * @param apk - The path to the actual apk file.
  * @throws {Error} If there was an error while granting permissions
  */
 async function grantAllPermissions(pkg, apk) {
@@ -225,9 +220,8 @@ async function grantAllPermissions(pkg, apk) {
  * This call is more performant than `grantPermission` one, since it combines
  * multiple `adb shell` calls into a single command.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {Array<string>} permissions - The list of permissions to be granted.
+ * @param pkg - The package name to be processed.
+ * @param permissions - The list of permissions to be granted.
  * @throws {Error} If there was an error while changing permissions.
  */
 async function grantPermissions(pkg, permissions) {
@@ -240,7 +234,7 @@ async function grantPermissions(pkg, permissions) {
         await this.shellChunks((perm) => ['pm', 'grant', pkg, perm], permissions);
     }
     catch (e) {
-        const err = /** @type {import('teen_process').ExecError} */ (e);
+        const err = e;
         if (!IGNORED_PERM_ERRORS.some((pattern) => pattern.test(err.stderr || err.message))) {
             throw err;
         }
@@ -249,9 +243,8 @@ async function grantPermissions(pkg, permissions) {
 /**
  * Grant single permission for the particular package.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string} permission - The full name of the permission to be granted.
+ * @param pkg - The package name to be processed.
+ * @param permission - The full name of the permission to be granted.
  * @throws {Error} If there was an error while changing permissions.
  */
 async function grantPermission(pkg, permission) {
@@ -259,7 +252,7 @@ async function grantPermission(pkg, permission) {
         await this.shell(['pm', 'grant', pkg, permission]);
     }
     catch (e) {
-        const err = /** @type {import('teen_process').ExecError} */ (e);
+        const err = e;
         if (!NOT_CHANGEABLE_PERM_ERROR.test(err.stderr || err.message)) {
             throw err;
         }
@@ -268,9 +261,8 @@ async function grantPermission(pkg, permission) {
 /**
  * Revoke single permission from the particular package.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string} permission - The full name of the permission to be revoked.
+ * @param pkg - The package name to be processed.
+ * @param permission - The full name of the permission to be revoked.
  * @throws {Error} If there was an error while changing permissions.
  */
 async function revokePermission(pkg, permission) {
@@ -278,7 +270,7 @@ async function revokePermission(pkg, permission) {
         await this.shell(['pm', 'revoke', pkg, permission]);
     }
     catch (e) {
-        const err = /** @type {import('teen_process').ExecError} */ (e);
+        const err = e;
         if (!NOT_CHANGEABLE_PERM_ERROR.test(err.stderr || err.message)) {
             throw err;
         }
@@ -287,11 +279,10 @@ async function revokePermission(pkg, permission) {
 /**
  * Retrieve the list of granted permissions for the particular package.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string?} [cmdOutput=null] - Optional parameter containing command output of
+ * @param pkg - The package name to be processed.
+ * @param cmdOutput - Optional parameter containing command output of
  * _dumpsys package_ command. It may speed up the method execution.
- * @return {Promise<string[]>} The list of granted permissions or an empty list.
+ * @returns The list of granted permissions or an empty list.
  * @throws {Error} If there was an error while changing permissions.
  */
 async function getGrantedPermissions(pkg, cmdOutput = null) {
@@ -302,11 +293,10 @@ async function getGrantedPermissions(pkg, cmdOutput = null) {
 /**
  * Retrieve the list of denied permissions for the particular package.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string?} [cmdOutput=null] - Optional parameter containing command output of
+ * @param pkg - The package name to be processed.
+ * @param cmdOutput - Optional parameter containing command output of
  * _dumpsys package_ command. It may speed up the method execution.
- * @return {Promise<string[]>} The list of denied permissions or an empty list.
+ * @returns The list of denied permissions or an empty list.
  */
 async function getDeniedPermissions(pkg, cmdOutput = null) {
     logger_js_1.log.debug('Retrieving denied permissions');
@@ -316,11 +306,10 @@ async function getDeniedPermissions(pkg, cmdOutput = null) {
 /**
  * Retrieve the list of requested permissions for the particular package.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string?} [cmdOutput=null] - Optional parameter containing command output of
+ * @param pkg - The package name to be processed.
+ * @param cmdOutput - Optional parameter containing command output of
  *                                    _dumpsys package_ command. It may speed up the method execution.
- * @return {Promise<string[]>} The list of requested permissions or an empty list.
+ * @returns The list of requested permissions or an empty list.
  */
 async function getReqPermissions(pkg, cmdOutput = null) {
     logger_js_1.log.debug('Retrieving requested permissions');
@@ -330,8 +319,7 @@ async function getReqPermissions(pkg, cmdOutput = null) {
 /**
  * Stop the particular package if it is running and clears its application data.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
+ * @param pkg - The package name to be processed.
  */
 async function stopAndClear(pkg) {
     try {
@@ -339,16 +327,15 @@ async function stopAndClear(pkg) {
         await this.clear(pkg);
     }
     catch (e) {
-        const err = /** @type {Error} */ (e);
+        const err = e;
         throw new Error(`Cannot stop and clear ${pkg}. Original error: ${err.message}`);
     }
 }
 /**
  * Get the package info from the installed application.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the installed package.
- * @return {Promise<import('./types').AppInfo>} The parsed application information.
+ * @param pkg - The name of the installed package.
+ * @returns The parsed application information.
  */
 async function getPackageInfo(pkg) {
     logger_js_1.log.debug(`Getting package info for '${pkg}'`);
@@ -358,8 +345,9 @@ async function getPackageInfo(pkg) {
         stdout = await this.shell(['dumpsys', 'package', pkg]);
     }
     catch (err) {
-        logger_js_1.log.debug(err.stack);
-        logger_js_1.log.warn(`Got an unexpected error while dumping package info: ${err.message}`);
+        const error = err;
+        logger_js_1.log.debug(error.stack);
+        logger_js_1.log.warn(`Got an unexpected error while dumping package info: ${error.message}`);
         return result;
     }
     const installedPattern = new RegExp(`^\\s*Package\\s+\\[${lodash_1.default.escapeRegExp(pkg)}\\][^:]+:$`, 'm');
@@ -380,10 +368,9 @@ async function getPackageInfo(pkg) {
 /**
  * Fetches base.apk of the given package to the local file system
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg The package identifier (must be already installed on the device)
- * @param {string} tmpDir The destination folder path
- * @returns {Promise<string>} Full path to the downloaded file
+ * @param pkg - The package identifier (must be already installed on the device)
+ * @param tmpDir - The destination folder path
+ * @returns Full path to the downloaded file
  * @throws {Error} If there was an error while fetching the .apk
  */
 async function pullApk(pkg, tmpDir) {
@@ -403,8 +390,7 @@ async function pullApk(pkg, tmpDir) {
  * The action literally simulates
  * clicking the corresponding application icon on the dashboard.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appId - Application package identifier
+ * @param appId - Application package identifier
  * @throws {Error} If the app cannot be activated
  */
 async function activateApp(appId) {
@@ -424,7 +410,8 @@ async function activateApp(appId) {
             logger_js_1.log.debug(`Command stdout: ${output}`);
         }
         catch (e) {
-            throw logger_js_1.log.errorWithException(`Cannot activate '${appId}'. Original error: ${e.message}`);
+            const error = e;
+            throw logger_js_1.log.errorWithException(`Cannot activate '${appId}'. Original error: ${error.message}`);
         }
         if (output.includes('monkey aborted')) {
             throw logger_js_1.log.errorWithException(`Cannot activate '${appId}'. Are you sure it is installed?`);
@@ -456,15 +443,13 @@ async function activateApp(appId) {
 /**
  * Check whether the particular package is present on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the package to check.
- * @param {import('./types').IsAppInstalledOptions} [opts={}]
- * @return {Promise<boolean>} True if the package is installed.
+ * @param pkg - The name of the package to check.
+ * @param opts - Options for checking installation
+ * @returns True if the package is installed.
  */
 async function isAppInstalled(pkg, opts = {}) {
     const { user, } = opts;
     logger_js_1.log.debug(`Getting install status for ${pkg}`);
-    /** @type {boolean} */
     let isInstalled;
     if (await this.getApiLevel() < 26) {
         try {
@@ -485,14 +470,14 @@ async function isAppInstalled(pkg, opts = {}) {
         if (support_1.util.hasValue(user)) {
             cmd.push('--user', user);
         }
-        /** @type {string} */
         let stdout;
         try {
             stdout = await this.shell(cmd);
         }
         catch (e) {
+            const error = e;
             // https://github.com/appium/appium-uiautomator2-driver/issues/810
-            if (lodash_1.default.includes(e.stderr || e.stdout || e.message, 'access user') && lodash_1.default.isEmpty(user)) {
+            if (lodash_1.default.includes(error.stderr || error.stdout || error.message, 'access user') && lodash_1.default.isEmpty(user)) {
                 stdout = await this.shell([...cmd, '--user', '0']);
             }
             else {
@@ -507,10 +492,9 @@ async function isAppInstalled(pkg, opts = {}) {
 /**
  * Start the particular URI on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} uri - The name of URI to start.
- * @param {string?} [pkg=null] - The name of the package to start the URI with.
- * @param {import('./types').StartUriOptions} [opts={}]
+ * @param uri - The name of URI to start.
+ * @param pkg - The name of the package to start the URI with.
+ * @param opts - Options for starting the URI
  */
 async function startUri(uri, pkg = null, opts = {}) {
     const { waitForLaunch = true, } = opts;
@@ -538,51 +522,49 @@ async function startUri(uri, pkg = null, opts = {}) {
 /**
  * Start the particular package/activity on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {import('./types').StartAppOptions} startAppOptions - Startup options mapping.
- * @return {Promise<string>} The output of the corresponding adb command.
+ * @param startAppOptions - Startup options mapping.
+ * @returns The output of the corresponding adb command.
  * @throws {Error} If there is an error while executing the activity
  */
 async function startApp(startAppOptions) {
     if (!startAppOptions.pkg || !(startAppOptions.activity || startAppOptions.action)) {
         throw new Error('pkg, and activity or intent action, are required to start an application');
     }
-    startAppOptions = lodash_1.default.clone(startAppOptions);
-    if (startAppOptions.activity) {
-        startAppOptions.activity = startAppOptions.activity.replace('$', '\\$');
+    const options = lodash_1.default.clone(startAppOptions);
+    if (options.activity) {
+        options.activity = options.activity.replace('$', '\\$');
     }
     // initializing defaults
-    lodash_1.default.defaults(startAppOptions, {
-        waitPkg: startAppOptions.pkg,
+    lodash_1.default.defaults(options, {
+        waitPkg: options.pkg,
         waitForLaunch: true,
         waitActivity: false,
         retry: true,
         stopApp: true
     });
     // preventing null waitpkg
-    startAppOptions.waitPkg = startAppOptions.waitPkg || startAppOptions.pkg;
+    options.waitPkg = options.waitPkg || options.pkg;
     const apiLevel = await this.getApiLevel();
-    const cmd = buildStartCmd(startAppOptions, apiLevel);
-    const intentName = `${startAppOptions.action}${startAppOptions.optionalIntentArguments
-        ? ' ' + startAppOptions.optionalIntentArguments
+    const cmd = buildStartCmd(options, apiLevel);
+    const intentName = `${options.action}${options.optionalIntentArguments
+        ? ' ' + options.optionalIntentArguments
         : ''}`;
     try {
         const shellOpts = {};
-        if (lodash_1.default.isInteger(startAppOptions.waitDuration)
-            // @ts-ignore waitDuration is an integer here
-            && startAppOptions.waitDuration >= 0) {
-            shellOpts.timeout = startAppOptions.waitDuration;
+        if (options.waitDuration !== undefined && lodash_1.default.isInteger(options.waitDuration)
+            && options.waitDuration >= 0) {
+            shellOpts.timeout = options.waitDuration;
         }
         const stdout = await this.shell(cmd, shellOpts);
         if (stdout.includes('Error: Activity class') && stdout.includes('does not exist')) {
-            if (startAppOptions.retry && startAppOptions.activity && !startAppOptions.activity.startsWith('.')) {
+            if (options.retry && options.activity && !options.activity.startsWith('.')) {
                 logger_js_1.log.debug(`We tried to start an activity that doesn't exist, ` +
-                    `retrying with '.${startAppOptions.activity}' activity name`);
-                startAppOptions.activity = `.${startAppOptions.activity}`;
-                startAppOptions.retry = false;
-                return await this.startApp(startAppOptions);
+                    `retrying with '.${options.activity}' activity name`);
+                options.activity = `.${options.activity}`;
+                options.retry = false;
+                return await this.startApp(options);
             }
-            throw new Error(`Activity name '${startAppOptions.activity}' used to start the app doesn't ` +
+            throw new Error(`Activity name '${options.activity}' used to start the app doesn't ` +
                 `exist or cannot be launched! Make sure it exists and is a launchable activity`);
         }
         else if (stdout.includes('Error: Intent does not match any activities')
@@ -592,25 +574,26 @@ async function startApp(startAppOptions) {
         }
         else if (stdout.includes('java.lang.SecurityException')) {
             // if the app is disabled on a real device it will throw a security exception
-            throw new Error(`The permission to start '${startAppOptions.activity}' activity has been denied.` +
+            throw new Error(`The permission to start '${options.activity}' activity has been denied.` +
                 `Make sure the activity/package names are correct.`);
         }
-        if (startAppOptions.waitActivity) {
-            await this.waitForActivity(startAppOptions.waitPkg, startAppOptions.waitActivity, startAppOptions.waitDuration);
+        if (options.waitActivity) {
+            await this.waitForActivity(options.waitPkg, options.waitActivity, options.waitDuration);
         }
         return stdout;
     }
     catch (e) {
-        const appDescriptor = startAppOptions.pkg || intentName;
+        const error = e;
+        const appDescriptor = options.pkg || intentName;
         throw new Error(`Cannot start the '${appDescriptor}' application. ` +
             `Consider checking the driver's troubleshooting documentation. ` +
-            `Original error: ${e.message}`);
+            `Original error: ${error.message}`);
     }
 }
 /**
  * Helper method to call `adb dumpsys window windows/displays`
- * @this {import('../adb.js').ADB}
- * @returns {Promise<string>}
+ *
+ * @returns The output of the dumpsys command
  */
 async function dumpWindows() {
     const apiLevel = await this.getApiLevel();
@@ -622,8 +605,7 @@ async function dumpWindows() {
 /**
  * Get the name of currently focused package and activity.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<import('./types').PackageActivityInfo>}
+ * @returns The focused package and activity information
  * @throws {Error} If there is an error while parsing the data.
  */
 async function getFocusedPackageAndActivity() {
@@ -633,18 +615,16 @@ async function getFocusedPackageAndActivity() {
         stdout = await this.dumpWindows();
     }
     catch (e) {
-        throw new Error(`Could not retrieve the currently focused package and activity. Original error: ${e.message}`);
+        const error = e;
+        throw new Error(`Could not retrieve the currently focused package and activity. Original error: ${error.message}`);
     }
     const nullFocusedAppRe = /^\s*mFocusedApp=null/m;
     // https://regex101.com/r/xZ8vF7/1
     const focusedAppRe = new RegExp('^\\s*mFocusedApp.+Record\\{.*\\s([^\\s\\/\\}]+)\\/([^\\s\\/\\}\\,]+)\\,?(\\s[^\\s\\/\\}]+)*\\}', 'mg');
     const nullCurrentFocusRe = /^\s*mCurrentFocus=null/m;
     const currentFocusAppRe = new RegExp('^\\s*mCurrentFocus.+\\{.+\\s([^\\s\\/]+)\\/([^\\s]+)\\b', 'mg');
-    /** @type {import('./types').PackageActivityInfo[]} */
     const focusedAppCandidates = [];
-    /** @type {import('./types').PackageActivityInfo[]} */
     const currentFocusAppCandidates = [];
-    /** @type {[import('./types').PackageActivityInfo[], RegExp][]} */
     const pairs = [
         [focusedAppCandidates, focusedAppRe],
         [currentFocusAppCandidates, currentFocusAppRe]
@@ -688,24 +668,22 @@ async function getFocusedPackageAndActivity() {
 /**
  * Wait for the given activity to be focused/non-focused.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the package to wait for.
- * @param {string} activity - The name of the activity, belonging to that package,
+ * @param pkg - The name of the package to wait for.
+ * @param activity - The name of the activity, belonging to that package,
  *                            to wait for.
- * @param {boolean} waitForStop - Whether to wait until the activity is focused (true)
+ * @param waitForStop - Whether to wait until the activity is focused (true)
  *                                or is not focused (false).
- * @param {number} [waitMs=20000] - Number of milliseconds to wait before timeout occurs.
- * @throws {error} If timeout happens.
+ * @param waitMs - Number of milliseconds to wait before timeout occurs.
+ * @throws {Error} If timeout happens.
  */
 async function waitForActivityOrNot(pkg, activity, waitForStop, waitMs = 20000) {
     if (!pkg || !activity) {
         throw new Error('Package and activity required.');
     }
-    const splitNames = (/** @type {string} */ names) => names.split(',').map(lodash_1.default.trim);
+    const splitNames = (names) => names.split(',').map(lodash_1.default.trim);
     const allPackages = splitNames(pkg);
     const allActivities = splitNames(activity);
-    const toFullyQualifiedActivityName = (/** @type {string} */ prefix, /** @type {string} */ suffix) => `${prefix}${suffix}`.replace(/\/\.?/g, '.').replace(/\.{2,}/g, '.');
-    /** @type {Set<string>} */
+    const toFullyQualifiedActivityName = (prefix, suffix) => `${prefix}${suffix}`.replace(/\/\.?/g, '.').replace(/\.{2,}/g, '.');
     const possibleActivityNamesSet = new Set();
     for (const oneActivity of allActivities) {
         if (oneActivity.startsWith('.')) {
@@ -741,7 +719,8 @@ async function waitForActivityOrNot(pkg, activity, waitForStop, waitMs = 20000)
             ({ appPackage, appActivity } = await this.getFocusedPackageAndActivity());
         }
         catch (e) {
-            logger_js_1.log.debug(e.message);
+            const error = e;
+            logger_js_1.log.debug(error.message);
             return false;
         }
         if (appActivity && appPackage) {
@@ -772,12 +751,11 @@ async function waitForActivityOrNot(pkg, activity, waitForStop, waitMs = 20000)
 /**
  * Wait for the given activity to be focused
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the package to wait for.
- * @param {string} act - The name of the activity, belonging to that package,
+ * @param pkg - The name of the package to wait for.
+ * @param act - The name of the activity, belonging to that package,
  *                            to wait for.
- * @param {number} [waitMs=20000] - Number of milliseconds to wait before timeout occurs.
- * @throws {error} If timeout happens.
+ * @param waitMs - Number of milliseconds to wait before timeout occurs.
+ * @throws {Error} If timeout happens.
  */
 async function waitForActivity(pkg, act, waitMs = 20000) {
     await this.waitForActivityOrNot(pkg, act, false, waitMs);
@@ -785,24 +763,22 @@ async function waitForActivity(pkg, act, waitMs = 20000) {
 /**
  * Wait for the given activity to be non-focused.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the package to wait for.
- * @param {string} act - The name of the activity, belonging to that package,
+ * @param pkg - The name of the package to wait for.
+ * @param act - The name of the activity, belonging to that package,
  *                            to wait for.
- * @param {number} [waitMs=20000] - Number of milliseconds to wait before timeout occurs.
- * @throws {error} If timeout happens.
+ * @param waitMs - Number of milliseconds to wait before timeout occurs.
+ * @throws {Error} If timeout happens.
  */
 async function waitForNotActivity(pkg, act, waitMs = 20000) {
     await this.waitForActivityOrNot(pkg, act, true, waitMs);
 }
-// #region Private functions
 /**
  * Builds command line representation for the given
  * application startup options
  *
- * @param {StartCmdOptions} startAppOptions - Application options mapping
- * @param {number} apiLevel - The actual OS API level
- * @returns {string[]} The actual command line array
+ * @param startAppOptions - Application options mapping
+ * @param apiLevel - The actual OS API level
+ * @returns The actual command line array
  */
 function buildStartCmd(startAppOptions, apiLevel) {
     const { user, waitForLaunch, pkg, activity, action, category, stopApp, flags, optionalIntentArguments, } = startAppOptions;
@@ -833,66 +809,12 @@ function buildStartCmd(startAppOptions, apiLevel) {
     }
     return cmd;
 }
-/**
- *
- * @param {string} value expect optionalIntentArguments to be a single string of the form:
- *     "-flag key"
- *     "-flag key value"
- * or a combination of these (e.g., "-flag1 key1 -flag2 key2 value2")
- * @returns {string[]}
- */
-function parseOptionalIntentArguments(value) {
-    // take a string and parse out the part before any spaces, and anything after
-    // the first space
-    /** @type {(str: string) => string[]} */
-    const parseKeyValue = (str) => {
-        str = str.trim();
-        const spacePos = str.indexOf(' ');
-        if (spacePos < 0) {
-            return str.length ? [str] : [];
-        }
-        else {
-            return [str.substring(0, spacePos).trim(), str.substring(spacePos + 1).trim()];
-        }
-    };
-    // cycle through the optionalIntentArguments and pull out the arguments
-    // add a space initially so flags can be distinguished from arguments that
-    // have internal hyphens
-    let optionalIntentArguments = ` ${value}`;
-    const re = / (-[^\s]+) (.+)/;
-    /** @type {string[]} */
-    const result = [];
-    while (true) {
-        const args = re.exec(optionalIntentArguments);
-        if (!args) {
-            if (optionalIntentArguments.length) {
-                // no more flags, so the remainder can be treated as 'key' or 'key value'
-                result.push(...parseKeyValue(optionalIntentArguments));
-            }
-            // we are done
-            return result;
-        }
-        // take the flag and see if it is at the beginning of the string
-        // if it is not, then it means we have been through already, and
-        // what is before the flag is the argument for the previous flag
-        const flag = args[1];
-        const flagPos = optionalIntentArguments.indexOf(flag);
-        if (flagPos !== 0) {
-            const prevArgs = optionalIntentArguments.substring(0, flagPos);
-            result.push(...parseKeyValue(prevArgs));
-        }
-        // add the flag, as there are no more earlier arguments
-        result.push(flag);
-        // make optionalIntentArguments hold the remainder
-        optionalIntentArguments = args[2];
-    }
-}
 /**
  * Parses the name of launchable package activity
  * from dumpsys output.
  *
- * @param {string} dumpsys the actual dumpsys output
- * @returns {string[]} Either the fully qualified
+ * @param dumpsys - The actual dumpsys output
+ * @returns Either the fully qualified
  * activity name as a single list item or an empty list if nothing could be parsed.
  * In Android 6 and older there is no reliable way to determine
  * the category name for the given activity, so this API just
@@ -968,39 +890,22 @@ function parseLaunchableActivityNames(dumpsys) {
 /**
  * Check if the given string is a valid component name
  *
- * @param {string} classString The string to verify
- * @return {RegExpExecArray?} The result of Regexp.exec operation
+ * @param classString - The string to verify
+ * @returns The result of Regexp.exec operation
  * or _null_ if no matches are found
  */
 function matchComponentName(classString) {
     // some.package/some.package.Activity
     return /^[\p{L}0-9./_]+$/u.exec(classString);
 }
-/**
- * Escapes special characters in command line arguments.
- * This is needed to avoid possible issues with how system `spawn`
- * call handles them.
- * See https://discuss.appium.io/t/how-to-modify-wd-proxy-and-uiautomator2-source-code-to-support-unicode/33466
- * for more details.
- *
- * @param {string} arg Non-escaped argument string
- * @returns The escaped argument
- */
-function escapeShellArg(arg) {
-    arg = `${arg}`;
-    if (support_1.system.isWindows()) {
-        return /[&|^\s]/.test(arg) ? `"${arg.replace(/"/g, '""')}"` : arg;
-    }
-    return arg.replace(/&/g, '\\&');
-}
 /**
  * Retrieves the list of permission names encoded in `dumpsys package` command output.
  *
- * @param {string} dumpsysOutput - The actual command output.
- * @param {string[]} groupNames - The list of group names to list permissions for.
- * @param {boolean?} [grantedState=null] - The expected state of `granted` attribute to filter with.
+ * @param dumpsysOutput - The actual command output.
+ * @param groupNames - The list of group names to list permissions for.
+ * @param grantedState - The expected state of `granted` attribute to filter with.
  *  No filtering is done if the parameter is not set.
- * @returns {string[]} The list of matched permission names or an empty list if no matches were found.
+ * @returns The list of matched permission names or an empty list if no matches were found.
  */
 function extractMatchingPermissions(dumpsysOutput, groupNames, grantedState = null) {
     const groupPatternByName = (groupName) => new RegExp(`^(\\s*${lodash_1.default.escapeRegExp(groupName)} permissions:[\\s\\S]+)`, 'm');
@@ -1047,9 +952,8 @@ function extractMatchingPermissions(dumpsysOutput, groupNames, grantedState = nu
 /**
  * Broadcast a message to the given intent.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} intent - The name of the intent to broadcast to.
- * @throws {error} If intent name is not a valid class name.
+ * @param intent - The name of the intent to broadcast to.
+ * @throws {Error} If intent name is not a valid class name.
  */
 async function broadcast(intent) {
     if (!this.isValidClass(intent)) {
@@ -1061,9 +965,8 @@ async function broadcast(intent) {
 /**
  * Get the list of process ids for the particular package on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg
- * @returns {Promise<number[]>} The list of matched process IDs or an empty list.
+ * @param pkg - The package name
+ * @returns The list of matched process IDs or an empty list.
  */
 async function listAppProcessIds(pkg) {
     logger_js_1.log.debug(`Getting IDs of all '${pkg}' package`);
@@ -1079,24 +982,81 @@ async function listAppProcessIds(pkg) {
  * Check whether the process with the particular name is running on the device
  * under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The id of the package to be checked.
+ * @param pkg - The id of the package to be checked.
  * @returns True if the given package is running.
  */
 async function isAppRunning(pkg) {
     return !lodash_1.default.isEmpty(await this.listAppProcessIds(pkg));
 }
+// Private methods
 /**
- * @typedef {Object} StartCmdOptions
- * @property {number|string} [user]
- * @property {boolean} [waitForLaunch]
- * @property {string} [pkg]
- * @property {string} [activity]
- * @property {string} [action]
- * @property {string} [category]
- * @property {boolean} [stopApp]
- * @property {string} [flags]
- * @property {string} [optionalIntentArguments]
+ * Parses optional intent arguments from a string.
+ *
+ * @param value - Expect optionalIntentArguments to be a single string of the form:
+ *     "-flag key"
+ *     "-flag key value"
+ * or a combination of these (e.g., "-flag1 key1 -flag2 key2 value2")
+ * @returns Parsed arguments array
  */
-// #endregion
+function parseOptionalIntentArguments(value) {
+    // take a string and parse out the part before any spaces, and anything after
+    // the first space
+    const parseKeyValue = (str) => {
+        str = str.trim();
+        const spacePos = str.indexOf(' ');
+        if (spacePos < 0) {
+            return str.length ? [str] : [];
+        }
+        else {
+            return [str.substring(0, spacePos).trim(), str.substring(spacePos + 1).trim()];
+        }
+    };
+    // cycle through the optionalIntentArguments and pull out the arguments
+    // add a space initially so flags can be distinguished from arguments that
+    // have internal hyphens
+    let optionalIntentArguments = ` ${value}`;
+    const re = / (-[^\s]+) (.+)/;
+    const result = [];
+    while (true) {
+        const args = re.exec(optionalIntentArguments);
+        if (!args) {
+            if (optionalIntentArguments.length) {
+                // no more flags, so the remainder can be treated as 'key' or 'key value'
+                result.push(...parseKeyValue(optionalIntentArguments));
+            }
+            // we are done
+            return result;
+        }
+        // take the flag and see if it is at the beginning of the string
+        // if it is not, then it means we have been through already, and
+        // what is before the flag is the argument for the previous flag
+        const flag = args[1];
+        const flagPos = optionalIntentArguments.indexOf(flag);
+        if (flagPos !== 0) {
+            const prevArgs = optionalIntentArguments.substring(0, flagPos);
+            result.push(...parseKeyValue(prevArgs));
+        }
+        // add the flag, as there are no more earlier arguments
+        result.push(flag);
+        // make optionalIntentArguments hold the remainder
+        optionalIntentArguments = args[2];
+    }
+}
+/**
+ * Escapes special characters in command line arguments.
+ * This is needed to avoid possible issues with how system `spawn`
+ * call handles them.
+ * See https://discuss.appium.io/t/how-to-modify-wd-proxy-and-uiautomator2-source-code-to-support-unicode/33466
+ * for more details.
+ *
+ * @param arg - Non-escaped argument string
+ * @returns The escaped argument
+ */
+function escapeShellArg(arg) {
+    arg = `${arg}`;
+    if (support_1.system.isWindows()) {
+        return /[&|^\s]/.test(arg) ? `"${arg.replace(/"/g, '""')}"` : arg;
+    }
+    return arg.replace(/&/g, '\\&');
+}
 //# sourceMappingURL=app-commands.js.map