appium-mac2-driver 4.3.5 → 4.4.0

package/node_modules/@appium/support/node_modules/asyncbox/lib/asyncbox.ts

@@ -1,365 +0,0 @@
-import {limitFunction} from 'p-limit';
-
-import type {
-  CancellablePromise,
-  LongSleepOptions,
-  MapFilterOptions,
-  SleepArg,
-  SleepOptions,
-  WaitForConditionOptions,
-} from './types.js';
-
-const LONG_SLEEP_THRESHOLD = 5000; // anything over 5000ms will turn into a spin
-
-/** Error thrown by {@link withTimeout} when the deadline is exceeded. */
-export class TimeoutError extends Error {
-  constructor(message?: string) {
-    super(message ?? 'Operation timed out');
-    this.name = 'TimeoutError';
-  }
-}
-
-/** Thrown when a promise is cancelled via `cancel`. */
-export class PromiseCancellationError extends Error {
-  constructor(message: string = 'Promise cancelled') {
-    super(message);
-    this.name = 'PromiseCancellationError';
-  }
-}
-
-/**
- * An async/await version of `setTimeout`. The returned promise has a `cancel()` method that clears
- * the timer and usually rejects with {@link PromiseCancellationError} unless you use the object form with
- * `cancelError: null` to resolve on cancel.
- *
- * @param ms - Milliseconds to wait
- * @returns A thenable you can `await`; call `.cancel()` to abort early.
- */
-export function sleep(ms: number): CancellablePromise<void>;
-/**
- * Object form: `ms` plus optional `cancelError` (non-empty string or `Error`, `null` to resolve on
- * cancel, or omitted / `undefined` / `''` for default {@link PromiseCancellationError}). Any non-array
- * object with a finite `ms` is accepted at runtime (including class instances), matching structural typing.
- *
- * @param options - Duration and optional cancellation behavior
- * @returns A thenable you can `await`; call `.cancel()` to abort early.
- */
-export function sleep(options: SleepOptions): CancellablePromise<void>;
-export function sleep(arg: SleepArg): CancellablePromise<void> {
-  const {ms, cancelError} = parseSleepArg(arg);
-  let timeoutId: NodeJS.Timeout | undefined;
-  let resolveFn: ((value: void) => void) | undefined;
-  let rejectFn: ((error: Error) => void) | undefined;
-
-  const promise = new Promise<void>((resolve, reject) => {
-    resolveFn = resolve;
-    rejectFn = reject;
-    timeoutId = setTimeout(resolve, ms);
-  }) as CancellablePromise<void>;
-
-  promise.cancel = () => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = undefined;
-    }
-    if (cancelError === null) {
-      resolveFn?.(undefined);
-    } else {
-      let err: Error;
-      if (typeof cancelError === 'string' && cancelError) {
-        err = new PromiseCancellationError(cancelError);
-      } else if (cancelError instanceof Error) {
-        err = cancelError;
-      } else {
-        err = new PromiseCancellationError();
-      }
-      rejectFn?.(err);
-    }
-    resolveFn = undefined;
-    rejectFn = undefined;
-  };
-
-  return promise;
-}
-
-/**
- * Resolves with `promise` or rejects if it does not settle before `timeoutMs`.
- *
- * If the deadline passes first: with no third argument (or a falsy non-error value), rejects
- * with {@link TimeoutError} whose message includes `timeoutMs`; with a non-empty string,
- * rejects with {@link TimeoutError} using that message; with an `Error` instance, rejects
- * with that same instance.
- *
- * @param promise - Promise to race against the timeout.
- * @param timeoutMs - Maximum time in milliseconds before rejecting if `promise` has not settled.
- * @param messageOrError - Optional override for the timeout rejection: custom {@link TimeoutError}
- * message when the string is non-empty, or an existing `Error` to reject with verbatim.
- * Omitted, `undefined`, or other falsy non-error values use the default timeout message (includes `timeoutMs`).
- */
-export async function withTimeout<T>(
-  promise: Promise<T>,
-  timeoutMs: number,
-  messageOrError?: string | Error,
-): Promise<T> {
-  let timer: NodeJS.Timeout | null = null;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise<T>((_resolve, reject) => {
-        timer = setTimeout(() => {
-          if (typeof messageOrError === 'string' && messageOrError) {
-            reject(new TimeoutError(messageOrError));
-          } else if (!messageOrError) {
-            reject(new TimeoutError(`Operation timed out after ${timeoutMs}ms`));
-          } else {
-            reject(messageOrError);
-          }
-        }, timeoutMs);
-      }),
-    ]);
-  } finally {
-    if (timer) {
-      clearTimeout(timer);
-    }
-  }
-}
-
-/**
- * Sometimes `Promise.delay` or `setTimeout` are inaccurate for large wait
- * times. To safely wait for these long times (e.g. in the 5+ minute range), you
- * can use `longSleep`.
- *
- * You can also pass a `progressCb` option which is a callback function that
- * receives an object with the properties `elapsedMs`, `timeLeft`, and
- * `progress`. This will be called on every wait interval so you can do your
- * wait logging or whatever.
- * @param ms - The number of milliseconds to wait
- * @param options - Options for controlling the long sleep behavior
- */
-export async function longSleep(
-  ms: number,
-  {thresholdMs = LONG_SLEEP_THRESHOLD, intervalMs = 1000, progressCb = null}: LongSleepOptions = {},
-): Promise<void> {
-  if (ms < thresholdMs) {
-    return await sleep(ms);
-  }
-  const endAt = Date.now() + ms;
-  let timeLeft: number;
-  let elapsedMs = 0;
-  do {
-    const pre = Date.now();
-    await sleep(intervalMs);
-    const post = Date.now();
-    timeLeft = endAt - post;
-    elapsedMs = elapsedMs + (post - pre);
-    if (typeof progressCb === 'function') {
-      progressCb({elapsedMs, timeLeft, progress: elapsedMs / ms});
-    }
-  } while (timeLeft > 0);
-}
-
-/**
- * An async/await way of running a method until it doesn't throw an error
- * @param times - The maximum number of times to retry the function
- * @param fn - The async function to retry
- * @param args - Arguments to pass to the function
- */
-export async function retry<T = any>(
-  times: number,
-  fn: (...args: any[]) => Promise<T>,
-  ...args: any[]
-): Promise<T | null> {
-  let tries = 0;
-  let done = false;
-  let res: T | null = null;
-  while (!done && tries < times) {
-    tries++;
-    try {
-      res = await fn(...args);
-      done = true;
-    } catch (err) {
-      if (tries >= times) {
-        throw err;
-      }
-    }
-  }
-  return res;
-}
-
-/**
- * You can also use `retryInterval` to add a sleep in between retries. This can
- * be useful if you want to throttle how fast we retry.
- * @param times - The maximum number of times to retry the function
- * @param sleepMs - The number of milliseconds to wait between retries
- * @param fn - The async function to retry
- * @param args - Arguments to pass to the function
- */
-export async function retryInterval<T = any>(
-  times: number,
-  sleepMs: number,
-  fn: (...args: any[]) => Promise<T>,
-  ...args: any[]
-): Promise<T | null> {
-  let count = 0;
-  const wrapped = async (): Promise<T> => {
-    count++;
-    let res: T;
-    try {
-      res = await fn(...args);
-    } catch (e) {
-      // do not pause when finished the last retry
-      if (count !== times) {
-        await sleep(sleepMs);
-      }
-      throw e;
-    }
-    return res;
-  };
-  return await retry(times, wrapped);
-}
-
-/**
- * Similar to `Array.prototype.map`; runs in parallel, serial, or with custom concurrency pool
- * @param coll - The collection to map over
- * @param mapper - The function to apply to each element
- * @param options - Options for controlling parallelism (default: true - fully parallel)
- */
-export async function asyncmap<T, R>(
-  coll: T[],
-  mapper: (value: T) => R | Promise<R>,
-  options: MapFilterOptions = true,
-): Promise<R[]> {
-  if (options === null) {
-    throw new Error('Options cannot be null');
-  }
-  // limitFunction requires the mapper to always return a promise
-  const mapperAsync = async (value: T): Promise<R> => mapper(value);
-  if (options === false) {
-    return coll.reduce<Promise<R[]>>(
-      async (acc, item) => [...(await acc), await mapperAsync(item)],
-      Promise.resolve([]),
-    );
-  }
-  const adjustedMapper =
-    options === true ? mapperAsync : limitFunction(mapperAsync, {concurrency: options.concurrency});
-  return Promise.all(coll.map(adjustedMapper));
-}
-
-/**
- * Similar to `Array.prototype.filter`; runs in parallel, serial, or with custom concurrency pool
- * @param coll - The collection to filter
- * @param filter - The function to test each element
- * @param options - Options for controlling parallelism (default: true - fully parallel)
- */
-export async function asyncfilter<T>(
-  coll: T[],
-  filter: (value: T) => boolean | Promise<boolean>,
-  options: MapFilterOptions = true,
-): Promise<T[]> {
-  if (options === null) {
-    throw new Error('Options cannot be null');
-  }
-  // limitFunction requires the filter to always return a promise
-  const filterAsync = async (value: T): Promise<boolean> => filter(value);
-  if (options === false) {
-    return coll.reduce<Promise<T[]>>(async (accP, item) => {
-      const acc = await accP;
-      if (await filterAsync(item)) {
-        acc.push(item);
-      }
-      return acc;
-    }, Promise.resolve([]));
-  }
-  const adjustedFilter =
-    options === true ? filterAsync : limitFunction(filterAsync, {concurrency: options.concurrency});
-  const bools = await Promise.all(coll.map(adjustedFilter));
-  return coll.reduce<T[]>((acc, item, i) => {
-    if (bools[i]) {
-      acc.push(item);
-    }
-    return acc;
-  }, []);
-}
-
-/**
- * Takes a condition (a function returning a boolean or boolean promise), and
- * waits until the condition is true.
- *
- * Throws a `/Condition unmet/` error if the condition has not been satisfied
- * within the allocated time, unless an error is provided in the options, as the
- * `error` property, which is either thrown itself, or used as the message.
- *
- * The condition result is returned if it is not falsy. If the condition throws an
- * error then this exception will be immediately passed through.
- *
- * The default options are: `{ waitMs: 5000, intervalMs: 500 }`
- * @param condFn - The condition function to evaluate
- * @param options - Options for controlling the wait behavior
- */
-export async function waitForCondition<T>(
-  condFn: () => Promise<T> | T,
-  options: WaitForConditionOptions = {},
-): Promise<T> {
-  const opts: WaitForConditionOptions & {waitMs: number; intervalMs: number} = {
-    ...options,
-    waitMs: typeof options.waitMs === 'number' ? options.waitMs : 5000,
-    intervalMs: typeof options.intervalMs === 'number' ? options.intervalMs : 500,
-  };
-  const debug = opts.logger ? opts.logger.debug.bind(opts.logger) : () => undefined;
-  const error = opts.error;
-  const begunAt = Date.now();
-  const endAt = begunAt + opts.waitMs;
-  const spin = async function spin(): Promise<T> {
-    const result = await condFn();
-    if (result) {
-      return result;
-    }
-    const now = Date.now();
-    const waited = now - begunAt;
-    const remainingTime = endAt - now;
-    if (now < endAt) {
-      debug(`Waited for ${waited} ms so far`);
-      await sleep(Math.min(opts.intervalMs, remainingTime));
-      return await spin();
-    }
-    // if there is an error option, it is either a string message or an error itself
-    if (error) {
-      throw typeof error === 'string' ? new Error(error) : error;
-    }
-    throw new Error(`Condition unmet after ${waited} ms. Timing out.`);
-  };
-  return await spin();
-}
-
-// Re-export types
-export type {
-  CancellablePromise,
-  Progress,
-  ProgressCallback,
-  LongSleepOptions,
-  SleepArg,
-  SleepOptions,
-  WaitForConditionOptions,
-} from './types.js';
-
-/** Non-array object values (including class instances); excludes `null` and arrays. */
-function isSleepArgObject(value: unknown): value is Record<PropertyKey, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
-function parseSleepArg(arg: SleepArg): {ms: number; cancelError?: string | Error | null} {
-  if (typeof arg === 'number') {
-    if (!Number.isFinite(arg)) {
-      throw new TypeError('sleep: expected a finite number or an object with ms');
-    }
-    return {ms: arg};
-  }
-  if (isSleepArgObject(arg)) {
-    const ms = arg.ms;
-    if (typeof ms !== 'number' || !Number.isFinite(ms)) {
-      throw new TypeError('sleep: options.ms must be a finite number');
-    }
-    return {ms, cancelError: arg.cancelError as string | Error | null | undefined};
-  }
-  throw new TypeError('sleep: expected a finite number or an object with ms');
-}

package/node_modules/@appium/support/node_modules/asyncbox/lib/types.ts

@@ -1,88 +0,0 @@
-/**
- * Parameter provided to a progress callback
- */
-export interface Progress {
-  /** Elapsed time in milliseconds since the operation started */
-  elapsedMs: number;
-  /** Remaining time in milliseconds until the operation completes */
-  timeLeft: number;
-  /** Progress as a number between 0 and 1 (0 = not started, 1 = complete) */
-  progress: number;
-}
-
-/**
- * Progress callback for {@link longSleep}
- */
-export type ProgressCallback = (progress: Progress) => void;
-
-/**
- * Options for {@link longSleep}
- */
-export interface LongSleepOptions {
-  /** Minimum duration in milliseconds before using long sleep behavior.
-   * @default 5000
-   */
-  thresholdMs?: number;
-  /** Interval in milliseconds between progress callbacks.
-   * @default 1000
-   */
-  intervalMs?: number;
-  /** Optional callback function to receive progress updates during the sleep */
-  progressCb?: ProgressCallback | null;
-}
-
-/**
- * Options for {@link asyncmap} and {@link asyncfilter}
- */
-export type MapFilterOptions = boolean | {concurrency: number};
-
-/**
- * Object form of {@link sleep}'s argument: duration plus optional cancellation rejection override.
- * Structural typing allows class instances; {@link sleep} accepts any non-array object with a finite `ms`.
- */
-export interface SleepOptions {
-  /** Duration in milliseconds */
-  ms: number;
-  /**
-   * When {@link sleep}'s `cancel` runs: a non-empty string becomes {@link PromiseCancellationError}
-   * with that message; an `Error` rejects with that same instance; `null` resolves the promise
-   * instead of rejecting; omitted, `undefined`, or `''` use the default {@link PromiseCancellationError}.
-   */
-  cancelError?: string | Error | null;
-}
-
-/**
- * Argument to {@link sleep}: either milliseconds or an options object (see {@link SleepOptions}).
- */
-export type SleepArg = number | SleepOptions;
-
-/**
- * A promise with a {@linkcode cancel} method (e.g. from {@link sleep}).
- *
- * @typeParam T - Resolved value type; {@link sleep} uses `void`.
- */
-export type CancellablePromise<T = void> = Promise<T> & {
-  cancel: () => void;
-};
-
-/**
- * Options for {@link waitForCondition}
- */
-export interface WaitForConditionOptions {
-  /** Maximum time to wait in milliseconds.
-   * @default 5000
-   */
-  waitMs?: number;
-  /** Interval in milliseconds between condition checks.
-   * @default 500
-   */
-  intervalMs?: number;
-  /** Optional logger object with a debug method for logging wait progress */
-  logger?: {
-    debug: (...args: any[]) => void;
-  };
-  /** Custom error message (string) or Error object to throw if condition is not met.
-   * If not provided, a default error is thrown
-   */
-  error?: string | Error;
-}

package/node_modules/@appium/support/node_modules/asyncbox/package.json

@@ -1,74 +0,0 @@
-{
-  "name": "asyncbox",
-  "version": "6.4.2",
-  "description": "A collection of small async/await utilities",
-  "keywords": [
-    "async",
-    "async/await",
-    "es7"
-  ],
-  "bugs": {
-    "url": "https://github.com/appium/asyncbox/issues"
-  },
-  "license": "Apache-2.0",
-  "author": "jlipps@gmail.com",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/appium/asyncbox.git"
-  },
-  "bin": {},
-  "directories": {
-    "lib": "./lib"
-  },
-  "files": [
-    "lib/**/*",
-    "build/cjs/lib/**/*",
-    "build/cjs/package.json",
-    "build/esm/lib/**/*",
-    "build/esm/package.json"
-  ],
-  "type": "module",
-  "main": "./build/cjs/lib/asyncbox.js",
-  "module": "./build/esm/lib/asyncbox.js",
-  "types": "./build/cjs/lib/asyncbox.d.ts",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./build/esm/lib/asyncbox.d.ts",
-        "default": "./build/esm/lib/asyncbox.js"
-      },
-      "require": {
-        "types": "./build/cjs/lib/asyncbox.d.ts",
-        "default": "./build/cjs/lib/asyncbox.js"
-      }
-    },
-    "./package.json": "./package.json"
-  },
-  "scripts": {
-    "build": "tsc -b tsconfig.esm.json tsconfig.cjs.json",
-    "postbuild": "node scripts/postbuild.mjs",
-    "clean": "node -e \"require('fs').rmSync('build', {recursive: true, force: true})\"",
-    "rebuild": "npm run clean; npm run build",
-    "dev": "npm run build -- --watch",
-    "prepare": "npm run rebuild",
-    "test": "node --test --enable-source-maps --test-force-exit --test-timeout=60000 \"./build/esm/test/**/*.spec.js\" \"./test/*.spec.cjs\"",
-    "lint": "oxlint -c oxlint.config.mjs .",
-    "lint:fix": "oxlint -c oxlint.config.mjs --fix .",
-    "format": "oxfmt -c oxfmt.config.mjs .",
-    "format:check": "oxfmt -c oxfmt.config.mjs --check .",
-    "watch": "npm run dev"
-  },
-  "dependencies": {
-    "p-limit": "^7.2.0"
-  },
-  "devDependencies": {
-    "@appium/oxc-config": "^1.1.0",
-    "@appium/semantic-release-config": "^1.1.0",
-    "@appium/tsconfig": "^1.2.0",
-    "@types/node": "^26.1.0"
-  },
-  "engines": {
-    "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
-    "npm": ">=10"
-  }
-}