appium-xcuitest-driver 10.3.0 → 10.4.1

package/lib/commands/context.js

@@ -18,457 +18,461 @@ const DEFAULT_LIST_WEB_FRAMES_RETRIES = 20;
 const DEFAULT_NATIVE_WINDOW_HANDLE = '1';
 
 
-const extensions = {
+/**
+ * @this {XCUITestDriver}
+ * @param {boolean} [useUrl=false]
+ * @returns {Promise<import('./types').ViewContext[]>}
+ */
+export async function getContextsAndViews(useUrl = true) {
+  this.log.debug('Retrieving contexts and views');
+  const webviews = await this.listWebFrames(useUrl);
   /**
-   * @this {XCUITestDriver}
-   * @param {boolean} [useUrl=false]
-   * @returns {Promise<import('./types').ViewContext[]>}
+   * @type {import('./types').ViewContext[]}
    */
-  async getContextsAndViews(useUrl = true) {
-    this.log.debug('Retrieving contexts and views');
-    const webviews = await this.listWebFrames(useUrl);
-    /**
-     * @type {import('./types').ViewContext[]}
-     */
-    const ctxs = [{id: NATIVE_WIN, view: {}}];
-    this.contexts = [NATIVE_WIN];
-    for (const view of webviews) {
-      ctxs.push({id: `${WEBVIEW_BASE}${view.id}`, view});
-      this.contexts.push(view.id.toString());
-    }
-    return ctxs;
-  },
+  const ctxs = [{id: NATIVE_WIN, view: {}}];
+  this.contexts = [NATIVE_WIN];
+  for (const view of webviews) {
+    ctxs.push({id: `${WEBVIEW_BASE}${view.id}`, view});
+    this.contexts.push(view.id.toString());
+  }
+  return ctxs;
+}
 
-  /**
-   * @deprecated this method is not used anywhere and will be removed in the future
-   * @this {XCUITestDriver}
-   * @returns {boolean}
-   */
-  useNewSafari() {
-    return this.isSimulator() && this.isSafari();
-  },
+/**
+ * @deprecated this method is not used anywhere and will be removed in the future
+ * @this {XCUITestDriver}
+ * @returns {boolean}
+ */
+export function useNewSafari() {
+  return this.isSimulator() && this.isSafari();
+}
 
-  /**
-   * @this {XCUITestDriver}
-   * @returns {Promise<void>}
-   */
-  async activateRecentWebview() {
-    this.log.debug('Activating a recent webview');
-    const timer = new timing.Timer().start();
-    const contextId = await this.getRecentWebviewContextId(/.*/, /.*/);
-    if (contextId) {
-      this.log.info(`Picking webview '${contextId}' after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
-      await this.setContext(contextId);
-      return;
-    }
-    const appDict = (/** @type {RemoteDebugger} */ (this.remote)).appDict;
-    const errSuffix = `Make sure your web application is debuggable ` +
-      `and could be inspected in Safari Web Inspector.`;
-    if (_.isEmpty(appDict)) {
-      throw new Error(
-        `The remote debugger did not return any connected web applications after ` +
-        `${timer.getDuration().asMilliSeconds.toFixed(0)}ms. ` +
-        `${errSuffix} ` +
-        `You may try to change the 'webviewConnectTimeout' capability value to ` +
-        `customize the retrieval timeout.`
+/**
+ * @this {XCUITestDriver}
+ * @returns {Promise<void>}
+ */
+export async function activateRecentWebview() {
+  this.log.debug('Activating a recent webview');
+  const timer = new timing.Timer().start();
+  const contextId = await this.getRecentWebviewContextId(/.*/, /.*/);
+  if (contextId) {
+    this.log.info(`Picking webview '${contextId}' after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
+    await this.setContext(contextId);
+    return;
+  }
+  const appDict = (/** @type {RemoteDebugger} */ (this.remote)).appDict;
+  const errSuffix = `Make sure your web application is debuggable ` +
+    `and could be inspected in Safari Web Inspector.`;
+  if (_.isEmpty(appDict)) {
+    throw new Error(
+      `The remote debugger did not return any connected web applications after ` +
+      `${timer.getDuration().asMilliSeconds.toFixed(0)}ms. ` +
+      `${errSuffix} ` +
+      `You may try to change the 'webviewConnectTimeout' capability value to ` +
+      `customize the retrieval timeout.`
+    );
+  }
+  const errSuffix2 = `${errSuffix} You may try to change the 'webviewConnectRetries' ` +
+    `capability value to customize the amount of pages retrieval retries.`;
+  const appsWithPages = _.values(appDict).filter(({pageArray}) => !_.isEmpty(pageArray));
+  if (appsWithPages.length > 0) {
+    throw new Error(
+      `The remote debugger returned ${util.pluralize('web application', appsWithPages.length, true)} ` +
+      `with pages after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms, ` +
+      `although none of them matched our page search criteria. ${errSuffix2}`
+    );
+  } else {
+    throw new Error(
+      `The remote debugger returned ${util.pluralize('web application', _.size(appDict), true)}, ` +
+      `but none of them had pages after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms. ` +
+      `${errSuffix2} Also, in rare cases the device restart or device OS upgrade may fix this ` +
+      `issue if none of the above advices helps.`
+    );
+  }
+}
+
+/**
+ * @this {XCUITestDriver}
+ * @returns {Promise<import('../types').Page[]>}
+ */
+export async function listWebFrames(useUrl = true) {
+  const shouldFilterByUrl = useUrl && !this.isRealDevice() && !!this.getCurrentUrl();
+  this.log.debug(
+    `Selecting by url: ${shouldFilterByUrl}` +
+    (shouldFilterByUrl ? ` (expected url: '${this.getCurrentUrl()}')` : '')
+  );
+
+  if (!this.remote) {
+    await this.connectToRemoteDebugger();
+  }
+  const doListPages = async (/** @type {number} */ retries) => {
+    try {
+      const pageArray = await (/** @type {RemoteDebugger} */ (this.remote)).selectApp(
+        shouldFilterByUrl ? this.getCurrentUrl() : undefined,
+        retries,
+        this.opts.ignoreAboutBlankUrl,
       );
-    }
-    const errSuffix2 = `${errSuffix} You may try to change the 'webviewConnectRetries' ` +
-      `capability value to customize the amount of pages retrieval retries.`;
-    const appsWithPages = _.values(appDict).filter(({pageArray}) => !_.isEmpty(pageArray));
-    if (appsWithPages.length > 0) {
-      throw new Error(
-        `The remote debugger returned ${util.pluralize('web application', appsWithPages.length, true)} ` +
-        `with pages after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms, ` +
-        `although none of them matched our page search criteria. ${errSuffix2}`
+      if (_.isEmpty(pageArray)) {
+        // we have no web frames, but continue anyway
+        this.log.debug(`No web frames found after ${util.pluralize('retry', retries, true)}`);
+      }
+      return pageArray;
+    } catch (err) {
+      this.log.debug(
+        `No available web pages after ${util.pluralize('retry', retries, true)}: ${err.message}`
       );
-    } else {
-      throw new Error(
-        `The remote debugger returned ${util.pluralize('web application', _.size(appDict), true)}, ` +
-        `but none of them had pages after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms. ` +
-        `${errSuffix2} Also, in rare cases the device restart or device OS upgrade may fix this ` +
-        `issue if none of the above advices helps.`
+      return [];
+    }
+  };
+
+  /** @type {number} */
+  const maxRetriesCount = _.isInteger(this.opts.webviewConnectRetries)
+    ? Math.max(/** @type {number} */ (this.opts.webviewConnectRetries), 1)
+    : DEFAULT_LIST_WEB_FRAMES_RETRIES;
+  this.log.debug(
+    `About to select a web application with ${util.pluralize('retry', maxRetriesCount, true)} ` +
+    `and 500ms interval between each retry. Consider customizing the value of 'webviewConnectRetries' ` +
+    `capability to change the amount of retries.`
+  );
+  return await doListPages(maxRetriesCount);
+}
+
+/**
+ * @this {XCUITestDriver}
+ * @returns {Promise<void>}
+ */
+export async function connectToRemoteDebugger() {
+  this.remote = await this.getNewRemoteDebugger();
+
+  // @ts-ignore static is fine
+  this.remote.on(RemoteDebugger.EVENT_PAGE_CHANGE, this.onPageChange.bind(this));
+  // @ts-ignore static is fine
+  this.remote.on(RemoteDebugger.EVENT_FRAMES_DETACHED, () => {
+    if (!_.isEmpty(this.curWebFrames)) {
+      const curWebFrames = this.curWebFrames;
+      this.log.debug(
+        `Clearing ${util.pluralize('frame', curWebFrames.length, true)}: ${curWebFrames.join(
+          ', ',
+        )}`,
       );
     }
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @returns {Promise<import('../types').Page[]>}
-   */
-  async listWebFrames(useUrl = true) {
-    const shouldFilterByUrl = useUrl && !this.isRealDevice() && !!this.getCurrentUrl();
-    this.log.debug(
-      `Selecting by url: ${shouldFilterByUrl}` +
-      (shouldFilterByUrl ? ` (expected url: '${this.getCurrentUrl()}')` : '')
+    this.curWebFrames = [];
+  });
+
+  const timeoutMs = this.opts.webviewConnectTimeout ?? DEFAULT_REMOTE_DEBUGGER_CONNECT_TIMEOUT_MS;
+  const apps = await this.remote.connect(timeoutMs);
+  if (_.isEmpty(apps)) {
+    this.log.info(
+      `The remote debugger did not report any active web applications within ${timeoutMs}ms timeout. ` +
+      `Consider increasing the value of 'webviewConnectTimeout' capability to wait longer ` +
+      `on slower devices.`
     );
+  }
+}
 
-    if (!this.remote) {
-      await this.connectToRemoteDebugger();
+/**
+ * Retrieves the list of available contexts.
+ *
+ * The list includes extended context information, like URLs and page names.
+ * This is different from the standard `getContexts` API, because the latter
+ * only has web view names without any additional information.
+ *
+ * @remarks In situations where multiple web views are available at once, the
+ * client code would have to connect to each of them in order to detect the
+ * one which needs to be interacted with. This extra effort is not needed with
+ * the information provided by this extension.
+ * @param {number} [waitForWebviewMs=0] - The period to poll for available webview(s) (in ms)
+ * @returns {Promise<Context[]>} The list of available context objects along with their properties.
+ * @this {XCUITestDriver}
+ */
+export async function mobileGetContexts(waitForWebviewMs = 0) {
+  // make sure it is a number, so the duration check works properly
+  if (!_.isNumber(waitForWebviewMs)) {
+    waitForWebviewMs = parseInt(waitForWebviewMs, 10);
+    if (isNaN(waitForWebviewMs)) {
+      waitForWebviewMs = 0;
     }
-    const doListPages = async (/** @type {number} */ retries) => {
-      try {
-        const pageArray = await (/** @type {RemoteDebugger} */ (this.remote)).selectApp(
-          shouldFilterByUrl ? this.getCurrentUrl() : undefined,
-          retries,
-          this.opts.ignoreAboutBlankUrl,
-        );
-        if (_.isEmpty(pageArray)) {
-          // we have no web frames, but continue anyway
-          this.log.debug(`No web frames found after ${util.pluralize('retry', retries, true)}`);
-        }
-        return pageArray;
-      } catch (err) {
-        this.log.debug(
-          `No available web pages after ${util.pluralize('retry', retries, true)}: ${err.message}`
-        );
-        return [];
-      }
-    };
+  }
 
-    /** @type {number} */
-    const maxRetriesCount = _.isInteger(this.opts.webviewConnectRetries)
-      ? Math.max(/** @type {number} */ (this.opts.webviewConnectRetries), 1)
-      : DEFAULT_LIST_WEB_FRAMES_RETRIES;
-    this.log.debug(
-      `About to select a web application with ${util.pluralize('retry', maxRetriesCount, true)} ` +
-      `and 500ms interval between each retry. Consider customizing the value of 'webviewConnectRetries' ` +
-      `capability to change the amount of retries.`
-    );
-    return await doListPages(maxRetriesCount);
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @returns {Promise<void>}
-   */
-  async connectToRemoteDebugger() {
-    this.remote = await this.getNewRemoteDebugger();
-
-    // @ts-ignore static is fine
-    this.remote.on(RemoteDebugger.EVENT_PAGE_CHANGE, this.onPageChange.bind(this));
-    // @ts-ignore static is fine
-    this.remote.on(RemoteDebugger.EVENT_FRAMES_DETACHED, () => {
-      if (!_.isEmpty(this.curWebFrames)) {
-        const curWebFrames = this.curWebFrames;
+  const curOpt = this.opts.fullContextList;
+  this.opts.fullContextList = true;
+
+  const timer = new timing.Timer().start();
+  try {
+    /** @type {FullContext[]} */
+    let contexts;
+    do {
+      contexts = /** @type {FullContext[]} */ (await this.getContexts());
+
+      if (contexts.length >= 2) {
         this.log.debug(
-          `Clearing ${util.pluralize('frame', curWebFrames.length, true)}: ${curWebFrames.join(
-            ', ',
-          )}`,
+          `Found webview context after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`,
         );
+        return contexts;
       }
-      this.curWebFrames = [];
-    });
-
-    const timeoutMs = this.opts.webviewConnectTimeout ?? DEFAULT_REMOTE_DEBUGGER_CONNECT_TIMEOUT_MS;
-    const apps = await this.remote.connect(timeoutMs);
-    if (_.isEmpty(apps)) {
-      this.log.info(
-        `The remote debugger did not report any active web applications within ${timeoutMs}ms timeout. ` +
-        `Consider increasing the value of 'webviewConnectTimeout' capability to wait longer ` +
-        `on slower devices.`
-      );
+      this.log.debug(`No webviews found in ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
+    } while (timer.getDuration().asMilliSeconds < waitForWebviewMs);
+    return contexts;
+  } finally {
+    // reset the option so there are no side effects
+    this.opts.fullContextList = curOpt;
+  }
+}
+
+/**
+ * @this {XCUITestDriver}
+ * @param {import('./types').PageChangeNotification} pageChangeNotification
+ * @returns {Promise<void>}
+ */
+export async function onPageChange(pageChangeNotification) {
+  this.log.debug(
+    `Remote debugger notified us of a new page listing: ${JSON.stringify(
+      pageChangeNotification,
+    )}`,
+  );
+  if (this.selectingNewPage) {
+    this.log.debug('We are in the middle of selecting a page, ignoring');
+    return;
+  }
+  if (!this.remote?.isConnected) {
+    this.log.debug('We have not yet connected, ignoring');
+    return;
+  }
+
+  const {appIdKey, pageArray} = pageChangeNotification;
+
+  /** @type {string[]} */
+  const newIds = [];
+  /** @type {string[]} */
+  const newPages = [];
+  /** @type {string|null} */
+  let keyId = null;
+  for (const page of pageArray) {
+    const id = page.id.toString();
+    newIds.push(id);
+    if (page.isKey) {
+      keyId = id;
     }
-  },
+    const contextId = `${appIdKey}.${id}`;
 
-  /**
-   * Retrieves the list of available contexts.
-   *
-   * The list includes extended context information, like URLs and page names.
-   * This is different from the standard `getContexts` API, because the latter
-   * only has web view names without any additional information.
-   *
-   * @remarks In situations where multiple web views are available at once, the
-   * client code would have to connect to each of them in order to detect the
-   * one which needs to be interacted with. This extra effort is not needed with
-   * the information provided by this extension.
-   * @param {number} [waitForWebviewMs=0] - The period to poll for available webview(s) (in ms)
-   * @returns {Promise<Context[]>} The list of available context objects along with their properties.
-   * @this {XCUITestDriver}
-   */
-  async mobileGetContexts(waitForWebviewMs = 0) {
-    // make sure it is a number, so the duration check works properly
-    if (!_.isNumber(waitForWebviewMs)) {
-      waitForWebviewMs = parseInt(waitForWebviewMs, 10);
-      if (isNaN(waitForWebviewMs)) {
-        waitForWebviewMs = 0;
+    // add if this is a new page
+    if (!_.includes(this.contexts, contextId)) {
+      if (isUrlIgnored(page.url, this.opts.safariIgnoreWebHostnames)) {
+        this.log.info(
+          `Not tracking '${page.url}' page because it is blacklisted. ` +
+            `'safariIgnoreWebHostnames'=${this.opts.safariIgnoreWebHostnames}`,
+        );
+      } else {
+        newPages.push(id);
+        this.contexts.push(contextId);
       }
     }
+  }
 
-    const curOpt = this.opts.fullContextList;
-    this.opts.fullContextList = true;
+  if (!keyId) {
+    // if there is no key id, pull the first id from the page array and use that
+    // as a stand in
+    this.log.debug('No key id found. Choosing first id from page array');
+    keyId = newIds[0] || null;
+  }
 
-    const timer = new timing.Timer().start();
-    try {
-      /** @type {FullContext[]} */
-      let contexts;
-      do {
-        contexts = /** @type {FullContext[]} */ (await this.getContexts());
-
-        if (contexts.length >= 2) {
-          this.log.debug(
-            `Found webview context after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`,
-          );
-          return contexts;
-        }
-        this.log.debug(`No webviews found in ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
-      } while (timer.getDuration().asMilliSeconds < waitForWebviewMs);
-      return contexts;
-    } finally {
-      // reset the option so there are no side effects
-      this.opts.fullContextList = curOpt;
-    }
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @param {import('./types').PageChangeNotification} pageChangeNotification
-   * @returns {Promise<void>}
-   */
-  async onPageChange(pageChangeNotification) {
+  if (!util.hasValue(this.curContext)) {
+    this.log.debug('We do not appear to have window set yet, ignoring');
+    return;
+  }
+  const [curAppIdKey, curPageIdKey] = this.curContext.split('.');
+  if (curAppIdKey !== appIdKey) {
+    this.log.debug('Page change not referring to currently selected app, ignoring.');
+    return;
+  }
+
+  /** @type {string|null} */
+  let newPage = null;
+  if (newPages.length) {
+    newPage = /** @type {string} */ (_.last(newPages));
+    this.log.debug(`We have new pages, selecting page '${newPage}'`);
+  } else if (!_.includes(newIds, curPageIdKey)) {
     this.log.debug(
-      `Remote debugger notified us of a new page listing: ${JSON.stringify(
-        pageChangeNotification,
-      )}`,
+      'New page listing from remote debugger does not contain ' +
+        'current window; assuming it is closed',
     );
-    if (this.selectingNewPage) {
-      this.log.debug('We are in the middle of selecting a page, ignoring');
-      return;
-    }
-    if (!this.remote?.isConnected) {
-      this.log.debug('We have not yet connected, ignoring');
+    if (!util.hasValue(keyId)) {
+      this.log.error(
+        'Do not have our current window anymore, and there ' +
+          'are not any more to load! Doing nothing...',
+      );
+      this.setCurrentUrl(undefined);
       return;
     }
 
-    const {appIdKey, pageArray} = pageChangeNotification;
-
-    /** @type {string[]} */
-    const newIds = [];
-    /** @type {string[]} */
-    const newPages = [];
-    /** @type {string|null} */
-    let keyId = null;
-    for (const page of pageArray) {
-      const id = page.id.toString();
-      newIds.push(id);
-      if (page.isKey) {
-        keyId = id;
-      }
-      const contextId = `${appIdKey}.${id}`;
-
-      // add if this is a new page
-      if (!_.includes(this.contexts, contextId)) {
-        if (isUrlIgnored(page.url, this.opts.safariIgnoreWebHostnames)) {
-          this.log.info(
-            `Not tracking '${page.url}' page because it is blacklisted. ` +
-              `'safariIgnoreWebHostnames'=${this.opts.safariIgnoreWebHostnames}`,
-          );
-        } else {
-          newPages.push(id);
-          this.contexts.push(contextId);
-        }
-      }
-    }
+    this.log.debug(`Debugger already selected page '${keyId}', ` + `confirming that choice.`);
+    this.curContext = `${appIdKey}.${keyId}`;
+    newPage = keyId;
+  } else {
+    // at this point, there are no new pages, and the current page still exists
+    this.log.debug('New page listing is same as old, doing nothing');
+  }
 
-    if (!keyId) {
-      // if there is no key id, pull the first id from the page array and use that
-      // as a stand in
-      this.log.debug('No key id found. Choosing first id from page array');
-      keyId = newIds[0] || null;
+  // make sure that the page listing isn't indicating a redirect
+  if (util.hasValue(this.curContext)) {
+    const currentPageId = parseInt(String(_.last(this.curContext.split('.'))), 10);
+    const page = _.find(pageArray, (p) => parseInt(String(p.id), 10) === currentPageId);
+    if (page && page.url !== this.getCurrentUrl()) {
+      this.log.debug(`Redirected from '${this.getCurrentUrl()}' to '${page.url}'`);
+      this.setCurrentUrl(page.url);
     }
+  }
 
-    if (!util.hasValue(this.curContext)) {
-      this.log.debug('We do not appear to have window set yet, ignoring');
-      return;
-    }
-    const [curAppIdKey, curPageIdKey] = this.curContext.split('.');
-    if (curAppIdKey !== appIdKey) {
-      this.log.debug('Page change not referring to currently selected app, ignoring.');
-      return;
+  if (util.hasValue(newPage)) {
+    this.selectingNewPage = true;
+    const oldContext = this.curContext;
+    this.curContext = `${appIdKey}.${newPage}`;
+    try {
+      await this.remote.selectPage(appIdKey, parseInt(newPage, 10));
+      await notifyBiDiContextChange.bind(this)();
+    } catch (e) {
+      this.log.warn(`Failed to select page: ${e.message}`);
+      this.curContext = oldContext;
+    } finally {
+      this.selectingNewPage = false;
     }
+  }
+}
 
-    /** @type {string|null} */
-    let newPage = null;
-    if (newPages.length) {
-      newPage = /** @type {string} */ (_.last(newPages));
-      this.log.debug(`We have new pages, selecting page '${newPage}'`);
-    } else if (!_.includes(newIds, curPageIdKey)) {
-      this.log.debug(
-        'New page listing from remote debugger does not contain ' +
-          'current window; assuming it is closed',
-      );
-      if (!util.hasValue(keyId)) {
-        this.log.error(
-          'Do not have our current window anymore, and there ' +
-            'are not any more to load! Doing nothing...',
-        );
-        this.setCurrentUrl(undefined);
-        return;
-      }
+/**
+ * @this {XCUITestDriver}
+ * @returns {Promise<void>}
+ */
+export async function stopRemote(closeWindowBeforeDisconnecting = false) {
+  if (!this.remote) {
+    throw this.log.errorWithException('Tried to leave a web frame but were not in one');
+  }
 
-      this.log.debug(`Debugger already selected page '${keyId}', ` + `confirming that choice.`);
-      this.curContext = `${appIdKey}.${keyId}`;
-      newPage = keyId;
-    } else {
-      // at this point, there are no new pages, and the current page still exists
-      this.log.debug('New page listing is same as old, doing nothing');
-    }
+  if (closeWindowBeforeDisconnecting) {
+    await this.closeWindow();
+  }
+  await this.remote.disconnect();
+  this.curContext = null;
+  await notifyBiDiContextChange.bind(this)();
+  this.curWebFrames = [];
+  this.remote = null;
+}
 
-    // make sure that the page listing isn't indicating a redirect
-    if (util.hasValue(this.curContext)) {
-      const currentPageId = parseInt(String(_.last(this.curContext.split('.'))), 10);
-      const page = _.find(pageArray, (p) => parseInt(String(p.id), 10) === currentPageId);
-      if (page && page.url !== this.getCurrentUrl()) {
-        this.log.debug(`Redirected from '${this.getCurrentUrl()}' to '${page.url}'`);
-        this.setCurrentUrl(page.url);
-      }
-    }
+/**
+ * @this {XCUITestDriver}
+ * @param {string|undefined|null} url
+ */
+export function setCurrentUrl(url) {
+  this._currentUrl = url;
+}
 
-    if (util.hasValue(newPage)) {
-      this.selectingNewPage = true;
-      const oldContext = this.curContext;
-      this.curContext = `${appIdKey}.${newPage}`;
-      try {
-        await this.remote.selectPage(appIdKey, parseInt(newPage, 10));
-        await notifyBiDiContextChange.bind(this)();
-      } catch (e) {
-        this.log.warn(`Failed to select page: ${e.message}`);
-        this.curContext = oldContext;
-      } finally {
-        this.selectingNewPage = false;
-      }
-    }
-  },
-};
+/**
+ * @this {XCUITestDriver}
+ * @returns {string|undefined|null}
+ */
+export function getCurrentUrl() {
+  return this._currentUrl;
+}
 
-const helpers = {
-  /**
-   * @this {XCUITestDriver}
-   * @returns {Promise<void>}
-   */
-  async stopRemote(closeWindowBeforeDisconnecting = false) {
-    if (!this.remote) {
-      throw this.log.errorWithException('Tried to leave a web frame but were not in one');
-    }
+/**
+ * @param {RegExp} titleRegExp
+ * @param {RegExp} urlRegExp
+ * @this {XCUITestDriver}
+ * @returns {Promise<string|undefined>}
+ */
+export async function getRecentWebviewContextId(titleRegExp, urlRegExp) {
+  if (!_.isRegExp(titleRegExp) && !_.isRegExp(urlRegExp)) {
+    throw new errors.InvalidArgumentError(
+      'A regular expression for either web view title or url must be provided',
+    );
+  }
 
-    if (closeWindowBeforeDisconnecting) {
-      await this.closeWindow();
-    }
-    await this.remote.disconnect();
-    this.curContext = null;
-    await notifyBiDiContextChange.bind(this)();
-    this.curWebFrames = [];
-    this.remote = null;
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @param {string|undefined|null} url
-   */
-  setCurrentUrl(url) {
-    this._currentUrl = url;
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @returns {string|undefined|null}
-   */
-  getCurrentUrl() {
-    return this._currentUrl;
-  },
-  /**
-   * @param {RegExp} titleRegExp
-   * @param {RegExp} urlRegExp
-   * @this {XCUITestDriver}
-   * @returns {Promise<string|undefined>}
-   */
-  async getRecentWebviewContextId(titleRegExp, urlRegExp) {
-    if (!_.isRegExp(titleRegExp) && !_.isRegExp(urlRegExp)) {
-      throw new errors.InvalidArgumentError(
-        'A regular expression for either web view title or url must be provided',
-      );
+  const currentUrl = this.getCurrentUrl();
+  const contexts = _.filter(await this.getContextsAndViews(false), 'view');
+  // first try to match by current url
+  if (currentUrl) {
+    const ctx = contexts.find(({view}) => (view?.url || '') === currentUrl);
+    if (ctx) {
+      return ctx.id;
     }
+  }
+  // if not, try to match by regular expression
+  return contexts.find(
+    ({view}) =>
+      (view?.title && titleRegExp?.test(view.title)) || (view?.url && urlRegExp?.test(view.url)),
+  )?.id;
+}
 
-    const currentUrl = this.getCurrentUrl();
-    const contexts = _.filter(await this.getContextsAndViews(false), 'view');
-    // first try to match by current url
-    if (currentUrl) {
-      const ctx = contexts.find(({view}) => (view?.url || '') === currentUrl);
-      if (ctx) {
-        return ctx.id;
-      }
-    }
-    // if not, try to match by regular expression
-    return contexts.find(
-      ({view}) =>
-        (view?.title && titleRegExp?.test(view.title)) || (view?.url && urlRegExp?.test(view.url)),
-    )?.id;
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @returns {boolean}
-   */
-  isWebContext() {
-    return !!this.curContext && this.curContext !== NATIVE_WIN;
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @returns {boolean}
-   */
-  isWebview() {
-    return this.isWebContext();
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @returns {Promise<RemoteDebugger>}
-   */
-  async getNewRemoteDebugger() {
-    const socketPath = this.isRealDevice()
-      ? undefined
-      : (await /** @type {import('../driver').Simulator} */ (this.device).getWebInspectorSocket() ?? undefined);
-    return createRemoteDebugger(
-      {
-        bundleId: this.opts.bundleId,
-        additionalBundleIds: this.opts.additionalWebviewBundleIds,
-        isSafari: this.isSafari(),
-        includeSafari: this.opts.includeSafariInWebviews,
-        pageLoadMs: this.pageLoadMs,
-        platformVersion: this.opts.platformVersion,
-        socketPath,
-        remoteDebugProxy: this.opts.remoteDebugProxy,
-        garbageCollectOnExecute: util.hasValue(this.opts.safariGarbageCollect)
-          ? !!this.opts.safariGarbageCollect
-          : false,
-        udid: this.opts.udid,
-        logAllCommunication: this.opts.safariLogAllCommunication,
-        logAllCommunicationHexDump: this.opts.safariLogAllCommunicationHexDump,
-        socketChunkSize: this.opts.safariSocketChunkSize,
-        webInspectorMaxFrameLength: this.opts.safariWebInspectorMaxFrameLength,
-        pageLoadStrategy: this.caps.pageLoadStrategy,
-      },
-      this.isRealDevice(),
-    );
-  },
-};
+/**
+ * @this {XCUITestDriver}
+ * @returns {boolean}
+ */
+export function isWebContext() {
+  return !!this.curContext && this.curContext !== NATIVE_WIN;
+}
 
-const commands = {
-  /**
-   * @this {XCUITestDriver}
-   * @returns {Promise<string>}
-   */
-  async getCurrentContext() {
-    if (this.curContext && this.curContext !== NATIVE_WIN) {
-      return `${WEBVIEW_BASE}${this.curContext}`;
-    }
-    return NATIVE_WIN;
-  },
+/**
+ * @this {XCUITestDriver}
+ * @returns {boolean}
+ */
+export function isWebview() {
+  return this.isWebContext();
+}
 
-  /**
-   * Set context
-   *
-   * @param {string|Context} name - The name of context to set. It could be 'null' as NATIVE_WIN.
-   * @param {any} [callback] The callback. (It is not called in this method)
-   * @param {boolean} [skipReadyCheck=false] - Whether it waits for the new context is ready
-   * @this {XCUITestDriver}
-   * @returns {Promise<void>}
-   */
-  async setContext(name, callback, skipReadyCheck = false) {
-    function alreadyInContext(desired, current) {
+/**
+ * @this {XCUITestDriver}
+ * @returns {Promise<RemoteDebugger>}
+ */
+export async function getNewRemoteDebugger() {
+  const socketPath = this.isRealDevice()
+    ? undefined
+    : (await /** @type {import('../driver').Simulator} */ (this.device).getWebInspectorSocket() ?? undefined);
+  return createRemoteDebugger(
+    {
+      bundleId: this.opts.bundleId,
+      additionalBundleIds: this.opts.additionalWebviewBundleIds,
+      isSafari: this.isSafari(),
+      includeSafari: this.opts.includeSafariInWebviews,
+      pageLoadMs: this.pageLoadMs,
+      platformVersion: this.opts.platformVersion,
+      socketPath,
+      remoteDebugProxy: this.opts.remoteDebugProxy,
+      garbageCollectOnExecute: util.hasValue(this.opts.safariGarbageCollect)
+        ? !!this.opts.safariGarbageCollect
+        : false,
+      udid: this.opts.udid,
+      logAllCommunication: this.opts.safariLogAllCommunication,
+      logAllCommunicationHexDump: this.opts.safariLogAllCommunicationHexDump,
+      socketChunkSize: this.opts.safariSocketChunkSize,
+      webInspectorMaxFrameLength: this.opts.safariWebInspectorMaxFrameLength,
+      pageLoadStrategy: this.caps.pageLoadStrategy,
+    },
+    this.isRealDevice(),
+  );
+}
+
+/**
+ * @this {XCUITestDriver}
+ * @returns {Promise<string>}
+ */
+export async function getCurrentContext() {
+  if (this.curContext && this.curContext !== NATIVE_WIN) {
+    return `${WEBVIEW_BASE}${this.curContext}`;
+  }
+  return NATIVE_WIN;
+}
+
+/**
+ * Set context
+ *
+ * @param {string|Context} name - The name of context to set. It could be 'null' as NATIVE_WIN.
+ * @param {any} [callback] The callback. (It is not called in this method)
+ * @param {boolean} [skipReadyCheck=false] - Whether it waits for the new context is ready
+ * @this {XCUITestDriver}
+ * @returns {Promise<void>}
+ */
+export async function setContext(name, callback, skipReadyCheck = false) {
+  function alreadyInContext(desired, current) {
       return (
         desired === current ||
         (desired === null && current === NATIVE_WIN) ||
@@ -563,88 +567,90 @@ const commands = {
       if (this.logs.safariNetwork) {
         (/** @type {RemoteDebugger} */ (this.remote)).startNetwork(
           this.logs.safariNetwork.onNetworkEvent.bind(this.logs.safariNetwork),
-        );
-      }
-    }
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @returns {Promise<string[]|FullContext[]>}
-   */
-  async getContexts() {
-    this.log.debug('Getting list of available contexts');
-    const contexts = await this.getContextsAndViews(false);
-
-    if (this.opts.fullContextList) {
-      return /** @type {import('./types').FullContext[]} */ (
-        contexts.map((context) => ({
-          id: context.id.toString(),
-          title: context.view?.title,
-          url: context.view?.url,
-          bundleId: context.view?.bundleId,
-        }))
       );
     }
-    return /** @type {string[]} */ (contexts.map((context) => context.id.toString()));
-  },
+  }
+}
 
-  /**
-   * @this {XCUITestDriver}
-   * @param {string} name
-   * @param {boolean} [skipReadyCheck]
-   * @returns {Promise<void>}
-   */
-  async setWindow(name, skipReadyCheck) {
-    if (!this.isWebContext()) {
-      // https://github.com/appium/appium/issues/20710
-      return;
-    }
-    try {
-      await this.setContext(name, _.noop, skipReadyCheck);
-    } catch (err) {
-      // translate the error in terms of windows
-      throw isErrorType(err, errors.NoSuchContextError) ? new errors.NoSuchWindowError() : err;
-    }
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @returns {Promise<string>}
-   */
-  async getWindowHandle() {
-    if (!this.isWebContext()) {
-      // https://github.com/appium/appium/issues/20710
-      return DEFAULT_NATIVE_WINDOW_HANDLE;
-    }
-    if (!this.curContext) {
-      throw new errors.InvalidContextError();
-    }
-    this.log.debug(`Getting current window handle`);
-    return this.curContext;
-  },
-  /**
-   * @this {XCUITestDriver}
-   * @returns {Promise<string[]>}
-   */
-  async getWindowHandles() {
-    if (!this.isWebContext()) {
-      // https://github.com/appium/appium/issues/20710
-      return [DEFAULT_NATIVE_WINDOW_HANDLE];
-    }
-    this.log.debug('Getting list of available window handles');
-    const contexts = await this.getContextsAndViews(false);
-    return (
-      contexts
-        // get rid of the native app context
-        .filter((context) => context.id !== NATIVE_WIN)
-        // get the `app.id` format expected
-        .map((context) =>
-          // This is non-nullable because the `FullContext` having `id` `NATIVE_WIN`
-          // _looks like_ the only with an empty view.
-          context.view?.id?.toString() ?? ''
-        )
+/**
+ * @this {XCUITestDriver}
+ * @returns {Promise<string[]|FullContext[]>}
+ */
+export async function getContexts() {
+  this.log.debug('Getting list of available contexts');
+  const contexts = await this.getContextsAndViews(false);
+
+  if (this.opts.fullContextList) {
+    return /** @type {import('./types').FullContext[]} */ (
+      contexts.map((context) => ({
+        id: context.id.toString(),
+        title: context.view?.title,
+        url: context.view?.url,
+        bundleId: context.view?.bundleId,
+      }))
     );
-  },
-};
+  }
+  return /** @type {string[]} */ (contexts.map((context) => context.id.toString()));
+}
+
+/**
+ * @this {XCUITestDriver}
+ * @param {string} name
+ * @param {boolean} [skipReadyCheck]
+ * @returns {Promise<void>}
+ */
+export async function setWindow(name, skipReadyCheck) {
+  if (!this.isWebContext()) {
+    // https://github.com/appium/appium/issues/20710
+    return;
+  }
+  try {
+    await this.setContext(name, _.noop, skipReadyCheck);
+  } catch (err) {
+    // translate the error in terms of windows
+    throw isErrorType(err, errors.NoSuchContextError) ? new errors.NoSuchWindowError() : err;
+  }
+}
+
+/**
+ * @this {XCUITestDriver}
+ * @returns {Promise<string>}
+ */
+export async function getWindowHandle() {
+  if (!this.isWebContext()) {
+    // https://github.com/appium/appium/issues/20710
+    return DEFAULT_NATIVE_WINDOW_HANDLE;
+  }
+  if (!this.curContext) {
+    throw new errors.InvalidContextError();
+  }
+  this.log.debug(`Getting current window handle`);
+  return this.curContext;
+}
+
+/**
+ * @this {XCUITestDriver}
+ * @returns {Promise<string[]>}
+ */
+export async function getWindowHandles() {
+  if (!this.isWebContext()) {
+    // https://github.com/appium/appium/issues/20710
+    return [DEFAULT_NATIVE_WINDOW_HANDLE];
+  }
+  this.log.debug('Getting list of available window handles');
+  const contexts = await this.getContextsAndViews(false);
+  return (
+    contexts
+      // get rid of the native app context
+      .filter((context) => context.id !== NATIVE_WIN)
+      // get the `app.id` format expected
+      .map((context) =>
+        // This is non-nullable because the `FullContext` having `id` `NATIVE_WIN`
+        // _looks like_ the only with an empty view.
+        context.view?.id?.toString() ?? ''
+    )
+  );
+}
 
 /**
  * Checks if a URL is blacklisted in the 'safariIgnoreWebHostnames' capability
@@ -691,7 +697,6 @@ export async function notifyBiDiContextChange() {
   this.eventEmitter.emit(BIDI_EVENT_NAME, makeObsoleteContextUpdatedEvent(name));
 }
 
-export default {...helpers, ...extensions, ...commands};
 
 /**
  * @typedef {import('../driver').XCUITestDriver} XCUITestDriver