appium-mac2-driver 4.3.6 → 4.4.0

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

@@ -0,0 +1,312 @@
+'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

@@ -0,0 +1,48 @@
+{
+  "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/bare-fs/binding.c

@@ -294,7 +294,7 @@ bare_fs_request_result_stat(js_env_t *env, js_callback_info_t *info) {
     uv_timespec_t time = req->handle.statbuf.st_##property; \
 \
     js_value_t *value; \
-    err = js_create_int64(env, time.tv_sec * 1000 + time.tv_nsec / 1000000, &value); \
+    err = js_create_int64(env, (int64_t) time.tv_sec * 1000 + time.tv_nsec / 1000000, &value); \
     assert(err == 0); \
 \
     err = js_set_element(env, result, i++, value); \

package/node_modules/bare-fs/index.js

@@ -1469,6 +1469,20 @@ async function cp(src, dst, opts, cb) {
     } else if (st.isFile()) {
       await copyFile(src, dst)
       await chmod(dst, st.mode)
+    } else if (st.isSymbolicLink()) {
+      try {
+        if (!(await lstat(dst)).isDirectory()) await unlink(dst)
+      } catch (e) {
+        if (e.code !== 'ENOENT') throw e
+      }
+
+      await symlink(await readlink(src), dst)
+    } else {
+      throw new FileError('cannot copy a special file', {
+        operation: 'cp',
+        code: 'ENOTSUP',
+        path: src
+      })
     }
   } catch (e) {
     err = e
@@ -1503,6 +1517,20 @@ function cpSync(src, dst, opts = {}) {
   } else if (st.isFile()) {
     copyFileSync(src, dst)
     chmodSync(dst, st.mode)
+  } else if (st.isSymbolicLink()) {
+    try {
+      if (!lstatSync(dst).isDirectory()) unlinkSync(dst)
+    } catch (e) {
+      if (e.code !== 'ENOENT') throw e
+    }
+
+    symlinkSync(readlinkSync(src), dst)
+  } else {
+    throw new FileError('cannot copy a special file', {
+      operation: 'cp',
+      code: 'ENOTSUP',
+      path: src
+    })
   }
 }
 
@@ -1736,9 +1764,7 @@ async function symlink(target, filepath, type, cb) {
       target = path.resolve(filepath, '..', target)
 
       try {
-        type = (await stat(target)).isDirectory()
-          ? constants.UV_FS_SYMLINK_DIR
-          : constants.UV_FS_SYMLINK_JUNCTION
+        type = (await stat(target)).isDirectory() ? constants.UV_FS_SYMLINK_DIR : 0
       } catch {
         type = 0
       }
@@ -1791,9 +1817,7 @@ function symlinkSync(target, filepath, type) {
       target = path.resolve(filepath, '..', target)
 
       try {
-        type = statSync(target).isDirectory()
-          ? constants.UV_FS_SYMLINK_DIR
-          : constants.UV_FS_SYMLINK_JUNCTION
+        type = statSync(target).isDirectory() ? constants.UV_FS_SYMLINK_DIR : 0
       } catch {
         type = 0
       }

package/node_modules/bare-fs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-fs",
-  "version": "4.8.2",
+  "version": "4.8.4",
   "description": "Native file system operations for Bare",
   "exports": {
     "./package": "./package.json",

package/node_modules/readable-stream/lib/internal/shims/process.js

@@ -0,0 +1,19 @@
+'use strict'
+
+/* wraps the internal process module, circumventing issues with some polyfills (see #539) */
+const process = ((base, esmKey, keys, isValid) => {
+  if (esmKey in base && base[esmKey] === true) {
+    let candidate
+    for (const key of keys) {
+      if (!(key in base)) {
+        continue
+      }
+      candidate = base[key]
+      if (isValid(candidate)) {
+        return candidate
+      }
+    }
+  }
+  return base
+})(require('process/'), '__esModule', ['default', 'process'], (candidate) => 'nextTick' in candidate)
+module.exports = process

package/node_modules/readable-stream/lib/internal/streams/destroy.js

@@ -2,7 +2,7 @@
 
 /* replacement start */
 
-const process = require('process/')
+const process = require('../shims/process')
 
 /* replacement end */
 

package/node_modules/readable-stream/lib/internal/streams/duplexify.js

@@ -1,6 +1,6 @@
 /* replacement start */
 
-const process = require('process/')
+const process = require('../shims/process')
 
 /* replacement end */
 

package/node_modules/readable-stream/lib/internal/streams/end-of-stream.js

@@ -5,7 +5,7 @@
 
 /* replacement start */
 
-const process = require('process/')
+const process = require('../shims/process')
 
 /* replacement end */
 

package/node_modules/readable-stream/lib/internal/streams/from.js

@@ -2,7 +2,7 @@
 
 /* replacement start */
 
-const process = require('process/')
+const process = require('../shims/process')
 
 /* replacement end */
 

package/node_modules/readable-stream/lib/internal/streams/legacy.js

@@ -42,8 +42,13 @@ Stream.prototype.pipe = function (dest, options) {
 
   // Don't leave dangling pipes when there are errors.
   function onerror(er) {
+    var _this$listenerCount
     cleanup()
-    if (EE.listenerCount(this, 'error') === 0) {
+    if (
+      ((_this$listenerCount = this.listenerCount) === null || _this$listenerCount === undefined
+        ? undefined
+        : _this$listenerCount.call(this, 'error')) === 0
+    ) {
       this.emit('error', er)
     }
   }

package/node_modules/readable-stream/lib/internal/streams/pipeline.js

@@ -1,6 +1,6 @@
 /* replacement start */
 
-const process = require('process/')
+const process = require('../shims/process')
 
 /* replacement end */
 // Ported from https://github.com/mafintosh/pump with

package/node_modules/readable-stream/lib/internal/streams/readable.js

@@ -23,7 +23,7 @@
 
 /* replacement start */
 
-const process = require('process/')
+const process = require('../shims/process')
 
 /* replacement end */
 

package/node_modules/readable-stream/lib/internal/streams/writable.js

@@ -27,7 +27,7 @@
 
 /* replacement start */
 
-const process = require('process/')
+const process = require('../shims/process')
 
 /* replacement end */
 

package/node_modules/readable-stream/package.json

@@ -1,6 +1,6 @@
 {
   "name": "readable-stream",
-  "version": "4.7.0",
+  "version": "4.8.0",
   "description": "Node.js Streams, a user-land copy of the stream library from Node.js",
   "homepage": "https://github.com/nodejs/readable-stream",
   "license": "MIT",
@@ -17,7 +17,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git://github.com/nodejs/readable-stream"
+    "url": "https://github.com/nodejs/readable-stream"
   },
   "bugs": {
     "url": "https://github.com/nodejs/readable-stream/issues"
@@ -61,6 +61,7 @@
     "@rollup/plugin-inject": "^4.0.4",
     "@rollup/plugin-node-resolve": "^13.3.0",
     "@sinonjs/fake-timers": "^9.1.2",
+    "ajv": "^8.20.0",
     "browserify": "^17.0.0",
     "c8": "^7.11.2",
     "esbuild": "^0.19.9",

package/node_modules/tar-stream/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tar-stream",
-  "version": "3.2.1",
+  "version": "3.2.2",
   "description": "tar-stream is a streaming tar parser and generator and nothing else. It operates purely using streams which means you can easily extract/parse tarballs without ever hitting the file system.",
   "main": "index.js",
   "exports": {
@@ -24,7 +24,7 @@
     }
   },
   "scripts": {
-    "test": "standard && brittle test/*.js"
+    "test": "standard && brittle-node test/*.js"
   },
   "repository": {
     "type": "git",
@@ -37,13 +37,13 @@
   },
   "homepage": "https://github.com/mafintosh/tar-stream",
   "dependencies": {
-    "b4a": "^1.6.4",
-    "bare-fs": "^4.5.5",
-    "fast-fifo": "^1.2.0",
-    "streamx": "^2.15.0"
+    "b4a": "^1.9.0",
+    "bare-fs": "^4.8.2",
+    "fast-fifo": "^1.3.2",
+    "streamx": "^2.28.1"
   },
   "devDependencies": {
-    "brittle": "^3.3.2",
+    "brittle": "^4.3.0",
     "concat-stream": "^2.0.0",
     "standard": "^17.0.1"
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-mac2-driver",
-  "version": "4.3.6",
+  "version": "4.4.0",
   "description": "XCTest-based Appium driver for macOS apps automation",
   "keywords": [
     "XCTest",
@@ -47,7 +47,8 @@
   "dependencies": {
     "@appium/strongbox": "2.0.1",
     "@colors/colors": "1.6.1",
-    "appium-xcode": "7.2.2",
+    "appium-xcode": "7.2.3",
+    "async-lock": "1.4.1",
     "asyncbox": "6.4.3",
     "axios": "1.20.0",
     "portscanner": "2.2.0",
@@ -81,6 +82,7 @@
     "@appium/strongbox",
     "@colors/colors",
     "appium-xcode",
+    "async-lock",
     "asyncbox",
     "axios",
     "portscanner",