appium-mac2-driver 4.5.0 → 4.5.1

package/node_modules/async-lock/lib/index.js

@@ -1,312 +0,0 @@
-'use strict';
-
-var AsyncLock = function (opts) {
-	opts = opts || {};
-
-	this.Promise = opts.Promise || Promise;
-
-	// format: {key : [fn, fn]}
-	// queues[key] = null indicates no job running for key
-	this.queues = Object.create(null);
-
-	// lock is reentrant for same domain
-	this.domainReentrant = opts.domainReentrant || false;
-	if (this.domainReentrant) {
-		if (typeof process === 'undefined' || typeof process.domain === 'undefined') {
-			throw new Error(
-				'Domain-reentrant locks require `process.domain` to exist. Please flip `opts.domainReentrant = false`, ' +
-				'use a NodeJS version that still implements Domain, or install a browser polyfill.');
-		}
-		// domain of current running func {key : fn}
-		this.domains = Object.create(null);
-	}
-
-	this.timeout = opts.timeout || AsyncLock.DEFAULT_TIMEOUT;
-	this.maxOccupationTime = opts.maxOccupationTime || AsyncLock.DEFAULT_MAX_OCCUPATION_TIME;
-	this.maxExecutionTime = opts.maxExecutionTime || AsyncLock.DEFAULT_MAX_EXECUTION_TIME;
-	if (opts.maxPending === Infinity || (Number.isInteger(opts.maxPending) && opts.maxPending >= 0)) {
-		this.maxPending = opts.maxPending;
-	} else {
-		this.maxPending = AsyncLock.DEFAULT_MAX_PENDING;
-	}
-};
-
-AsyncLock.DEFAULT_TIMEOUT = 0; //Never
-AsyncLock.DEFAULT_MAX_OCCUPATION_TIME = 0; //Never
-AsyncLock.DEFAULT_MAX_EXECUTION_TIME = 0; //Never
-AsyncLock.DEFAULT_MAX_PENDING = 1000;
-
-/**
- * Acquire Locks
- *
- * @param {String|Array} key 	resource key or keys to lock
- * @param {function} fn 	async function
- * @param {function} cb 	callback function, otherwise will return a promise
- * @param {Object} opts 	options
- */
-AsyncLock.prototype.acquire = function (key, fn, cb, opts) {
-	if (Array.isArray(key)) {
-		return this._acquireBatch(key, fn, cb, opts);
-	}
-
-	if (typeof (fn) !== 'function') {
-		throw new Error('You must pass a function to execute');
-	}
-
-	// faux-deferred promise using new Promise() (as Promise.defer is deprecated)
-	var deferredResolve = null;
-	var deferredReject = null;
-	var deferred = null;
-
-	if (typeof (cb) !== 'function') {
-		opts = cb;
-		cb = null;
-
-		// will return a promise
-		deferred = new this.Promise(function(resolve, reject) {
-			deferredResolve = resolve;
-			deferredReject = reject;
-		});
-	}
-
-	opts = opts || {};
-
-	var resolved = false;
-	var timer = null;
-	var occupationTimer = null;
-	var executionTimer = null;
-	var self = this;
-
-	var done = function (locked, err, ret) {
-
-		if (occupationTimer) {
-			clearTimeout(occupationTimer);
-			occupationTimer = null;
-		}
-
-		if (executionTimer) {
-			clearTimeout(executionTimer);
-			executionTimer = null;
-		}
-
-		if (locked) {
-			if (!!self.queues[key] && self.queues[key].length === 0) {
-				delete self.queues[key];
-			}
-			if (self.domainReentrant) {
-				delete self.domains[key];
-			}
-		}
-
-		if (!resolved) {
-			if (!deferred) {
-				if (typeof (cb) === 'function') {
-					cb(err, ret);
-				}
-			}
-			else {
-				//promise mode
-				if (err) {
-					deferredReject(err);
-				}
-				else {
-					deferredResolve(ret);
-				}
-			}
-			resolved = true;
-		}
-
-		if (locked) {
-			//run next func
-			if (!!self.queues[key] && self.queues[key].length > 0) {
-				self.queues[key].shift()();
-			}
-		}
-	};
-
-	var exec = function (locked) {
-		if (resolved) { // may due to timed out
-			return done(locked);
-		}
-
-		if (timer) {
-			clearTimeout(timer);
-			timer = null;
-		}
-
-		if (self.domainReentrant && locked) {
-			self.domains[key] = process.domain;
-		}
-
-		var maxExecutionTime = opts.maxExecutionTime || self.maxExecutionTime;
-		if (maxExecutionTime) {
-			executionTimer = setTimeout(function () {
-				if (!!self.queues[key]) {
-					done(locked, new Error('Maximum execution time is exceeded ' + key));
-				}
-			}, maxExecutionTime);
-		}
-
-		// Callback mode
-		if (fn.length === 1) {
-			var called = false;
-			try {
-				fn(function (err, ret) {
-					if (!called) {
-						called = true;
-						done(locked, err, ret);
-					}
-				});
-			} catch (err) {
-				// catching error thrown in user function fn
-				if (!called) {
-					called = true;
-					done(locked, err);
-				}
-			}
-		}
-		else {
-			// Promise mode
-			self._promiseTry(function () {
-				return fn();
-			})
-			.then(function(ret){
-				done(locked, undefined, ret);
-			}, function(error){
-				done(locked, error);
-			});
-		}
-	};
-
-	if (self.domainReentrant && !!process.domain) {
-		exec = process.domain.bind(exec);
-	}
-
-	var maxPending = opts.maxPending || self.maxPending;
-
-	if (!self.queues[key]) {
-		self.queues[key] = [];
-		exec(true);
-	}
-	else if (self.domainReentrant && !!process.domain && process.domain === self.domains[key]) {
-		// If code is in the same domain of current running task, run it directly
-		// Since lock is re-enterable
-		exec(false);
-	}
-	else if (self.queues[key].length >= maxPending) {
-		done(false, new Error('Too many pending tasks in queue ' + key));
-	}
-	else {
-		var taskFn = function () {
-			exec(true);
-		};
-		if (opts.skipQueue) {
-			self.queues[key].unshift(taskFn);
-		} else {
-			self.queues[key].push(taskFn);
-		}
-
-		var timeout = opts.timeout || self.timeout;
-		if (timeout) {
-			timer = setTimeout(function () {
-				timer = null;
-				done(false, new Error('async-lock timed out in queue ' + key));
-			}, timeout);
-		}
-	}
-
-	var maxOccupationTime = opts.maxOccupationTime || self.maxOccupationTime;
-		if (maxOccupationTime) {
-			occupationTimer = setTimeout(function () {
-				if (!!self.queues[key]) {
-					done(false, new Error('Maximum occupation time is exceeded in queue ' + key));
-				}
-			}, maxOccupationTime);
-		}
-
-	if (deferred) {
-		return deferred;
-	}
-};
-
-/*
- * Below is how this function works:
- *
- * Equivalent code:
- * self.acquire(key1, function(cb){
- *     self.acquire(key2, function(cb){
- *         self.acquire(key3, fn, cb);
- *     }, cb);
- * }, cb);
- *
- * Equivalent code:
- * var fn3 = getFn(key3, fn);
- * var fn2 = getFn(key2, fn3);
- * var fn1 = getFn(key1, fn2);
- * fn1(cb);
- */
-AsyncLock.prototype._acquireBatch = function (keys, fn, cb, opts) {
-	if (typeof (cb) !== 'function') {
-		opts = cb;
-		cb = null;
-	}
-
-	var self = this;
-	var getFn = function (key, fn) {
-		return function (cb) {
-			self.acquire(key, fn, cb, opts);
-		};
-	};
-
-	var fnx = keys.reduceRight(function (prev, key) {
-		return getFn(key, prev);
-	}, fn);
-
-	if (typeof (cb) === 'function') {
-		fnx(cb);
-	}
-	else {
-		return new this.Promise(function (resolve, reject) {
-			// check for promise mode in case keys is empty array
-			if (fnx.length === 1) {
-				fnx(function (err, ret) {
-					if (err) {
-						reject(err);
-					}
-					else {
-						resolve(ret);
-					}
-				});
-			} else {
-				resolve(fnx());
-			}
-		});
-	}
-};
-
-/*
- *	Whether there is any running or pending asyncFunc
- *
- *	@param {String} key
- */
-AsyncLock.prototype.isBusy = function (key) {
-	if (!key) {
-		return Object.keys(this.queues).length > 0;
-	}
-	else {
-		return !!this.queues[key];
-	}
-};
-
-/**
- * Promise.try() implementation to become independent of Q-specific methods
- */
-AsyncLock.prototype._promiseTry = function(fn) {
-	try {
-		return this.Promise.resolve(fn());
-	} catch (e) {
-		return this.Promise.reject(e);
-	}
-};
-
-module.exports = AsyncLock;

package/node_modules/async-lock/package.json

@@ -1,48 +0,0 @@
-{
-  "name": "async-lock",
-  "description": "Lock on asynchronous code",
-  "version": "1.4.1",
-  "author": {
-    "name": "Rogier Schouten",
-    "url": "https://github.com/rogierschouten/",
-    "email": "github@workingcode.ninja"
-  },
-  "private": false,
-  "homepage": "https://github.com/rogierschouten/async-lock",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/rogierschouten/async-lock.git"
-  },
-  "bugs": {
-    "url": "https://github.com/rogierschouten/async-lock/issues"
-  },
-  "license": "MIT",
-  "keywords": [
-    "lock",
-    "async",
-    "concurrency",
-    "critical",
-    "section",
-    "mutex"
-  ],
-  "engines": {},
-  "scripts": {
-    "start": "grunt",
-    "test": "grunt test"
-  },
-  "devDependencies": {
-    "bluebird": "^3.5.1",
-    "grunt": "^1.0.4",
-    "grunt-cli": "^1.2.0",
-    "grunt-contrib-clean": "^1.1.0",
-    "grunt-contrib-jshint": "^3.2.0",
-    "grunt-contrib-watch": "^1.1.0",
-    "grunt-env": "^1.0.1",
-    "grunt-mocha-test": "^0.13.3",
-    "load-grunt-tasks": "^4.0.0",
-    "lodash": "^4.17.20",
-    "mocha": "^10.2.0",
-    "q": "^1.5.1",
-    "should": "^13.2.1"
-  }
-}

package/node_modules/asyncbox/build/cjs/lib/asyncbox.d.ts

@@ -1,103 +0,0 @@
-import type { CancellablePromise, LongSleepOptions, MapFilterOptions, SleepOptions, WaitForConditionOptions } from './types.js';
-/** Error thrown by {@link withTimeout} when the deadline is exceeded. */
-export declare class TimeoutError extends Error {
-    constructor(message?: string);
-}
-/** Thrown when a promise is cancelled via `cancel`. */
-export declare class PromiseCancellationError extends Error {
-    constructor(message?: string);
-}
-/**
- * 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 declare 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 declare function sleep(options: SleepOptions): CancellablePromise<void>;
-/**
- * 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 declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, messageOrError?: string | Error): Promise<T>;
-/**
- * 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 declare function longSleep(ms: number, { thresholdMs, intervalMs, progressCb }?: LongSleepOptions): Promise<void>;
-/**
- * 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 declare function retry<T = any>(times: number, fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T | null>;
-/**
- * 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 declare function retryInterval<T = any>(times: number, sleepMs: number, fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T | null>;
-/**
- * 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 declare function asyncmap<T, R>(coll: T[], mapper: (value: T) => R | Promise<R>, options?: MapFilterOptions): Promise<R[]>;
-/**
- * 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 declare function asyncfilter<T>(coll: T[], filter: (value: T) => boolean | Promise<boolean>, options?: MapFilterOptions): Promise<T[]>;
-/**
- * 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 declare function waitForCondition<T>(condFn: () => Promise<T> | T, options?: WaitForConditionOptions): Promise<T>;
-export type { CancellablePromise, Progress, ProgressCallback, LongSleepOptions, SleepArg, SleepOptions, WaitForConditionOptions, } from './types.js';
-//# sourceMappingURL=asyncbox.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/asyncbox.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asyncbox.d.ts","sourceRoot":"","sources":["../../../lib/asyncbox.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAEhB,YAAY,EACZ,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAepB,yEAAyE;AACzE,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED,uDAAuD;AACvD,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,OAAO,GAAE,MAA4B;CAIlD;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;AAC5D;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;AAsCvE;;;;;;;;;;;;;GAaG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,cAAc,CAAC,EAAE,MAAM,GAAG,KAAK,GAC9B,OAAO,CAAC,CAAC,CAAC,CAsBZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,SAAS,CAC7B,EAAE,EAAE,MAAM,EACV,EAAC,WAAkC,EAAE,UAAiB,EAAE,UAAiB,EAAC,GAAE,gBAAqB,GAChG,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED;;;;;GAKG;AACH,wBAAsB,KAAK,CAAC,CAAC,GAAG,GAAG,EACjC,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,GAAG,IAAI,EAAE,GAAG,EAAE,GACb,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAgBnB;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,CAAC,GAAG,GAAG,EACzC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,GAAG,IAAI,EAAE,GAAG,EAAE,GACb,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAiBnB;AAED;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,IAAI,EAAE,CAAC,EAAE,EACT,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACpC,OAAO,GAAE,gBAAuB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAed;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,IAAI,EAAE,CAAC,EAAE,EACT,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EAChD,OAAO,GAAE,gBAAuB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAwBd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAC5B,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,CAAC,CAAC,CA8BZ;AAGD,YAAY,EACV,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,YAAY,EACZ,uBAAuB,GACxB,MAAM,YAAY,CAAC"}