aveazul 0.1.4 → 1.0.0

package/README.md

@@ -1,10 +1,18 @@
 # AveAzul
 
-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
 
 ## Installation
 
@@ -27,6 +35,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);
@@ -58,8 +86,37 @@ AveAzul.using(getResource(), (resource) => {
   console.log(result); // "operation completed"
   // Resource is automatically closed here, even if an error occurred
 });
+
+// Using spread to apply array results as arguments
+AveAzul.all([getUser(1), getPosts(1), getComments(1)]).spread(
+  (user, posts, comments) => {
+    // Instead of using .then(([user, posts, comments]) => {...})
+    console.log(
+      `User ${user.name} has ${posts.length} posts and ${comments.length} comments`
+    );
+    return { user, activity: { posts, comments } };
+  }
+);
 ```
 
+## 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
@@ -67,33 +124,45 @@ AveAzul.using(getResource(), (resource) => {
 - `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
 - `timeout(ms, message?)` - Reject after specified time
 - `props(obj)` - Resolve object properties
+- `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
 
 ### 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
 - `promisify(fn, options?)` - Convert callback-style functions to promises (preserves original function properties)
+- `fromNode(fn, options?)` - Convert Node-style callback functions to promise-returning functions
+- `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
 
 ### PromisifyAll Options
 
@@ -112,12 +181,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/aveazul.js

@@ -6,8 +6,10 @@ const { promisifyAll } = require("./promisify-all");
 const { Disposer } = require("./disposer");
 const { using } = require("./using");
 const { isPromise, triggerUncaughtException } = require("./util");
+
 /**
- * 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
@@ -31,8 +33,8 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that resolves with the original value
    */
   tap(fn) {
-    return this.then((value) => {
-      fn(value);
+    return this.then(async (value) => {
+      await fn(value);
       return value;
     });
   }
@@ -53,8 +55,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 });
   }
 
   /**
@@ -67,6 +79,30 @@ 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) => {
+      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 AveAzul.any(args);
+    });
+  }
+
   /**
    * Bluebird-style each() method for array iteration
    * Similar to Bluebird's Promise.prototype.each()
@@ -222,8 +258,168 @@ class AveAzul extends Promise {
     if (typeof fn !== "function") {
       throw new TypeError("Expected a function");
     }
+
     return new Disposer(fn, this);
   }
+
+  /**
+   * Bluebird-style spread() method for handling array arguments
+   * Similar to Bluebird's Promise.prototype.spread()
+   * @param {Function} fn - Function to apply to the array arguments
+   * @returns {Promise} Promise that resolves with the function's return value
+   */
+  spread(fn) {
+    if (typeof fn !== "function") {
+      return AveAzul.reject(
+        new TypeError("expecting a function but got " + fn)
+      );
+    }
+
+    return this.then(async (args) => {
+      if (Array.isArray(args)) {
+        for (let i = 0; i < args.length; i++) {
+          if (isPromise(args[i])) {
+            args[i] = await args[i];
+          }
+        }
+        return fn(...args);
+      } else {
+        return fn(args);
+      }
+    });
+  }
+
+  some(count) {
+    return this.then((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 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;
+
+        const addDone = (result) => {
+          results.push(result);
+          if (results.length >= count) {
+            // Resolve with exactly count results to match Bluebird's behavior
+            resolve(results.slice(0, count));
+          }
+        };
+
+        const addError = (err) => {
+          errors.push(err);
+          if (len - errors.length < count) {
+            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) => {
+      if (!Array.isArray(value)) {
+        // Check if value is iterable
+        if (value != null && typeof value[Symbol.iterator] === "function") {
+          // Convert iterable to array
+          value = Array.from(value);
+        } else {
+          throw new TypeError(
+            "expecting an array or an iterable object but got " + value
+          );
+        }
+      }
+
+      return AveAzul.all(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);
+    });
+  }
 }
 
 /**
@@ -249,7 +445,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
@@ -371,6 +576,52 @@ AveAzul.using = (resources, ...args) => {
   return using([resources, ...args], handler, AveAzul, false);
 };
 
+/**
+ * Bluebird-style join() for joining promises
+ *
+ * @param {...Promise} args - Promises to join
+ * @param {Function} handler - Handler function to apply to the joined results
+ * @returns {Promise} Promise that resolves with the handler's return value
+ */
+AveAzul.join = function (...args) {
+  if (args.length > 1 && typeof args.at(-1) === "function") {
+    const handler = args.pop();
+    return AveAzul.all(args).then((results) => handler(...results));
+  } else {
+    return AveAzul.all(args);
+  }
+};
+
+function fromCallback(fn, options) {
+  return new AveAzul((resolve, reject) => {
+    try {
+      fn((err, ...args) => {
+        if (err) {
+          reject(err);
+        } else {
+          if (options && options.multiArgs) {
+            resolve(args);
+          } else {
+            resolve(args[0]);
+          }
+        }
+      });
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+AveAzul.fromNode = fromCallback;
+
+/**
+ * Bluebird-style fromCallback() for converting callback-based functions to promises
+ * @param {Function} fn - Function to convert
+ * @param {Object} [options] - Options object
+ * @returns {Promise} Promise that resolves with the function's return value
+ */
+AveAzul.fromCallback = fromCallback;
+
 /**
  * @description
  * When fatal error and AveAzul needs to crash the process,
@@ -380,4 +631,18 @@ AveAzul.using = (resources, ...args) => {
  */
 AveAzul.___throwUncaughtError = triggerUncaughtException;
 
+/**
+ * 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);
+};
+
+// Setup the not implemented methods
+const { setupNotImplemented } = require("./not-implemented");
+setupNotImplemented(AveAzul);
+
 module.exports = AveAzul;

package/lib/disposer.js

@@ -5,8 +5,8 @@
  * @private
  */
 class Disposer {
-  constructor(data, promise) {
-    this._data = data; // The cleanup function
+  constructor(fn, promise) {
+    this._data = fn; // The cleanup function
     this._promise = promise; // The promise that resolves to the resource
   }
 }

package/lib/not-implemented.js

@@ -0,0 +1,111 @@
+"use strict";
+
+function createNotImplemented(name) {
+  return function () {
+    const msg = name + " Not implemented in aveazul";
+    console.error(msg);
+    throw new Error(msg);
+  };
+}
+
+function createInstanceNotImplemented(AveAzul) {
+  const methods = [
+    "then",
+    "spread",
+    "catch",
+    "error",
+    "finally",
+    "bind",
+    "isFulfilled",
+    "isRejected",
+    "isPending",
+    "isCancelled",
+    "value",
+    "reason",
+    "all",
+    "props",
+    "any",
+    "some",
+    "map",
+    "reduce",
+    "filter",
+    "each",
+    "mapSeries",
+    "disposer",
+    "asCallback",
+    "delay",
+    "timeout",
+    "cancel",
+    "tap",
+    "tapCatch",
+    "call",
+    "get",
+    "return",
+    "throw",
+    "catchReturn",
+    "catchThrow",
+    "reflect",
+    "suppressUnhandledRejections",
+    "done",
+  ];
+
+  const proto = AveAzul.prototype;
+  const ret = [];
+  for (const method of methods) {
+    if (!proto[method]) {
+      ret.push(method);
+      proto[method] = createNotImplemented("instance " + method);
+    }
+  }
+  return ret;
+}
+
+function createStaticNotImplemented(AveAzul) {
+  const methods = [
+    "join",
+    "try",
+    "method",
+    "resolve",
+    "reject",
+    "props",
+    "any",
+    "some",
+    "map",
+    "reduce",
+    "filter",
+    "each",
+    "mapSeries",
+    "race",
+    "using",
+    "promisify",
+    "promisifyAll",
+    "fromCallback",
+    "delay",
+    "coroutine",
+    "coroutine.addYieldHandler",
+    "getNewLibraryCopy",
+    "noConflict",
+    "setScheduler",
+  ];
+  const ret = [];
+  for (const method of methods) {
+    if (!AveAzul[method]) {
+      ret.push(method);
+      AveAzul[method] = createNotImplemented("static " + method);
+    }
+  }
+  return ret;
+}
+
+function setupNotImplemented(AveAzul) {
+  const instanceMethods = createInstanceNotImplemented(AveAzul);
+  const staticMethods = createStaticNotImplemented(AveAzul);
+  AveAzul.__notImplementedInstance = instanceMethods;
+  AveAzul.__notImplementedStatic = staticMethods;
+}
+
+module.exports = {
+  createInstanceNotImplemented,
+  createStaticNotImplemented,
+  setupNotImplemented,
+};

package/lib/promisify-all.js

@@ -7,6 +7,7 @@ const {
   isConstructor,
   isPromisified,
   getObjectKeys,
+  isExcludedPrototype,
 } = require("./util");
 
 const defaultSuffix = "Async";
@@ -22,12 +23,6 @@ const defaultPromisifier = (fn, _defaultPromisifier, options) => {
   });
 };
 
-const excludedPrototypes = [
-  Object.getPrototypeOf(Array),
-  Object.getPrototypeOf(Object),
-  Object.getPrototypeOf(Function),
-];
-
 const excludedClasses = [Array, Object, Function];
 
 // Helper function to determine if a class extends from any excluded class
@@ -54,17 +49,9 @@ function promisifyAll2(obj, options) {
     return;
   }
 
-  const allKeys = getObjectKeys(obj, excludedPrototypes);
+  const allKeys = getObjectKeys(obj);
 
   for (const key of allKeys) {
-    if (key.endsWith(options.suffix)) {
-      throw new TypeError(
-        "Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a    See http://goo.gl/MqrFmX\u000a".replace(
-          "%s",
-          options.suffix
-        )
-      );
-    }
     const value = obj[key];
     const promisifiedKey = key + options.suffix;
     const passesDefaultFilter =
@@ -78,6 +65,16 @@ function promisifyAll2(obj, options) {
     ) {
       continue;
     }
+
+    if (key.endsWith(options.suffix)) {
+      throw new TypeError(
+        "Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a    See http://goo.gl/MqrFmX\u000a".replace(
+          "%s",
+          options.suffix
+        )
+      );
+    }
+
     obj[promisifiedKey] = options.promisifier(value, defaultPromisifier, {
       context: obj,
       copyProps: false,
@@ -110,7 +107,7 @@ function promisifyAll(target, _options) {
     );
   }
 
-  const allKeys = getObjectKeys(target, excludedPrototypes);
+  const allKeys = getObjectKeys(target);
 
   for (const key of allKeys) {
     const value = target[key];
@@ -121,7 +118,7 @@ function promisifyAll(target, _options) {
       isClass(value)
     ) {
       const proto = Object.getPrototypeOf(value);
-      if (!excludedPrototypes.includes(proto)) {
+      if (!isExcludedPrototype(proto)) {
         promisifyAll2(proto, options);
       }
 

package/lib/using.js

@@ -3,6 +3,7 @@
 const { Disposer } = require("./disposer");
 const { isPromise } = require("./util");
 
+const SYM_FN_DISPOSE = Symbol("fnDispose");
 /**
  * @description
  * The using function is a utility function that allows you to acquire resources,
@@ -37,10 +38,15 @@ function using(resources, handler, Promise, asArray) {
     });
 
     return Promise.map(promiseRes, async (resource) => {
-      if (resource instanceof Disposer) {
+      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;
@@ -68,18 +74,18 @@ function using(resources, handler, Promise, asArray) {
     const errors = [];
     return Promise.each(processedResources, async (resource) => {
       // dispose all resources that were acquired without errors
-      if (!resource._error && resource.hasOwnProperty("_result")) {
-        if (resource instanceof Disposer) {
-          try {
-            await resource._data(resource._result);
-          } catch (error) {
-            errors.push(error);
-          }
+      if (resource && resource[SYM_FN_DISPOSE]) {
+        try {
+          await resource[SYM_FN_DISPOSE](resource._result);
+        } catch (error) {
+          errors.push(error);
         }
       }
     }).finally(() => {
       if (errors.length > 0) {
-        Promise.___throwUncaughtError(new Error("cleanup resources failed"));
+        Promise.___throwUncaughtError(
+          new AggregateError(errors, "cleanup resources failed", errors)
+        );
       }
     });
   };
@@ -97,26 +103,25 @@ function using(resources, handler, Promise, asArray) {
       results.push(resource._result);
     }
 
-    let handlerResult;
-    let handlerSyncError;
+    let handlerPromise;
+
     try {
       // now call the handler with the results
-      if (asArray) {
-        handlerResult = handler(results);
-      } else {
-        handlerResult = handler(...results);
-      }
+      handlerPromise = Promise.resolve(
+        asArray ? handler(results) : handler(...results)
+      );
     } catch (error) {
       // catch sync error from handler
-      handlerSyncError = error;
+      handlerPromise = Promise.reject(error);
     }
 
-    return disposeResources(processedResources).then(() => {
-      if (handlerSyncError) {
-        throw handlerSyncError;
-      }
-      return handlerResult;
-    });
+    return handlerPromise
+      .tap(() => {
+        return disposeResources(processedResources);
+      })
+      .tapCatch(() => {
+        return disposeResources(processedResources);
+      });
   });
 }
 

package/lib/util.js

@@ -9,43 +9,34 @@
  * @param {*} fn - The value to check
  * @returns {boolean} - True if the function is a class, false otherwise
  */
+const thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
 function isClass(fn) {
-  // Early return for non-functions or null/undefined
-  if (!fn || typeof fn !== "function") return false;
-
-  // Method 1: Check for ES6 class syntax
-  // This detects class declarations and class expressions
   try {
-    const fnStr = fn.toString();
-    if (fnStr.startsWith("class ") || /^class\s+/.test(fnStr)) {
-      return true;
+    if (typeof fn === "function") {
+      const keys = Object.getOwnPropertyNames(fn.prototype);
+
+      const fnStr = fn.toString();
+      const es6Class = fnStr.startsWith("class ") || /^class\s+/.test(fnStr);
+      const hasMethods = keys.length > 1;
+      const hasMethodsOtherThanConstructor =
+        keys.length > 0 && !(keys.length === 1 && keys[0] === "constructor");
+      const hasThisAssignmentAndStaticMethods =
+        thisAssignmentPattern.test(fnStr) &&
+        Object.getOwnPropertyNames(fn).length > 0;
+
+      if (
+        es6Class ||
+        hasMethods ||
+        hasMethodsOtherThanConstructor ||
+        hasThisAssignmentAndStaticMethods
+      ) {
+        return true;
+      }
     }
+    return false;
   } catch (e) {
-    // Ignore errors that might occur when calling toString()
-    // Some objects might have custom toString implementations that throw
     return false;
   }
-
-  // Method 2: Check for constructor functions (ES5 class pattern)
-  // A proper constructor has its .prototype.constructor pointing back to itself
-  if (fn.prototype && fn.prototype.constructor === fn) {
-    // Additional validation to filter out regular functions
-    // that happen to have the correct prototype structure
-
-    // Check if the prototype has any methods other than constructor
-    // This is a strong indicator of a class-like structure
-    const hasOwnMethods = Object.getOwnPropertyNames(fn.prototype).some(
-      (name) =>
-        name !== "constructor" && typeof fn.prototype[name] === "function"
-    );
-
-    // If it has prototype methods OR has static properties/methods
-    // Either condition suggests it's being used as a class
-    return hasOwnMethods || Object.getOwnPropertyNames(fn).length > 0;
-  }
-
-  // Not a class by any of our detection methods
-  return false;
 }
 
 const rident = /^[a-z$_][a-z$_0-9]*$/i;
@@ -127,12 +118,25 @@ function isPromise(obj) {
   );
 }
 
+// istanbul ignore next
+const emptyFatArrow = () => {};
+// istanbul ignore next
+const emptyFunction = function () {};
+
 const defaultExcluded = [
   Object.getPrototypeOf(Array), // Array.prototype
   Object.getPrototypeOf(Object), // Object.prototype
   Object.getPrototypeOf(Function), // Function.prototype
+  Object.getPrototypeOf([]),
+  Object.getPrototypeOf({}),
+  Object.getPrototypeOf(emptyFatArrow),
+  Object.getPrototypeOf(emptyFunction),
 ];
 
+function isExcludedPrototype(proto) {
+  return defaultExcluded.includes(proto);
+}
+
 /**
  * Gets all property keys from an object and its prototype chain, excluding standard
  * prototypes like Object.prototype, Array.prototype, and Function.prototype
@@ -187,3 +191,4 @@ module.exports.isPromisified = isPromisified;
 module.exports.isPromise = isPromise;
 module.exports.triggerUncaughtException = triggerUncaughtException;
 module.exports.getObjectKeys = getObjectKeys;
+module.exports.isExcludedPrototype = isExcludedPrototype;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aveazul",
-  "version": "0.1.4",
-  "description": "Bluebird-like APIs in extended native Promise",
+  "version": "1.0.0",
+  "description": "Bluebird drop-in replacement built on native Promise",
   "main": "lib/aveazul.js",
   "homepage": "https://github.com/jchip/aveazul",
   "license": "Apache-2.0",
@@ -11,9 +11,14 @@
     "test:coverage": "jest test --coverage",
     "test:bluebird": "USE_BLUEBIRD=true jest test",
     "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand --no-coverage",
-    "test:debug:bluebird": "USE_BLUEBIRD=true node --inspect-brk node_modules/.bin/jest --runInBand --no-coverage"
+    "test:debug:bluebird": "USE_BLUEBIRD=true node --inspect-brk node_modules/.bin/jest --runInBand --no-coverage",
+    "jest": "jest --no-coverage",
+    "jest:bluebird": "USE_BLUEBIRD=true jest --no-coverage"
   },
   "author": "Joel Chen",
+  "contributors": [
+    "Claude (AI assistant)"
+  ],
   "files": [
     "lib"
   ],
@@ -21,7 +26,34 @@
     "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"
   ],
   "repository": {
     "type": "git",