asyncbox - npm Package Compare versions

Comparing version 2.9.4 to 3.0.0

build/lib/asyncbox.d.ts

@@ -126,3 +126,3 @@ /**
 export function longSleep(ms: number, { thresholdMs, intervalMs, progressCb, }?: LongSleepOptions | undefined): Promise<void>;
-import B from "bluebird";
+import B from 'bluebird';
 //# sourceMappingURL=asyncbox.d.ts.map

build/lib/asyncbox.js

 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.asyncfilter = asyncfilter;
-exports.asyncify = asyncify;
-exports.asyncmap = asyncmap;
-exports.longSleep = longSleep;
-exports.nodeify = nodeify;
-exports.nodeifyAll = nodeifyAll;
-exports.parallel = void 0;
-exports.retry = retry;
-exports.retryInterval = retryInterval;
-exports.sleep = sleep;
-exports.waitForCondition = waitForCondition;
-require("source-map-support/register");
-var _bluebird = _interopRequireDefault(require("bluebird"));
-var _lodash = _interopRequireDefault(require("lodash"));
-
-const LONG_SLEEP_THRESHOLD = 5000;
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.longSleep = exports.waitForCondition = exports.asyncfilter = exports.asyncmap = exports.parallel = exports.asyncify = exports.retryInterval = exports.nodeifyAll = exports.nodeify = exports.retry = exports.sleep = void 0;
+const bluebird_1 = __importDefault(require("bluebird"));
+const lodash_1 = __importDefault(require("lodash"));
+const LONG_SLEEP_THRESHOLD = 5000; // anything over 5000ms will turn into a spin
+/**
+ * An async/await version of setTimeout
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
 async function sleep(ms) {
-  return await _bluebird.default.delay(ms);
+    return await bluebird_1.default.delay(ms);
 }
-
-async function longSleep(ms, {
-  thresholdMs = LONG_SLEEP_THRESHOLD,
-  intervalMs = 1000,
-  progressCb = null
-} = {}) {
-  if (ms < thresholdMs) {
-    return await sleep(ms);
-  }
-  const endAt = Date.now() + ms;
-  let timeLeft;
-  let elapsedMs = 0;
-  do {
-    const pre = Date.now();
-    await sleep(intervalMs);
-    const post = Date.now();
-    timeLeft = endAt - post;
-    elapsedMs = elapsedMs + (post - pre);
-    if (_lodash.default.isFunction(progressCb)) {
-      progressCb({
-        elapsedMs,
-        timeLeft,
-        progress: elapsedMs / ms
-      });
+exports.sleep = sleep;
+/**
+ * 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`.
+ *
+ * sYou 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 {number} ms
+ * @param {LongSleepOptions} [opts]
+ * @returns {Promise<void>}
+ */
+async function longSleep(ms, { thresholdMs = LONG_SLEEP_THRESHOLD, intervalMs = 1000, progressCb = null, } = {}) {
+    if (ms < thresholdMs) {
+        return await sleep(ms);
     }
-  } while (timeLeft > 0);
+    const endAt = Date.now() + ms;
+    let timeLeft;
+    let elapsedMs = 0;
+    do {
+        const pre = Date.now();
+        await sleep(intervalMs);
+        const post = Date.now();
+        timeLeft = endAt - post;
+        elapsedMs = elapsedMs + (post - pre);
+        if (lodash_1.default.isFunction(progressCb)) {
+            progressCb({ elapsedMs, timeLeft, progress: elapsedMs / ms });
+        }
+    } while (timeLeft > 0);
 }
-
+exports.longSleep = longSleep;
+/**
+ * An async/await way of running a method until it doesn't throw an error
+ * @template [T=any]
+ * @param {number} times
+ * @param {(...args: any[]) => Promise<T>} fn
+ * @param  {...any} args
+ * @returns {Promise<T?>}
+ */
 async function retry(times, fn, ...args) {
-  let tries = 0;
-  let done = false;
-  let res = null;
-  while (!done && tries < times) {
-    tries++;
-    try {
-      res = await fn(...args);
-      done = true;
-    } catch (err) {
-      if (tries >= times) {
-        throw err;
-      }
+    let tries = 0;
+    let done = false;
+    let res = null;
+    while (!done && tries < times) {
+        tries++;
+        try {
+            res = await fn(...args);
+            done = true;
+        }
+        catch (err) {
+            if (tries >= times) {
+                throw err;
+            }
+        }
     }
-  }
-  return res;
+    return res;
 }
-
+exports.retry = retry;
+/**
+ * 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.
+ * @template [T=any]
+ * @param {number} times
+ * @param {number} sleepMs
+ * @param {(...args: any[]) => Promise<T>} fn
+ * @param  {...any} args
+ * @returns {Promise<T?>}
+ */
 async function retryInterval(times, sleepMs, fn, ...args) {
-  let count = 0;
-  let wrapped = async () => {
-    count++;
-    let res;
-    try {
-      res = await fn(...args);
-    } catch (e) {
-      if (count !== times) {
-        await sleep(sleepMs);
-      }
-      throw e;
-    }
-    return res;
-  };
-  return await retry(times, wrapped);
+    let count = 0;
+    let wrapped = async () => {
+        count++;
+        let res;
+        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);
 }
-const parallel = _bluebird.default.all;
-
+exports.retryInterval = retryInterval;
+const parallel = bluebird_1.default.all;
 exports.parallel = parallel;
+/**
+ * Export async functions (Promises) and import this with your ES5 code to use
+ * it with Node.
+ * @template [R=any]
+ * @param {any} promisey
+ * @param {(err: any, value?: R) => void} cb
+ * @returns {Promise<R>}
+ */
 function nodeify(promisey, cb) {
-  return _bluebird.default.resolve(promisey).nodeify(cb);
+    return bluebird_1.default.resolve(promisey).nodeify(cb);
 }
-
+exports.nodeify = nodeify;
+/**
+ * Node-ify an entire object of `Promise`-returning functions
+ * @param {Record<string,(...args: any[]) => any>} promiseyMap
+ * @returns {Record<string,(...args: any[])=>void>}
+ */
 function nodeifyAll(promiseyMap) {
-  let cbMap = {};
-  for (const [name, fn] of _lodash.default.toPairs(promiseyMap)) {
-    cbMap[name] = function (...args) {
-      const _cb = args.slice(-1)[0];
-      args = args.slice(0, -1);
-      nodeify(fn(...args), _cb);
-    };
-  }
-  return cbMap;
+    /** @type {Record<string,(...args: any[])=>void>} */
+    let cbMap = {};
+    for (const [name, fn] of lodash_1.default.toPairs(promiseyMap)) {
+        cbMap[name] = function (...args) {
+            const _cb = args.slice(-1)[0];
+            args = args.slice(0, -1);
+            nodeify(fn(...args), _cb);
+        };
+    }
+    return cbMap;
 }
-
+exports.nodeifyAll = nodeifyAll;
+/**
+ * @param {(...args: any[]) => any|Promise<any>} fn
+ * @param  {...any} args
+ */
 function asyncify(fn, ...args) {
-  _bluebird.default.resolve(fn(...args)).done();
+    bluebird_1.default.resolve(fn(...args)).done();
 }
-
+exports.asyncify = asyncify;
+/**
+ * Similar to `Array.prototype.map`; runs in serial
+ * @param {any[]} coll
+ * @param {(value: any) => any|Promise<any>} mapper
+ * @returns {Promise<any[]>}
+ */
 async function asyncmap(coll, mapper, runInParallel = true) {
-  if (runInParallel) {
-    return parallel(coll.map(mapper));
-  }
-  let newColl = [];
-  for (let item of coll) {
-    newColl.push(await mapper(item));
-  }
-  return newColl;
+    if (runInParallel) {
+        return parallel(coll.map(mapper));
+    }
+    let newColl = [];
+    for (let item of coll) {
+        newColl.push(await mapper(item));
+    }
+    return newColl;
 }
-
+exports.asyncmap = asyncmap;
+/**
+ * Similar to `Array.prototype.filter`
+ * @param {any[]} coll
+ * @param {(value: any) => any|Promise<any>} filter
+ * @param {boolean} runInParallel
+ * @returns {Promise<any[]>}
+ */
 async function asyncfilter(coll, filter, runInParallel = true) {
-  let newColl = [];
-  if (runInParallel) {
-    let bools = await parallel(coll.map(filter));
-    for (let i = 0; i < coll.length; i++) {
-      if (bools[i]) {
-        newColl.push(coll[i]);
-      }
+    let newColl = [];
+    if (runInParallel) {
+        let bools = await parallel(coll.map(filter));
+        for (let i = 0; i < coll.length; i++) {
+            if (bools[i]) {
+                newColl.push(coll[i]);
+            }
+        }
     }
-  } else {
-    for (let item of coll) {
-      if (await filter(item)) {
-        newColl.push(item);
-      }
+    else {
+        for (let item of coll) {
+            if (await filter(item)) {
+                newColl.push(item);
+            }
+        }
     }
-  }
-  return newColl;
+    return newColl;
 }
-
+exports.asyncfilter = asyncfilter;
+/**
+ * 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 }`
+ * @template T
+ * @param {() => Promise<T>|T} condFn
+ * @param {WaitForConditionOptions} [options]
+ * @returns {Promise<T>}
+ */
 async function waitForCondition(condFn, options = {}) {
-  const opts = _lodash.default.defaults(options, {
-    waitMs: 5000,
-    intervalMs: 500
-  });
-  const debug = opts.logger ? opts.logger.debug.bind(opts.logger) : _lodash.default.noop;
-  const error = opts.error;
-  const begunAt = Date.now();
-  const endAt = begunAt + opts.waitMs;
-  const spin = async function spin() {
-    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 _bluebird.default.delay(Math.min(opts.intervalMs, remainingTime));
-      return await spin();
-    }
-    throw error ? _lodash.default.isString(error) ? new Error(error) : error : new Error(`Condition unmet after ${waited} ms. Timing out.`);
-  };
-  return await spin();
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"file":"lib/asyncbox.js","names":["LONG_SLEEP_THRESHOLD","sleep","ms","B","delay","longSleep","thresholdMs","intervalMs","progressCb","endAt","Date","now","timeLeft","elapsedMs","pre","post","_","isFunction","progress","retry","times","fn","args","tries","done","res","err","retryInterval","sleepMs","count","wrapped","e","parallel","all","nodeify","promisey","cb","resolve","nodeifyAll","promiseyMap","cbMap","name","toPairs","_cb","slice","asyncify","asyncmap","coll","mapper","runInParallel","map","newColl","item","push","asyncfilter","filter","bools","i","length","waitForCondition","condFn","options","opts","defaults","waitMs","debug","logger","bind","noop","error","begunAt","spin","result","waited","remainingTime","Math","min","isString","Error"],"sourceRoot":"../..","sources":["lib/asyncbox.js"],"sourcesContent":["// transpile:main\n\nimport B from 'bluebird';\nimport _ from 'lodash';\n\nconst LONG_SLEEP_THRESHOLD = 5000; // anything over 5000ms will turn into a spin\n\n/**\n * An async/await version of setTimeout\n * @param {number} ms\n * @returns {Promise<void>}\n */\nasync function sleep (ms) {\n  return await B.delay(ms);\n}\n\n/**\n * Sometimes `Promise.delay` or `setTimeout` are inaccurate for large wait\n * times. To safely wait for these long times (e.g. in the 5+ minute range), you\n * can use `longSleep`.\n *\n * sYou can also pass a `progressCb` option which is a callback function that\n * receives an object with the properties `elapsedMs`, `timeLeft`, and\n * `progress`. This will be called on every wait interval so you can do your\n * wait logging or whatever.\n * @param {number} ms\n * @param {LongSleepOptions} [opts]\n * @returns {Promise<void>}\n */\nasync function longSleep (ms, {\n  thresholdMs = LONG_SLEEP_THRESHOLD,\n  intervalMs = 1000,\n  progressCb = null,\n} = {}) {\n  if (ms < thresholdMs) {\n    return await sleep(ms);\n  }\n  const endAt = Date.now() + ms;\n  let timeLeft;\n  let elapsedMs = 0;\n  do {\n    const pre = Date.now();\n    await sleep(intervalMs);\n    const post = Date.now();\n    timeLeft = endAt - post;\n    elapsedMs = elapsedMs + (post - pre);\n    if (_.isFunction(progressCb)) {\n      progressCb({elapsedMs, timeLeft, progress: elapsedMs / ms});\n    }\n  } while (timeLeft > 0);\n}\n\n/**\n * An async/await way of running a method until it doesn't throw an error\n * @template [T=any]\n * @param {number} times\n * @param {(...args: any[]) => Promise<T>} fn\n * @param  {...any} args\n * @returns {Promise<T?>}\n */\nasync function retry (times, fn, ...args) {\n  let tries = 0;\n  let done = false;\n  let res = null;\n  while (!done && tries < times) {\n    tries++;\n    try {\n      res = await fn(...args);\n      done = true;\n    } catch (err) {\n      if (tries >= times) {\n        throw err;\n      }\n    }\n  }\n  return res;\n}\n\n/**\n * You can also use `retryInterval` to add a sleep in between retries. This can\n * be useful if you want to throttle how fast we retry.\n * @template [T=any]\n * @param {number} times\n * @param {number} sleepMs\n * @param {(...args: any[]) => Promise<T>} fn\n * @param  {...any} args\n * @returns {Promise<T?>}\n */\nasync function retryInterval (times, sleepMs, fn, ...args) {\n  let count = 0;\n  let wrapped = async () => {\n    count++;\n    let res;\n    try {\n      res = await fn(...args);\n    } catch (e) {\n      // do not pause when finished the last retry\n      if (count !== times) {\n        await sleep(sleepMs);\n      }\n      throw e;\n    }\n    return res;\n  };\n  return await retry(times, wrapped);\n}\n\nconst parallel = B.all;\n\n/**\n * Export async functions (Promises) and import this with your ES5 code to use\n * it with Node.\n * @template [R=any]\n * @param {any} promisey\n * @param {(err: any, value?: R) => void} cb\n * @returns {Promise<R>}\n */\nfunction nodeify (promisey, cb) { // eslint-disable-line promise/prefer-await-to-callbacks\n  return B.resolve(promisey).nodeify(cb);\n}\n\n/**\n * Node-ify an entire object of `Promise`-returning functions\n * @param {Record<string,(...args: any[]) => any>} promiseyMap\n * @returns {Record<string,(...args: any[])=>void>}\n */\nfunction nodeifyAll (promiseyMap) {\n  /** @type {Record<string,(...args: any[])=>void>} */\n  let cbMap = {};\n  for (const [name, fn] of _.toPairs(promiseyMap)) {\n    cbMap[name] = function (...args) {\n      const _cb = args.slice(-1)[0];\n      args = args.slice(0, -1);\n      nodeify(fn(...args), _cb);\n    };\n  }\n  return cbMap;\n}\n\n/**\n * @param {(...args: any[]) => any|Promise<any>} fn\n * @param  {...any} args\n */\nfunction asyncify (fn, ...args) {\n  B.resolve(fn(...args)).done();\n}\n\n/**\n * Similar to `Array.prototype.map`; runs in serial\n * @param {any[]} coll\n * @param {(value: any) => any|Promise<any>} mapper\n * @returns {Promise<any[]>}\n */\nasync function asyncmap (coll, mapper, runInParallel = true) {\n  if (runInParallel) {\n    return parallel(coll.map(mapper));\n  }\n\n  let newColl = [];\n  for (let item of coll) {\n    newColl.push(await mapper(item));\n  }\n  return newColl;\n}\n\n/**\n * Similar to `Array.prototype.filter`\n * @param {any[]} coll\n * @param {(value: any) => any|Promise<any>} filter\n * @param {boolean} runInParallel\n * @returns {Promise<any[]>}\n */\nasync function asyncfilter (coll, filter, runInParallel = true) {\n  let newColl = [];\n  if (runInParallel) {\n    let bools = await parallel(coll.map(filter));\n    for (let i = 0; i < coll.length; i++) {\n      if (bools[i]) {\n        newColl.push(coll[i]);\n      }\n    }\n  } else {\n    for (let item of coll) {\n      if (await filter(item)) {\n        newColl.push(item);\n      }\n    }\n  }\n  return newColl;\n}\n\n/**\n * Takes a condition (a function returning a boolean or boolean promise), and\n * waits until the condition is true.\n *\n * Throws a `/Condition unmet/` error if the condition has not been satisfied\n * within the allocated time, unless an error is provided in the options, as the\n * `error` property, which is either thrown itself, or used as the message.\n *\n * The condition result is returned if it is not falsy. If the condition throws an\n * error then this exception will be immediately passed through.\n *\n * The default options are: `{ waitMs: 5000, intervalMs: 500 }`\n * @template T\n * @param {() => Promise<T>|T} condFn\n * @param {WaitForConditionOptions} [options]\n * @returns {Promise<T>}\n */\nasync function waitForCondition (condFn, options = {}) {\n  /** @type {WaitForConditionOptions & {waitMs: number, intervalMs: number}} */\n  const opts = _.defaults(options, {\n    waitMs: 5000,\n    intervalMs: 500,\n  });\n  const debug = opts.logger ? opts.logger.debug.bind(opts.logger) : _.noop;\n  const error = opts.error;\n  const begunAt = Date.now();\n  const endAt = begunAt + opts.waitMs;\n  /** @returns {Promise<T>} */\n  const spin = async function spin () {\n    const result = await condFn();\n    if (result) {\n      return result;\n    }\n    const now = Date.now();\n    const waited = now - begunAt;\n    const remainingTime = endAt - now;\n    if (now < endAt) {\n      debug(`Waited for ${waited} ms so far`);\n      await B.delay(Math.min(opts.intervalMs, remainingTime));\n      return await spin();\n    }\n    // if there is an error option, it is either a string message or an error itself\n    throw error\n      ? (_.isString(error) ? new Error(error) : error)\n      : new Error(`Condition unmet after ${waited} ms. Timing out.`);\n  };\n  return await spin();\n}\n\nexport {\n  sleep, retry, nodeify, nodeifyAll, retryInterval, asyncify, parallel,\n  asyncmap, asyncfilter, waitForCondition, longSleep,\n};\n\n/**\n * Options for {@link waitForCondition}\n * @typedef WaitForConditionOptions\n * @property {number} [waitMs]\n * @property {number} [intervalMs]\n * @property {{debug: (...args: any[]) => void}} [logger]\n * @property {string|Error} [error]\n */\n\n/**\n * Options for {@link longSleep}\n * @typedef LongSleepOptions\n * @property {number} [thresholdMs]\n * @property {number} [intervalMs]\n * @property {ProgressCallback?} [progressCb]\n */\n\n/**\n * Parameter provided to a {@link ProgressCallback}\n * @typedef Progress\n * @property {number} elapsedMs\n * @property {number} timeLeft\n * @property {number} progress\n */\n\n/**\n * Progress callback for {@link longSleep}\n * @callback ProgressCallback\n * @param {Progress} progress\n * @returns {void}\n */\n"],"mappings":"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"}
+    /** @type {WaitForConditionOptions & {waitMs: number, intervalMs: number}} */
+    const opts = lodash_1.default.defaults(options, {
+        waitMs: 5000,
+        intervalMs: 500,
+    });
+    const debug = opts.logger ? opts.logger.debug.bind(opts.logger) : lodash_1.default.noop;
+    const error = opts.error;
+    const begunAt = Date.now();
+    const endAt = begunAt + opts.waitMs;
+    /** @returns {Promise<T>} */
+    const spin = async function spin() {
+        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 bluebird_1.default.delay(Math.min(opts.intervalMs, remainingTime));
+            return await spin();
+        }
+        // if there is an error option, it is either a string message or an error itself
+        throw error
+            ? (lodash_1.default.isString(error) ? new Error(error) : error)
+            : new Error(`Condition unmet after ${waited} ms. Timing out.`);
+    };
+    return await spin();
+}
+exports.waitForCondition = waitForCondition;
+/**
+ * Options for {@link waitForCondition}
+ * @typedef WaitForConditionOptions
+ * @property {number} [waitMs]
+ * @property {number} [intervalMs]
+ * @property {{debug: (...args: any[]) => void}} [logger]
+ * @property {string|Error} [error]
+ */
+/**
+ * Options for {@link longSleep}
+ * @typedef LongSleepOptions
+ * @property {number} [thresholdMs]
+ * @property {number} [intervalMs]
+ * @property {ProgressCallback?} [progressCb]
+ */
+/**
+ * Parameter provided to a {@link ProgressCallback}
+ * @typedef Progress
+ * @property {number} elapsedMs
+ * @property {number} timeLeft
+ * @property {number} progress
+ */
+/**
+ * Progress callback for {@link longSleep}
+ * @callback ProgressCallback
+ * @param {Progress} progress
+ * @returns {void}
+ */
+//# sourceMappingURL=asyncbox.js.map

lib/asyncbox.js

@@ -1,3 +0,1 @@
-// transpile:main
-
 import B from 'bluebird';
@@ -4,0 +2,0 @@ import _ from 'lodash';

package.json

@@ -9,3 +9,3 @@ {
   ],
-  "version": "2.9.4",
+  "version": "3.0.0",
   "author": "[e-mail]",
@@ -21,3 +21,3 @@ "license": "Apache-2.0",
   "engines": {
-    "node": ">=10"
+    "node": ">=16"
   },
@@ -34,31 +34,39 @@ "main": "./build/lib/asyncbox.js",
   "dependencies": {
-    "@babel/runtime": "^7.0.0",
     "bluebird": "^3.5.1",
     "lodash": "^4.17.4",
-    "source-map-support": "^0.5.5",
-    "@types/bluebird": "^3.5.37"
+    "source-map-support": "^0.x"
   },
   "scripts": {
-    "clean": "rm -rf node_modules && rm -f package-lock.json && npm install",
-    "prepare": "gulp prepublish && tsc",
-    "test": "gulp once",
-    "e2e-test": "gulp e2e-test",
-    "build": "gulp transpile && tsc",
-    "lint": "gulp eslint",
-    "watch": "gulp watch"
+    "build": "tsc -b",
+    "clean": "npm run build -- --clean",
+    "rebuild": "npm run clean; npm run build",
+    "dev": "npm run build -- --watch",
+    "prepare": "npm run rebuild",
+    "test": "mocha --exit --timeout 1m \"./test/**/*-specs.js\"",
+    "lint": "eslint .",
+    "watch": "npm run dev"
   },
   "devDependencies": {
+    "@appium/eslint-config-appium": "^8.0.4",
+    "@appium/eslint-config-appium-ts": "^0.x",
+    "@appium/tsconfig": "^0.x",
+    "@types/bluebird": "^3.5.37",
     "@types/lodash": "^4.14.189",
-    "ajv": "^6.5.3",
-    "appium-gulp-plugins": "^4.0.0",
-    "chai": "4.2.0",
+    "@types/node": "^20.4.7",
+    "@typescript-eslint/eslint-plugin": "^6.9.0",
+    "@typescript-eslint/parser": "^6.9.0",
+    "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
-    "eslint-config-appium": "^4.0.0",
-    "gulp": "^4.0.0",
-    "request": "^2.47.0",
-    "should": "^13.2.1",
-    "sinon": "^11.1.2",
-    "typescript": "~4.7.0"
+    "eslint": "^8.46.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-import-resolver-typescript": "^3.5.5",
+    "eslint-plugin-import": "^2.28.0",
+    "eslint-plugin-mocha": "^10.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "mocha": "^10.0.0",
+    "sinon": "^16.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6"
   },
   "types": "./build/lib/asyncbox.d.ts"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Improved metrics

Dependency count

3

decreased by-40%

Number of package files

8

increased by14.29%

Lines of code

650

increased by7.08%

Number of medium supply chain risk alerts

0

decreased by-100%

Worsened metrics

Total package byte prevSize

44877

decreased by-14.09%

Dev dependency count

20

increased by81.82%

Dependency changes

• - Removed@babel/runtime@^7.0.0

• - Removed@types/bluebird@^3.5.37

• - Removed@babel/runtime@7.26.0(transitive)

• - Removed@types/bluebird@3.5.42(transitive)

• - Removedregenerator-runtime@0.14.1(transitive)

• Updatedsource-map-support@^0.x