appium-xcuitest-driver 10.13.1 → 10.13.2

package/lib/commands/{file-movement.js → file-movement.ts}

@@ -5,9 +5,12 @@ import {services} from 'appium-ios-device';
 import {
   pullFile as realDevicePullFile,
   pullFolder as realDevicePullFolder,
-  pushFile as realDevicePushFile
+  pushFile as realDevicePushFile,
 } from '../device/real-device-management';
 import {errors} from 'appium/driver';
+import type {Simulator} from 'appium-ios-simulator';
+import type {XCUITestDriver} from '../driver';
+import type {ContainerObject, ContainerRootSupplier} from './types';
 
 const CONTAINER_PATH_MARKER = '@';
 // https://regex101.com/r/PLdB0G/2
@@ -17,16 +20,16 @@ const CONTAINER_DOCUMENTS_PATH = 'Documents';
 const OBJECT_NOT_FOUND_ERROR_MESSAGE = 'OBJECT_NOT_FOUND';
 
 /**
- * Parses the actual path and the bundle identifier from the given path string
+ * Parses the actual path and the bundle identifier from the given path string.
  *
- * @this {XCUITestDriver}
- * @param {string} remotePath - The given path string. The string should
- * match `CONTAINER_PATH_PATTERN` regexp, otherwise an error is going
- * to be thrown. A valid string example: `@bundle.identifier:container_type/relative_path_in_container`
- * @param {import('./types').ContainerRootSupplier|string} [containerRootSupplier] - Container root path supplier function or string value
- * @returns {Promise<import('./types').ContainerObject>}
+ * @param remotePath - Path string matching `CONTAINER_PATH_PATTERN`, e.g. `@bundle.id:container/relative/path`
+ * @param containerRootSupplier - Container root path supplier or explicit root
  */
-export async function parseContainerPath(remotePath, containerRootSupplier) {
+export async function parseContainerPath(
+  this: XCUITestDriver,
+  remotePath: string,
+  containerRootSupplier?: ContainerRootSupplier | string,
+): Promise<ContainerObject> {
   const match = CONTAINER_PATH_PATTERN.exec(remotePath);
   if (!match) {
     throw new Error(
@@ -35,8 +38,9 @@ export async function parseContainerPath(remotePath, containerRootSupplier) {
         `relative path with a single slash. '${remotePath}' is given instead`,
     );
   }
-  let [, bundleId, relativePath] = match;
-  let containerType = null;
+  const [, bundleIdMatch, relativePath] = match;
+  let bundleId = bundleIdMatch;
+  let containerType: string | null = null;
   const typeSeparatorPos = bundleId.indexOf(CONTAINER_TYPE_SEPARATOR);
   // We only consider container type exists if its length is greater than zero
   // not counting the colon
@@ -58,12 +62,147 @@ export async function parseContainerPath(remotePath, containerRootSupplier) {
 }
 
 /**
+ * Pushes the given data to a file on the remote device.
+ *
+ * @param remotePath The full path to the remote file or
+ * a file inside a package bundle. Check the documentation on
+ * `pushFileToRealDevice` and `pushFileToSimulator` for more information
+ * on acceptable values.
+ * @param base64Data Base64 encoded data to be written to the
+ * remote file. The remote file will be silently overridden if it already exists.
+ * @throws {Error} If there was an error while pushing the data
+ */
+export async function pushFile(
+  this: XCUITestDriver,
+  remotePath: string,
+  base64Data: string | number[] | Buffer,
+): Promise<void> {
+  if (remotePath.endsWith('/')) {
+    throw new errors.InvalidArgumentError(
+      `It is expected that remote path points to a file and not to a folder. ` +
+        `'${remotePath}' is given instead`,
+    );
+  }
+  let b64StringData: string;
+  if (_.isArray(base64Data)) {
+    // some clients (ahem) java, send a byte array encoding utf8 characters
+    // instead of a string, which would be infinitely better!
+    b64StringData = Buffer.from(base64Data).toString('utf8');
+  } else if (Buffer.isBuffer(base64Data)) {
+    b64StringData = base64Data.toString('utf8');
+  } else {
+    b64StringData = base64Data as string;
+  }
+  return this.isSimulator()
+    ? await pushFileToSimulator.bind(this)(remotePath, b64StringData)
+    : await pushFileToRealDevice.bind(this)(remotePath, b64StringData);
+}
+
+/**
+ * Pushes the given data to a file on the remote device.
+ *
+ * @param remotePath - The full path to the remote file
+ * or a specially formatted path, which points to an item inside an app bundle.
+ * @param payload - Base64-encoded content of the file to be pushed.
+ */
+export async function mobilePushFile(
+  this: XCUITestDriver,
+  remotePath: string,
+  payload: string,
+): Promise<void> {
+  return await this.pushFile(remotePath, payload);
+}
+
+/**
+ * Pulls a remote file from the device.
+ *
+ * @param remotePath The full path to the remote file
+ * or a specially formatted path, which points to an item inside app bundle.
+ * See the documentation for `pullFromRealDevice` and `pullFromSimulator`
+ * to get more information on acceptable values.
+ * @returns Base64 encoded content of the pulled file
+ * @throws {Error} If the pull operation failed
+ */
+export async function pullFile(this: XCUITestDriver, remotePath: string): Promise<string> {
+  if (remotePath.endsWith('/')) {
+    throw new errors.InvalidArgumentError(
+      `It is expected that remote path points to a file and not to a folder. ` +
+        `'${remotePath}' is given instead`,
+    );
+  }
+  return this.isSimulator()
+    ? await pullFromSimulator.bind(this)(remotePath, true)
+    : await pullFromRealDevice.bind(this)(remotePath, true);
+}
+
+/**
+ * Pulls a remote file from the device.
  *
- * @param {string} originalPath
- * @param {string} root
- * @returns {void}
+ * @param remotePath - The full path to the remote file
+ * or a specially formatted path, which points to an item inside app bundle.  See the documentation for `pullFromRealDevice` and `pullFromSimulator` to get more information on acceptable values.
+ * @returns The same as in `pullFile`
  */
-function verifyIsSubPath(originalPath, root) {
+export async function mobilePullFile(this: XCUITestDriver, remotePath: string): Promise<string> {
+  return await this.pullFile(remotePath);
+}
+
+/**
+ * Delete a remote folder from the device.
+ *
+ * @param remotePath - The full path to the remote folder or a specially formatted path, which points to an item inside app bundle. See the documentation for `pullFromRealDevice` and `pullFromSimulator` to get more information on acceptable values.
+ * @returns Nothing
+ */
+export async function mobileDeleteFolder(this: XCUITestDriver, remotePath: string): Promise<void> {
+  if (!remotePath.endsWith('/')) {
+    remotePath = `${remotePath}/`;
+  }
+  await deleteFileOrFolder.bind(this)(remotePath);
+}
+
+/**
+ * Delete a remote file from the device.
+ *
+ * @param remotePath - The full path to the remote file or a specially formatted path, which points to an item inside app bundle. See the documentation for `pullFromRealDevice` and `pullFromSimulator` to get more information on acceptable values.
+ * @returns Nothing
+ */
+export async function mobileDeleteFile(this: XCUITestDriver, remotePath: string): Promise<void> {
+  if (remotePath.endsWith('/')) {
+    throw new errors.InvalidArgumentError(
+      `It is expected that remote path points to a file and not to a folder. ` +
+        `'${remotePath}' is given instead`,
+    );
+  }
+  await deleteFileOrFolder.bind(this)(remotePath);
+}
+
+/**
+ * Pulls the whole folder from the remote device
+ *
+ * @param remotePath The full path to a folder on the
+ * remote device or a folder inside an application bundle
+ * @returns Zipped and base64-encoded content of the folder
+ * @throws {Error} If there was a failure while getting the folder content
+ */
+export async function pullFolder(this: XCUITestDriver, remotePath: string): Promise<string> {
+  if (!remotePath.endsWith('/')) {
+    remotePath = `${remotePath}/`;
+  }
+  return this.isSimulator()
+    ? await pullFromSimulator.bind(this)(remotePath, false)
+    : await pullFromRealDevice.bind(this)(remotePath, false);
+}
+
+/**
+ * Pulls the whole folder from the device under test.
+ *
+ * @param remotePath - The full path to the remote folder
+ * @returns The same as `pullFolder`
+ */
+export async function mobilePullFolder(this: XCUITestDriver, remotePath: string): Promise<string> {
+  return await this.pullFolder(remotePath);
+}
+
+function verifyIsSubPath(originalPath: string, root: string): void {
   const normalizedRoot = path.normalize(root);
   const normalizedPath = path.normalize(path.dirname(originalPath));
   // If originalPath is root, `/`, originalPath should equal to normalizedRoot
@@ -72,15 +211,12 @@ function verifyIsSubPath(originalPath, root) {
   }
 }
 
-/**
- *
- * @this {XCUITestDriver}
- * @param {string} [bundleId]
- * @param {string} [containerType]
- * @returns {Promise<any>}
- */
-async function createAfcClient(bundleId, containerType) {
-  const udid = this.device.udid;
+async function createAfcClient(
+  this: XCUITestDriver,
+  bundleId?: string | null,
+  containerType?: string | null,
+): Promise<any> {
+  const udid = this.device.udid as string;
 
   if (!bundleId) {
     return await services.startAfcService(udid);
@@ -100,22 +236,14 @@ async function createAfcClient(bundleId, containerType) {
     : await service.vendContainer(bundleId);
 }
 
-/**
- *
- * @param {string} [containerType]
- * @returns {boolean}
- */
-function isDocumentsContainer(containerType) {
-  return _.toLower(containerType) === _.toLower(CONTAINER_DOCUMENTS_PATH);
+function isDocumentsContainer(containerType?: string | null): boolean {
+  return _.toLower(containerType ?? '') === _.toLower(CONTAINER_DOCUMENTS_PATH);
 }
 
-/**
- *
- * @this {XCUITestDriver}
- * @param {string} remotePath
- * @returns {Promise<{service: any, relativePath: string}>}
- */
-async function createService(remotePath) {
+async function createService(
+  this: XCUITestDriver,
+  remotePath: string,
+): Promise<{service: any; relativePath: string}> {
   if (CONTAINER_PATH_PATTERN.test(remotePath)) {
     const {bundleId, pathInContainer, containerType} = await parseContainerPath.bind(this)(remotePath);
     const service = await createAfcClient.bind(this)(bundleId, containerType);
@@ -132,22 +260,18 @@ async function createService(remotePath) {
 /**
  * Save the given base64 data chunk as a binary file on the Simulator under test.
  *
- * @this {XCUITestDriver}
- * @param {string} remotePath - The remote path on the device. This variable can be prefixed with
- *                              bundle id, so then the file will be uploaded to the corresponding
- *                              application container instead of the default media folder, for example
- *                              '@com.myapp.bla:data/RelativePathInContainer/111.png'. The '@' character at the
- *                              beginning of the argument is mandatory in such case. The colon at the end of bundle identifier
- *                              is optional and is used to distinguish the container type.
- *                              Possible values there are 'app', 'data', 'groups', '<A specific App Group container>'.
- *                              The default value is 'app'.
- *                              The relative folder path is ignored if the file is going to be uploaded
- *                              to the default media folder and only the file name is considered important.
- * @param {string} base64Data - Base-64 encoded content of the file to be uploaded.
+ * @param remotePath - Remote path on the simulator. Supports bundle-id-prefixed format
+ *                     (e.g. `@com.myapp.bla:data/path/in/container/file.png`) to target
+ *                     application containers; otherwise uploads to the default media folder.
+ * @param base64Data - Base-64 encoded content of the file to be uploaded.
  */
-async function pushFileToSimulator(remotePath, base64Data) {
+async function pushFileToSimulator(
+  this: XCUITestDriver,
+  remotePath: string,
+  base64Data: string,
+): Promise<void> {
   const buffer = Buffer.from(base64Data, 'base64');
-  const device = /** @type {import('appium-ios-simulator').Simulator} */ (this.device);
+  const device = this.device as Simulator;
   if (CONTAINER_PATH_PATTERN.test(remotePath)) {
     const {bundleId, pathInContainer: dstPath} = await parseContainerPath.bind(this)(
       remotePath,
@@ -176,24 +300,18 @@ async function pushFileToSimulator(remotePath, base64Data) {
 }
 
 /**
- * Save the given base64 data chunk as a binary file on the device under test.
+ * Save the given base64 data chunk as a binary file on a real device.
  *
- * @this {XCUITestDriver}
- * @param {string} remotePath - The remote path on the device. This variable can be prefixed with
- *                              bundle id, so then the file will be uploaded to the corresponding
- *                              application container instead of the default media folder. Use
- *                              `@<app_bundle_id>:<optional_container_type>/<path_to_the_file_or_folder_inside_container>`
- *                              format to pull a file or a folder from an application container of the given type.
- *                              The only supported container type is 'documents'. If the container type is not set
- *                              explicitly for a bundle id, then the default application container is going to be mounted
- *                              (aka --container ifuse argument)
- *                              e.g. If `@com.myapp.bla:documents/111.png` is provided,
- *                                   `On My iPhone/<app name>` in Files app will be mounted in the host machine.
- *                                   Base64 encoded `111.png` will be pushed into `On My iPhone/<app name>/111.png`
- *                                   as base64 decoded data.
- * @param {string} base64Data - Base-64 encoded content of the file to be uploaded.
+ * @param remotePath - Remote path on the device. Supports the same bundle-id-prefixed
+ *                     format as simulator uploads (e.g. `@com.myapp.bla:documents/file.png`)
+ *                     to target application containers; otherwise defaults to media folder.
+ * @param base64Data - Base-64 encoded content of the file to be uploaded.
  */
-async function pushFileToRealDevice(remotePath, base64Data) {
+async function pushFileToRealDevice(
+  this: XCUITestDriver,
+  remotePath: string,
+  base64Data: string,
+): Promise<void> {
   const {service, relativePath} = await createService.bind(this)(remotePath);
   try {
     await realDevicePushFile(service, Buffer.from(base64Data, 'base64'), relativePath);
@@ -205,13 +323,7 @@ async function pushFileToRealDevice(remotePath, base64Data) {
   }
 }
 
-/**
- *
- * @this {XCUITestDriver}
- * @param {string} remotePath
- * @returns {Promise<void>}
- */
-async function deleteFileOrFolder(remotePath) {
+async function deleteFileOrFolder(this: XCUITestDriver, remotePath: string): Promise<void> {
   return this.isSimulator()
     ? await deleteFromSimulator.bind(this)(remotePath)
     : await deleteFromRealDevice.bind(this)(remotePath);
@@ -221,19 +333,22 @@ async function deleteFileOrFolder(remotePath) {
  * Get the content of given file or folder from iOS Simulator and return it as base-64 encoded string.
  * Folder content is recursively packed into a zip archive.
  *
- * @this {XCUITestDriver}
- * @param {string} remotePath - The path to a file or a folder, which exists in the corresponding application
+ * @param remotePath - The path to a file or a folder, which exists in the corresponding application
  *                              container on Simulator. Use
  *                              `@<app_bundle_id>:<optional_container_type>/<path_to_the_file_or_folder_inside_container>`
  *                              format to pull a file or a folder from an application container of the given type.
  *                              Possible container types are `app`, `data`, `groups`, `<A specific App Group container>`.
  *                              The default type is `app`.
- * @param {boolean} isFile - Whether the destination item is a file or a folder
- * @returns {Promise<string>} Base-64 encoded content of the file.
+ * @param isFile - Whether the destination item is a file or a folder
+ * @returns Base-64 encoded content of the file.
  */
-async function pullFromSimulator(remotePath, isFile) {
+async function pullFromSimulator(
+  this: XCUITestDriver,
+  remotePath: string,
+  isFile: boolean,
+): Promise<string> {
   let pathOnServer;
-  const device = /** @type {import('appium-ios-simulator').Simulator} */ (this.device);
+  const device = this.device as Simulator;
   if (CONTAINER_PATH_PATTERN.test(remotePath)) {
     const {bundleId, pathInContainer: dstPath} = await parseContainerPath.bind(this)(
       remotePath,
@@ -266,8 +381,7 @@ async function pullFromSimulator(remotePath, isFile) {
  * Get the content of given file or folder from the real device under test and return it as base-64 encoded string.
  * Folder content is recursively packed into a zip archive.
  *
- * @this {XCUITestDriver}
- * @param {string} remotePath - The path to an existing remote file on the device. This variable can be prefixed with
+ * @param remotePath - The path to an existing remote file on the device. This variable can be prefixed with
  *                              bundle id, so then the file will be downloaded from the corresponding
  *                              application container instead of the default media folder. Use
  *                              `@<app_bundle_id>:<optional_container_type>/<path_to_the_file_or_folder_inside_container>`
@@ -280,10 +394,14 @@ async function pullFromSimulator(remotePath, isFile) {
  *                                   `On My iPhone/<app name>/111.png` will be pulled into the mounted host machine
  *                                   and Appium returns the data as base64-encoded string to client.
  *                                   `@com.myapp.bla:documents/` means `On My iPhone/<app name>`.
- * @param {boolean} isFile - Whether the destination item is a file or a folder
- * @returns {Promise<string>} Base-64 encoded content of the remote file
+ * @param isFile - Whether the destination item is a file or a folder
+ * @returns Base-64 encoded content of the remote file
  */
-async function pullFromRealDevice(remotePath, isFile) {
+async function pullFromRealDevice(
+  this: XCUITestDriver,
+  remotePath: string,
+  isFile: boolean,
+): Promise<string> {
   const {service, relativePath} = await createService.bind(this)(remotePath);
   try {
     const fileInfo = await service.getFileInfo(relativePath);
@@ -305,18 +423,17 @@ async function pullFromRealDevice(remotePath, isFile) {
 /**
  * Remove the file or folder from the device
  *
- * @this {XCUITestDriver}
- * @param {string} remotePath - The path to a file or a folder, which exists in the corresponding application
+ * @param remotePath - The path to a file or a folder, which exists in the corresponding application
  *                              container on Simulator. Use
  *                              `@<app_bundle_id>:<optional_container_type>/<path_to_the_file_or_folder_inside_container>`
  *                              format to pull a file or a folder from an application container of the given type.
  *                              Possible container types are 'app', 'data', 'groups', '<A specific App Group container>'.
  *                              The default type is 'app'.
- * @returns {Promise<void>}
+ * @returns Nothing
  */
-async function deleteFromSimulator(remotePath) {
-  let pathOnServer;
-  const device = /** @type {import('appium-ios-simulator').Simulator} */ (this.device);
+async function deleteFromSimulator(this: XCUITestDriver, remotePath: string): Promise<void> {
+  let pathOnServer: string;
+  const device = this.device as Simulator;
   if (CONTAINER_PATH_PATTERN.test(remotePath)) {
     const {bundleId, pathInContainer: dstPath} = await parseContainerPath.bind(this)(
       remotePath,
@@ -343,8 +460,7 @@ async function deleteFromSimulator(remotePath) {
 /**
  * Remove the file or folder from the device
  *
- * @this {XCUITestDriver}
- * @param {string} remotePath - The path to an existing remote file on the device. This variable can be prefixed with
+ * @param remotePath - The path to an existing remote file on the device. This variable can be prefixed with
  *                              bundle id, so then the file will be downloaded from the corresponding
  *                              application container instead of the default media folder. Use
  *                              `@<app_bundle_id>:<optional_container_type>/<path_to_the_file_or_folder_inside_container>`
@@ -357,9 +473,9 @@ async function deleteFromSimulator(remotePath) {
  *                                   `On My iPhone/<app name>/111.png` will be pulled into the mounted host machine
  *                                   and Appium returns the data as base64-encoded string to client.
  *                                   `@com.myapp.bla:documents/` means `On My iPhone/<app name>`.
- * @returns {Promise<void>}
+ * @returns Nothing
  */
-async function deleteFromRealDevice(remotePath) {
+async function deleteFromRealDevice(this: XCUITestDriver, remotePath: string): Promise<void> {
   const {service, relativePath} = await createService.bind(this)(remotePath);
   try {
     await service.deleteDirectory(relativePath);
@@ -373,142 +489,3 @@ async function deleteFromRealDevice(remotePath) {
   }
 }
 
-/**
- * Pushes the given data to a file on the remote device
- *
- * @param {string} remotePath The full path to the remote file or
- * a file inside a package bundle. Check the documentation on
- * `pushFileToRealDevice` and `pushFileToSimulator` for more information
- * on acceptable values.
- * @param {string} base64Data Base64 encoded data to be written to the
- * remote file. The remote file will be silently overridden if it already exists.
- * @throws {Error} If there was an error while pushing the data
- * @this {XCUITestDriver}
- */
-export async function pushFile(remotePath, base64Data) {
-  if (remotePath.endsWith('/')) {
-    throw new errors.InvalidArgumentError(
-      `It is expected that remote path points to a file and not to a folder. ` +
-        `'${remotePath}' is given instead`,
-    );
-  }
-  if (_.isArray(base64Data)) {
-    // some clients (ahem) java, send a byte array encoding utf8 characters
-    // instead of a string, which would be infinitely better!
-    base64Data = Buffer.from(base64Data).toString('utf8');
-  }
-  return this.isSimulator()
-    ? await pushFileToSimulator.bind(this)(remotePath, base64Data)
-    : await pushFileToRealDevice.bind(this)(remotePath, base64Data);
-}
-
-/**
- * Pushes the given data to a file on the remote device.
- *
- * @param {string} remotePath - The full path to the remote file
- * or a specially formatted path, which points to an item inside an app bundle.
- * @param {string} payload - Base64-encoded content of the file to be pushed.
- * @this {XCUITestDriver}
- */
-export async function mobilePushFile(remotePath, payload) {
-  return await this.pushFile(remotePath, payload);
-}
-
-/**
- * Pulls a remote file from the device.
- *
- * @param {string} remotePath The full path to the remote file
- * or a specially formatted path, which points to an item inside app bundle.
- * See the documentation for `pullFromRealDevice` and `pullFromSimulator`
- * to get more information on acceptable values.
- * @returns {Promise<string>} Base64 encoded content of the pulled file
- * @throws {Error} If the pull operation failed
- * @this {XCUITestDriver}
- */
-export async function pullFile(remotePath) {
-  if (remotePath.endsWith('/')) {
-    throw new errors.InvalidArgumentError(
-      `It is expected that remote path points to a file and not to a folder. ` +
-        `'${remotePath}' is given instead`,
-    );
-  }
-  return this.isSimulator()
-    ? await pullFromSimulator.bind(this)(remotePath, true)
-    : await pullFromRealDevice.bind(this)(remotePath, true);
-}
-
-/**
- * Pulls a remote file from the device.
- *
- * @param {string} remotePath - The full path to the remote file
- * or a specially formatted path, which points to an item inside app bundle.  See the documentation for `pullFromRealDevice` and `pullFromSimulator` to get more information on acceptable values.
- * @returns {Promise<string>} The same as in `pullFile`
- * @this {XCUITestDriver}
- */
-export async function mobilePullFile(remotePath) {
-  return await this.pullFile(remotePath);
-}
-
-/**
- * Delete a remote folder from the device.
- *
- * @param {string} remotePath - The full path to the remote folder or a specially formatted path, which points to an item inside app bundle. See the documentation for `pullFromRealDevice` and `pullFromSimulator` to get more information on acceptable values.
- * @this {XCUITestDriver}
- * @returns {Promise<void>}
- */
-export async function mobileDeleteFolder(remotePath) {
-  if (!remotePath.endsWith('/')) {
-    remotePath = `${remotePath}/`;
-  }
-  await deleteFileOrFolder.bind(this)(remotePath);
-}
-
-/**
- * Delete a remote file from the device.
- *
- * @param {string} remotePath - The full path to the remote file or a specially formatted path, which points to an item inside app bundle. See the documentation for `pullFromRealDevice` and `pullFromSimulator` to get more information on acceptable values.
- * @this {XCUITestDriver}
- * @returns {Promise<void>}
- */
-export async function mobileDeleteFile(remotePath) {
-  if (remotePath.endsWith('/')) {
-    throw new errors.InvalidArgumentError(
-      `It is expected that remote path points to a file and not to a folder. ` +
-        `'${remotePath}' is given instead`,
-    );
-  }
-  await deleteFileOrFolder.bind(this)(remotePath);
-}
-
-/**
- * Pulls the whole folder from the remote device
- *
- * @param {string} remotePath The full path to a folder on the
- * remote device or a folder inside an application bundle
- * @returns {Promise<string>} Zipped and base64-encoded content of the folder
- * @throws {Error} If there was a failure while getting the folder content
- * @this {XCUITestDriver}
- */
-export async function pullFolder(remotePath) {
-  if (!remotePath.endsWith('/')) {
-    remotePath = `${remotePath}/`;
-  }
-  return this.isSimulator()
-    ? await pullFromSimulator.bind(this)(remotePath, false)
-    : await pullFromRealDevice.bind(this)(remotePath, false);
-}
-
-/**
- * Pulls the whole folder from the device under test.
- *
- * @param {string} remotePath - The full path to the remote folder
- * @returns {Promise<string>} The same as `pullFolder`
- * @this {XCUITestDriver}
- */
-export async function mobilePullFolder(remotePath) {
-  return await this.pullFolder(remotePath);
-}
-
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- */