aveazul 0.1.5 → 1.0.1

package/README.md

@@ -1,10 +1,22 @@
-# AveAzul
+# AveAzul.js
 
-AveAzul ("Blue Bird" in Spanish) is a Promise library that extends native Promises with Bluebird-like utility methods. Built on top of native Promises, it provides a familiar API for Node.js developers who are used to working with [Bluebird](https://github.com/petkaantonov/bluebird) ([npm](https://www.npmjs.com/package/bluebird)).
+AveAzul ("Blue Bird" in Spanish) serves as a near drop-in replacement for Bluebird. It's built on native Promise, by extending it with the familiar utility methods from Bluebird.
 
-This library helps migrate legacy code that uses Bluebird specific APIs to native Promises with minimal changes. It aims to provide a drop-in replacement that maintains compatibility while leveraging native Promises.
+## Purpose
 
-Do you prefer Bluebird's API with native Promises? AveAzul gives you both - familiar Bluebird methods built on native Promise.
+The primary goal is to help migrate legacy code, that uses Bluebird APIs extensively, to native Promises. While not a 100% drop-in replacement (some aspects of Bluebird simply can't be replicated), it offers a practical migration path with minimal changes for most cases.
+
+Further, if you like Bluebird's API but want to use native Promises, AveAzul gives you both - familiar Bluebird methods built on native Promise.
+
+## Features
+
+- Built on native Promises
+- Implements most commonly used Bluebird methods
+- Comprehensive test suite ensuring compatibility
+
+## Requirements
+
+- node.js version >= 12
 
 ## Installation
 
@@ -27,6 +39,26 @@ AveAzul.resolve([1, 2, 3])
   .filter((x) => x > 2)
   .then((result) => console.log(result)); // [4, 6]
 
+// Wait for at least 2 promises to be fulfilled
+const fetchUrls = [
+  fetch("https://api.example.com/data1"),
+  fetch("https://api.example.com/data2"),
+  fetch("https://api.example.com/data3"),
+  fetch("https://api.example.com/data4"),
+];
+AveAzul.some(fetchUrls, 2).then((results) =>
+  console.log(`Got the first 2 successful results`)
+);
+
+// Process items sequentially with mapSeries
+AveAzul.resolve([1, 2, 3])
+  .mapSeries(async (x) => {
+    // Each item is processed only after the previous one completes
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    return x * 2;
+  })
+  .then((result) => console.log(result)); // [2, 4, 6]
+
 // Promisify callback-style functions
 const fs = require("fs");
 const readFile = AveAzul.promisify(fs.readFile);
@@ -71,6 +103,24 @@ AveAzul.all([getUser(1), getPosts(1), getComments(1)]).spread(
 );
 ```
 
+## Migration from Bluebird
+
+For most applications, migrating from Bluebird to AveAzul should be as simple as:
+
+```javascript
+// From
+const Promise = require("bluebird");
+
+// To
+const Promise = require("aveazul");
+```
+
+Key differences to be aware of:
+
+- Some advanced debugging features are not available
+- Performance characteristics may differ
+- A few very specialized methods not available
+
 ## API
 
 ### Instance Methods
@@ -78,6 +128,7 @@ AveAzul.all([getUser(1), getPosts(1), getComments(1)]).spread(
 - `tap(fn)` - Execute side effects and return original value
 - `filter(fn)` - Filter array elements
 - `map(fn)` - Transform array elements
+- `mapSeries(fn)` - Transform array elements sequentially
 - `return(value)` - Inject a new value
 - `each(fn)` - Iterate over array elements
 - `delay(ms)` - Delay resolution
@@ -86,16 +137,23 @@ AveAzul.all([getUser(1), getPosts(1), getComments(1)]).spread(
 - `spread(fn)` - Apply array values as arguments to function
 - `tapCatch(fn)` - Execute side effects on rejection
 - `reduce(fn, initialValue?)` - Reduce array elements
+- `some(count)` - Resolves when a specified number of promises in the array have resolved
 - `throw(reason)` - Return rejected promise
 - `catchThrow(reason)` - Catch and throw new error
 - `catchReturn(value)` - Catch and return value
 - `get(propertyPath)` - Retrieve property value
 - `disposer(fn)` - Create a disposer for use with AveAzul.using() for resource cleanup
+- `any()` - Resolves when any promise in the iterable resolves, rejecting if all reject
+- `all()` - Like Promise.all(), resolves when all promises resolve, rejects if any reject
+- `call(propertyName, ...args)` - Call a method on the resolved value with the provided arguments
+- `asCallback(callback, options?)` - Register a Node-style callback that handles the resolution or rejection
+- `error(handler)` - Like catch(), but only catches operational errors, letting programmer errors bubble up
 
 ### Static Methods
 
 - `delay(ms, value?)` - Resolve after specified time
 - `map(value, fn)` - Transform array elements
+- `mapSeries(value, fn)` - Transform array elements one at a time in sequence
 - `try(fn)` - Wrap sync/async functions
 - `props(obj)` - Resolve object properties
 - `defer()` - Create a deferred promise
@@ -104,12 +162,17 @@ AveAzul.all([getUser(1), getPosts(1), getComments(1)]).spread(
 - `fromCallback(fn, options?)` - Alias for fromNode
 - `each(items, fn)` - Iterate over array elements
 - `reduce(array, fn, initialValue?)` - Reduce array elements
+- `some(promises, count)` - Wait for a specified number of promises to be fulfilled
 - `method(fn)` - Creates a method that returns a promise resolving to the value returned by the original function
 - `throw(reason)` - Return rejected promise
 - `promisifyAll(target, options?)` - Convert all methods of an object/class to promises
 - `using(resources, fn)` - Manage resources with automatic cleanup
 - `join(...values, handler?)` - Wait for multiple promises and pass their resolved values as separate arguments to the handler function. If no handler is provided, behaves like Promise.all
 
+### Error Types
+
+- `AveAzul.OperationalError` - Error type for representing expected operational errors (network failures, validation errors, etc.)
+
 ### PromisifyAll Options
 
 - `suffix` (default: 'Async') - Suffix to append to promisified method names
@@ -127,12 +190,19 @@ npm install
 npm test
 npm run test:watch
 npm run test:coverage
+
+# Test against Bluebird for compatibility
+npm run jest:bluebird -- test/[name].test.js
 ```
 
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
 ## License
 
 Apache-2.0
 
 ## Author
 
-Joel Chen
+Joel Chen, with assistant from Cursor Claude-3.7-sonnet

package/lib/any.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const { toArray, isPromise } = require("./util");
+const { AggregateError } = require("@jchip/error");
+
+function addStaticAny(AveAzul, force = false) {
+  if (force || !AveAzul.any) {
+    AveAzul.any = function (args) {
+      try {
+        args = toArray(args);
+      } catch (error) {
+        return AveAzul.reject(error);
+      }
+
+      if (args.length === 0) {
+        return AveAzul.reject(
+          new RangeError(
+            "Input array must contain at least 1 items but contains only 0 items"
+          )
+        );
+      }
+
+      return new AveAzul((resolve, reject) => {
+        const len = args.length;
+        let settled = false;
+        const errors = [];
+
+        const doFinish = (value) => {
+          if (settled) return;
+          settled = true;
+          resolve(value);
+        };
+
+        const addError = (err) => {
+          errors.push(err);
+          if (!settled && errors.length >= len) {
+            settled = true;
+            reject(new AggregateError(errors));
+          }
+        };
+
+        for (let i = 0; i < len; i++) {
+          const arg = args[i];
+          if (isPromise(arg)) {
+            arg.then(doFinish, addError);
+          } else {
+            doFinish(arg);
+          }
+        }
+      });
+    };
+  }
+}
+
+module.exports.addStaticAny = addStaticAny;

package/lib/aveazul.js

@@ -5,10 +5,12 @@ const { promisify } = require("./promisify");
 const { promisifyAll } = require("./promisify-all");
 const { Disposer } = require("./disposer");
 const { using } = require("./using");
-const { isPromise, triggerUncaughtException } = require("./util");
-
+const { isPromise, triggerUncaughtException, toArray } = require("./util");
+const { AggregateError } = require("@jchip/error");
+const { OperationalError, isOperationalError } = require("./operational-error");
 /**
- * AveAzul ("Blue Bird" in Spanish) - Extended Promise class that provides Bluebird-like utility methods
+ * @fileoverview
+ * AveAzul ("Blue Bird" in Spanish) - Extended Promise class that provides Bluebird like utility methods
  * This implementation is inspired by and provides similar APIs to the Bluebird Promise library,
  * but built on top of native Promises. The name is a Spanish play on words referencing Bluebird.
  * @extends Promise
@@ -54,8 +56,18 @@ class AveAzul extends Promise {
    * @param {Function} fn - Map function to apply to each element
    * @returns {Promise} Promise that resolves with the mapped array
    */
-  map(fn) {
-    return this.then((value) => xaa.map(value, fn));
+  map(fn, options = { concurrency: 50 }) {
+    return this.then((value) => xaa.map(value, fn, options));
+  }
+
+  /**
+   * Bluebird-style mapSeries() method for array operations
+   * Similar to Bluebird's Promise.prototype.mapSeries()
+   * @param {Function} fn - Map function to apply to each element
+   * @returns {Promise} Promise that resolves with the mapped array
+   */
+  mapSeries(fn) {
+    return this.map(fn, { concurrency: 1 });
   }
 
   /**
@@ -68,6 +80,17 @@ class AveAzul extends Promise {
     return this.then(() => value);
   }
 
+  /**
+   * Bluebird-style any() method for waiting for any promises to resolve
+   * @param {Array|Iterable} promises - Array or iterable of promises
+   * @returns {Promise} Promise that resolves with the first resolved promise
+   */
+  any() {
+    return this.then((args) => {
+      return AveAzul.any(toArray(args));
+    });
+  }
+
   /**
    * Bluebird-style each() method for array iteration
    * Similar to Bluebird's Promise.prototype.each()
@@ -105,7 +128,12 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that rejects if timeout occurs
    */
   timeout(ms, message = "operation timed out") {
-    return AveAzul.resolve(xaa.timeout(ms, message).run(this));
+    return xaa
+      .timeout(ms, message, {
+        Promise: AveAzul,
+        TimeoutError: OperationalError,
+      })
+      .run(this);
   }
 
   /**
@@ -253,6 +281,136 @@ class AveAzul extends Promise {
       }
     });
   }
+
+  some(count) {
+    return this.then((args) => {
+      args = toArray(args);
+
+      return new AveAzul((resolve, reject) => {
+        // If too many promises are rejected so that the promise can never become fulfilled,
+        // it will be immediately rejected with an AggregateError of the rejection reasons
+        // in the order they were thrown in.
+        const errors = [];
+        // The fulfillment value is an array with count values
+        // in the order they were fulfilled.
+        const results = [];
+        const len = args.length;
+
+        let settled = false;
+
+        const addDone = (result) => {
+          if (settled) return;
+          results.push(result);
+          if (results.length >= count) {
+            settled = true;
+            // Resolve with exactly count results to match Bluebird's behavior
+            resolve(results.slice(0, count));
+          }
+        };
+
+        const addError = (err) => {
+          if (settled) return;
+          errors.push(err);
+          if (len - errors.length < count) {
+            settled = true;
+            reject(new AggregateError(errors, `aggregate error`));
+          }
+        };
+
+        for (let i = 0; i < len; i++) {
+          const x = args[i];
+          if (isPromise(x)) {
+            x.then(addDone, addError);
+          } else {
+            addDone(x);
+          }
+        }
+      });
+    });
+  }
+
+  /**
+   * Bluebird-style all() method for array operations
+   * Similar to Promise.all() but operates on the resolved value of this promise
+   * @returns {Promise} Promise that resolves when all items in the array resolve
+   */
+  all() {
+    return this.then((value) => {
+      return AveAzul.all(toArray(value));
+    });
+  }
+
+  /**
+   * Bluebird-style asCallback() method
+   * Attaches a callback to the promise and returns the promise.
+   * The callback is invoked when the promise is resolved or rejected.
+   *
+   * @param {Function} cb - Node.js-style callback function (err, value)
+   * @param {Object} [options] - Additional options
+   * @param {boolean} [options.spread=false] - Pass array values as arguments to callback
+   * @returns {Promise} The same promise instance
+   */
+  asCallback(cb, options = {}) {
+    if (typeof cb !== "function") {
+      return this;
+    }
+
+    const spread = options && options.spread === true;
+
+    this.then(
+      (value) => {
+        try {
+          if (spread && Array.isArray(value)) {
+            cb(null, ...value);
+          } else {
+            cb(null, value);
+          }
+        } catch (err) {
+          AveAzul.___throwUncaughtError(err);
+        }
+      },
+      (reason) => {
+        try {
+          cb(reason);
+        } catch (err) {
+          AveAzul.___throwUncaughtError(err);
+        }
+      }
+    );
+
+    return this;
+  }
+
+  nodeify(cb, options) {
+    return this.asCallback(cb, options);
+  }
+
+  /**
+   * Bluebird-style call() method for calling a method on the resolved value
+   * @param {string} methodName - Name of the method to call
+   * @param {...any} args - Arguments to pass to the method
+   * @returns {Promise} Promise that resolves with the method's return value
+   */
+  call(methodName, ...args) {
+    return this.then(function (obj) {
+      return obj[methodName].call(obj, ...args);
+    });
+  }
+
+  /**
+   * Catches only operational errors and passes them to the handler.
+   * Programmer errors (non-operational) are rethrown.
+   * @param {Function} handler - Function to handle operational errors
+   * @returns {Promise} - Promise with the error handled or rethrown
+   */
+  error(handler) {
+    return this.catch((err) => {
+      if (isOperationalError(err)) {
+        return handler(err);
+      }
+      throw err;
+    });
+  }
 }
 
 /**
@@ -278,7 +436,16 @@ AveAzul.delay = (ms, value) => {
  * @param {Function} fn - Map function to apply to each element
  * @returns {Promise} Promise that resolves with the mapped array
  */
-AveAzul.map = (value, fn) => AveAzul.resolve(xaa.map(value, fn));
+AveAzul.map = (value, fn, options = { concurrency: 50 }) =>
+  AveAzul.resolve(value).map(fn, options);
+
+/**
+ * Bluebird-style mapSeries() for array operations
+ * @param {Array} value - Array to map over
+ * @param {Function} fn - Map function to apply to each element
+ * @returns {Promise} Promise that resolves with the mapped array
+ */
+AveAzul.mapSeries = (value, fn) => AveAzul.map(value, fn, { concurrency: 1 });
 
 /**
  * Bluebird-style try() for wrapping sync/async functions
@@ -408,7 +575,7 @@ AveAzul.using = (resources, ...args) => {
  * @returns {Promise} Promise that resolves with the handler's return value
  */
 AveAzul.join = function (...args) {
-  if (args.length > 1 && typeof args.at(-1) === "function") {
+  if (args.length > 1 && typeof args[args.length - 1] === "function") {
     const handler = args.pop();
     return AveAzul.all(args).then((results) => handler(...results));
   } else {
@@ -455,7 +622,24 @@ AveAzul.fromCallback = fromCallback;
  */
 AveAzul.___throwUncaughtError = triggerUncaughtException;
 
-module.exports = AveAzul;
+/**
+ * Bluebird-style some() for waiting for some promises to resolve
+ * @param {Array|Iterable} promises - Array or iterable of promises
+ * @param {number} count - Number of promises that need to resolve
+ * @returns {Promise} Promise that resolves when count promises have resolved
+ */
+AveAzul.some = function (promises, count) {
+  return AveAzul.resolve(promises).some(count);
+};
 
+const { addStaticAny } = require("./any");
+addStaticAny(AveAzul);
+
+// Setup the not implemented methods
 const { setupNotImplemented } = require("./not-implemented");
 setupNotImplemented(AveAzul);
+
+// Add these static properties after the class definition
+AveAzul.OperationalError = OperationalError;
+
+module.exports = AveAzul;

package/lib/not-implemented.js

@@ -10,17 +10,18 @@ function createNotImplemented(name) {
 
 function createInstanceNotImplemented(AveAzul) {
   const methods = [
+    "then",
     "spread",
-    "error",
+    "catch",
+    "finally",
     "bind",
-    "join",
-    "try",
-    "method",
     "isFulfilled",
     "isRejected",
     "isPending",
+    "isCancelled",
     "value",
     "reason",
+    "all",
     "props",
     "any",
     "some",
@@ -29,13 +30,22 @@ function createInstanceNotImplemented(AveAzul) {
     "filter",
     "each",
     "mapSeries",
+    "disposer",
+    "asCallback",
+    "delay",
+    "timeout",
+    "cancel",
     "tap",
     "tapCatch",
-    "catchThrow",
-    "catchReturn",
+    "call",
     "get",
+    "return",
     "throw",
-    "call",
+    "catchReturn",
+    "catchThrow",
+    "reflect",
+    "suppressUnhandledRejections",
+    "done",
   ];
 
   const proto = AveAzul.prototype;
@@ -56,22 +66,25 @@ function createStaticNotImplemented(AveAzul) {
     "method",
     "resolve",
     "reject",
-    "all",
     "props",
     "any",
     "some",
     "map",
+    "reduce",
     "filter",
     "each",
     "mapSeries",
     "race",
+    "using",
     "promisify",
     "promisifyAll",
-    "fromNode",
     "fromCallback",
     "delay",
     "coroutine",
-    "config",
+    "coroutine.addYieldHandler",
+    "getNewLibraryCopy",
+    "noConflict",
+    "setScheduler",
   ];
   const ret = [];
   for (const method of methods) {
@@ -84,9 +97,9 @@ function createStaticNotImplemented(AveAzul) {
 }
 
 function setupNotImplemented(AveAzul) {
-  const instance = createInstanceNotImplemented(AveAzul);
+  const instanceMethods = createInstanceNotImplemented(AveAzul);
   const staticMethods = createStaticNotImplemented(AveAzul);
-  AveAzul.__notImplementedInstance = instance;
+  AveAzul.__notImplementedInstance = instanceMethods;
   AveAzul.__notImplementedStatic = staticMethods;
 }
 

package/lib/operational-error.js

@@ -0,0 +1,46 @@
+"use strict";
+
+/**
+ * OperationalError class for representing errors that are expected during normal operation
+ * Similar to Bluebird's OperationalError
+ */
+class OperationalError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OperationalError";
+    this.isOperational = true;
+
+    // Capture stack trace
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+/**
+ * Check if an error is an operational error
+ * @param {*} error - Error to check
+ * @returns {boolean} True if the error is operational
+ */
+function isOperationalError(error) {
+  if (!error || typeof error !== "object") return false;
+  return error instanceof OperationalError || error.isOperational === true;
+}
+
+/**
+ * Check if an error is a programmer error (unexpected, likely a bug)
+ * @param {*} error - Error to check
+ * @returns {boolean} True if the error is a programmer error
+ */
+function isProgrammerError(error) {
+  if (!error || typeof error !== "object") return false;
+  return !isOperationalError(error);
+}
+
+// Only export the OperationalError class
+module.exports = {
+  OperationalError,
+  // Internal utilities used by AveAzul.prototype.error
+  isOperationalError,
+  isProgrammerError,
+};

package/lib/promisify-all.js

@@ -76,7 +76,7 @@ function promisifyAll2(obj, options) {
     }
 
     obj[promisifiedKey] = options.promisifier(value, defaultPromisifier, {
-      context: obj,
+      // context: obj, // promisified function should get the binded object using this
       copyProps: false,
       multiArgs: options.multiArgs,
       Promise: options.Promise,

package/lib/promisify.js

@@ -22,7 +22,7 @@ module.exports.promisify = function promisify(fn, _options) {
   const Promise = options.Promise;
   const multiArgs = !!options.multiArgs;
 
-  const promisifiedFn = (...args) => {
+  const promisifiedFn = function (...args) {
     return new Promise((resolve, reject) => {
       // add a callback to the end of the arguments to transfer the result to the promise
       args.push((err, ...values) => {
@@ -37,7 +37,7 @@ module.exports.promisify = function promisify(fn, _options) {
       });
 
       // call the original function with the updated args
-      fn.call(options.context, ...args);
+      fn.call(options.context || this, ...args);
     });
   };
 

package/lib/using.js

@@ -2,6 +2,7 @@
 
 const { Disposer } = require("./disposer");
 const { isPromise } = require("./util");
+const { AggregateError } = require("@jchip/error");
 
 const SYM_FN_DISPOSE = Symbol("fnDispose");
 /**
@@ -28,6 +29,25 @@ function using(resources, handler, Promise, asArray) {
   // Expect Promise to be AveAzul or Bluebird that has map method
   const acquisitionErrors = [];
 
+  // Helper function to process a disposer
+  const processDisposer = async (resource, disposer) => {
+    try {
+      const res = await disposer._promise;
+      resource._result = res;
+      resource[SYM_FN_DISPOSE] = disposer._data;
+    } catch (error) {
+      acquisitionErrors.push(error);
+      resource._error = error;
+    }
+    return resource;
+  };
+
+  // Helper to check if something is a disposer
+  const isDisposer = (obj) =>
+    obj &&
+    (obj instanceof Disposer ||
+      (obj._promise && typeof obj._data === "function"));
+
   const acquireResources = () => {
     const promiseRes = resources.map((resource) => {
       // if it's a promise-like, wait for its resolved value
@@ -38,27 +58,21 @@ function using(resources, handler, Promise, asArray) {
     });
 
     return Promise.map(promiseRes, async (resource) => {
-      if (
-        resource &&
-        (resource instanceof Disposer ||
-          (resource._promise && typeof resource._data === "function"))
-      ) {
-        try {
-          const res = await resource._promise;
-          resource._result = res;
-          resource[SYM_FN_DISPOSE] = resource._data;
-        } catch (error) {
-          acquisitionErrors.push(error);
-          resource._error = error;
-        }
-        return resource;
+      // If it's directly a disposer
+      if (isDisposer(resource)) {
+        return processDisposer(resource, resource);
       }
 
       // if it's a promise like, wait for its resolved value
       if (resource && resource.___promise) {
         try {
           const res = await resource.___promise;
-          resource._result = res;
+          // Check if the resolved value is a disposer
+          if (isDisposer(res)) {
+            return processDisposer(resource, res);
+          } else {
+            resource._result = res;
+          }
         } catch (error) {
           acquisitionErrors.push(error);
           resource._error = error;

package/lib/util.js

@@ -183,6 +183,23 @@ function triggerUncaughtException(error) {
   }, 0);
 }
 
+function toArray(args) {
+  if (!Array.isArray(args)) {
+    // Check if args is iterable
+    if (args != null && typeof args[Symbol.iterator] === "function") {
+      // Convert iterable to array, must do this to get the length, in order
+      // to detect if too many errors occurred and completion is impossible.
+      args = Array.from(args);
+    } else {
+      throw new TypeError(
+        "expecting an array or an iterable object but got " + args
+      );
+    }
+  }
+
+  return args;
+}
+
 module.exports.copyOwnProperties = copyOwnProperties;
 module.exports.isClass = isClass;
 module.exports.isIdentifier = isIdentifier;
@@ -192,3 +209,4 @@ module.exports.isPromise = isPromise;
 module.exports.triggerUncaughtException = triggerUncaughtException;
 module.exports.getObjectKeys = getObjectKeys;
 module.exports.isExcludedPrototype = isExcludedPrototype;
+module.exports.toArray = toArray;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aveazul",
-  "version": "0.1.5",
-  "description": "Bluebird-like APIs in extended native Promise",
+  "version": "1.0.1",
+  "description": "Bluebird drop-in replacement built on native Promise",
   "main": "lib/aveazul.js",
   "homepage": "https://github.com/jchip/aveazul",
   "license": "Apache-2.0",
@@ -16,6 +16,9 @@
     "jest:bluebird": "USE_BLUEBIRD=true jest --no-coverage"
   },
   "author": "Joel Chen",
+  "contributors": [
+    "Claude (AI assistant)"
+  ],
   "files": [
     "lib"
   ],
@@ -23,18 +26,51 @@
     "promise",
     "async",
     "bluebird",
-    "nodejs"
+    "nodejs",
+    "node.js",
+    "promises",
+    "promise-library",
+    "native-promise",
+    "es6-promise",
+    "migration",
+    "promisify",
+    "utility",
+    "using",
+    "disposer",
+    "spread",
+    "promise-map",
+    "async-map",
+    "p-map",
+    "map-series",
+    "async-await",
+    "promise-chain",
+    "promise-utils",
+    "asynchronous",
+    "callback",
+    "promisifyall",
+    "timeout",
+    "delay",
+    "any",
+    "props",
+    "filter",
+    "reduce",
+    "aveazul",
+    "aveazul.js"
   ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jchip/aveazul.git"
   },
   "dependencies": {
-    "xaa": "^1.7.3"
+    "@jchip/error": "^1.0.3",
+    "xaa": "^1.8.0"
   },
   "devDependencies": {
     "bluebird": "^3.7.2",
-    "jest": "^29.7.0",
+    "jest": "^28.0.0",
     "rimraf": "^3.0.1"
+  },
+  "engines": {
+    "node": ">=12.0.0"
   }
 }