appium-mac2-driver 4.5.0 → 4.6.0

package/node_modules/@appium/base-driver/lib/express/websocket.ts

@@ -0,0 +1,71 @@
+import {util} from '@appium/support';
+import type {AppiumServer, WSServer} from '@appium/types';
+
+export const DEFAULT_WS_PATHNAME_PREFIX = '/ws';
+
+/**
+ * Adds a WebSocket handler to this server's mapping.
+ * @see AppiumServerExtension.addWebSocketHandler
+ */
+export async function addWebSocketHandler(
+  this: AppiumServer,
+  handlerPathname: string,
+  handlerServer: WSServer,
+): Promise<void> {
+  this.webSocketsMapping[handlerPathname] = handlerServer;
+}
+
+/**
+ * Returns WebSocket handlers for this server, optionally filtered by pathname.
+ * @see AppiumServerExtension.getWebSocketHandlers
+ */
+export async function getWebSocketHandlers(
+  this: AppiumServer,
+  keysFilter: string | null = null,
+): Promise<Record<string, WSServer>> {
+  return Object.entries(this.webSocketsMapping).reduce<Record<string, WSServer>>((acc, [pathname, wsServer]) => {
+    if (typeof keysFilter !== 'string' || pathname.includes(keysFilter)) {
+      acc[pathname] = wsServer;
+    }
+    return acc;
+  }, {});
+}
+
+/**
+ * Removes a WebSocket handler by pathname.
+ * @see AppiumServerExtension.removeWebSocketHandler
+ */
+export async function removeWebSocketHandler(this: AppiumServer, handlerPathname: string): Promise<boolean> {
+  const wsServer = this.webSocketsMapping?.[handlerPathname];
+  if (!wsServer) {
+    return false;
+  }
+
+  try {
+    wsServer.close();
+    for (const client of wsServer.clients || []) {
+      client.terminate();
+    }
+    return true;
+  } catch {
+    // ignore
+  } finally {
+    delete this.webSocketsMapping[handlerPathname];
+  }
+  return false;
+}
+
+/**
+ * Removes all WebSocket handlers from this server.
+ * @see AppiumServerExtension.removeAllWebSocketHandlers
+ */
+export async function removeAllWebSocketHandlers(this: AppiumServer): Promise<boolean> {
+  if (util.isEmpty(this.webSocketsMapping)) {
+    return false;
+  }
+
+  const results = await Promise.all(
+    Object.keys(this.webSocketsMapping).map((pathname) => this.removeWebSocketHandler(pathname)),
+  );
+  return results.some(Boolean);
+}

package/node_modules/@appium/base-driver/lib/helpers/capabilities.ts

@@ -0,0 +1,87 @@
+import {util} from '@appium/support';
+import type {AppiumLogger, Capabilities, Constraints, W3CCapabilities} from '@appium/types';
+
+/**
+ * Determine whether the given argument is valid
+ * W3C capabilities instance.
+ */
+export function isW3cCaps(caps: unknown): caps is W3CCapabilities<Constraints> {
+  if (!util.isPlainObject(caps)) {
+    return false;
+  }
+
+  const c = caps as Record<string, unknown>;
+  const isFirstMatchValid = () =>
+    Array.isArray(c.firstMatch) &&
+    !util.isEmpty(c.firstMatch) &&
+    c.firstMatch.every((item) => util.isPlainObject(item));
+  const isAlwaysMatchValid = () => util.isPlainObject(c.alwaysMatch);
+  if (Object.hasOwn(c, 'firstMatch') && Object.hasOwn(c, 'alwaysMatch')) {
+    return isFirstMatchValid() && isAlwaysMatchValid();
+  }
+  if (Object.hasOwn(c, 'firstMatch')) {
+    return isFirstMatchValid();
+  }
+  if (Object.hasOwn(c, 'alwaysMatch')) {
+    return isAlwaysMatchValid();
+  }
+  return false;
+}
+
+/**
+ * Normalize capability values according to constraints (e.g. string 'true' → boolean).
+ */
+export function fixCaps<C extends Constraints>(
+  oldCaps: Record<string, unknown>,
+  desiredCapConstraints: C,
+  log: AppiumLogger,
+): Capabilities<C> {
+  const caps = {...oldCaps} as Record<string, unknown>;
+
+  const logCastWarning = (prefix: string) => log.warn(`${prefix}. This may cause unexpected behavior`);
+
+  // boolean capabilities can be passed in as strings 'false' and 'true'
+  // which we want to translate into boolean values
+  const booleanCaps = Object.keys(desiredCapConstraints).filter(
+    (key) => desiredCapConstraints[key as keyof C]?.isBoolean === true,
+  );
+  for (const cap of booleanCaps) {
+    const value = oldCaps[cap];
+    if (typeof value !== 'string') {
+      continue;
+    }
+
+    if (!['true', 'false'].includes(value.toLowerCase())) {
+      logCastWarning(`String capability '${cap}' ('${value}') cannot be converted to a boolean`);
+      continue;
+    }
+
+    logCastWarning(`Capability '${cap}' changed from string '${value}' to boolean`);
+    caps[cap] = value.toLowerCase() === 'true';
+  }
+
+  // int capabilities are often sent in as strings by frameworks
+  const intCaps = Object.keys(desiredCapConstraints).filter(
+    (key) => desiredCapConstraints[key as keyof C]?.isNumber === true,
+  );
+  for (const cap of intCaps) {
+    const value = oldCaps[cap];
+    if (typeof value !== 'string') {
+      continue;
+    }
+
+    const intValue = parseInt(value as string, 10);
+    const floatValue = parseFloat(value as string);
+    const newValue = floatValue !== intValue ? floatValue : intValue;
+
+    if (Number.isNaN(newValue)) {
+      logCastWarning(`String capability '${cap}' ('${value}') cannot be converted to a number`);
+      continue;
+    }
+
+    logCastWarning(`Capability '${cap}' changed from string '${value}' to number ${newValue}`);
+    caps[cap] = newValue;
+  }
+
+  return caps as Capabilities<C>;
+}

package/node_modules/@appium/base-driver/lib/helpers/extension-command-name.ts

@@ -0,0 +1,25 @@
+import {util} from '@appium/support';
+import type {Constraints, Driver, DriverClass} from '@appium/types';
+
+import type {BaseDriver} from '../basedriver/driver';
+
+/**
+ * Resolves the name of extension method corresponding to an `execute` command string
+ * based on the driver's `executeMethodMap`.
+ *
+ * @param commandName - The command name to resolve.
+ * @returns The resolved extension command name if a mapping exists. Otherwise, the original command name.
+ */
+export function resolveExecuteExtensionName<C extends Constraints>(this: BaseDriver<C>, commandName: string): string {
+  const Driver = this.constructor as DriverClass<Driver<C>>;
+  const methodMap = Driver.executeMethodMap;
+
+  if (methodMap && util.isPlainObject(methodMap) && commandName in methodMap) {
+    const command = methodMap[commandName]?.command;
+    if (typeof command === 'string') {
+      return command;
+    }
+  }
+
+  return commandName;
+}

package/node_modules/@appium/base-driver/lib/helpers/levenshtein-match.ts

@@ -0,0 +1,75 @@
+import type {StringRecord} from '@appium/types';
+import {distance} from 'fastest-levenshtein';
+
+/**
+ * Inclusive maximum Levenshtein edit distance for offering a "did you mean" hint.
+ * Matches with distance greater than this value are treated as unrelated.
+ */
+export const LEVENSHTEIN_SUGGESTION_MAX_EDIT_DISTANCE = 2;
+
+export interface LevenshteinRankResult {
+  /** Candidates sorted by ascending edit distance from `target`, then alphabetically within ties. */
+  sorted: string[];
+  /** Closest name only if its edit distance is at most `maxEditDistance` (inclusive). */
+  suggestion: string | undefined;
+}
+
+/**
+ * Sorts candidates by Levenshtein distance from `target` and optionally picks a suggestion
+ * when the closest match is within `maxEditDistance` edits (single pass over candidates).
+ */
+export function rankLevenshteinCandidates(
+  target: string,
+  candidates: readonly string[],
+  maxEditDistance: number = LEVENSHTEIN_SUGGESTION_MAX_EDIT_DISTANCE,
+): LevenshteinRankResult {
+  if (!candidates.length) {
+    return {sorted: [], suggestion: undefined};
+  }
+
+  const matchesMap: StringRecord<string[]> = candidates
+    .map((name) => [distance(target, name), name] as const)
+    .reduce(
+      (acc, [dist, name]) => {
+        const key = String(dist);
+        if (key in acc) {
+          acc[key].push(name);
+        } else {
+          acc[key] = [name];
+        }
+        return acc;
+      },
+      {} as StringRecord<string[]>,
+    );
+  const sortedDistanceKeys = Object.keys(matchesMap).sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+  const sorted = sortedDistanceKeys.flatMap((k) => (matchesMap[k] ?? []).sort());
+
+  const best = sorted[0];
+  const firstDistanceKey = sortedDistanceKeys[0];
+  const minDist = firstDistanceKey !== undefined ? parseInt(firstDistanceKey, 10) : NaN;
+  const suggestion =
+    maxEditDistance >= 0 && best !== undefined && !Number.isNaN(minDist) && minDist <= maxEditDistance
+      ? best
+      : undefined;
+  return {sorted, suggestion};
+}
+
+/**
+ * Sorts strings by ascending Levenshtein distance from `target`.
+ * Strings with the same distance are sorted alphabetically.
+ */
+export function sortByLevenshteinDistance(target: string, candidates: readonly string[]): string[] {
+  return rankLevenshteinCandidates(target, candidates, Number.POSITIVE_INFINITY).sorted;
+}
+
+/**
+ * Returns the closest string in `candidates` by Levenshtein distance only if that
+ * distance is at most `maxEditDistance` (inclusive).
+ */
+export function getLevenshteinSuggestion(
+  target: string,
+  candidates: readonly string[],
+  maxEditDistance: number = LEVENSHTEIN_SUGGESTION_MAX_EDIT_DISTANCE,
+): string | undefined {
+  return rankLevenshteinCandidates(target, candidates, maxEditDistance).suggestion;
+}

package/node_modules/@appium/base-driver/lib/helpers/session.ts

@@ -0,0 +1,8 @@
+/**
+ * Extract the first 8 characters of session ID to prefix the log.
+ *
+ * @param sessionId session identifier
+ */
+export function calcSignature(sessionId: string): string {
+  return sessionId.substring(0, 8);
+}

package/node_modules/@appium/base-driver/lib/index.ts

@@ -0,0 +1,50 @@
+// BaseDriver exports
+export {ExtensionCore} from './basedriver/extension-core';
+import {BaseDriver} from './basedriver/driver';
+export {DriverCore} from './basedriver/core';
+export {DeviceSettings} from './basedriver/device-settings';
+export {AppiumIpc} from './basedriver/ipc';
+
+export {BaseDriver};
+export default BaseDriver;
+export {DEFAULT_BASE_PATH, MAX_LOG_BODY_LENGTH, PROTOCOLS, W3C_ELEMENT_KEY} from './constants';
+
+// MJSONWP exports
+export * from './protocol';
+export {errorFromMJSONWPStatusCode as errorFromCode} from './protocol';
+
+// Express exports
+/** @deprecated Removed in Appium 4. Use hard-copied test fixtures in driver CI instead. */
+export {normalizeBasePath, server} from './express/server';
+export {TEST_FIXTURES_DIR as STATIC_DIR} from './test-pages';
+
+// jsonwp-proxy exports
+/** @deprecated The JWProxy export is deprecated. Please use WebDriverProxy instead */
+export {JWProxy} from './jsonwp-proxy/proxy';
+export {JWProxy as WebDriverProxy} from './jsonwp-proxy/proxy';
+
+// jsonwp-status exports
+export {codes as statusCodes, getSummaryByCode} from './jsonwp-status/status';
+
+// W3C capabilities parser
+export {
+  isStandardCap,
+  PREFIXED_APPIUM_OPTS_CAP,
+  processCapabilities,
+  promoteAppiumOptions,
+  promoteAppiumOptionsForObject,
+  STANDARD_CAPS,
+  validateCaps,
+} from './basedriver/capabilities';
+
+// Web socket helpers
+export {DEFAULT_WS_PATHNAME_PREFIX} from './express/websocket';
+
+// BiDi exports
+export {BIDI_COMMANDS} from './protocol/bidi-commands';
+
+export {generateDriverLogPrefix} from './basedriver/helpers';
+
+export {isW3cCaps} from './helpers/capabilities';
+
+export type {ServerOpts} from './express/server';

package/node_modules/@appium/base-driver/lib/jsonwp-proxy/protocol-converter.ts

@@ -0,0 +1,246 @@
+import {logger, util} from '@appium/support';
+import type {AppiumLogger, HTTPBody, ProxyResponse} from '@appium/types';
+
+import {duplicateKeys} from '../basedriver/helpers';
+import {MJSONWP_ELEMENT_KEY, PROTOCOLS, W3C_ELEMENT_KEY} from '../constants';
+
+export type ProxyFunction = (url: string, method: string, body?: HTTPBody) => Promise<[ProxyResponse, HTTPBody]>;
+
+export const COMMAND_URLS_CONFLICTS = [
+  {
+    commandNames: ['execute', 'executeAsync'],
+    jsonwpConverter: (url: string) => url.replace(/\/execute.*/, url.includes('async') ? '/execute_async' : '/execute'),
+    w3cConverter: (url: string) =>
+      url.replace(/\/execute.*/, url.includes('async') ? '/execute/async' : '/execute/sync'),
+  },
+  {
+    commandNames: ['getElementScreenshot'],
+    jsonwpConverter: (url: string) => url.replace(/\/element\/([^/]+)\/screenshot$/, '/screenshot/$1'),
+    w3cConverter: (url: string) => url.replace(/\/screenshot\/([^/]+)/, '/element/$1/screenshot'),
+  },
+  {
+    commandNames: ['getWindowHandles', 'getWindowHandle'],
+    jsonwpConverter(url: string) {
+      return url.endsWith('/window')
+        ? url.replace(/\/window$/, '/window_handle')
+        : url.replace(/\/window\/handle(s?)$/, '/window_handle$1');
+    },
+    w3cConverter(url: string) {
+      return url.endsWith('/window_handle')
+        ? url.replace(/\/window_handle$/, '/window')
+        : url.replace(/\/window_handles$/, '/window/handles');
+    },
+  },
+  {
+    commandNames: ['getProperty'],
+    jsonwpConverter: (w3cUrl: string) => {
+      const w3cPropertyRegex = /\/element\/([^/]+)\/property\/([^/]+)/;
+      return w3cUrl.replace(w3cPropertyRegex, '/element/$1/attribute/$2');
+    },
+    // Don't convert JSONWP URL to W3C. W3C accepts /attribute and /property
+    w3cConverter: (jsonwpUrl: string) => jsonwpUrl,
+  },
+] as const;
+
+const {MJSONWP, W3C} = PROTOCOLS;
+const DEFAULT_LOG = logger.getLogger('Protocol Converter');
+
+export class ProtocolConverter {
+  private _downstreamProtocol: string | null | undefined = null;
+  private readonly _log: AppiumLogger | null;
+
+  /**
+   * @param proxyFunc - Function to perform the actual proxy request
+   * @param log - Logger instance, or null to use the default
+   */
+  constructor(
+    public proxyFunc: ProxyFunction,
+    log: AppiumLogger | null = null,
+  ) {
+    this._log = log;
+  }
+
+  get log(): AppiumLogger {
+    return this._log ?? DEFAULT_LOG;
+  }
+
+  get downstreamProtocol(): string | null | undefined {
+    return this._downstreamProtocol;
+  }
+
+  set downstreamProtocol(value: string | null | undefined) {
+    this._downstreamProtocol = value;
+  }
+
+  /**
+   * Handle "crossing" endpoints for the case when upstream and downstream
+   * drivers operate different protocols.
+   */
+  async convertAndProxy(
+    commandName: string,
+    url: string,
+    method: string,
+    body?: HTTPBody,
+  ): Promise<[ProxyResponse, HTTPBody]> {
+    if (!this.downstreamProtocol) {
+      return await this.proxyFunc(url, method, body);
+    }
+
+    // Same url, but different arguments
+    switch (commandName) {
+      case 'timeouts':
+        return await this.proxySetTimeouts(url, method, body);
+      case 'setWindow':
+        return await this.proxySetWindow(url, method, body);
+      case 'setValue':
+        return await this.proxySetValue(url, method, body);
+      case 'performActions':
+        return await this.proxyPerformActions(url, method, body);
+      case 'releaseActions':
+        return await this.proxyReleaseActions(url, method);
+      case 'setFrame':
+        return await this.proxySetFrame(url, method, body);
+      default:
+        break;
+    }
+
+    // Same arguments, but different URLs
+    for (const {commandNames, jsonwpConverter, w3cConverter} of COMMAND_URLS_CONFLICTS) {
+      if (!(commandNames as readonly string[]).includes(commandName)) {
+        continue;
+      }
+      const rewrittenUrl = this.downstreamProtocol === MJSONWP ? jsonwpConverter(url) : w3cConverter(url);
+      if (rewrittenUrl === url) {
+        this.log.debug(`Did not know how to rewrite the original URL '${url}' for ${this.downstreamProtocol} protocol`);
+        break;
+      }
+      this.log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' for ${this.downstreamProtocol} protocol`);
+      return await this.proxyFunc(rewrittenUrl, method, body);
+    }
+
+    // No matches found. Proceed normally
+    return await this.proxyFunc(url, method, body);
+  }
+
+  /**
+   * W3C /timeouts can take as many as 3 timeout types at once, MJSONWP /timeouts only takes one
+   * at a time. So if we're using W3C and proxying to MJSONWP and there's more than one timeout type
+   * provided in the request, we need to do 3 proxies and combine the result.
+   */
+  private getTimeoutRequestObjects(body: HTTPBody): Record<string, unknown>[] {
+    if (body == null) {
+      return [];
+    }
+
+    const bodyObj = (util.safeJsonParse(body) as Record<string, unknown>) ?? {};
+    if (this.downstreamProtocol === W3C && Object.hasOwn(bodyObj, 'ms') && Object.hasOwn(bodyObj, 'type')) {
+      const typeToW3C = (x: string) => (x === 'page load' ? 'pageLoad' : x);
+      return [
+        {
+          [typeToW3C(bodyObj.type as string)]: bodyObj.ms,
+        },
+      ];
+    }
+
+    if (this.downstreamProtocol === MJSONWP && (!Object.hasOwn(bodyObj, 'ms') || !Object.hasOwn(bodyObj, 'type'))) {
+      const typeToJSONWP = (x: string) => (x === 'pageLoad' ? 'page load' : x);
+      return (
+        Object.entries(bodyObj)
+          // Only transform the entry if ms value is a valid positive float number
+          .filter((pair) => /^\d+(?:[.,]\d*?)?$/.test(`${pair[1]}`))
+          .map((pair) => ({
+            type: typeToJSONWP(pair[0]),
+            ms: pair[1],
+          }))
+      );
+    }
+
+    return [bodyObj];
+  }
+
+  /**
+   * Proxy an array of timeout objects and merge the result.
+   */
+  private async proxySetTimeouts(url: string, method: string, body?: HTTPBody): Promise<[ProxyResponse, HTTPBody]> {
+    const timeoutRequestObjects = this.getTimeoutRequestObjects(body);
+    if (timeoutRequestObjects.length === 0) {
+      return await this.proxyFunc(url, method, body);
+    }
+    this.log.debug(
+      'Will send the following request bodies to /timeouts: %s',
+      logger.markSensitive(JSON.stringify(timeoutRequestObjects)),
+    );
+
+    let response!: ProxyResponse;
+    let resBody!: HTTPBody;
+    for (const timeoutObj of timeoutRequestObjects) {
+      [response, resBody] = await this.proxyFunc(url, method, timeoutObj as HTTPBody);
+
+      // If we got a non-MJSONWP response, return the result, nothing left to do
+      if (this.downstreamProtocol !== MJSONWP) {
+        return [response, resBody];
+      }
+      // If we got an error, return the error right away
+      if (response.statusCode >= 400) {
+        return [response, resBody];
+      }
+      // ...Otherwise, continue to the next timeouts call
+    }
+    return [response, resBody];
+  }
+
+  private async proxySetWindow(url: string, method: string, body: HTTPBody): Promise<[ProxyResponse, HTTPBody]> {
+    const bodyObj = util.safeJsonParse(body);
+    if (util.isPlainObject(bodyObj)) {
+      const obj = bodyObj as Record<string, unknown>;
+      if (this.downstreamProtocol === W3C && Object.hasOwn(bodyObj, 'name') && !Object.hasOwn(bodyObj, 'handle')) {
+        this.log.debug(`Copied 'name' value '${obj.name}' to 'handle' as per W3C spec`);
+        return await this.proxyFunc(url, method, {...obj, handle: obj.name});
+      }
+      if (this.downstreamProtocol === MJSONWP && Object.hasOwn(bodyObj, 'handle') && !Object.hasOwn(bodyObj, 'name')) {
+        this.log.debug(`Copied 'handle' value '${obj.handle}' to 'name' as per JSONWP spec`);
+        return await this.proxyFunc(url, method, {...obj, name: obj.handle});
+      }
+    }
+    return await this.proxyFunc(url, method, body);
+  }
+
+  private async proxySetValue(url: string, method: string, body: HTTPBody): Promise<[ProxyResponse, HTTPBody]> {
+    const bodyObj = util.safeJsonParse(body) as Record<string, unknown> | undefined;
+    if (util.isPlainObject(bodyObj) && (util.hasValue(bodyObj?.text) || util.hasValue(bodyObj?.value))) {
+      let {text, value} = bodyObj;
+      if (util.hasValue(text) && !util.hasValue(value)) {
+        value = typeof text === 'string' ? [...text] : Array.isArray(text) ? text : [];
+        this.log.debug(`Added 'value' property to 'setValue' request body`);
+      } else if (!util.hasValue(text) && util.hasValue(value)) {
+        text = Array.isArray(value) ? value.join('') : typeof value === 'string' ? value : '';
+        this.log.debug(`Added 'text' property to 'setValue' request body`);
+      }
+      return await this.proxyFunc(url, method, {...bodyObj, text, value});
+    }
+    return await this.proxyFunc(url, method, body);
+  }
+
+  private async proxySetFrame(url: string, method: string, body: HTTPBody): Promise<[ProxyResponse, HTTPBody]> {
+    const bodyObj = util.safeJsonParse(body);
+    if (Object.hasOwn(bodyObj ?? {}, 'id') && util.isPlainObject((bodyObj as Record<string, unknown>).id)) {
+      return await this.proxyFunc(url, method, {
+        ...(bodyObj as object),
+        id: duplicateKeys((bodyObj as Record<string, unknown>).id as object, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY),
+      });
+    }
+    return await this.proxyFunc(url, method, body);
+  }
+
+  private async proxyPerformActions(url: string, method: string, body: HTTPBody): Promise<[ProxyResponse, HTTPBody]> {
+    const bodyObj = util.safeJsonParse(body);
+    if (util.isPlainObject(bodyObj)) {
+      return await this.proxyFunc(url, method, duplicateKeys(bodyObj as object, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY));
+    }
+    return await this.proxyFunc(url, method, body);
+  }
+
+  private async proxyReleaseActions(url: string, method: string): Promise<[ProxyResponse, HTTPBody]> {
+    return await this.proxyFunc(url, method);
+  }
+}

package/node_modules/@appium/base-driver/lib/jsonwp-proxy/proxy-request.ts

@@ -0,0 +1,52 @@
+import axios from 'axios';
+
+export class ProxyRequest {
+  private readonly _requestConfig: axios.RawAxiosRequestConfig;
+  private _resultPromise: Promise<axios.AxiosResponse> | null;
+  private _abortController: AbortController | null;
+  private _cancelled: boolean;
+
+  constructor(requestConfig: axios.RawAxiosRequestConfig<any>) {
+    this._requestConfig = requestConfig;
+    this._resultPromise = null;
+    this._abortController = null;
+    this._cancelled = false;
+  }
+
+  async execute(): Promise<axios.AxiosResponse> {
+    if (this._resultPromise) {
+      return await this._resultPromise;
+    }
+
+    const abortController = new AbortController();
+    this._abortController = abortController;
+    this._cancelled = false;
+
+    try {
+      this._resultPromise = this._makeRequest(abortController.signal);
+      return await this._resultPromise;
+    } finally {
+      this._abortController = null;
+    }
+  }
+
+  cancel(): void {
+    this._cancelled = true;
+    this._abortController?.abort();
+  }
+
+  private async _makeRequest(signal: AbortSignal): Promise<axios.AxiosResponse> {
+    try {
+      return await axios({
+        ...this._requestConfig,
+        signal,
+      });
+    } catch (err) {
+      if (this._cancelled && axios.isCancel(err)) {
+        // The request was cancelled; do not propagate the error to callers.
+        return await new Promise<axios.AxiosResponse>(() => {});
+      }
+      throw err;
+    }
+  }
+}