aveazul 2.0.1 → 2.1.1

package/README.md

@@ -16,7 +16,7 @@ Further, if you like Bluebird's API but want to use native Promises, AveAzul giv
 
 ## Requirements
 
-- node.js version >= 22.12
+- node.js version >= 22.18
 
 ## Installation
 

package/dist/aveazul.d.ts

@@ -1,5 +1,5 @@
-import { PromisifyOptions } from "./promisify.js";
-import { PromisifyAllOptions } from "./promisify-all.js";
+import { type PromisifyOptions } from "./promisify.js";
+import { type PromisifyAllOptions } from "./promisify-all.js";
 import { Disposer } from "./disposer.js";
 import { triggerUncaughtException } from "./util.js";
 import { OperationalError, isOperationalError, isProgrammerError } from "./operational-error.js";
@@ -57,12 +57,40 @@ export type AveAzulInstance<T> = AveAzul<T>;
  */
 declare class AveAzul<T> extends Promise<T> {
     constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: unknown) => void) => void);
+    /**
+     * `resolve`/`reject`/`all` are inherited from Promise. Per the ECMAScript
+     * spec they construct through `this`, so at runtime they already hand back
+     * AveAzul instances -- but `PromiseConstructor` types them as plain `Promise`,
+     * which drops every AveAzul method (`.spread()`, `.disposer()`, ...). These
+     * ambient re-declarations state the real return types; they add `declare`, so
+     * nothing is emitted and no behavior changes. They match what the exported
+     * `AveAzulClass` interface has always promised.
+     */
+    static resolve: {
+        <U>(value: U | PromiseLike<U>): AveAzul<U>;
+        (): AveAzul<void>;
+    };
+    static reject: <U = never>(reason?: unknown) => AveAzul<U>;
+    static all: <U>(values: Iterable<U | PromiseLike<U>>) => AveAzul<Awaited<U>[]>;
     /**
      * Note: Per ECMAScript specification, when extending Promise, both .then() and static methods
      * (resolve, reject, all, etc) must return instances of the derived class (AveAzul), so there's
      * no need to explicitly wrap returns in new AveAzul(). This behavior is standard across all
      * spec-compliant JS engines (V8, SpiderMonkey, JavaScriptCore, etc).
      */
+    /**
+     * The instance-side counterpart to the `declare static` block above, and for the same reason:
+     * `then`/`catch`/`finally` construct through `this` (SpeciesConstructor), so each one really
+     * hands back an AveAzul -- but `Promise`'s lib types say plain `Promise`, so the first link in
+     * any chain loses every bluebird method and callers need `as AveAzulInstance<T>` to get them
+     * back. These are `declare`, so nothing is emitted and no runtime behavior changes.
+     *
+     * `AveAzul<T>` still satisfies `Promise<T>`/`PromiseLike<T>` after this, since the returned
+     * AveAzul is itself a Promise - await and interop are unaffected.
+     */
+    then: <TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null) => AveAzul<TResult1 | TResult2>;
+    catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null) => AveAzul<T | TResult>;
+    finally: (onfinally?: (() => void) | undefined | null) => AveAzul<T>;
     /**
      * Bluebird-style tap() method that lets you perform side effects in a chain
      * Similar to Bluebird's Promise.prototype.tap()
@@ -195,7 +223,7 @@ declare class AveAzul<T> extends Promise<T> {
      * @param options - Additional options
      * @returns The same promise instance
      */
-    asCallback(cb: ((err: Error | null, value?: T) => void) | undefined | null, options?: AsCallbackOptions): AveAzul<T>;
+    asCallback(cb: ((err: Error | null, value?: T) => void) | ((err: Error | null, ...values: any[]) => void) | undefined | null, options?: AsCallbackOptions): AveAzul<T>;
     nodeify(cb: ((err: Error | null, value?: T) => void) | undefined | null, options?: AsCallbackOptions): AveAzul<T>;
     /**
      * Bluebird-style call() method for calling a method on the resolved value

package/dist/aveazul.js

@@ -17,12 +17,6 @@ class AveAzul extends Promise {
     constructor(executor) {
         super(executor);
     }
-    /**
-     * Note: Per ECMAScript specification, when extending Promise, both .then() and static methods
-     * (resolve, reject, all, etc) must return instances of the derived class (AveAzul), so there's
-     * no need to explicitly wrap returns in new AveAzul(). This behavior is standard across all
-     * spec-compliant JS engines (V8, SpiderMonkey, JavaScriptCore, etc).
-     */
     /**
      * Bluebird-style tap() method that lets you perform side effects in a chain
      * Similar to Bluebird's Promise.prototype.tap()
@@ -415,6 +409,10 @@ class AveAzul extends Promise {
      * @returns Promise that resolves with the function's return value
      */
     static try(fn) {
+        // xaa.wrap() reports the function's declared return type, so a fn returning a
+        // thenable comes back as Promise<T | PromiseLike<T>>; pinning resolve()'s type
+        // argument to that keeps the inference off the narrower outer T. The awaited
+        // value is a T, which is what the cast records.
         return AveAzul.resolve(xaa.wrap(fn));
     }
     /**

package/dist/not-implemented.d.ts

@@ -1,4 +1,11 @@
-import type { AveAzulClass } from "./aveazul.js";
-export declare function createInstanceNotImplemented(AveAzul: AveAzulClass): string[];
-export declare function createStaticNotImplemented(AveAzul: AveAzulClass): string[];
-export declare function setupNotImplemented(AveAzul: AveAzulClass): void;
+/**
+ * What these helpers actually need from their target: they only read/assign the
+ * target's `prototype` members and its own static keys, so any constructor will
+ * do — the real AveAzul class, or a stand-in in tests.
+ */
+export type NotImplementedTarget = {
+    prototype: object;
+};
+export declare function createInstanceNotImplemented(AveAzul: NotImplementedTarget): string[];
+export declare function createStaticNotImplemented(AveAzul: NotImplementedTarget): string[];
+export declare function setupNotImplemented(AveAzul: NotImplementedTarget): void;

package/dist/promisify-all.d.ts

@@ -1,4 +1,4 @@
-import { PromisifyOptions } from "./promisify.js";
+import { type PromisifyOptions } from "./promisify.js";
 type FilterFunction = (name: string, value: unknown, target: object, passesDefaultFilter?: boolean) => boolean;
 type PromisifierFunction = (fn: (...args: any[]) => void, defaultPromisifier: (fn: (...args: any[]) => void, dp: any, options: PromisifyAllOptions) => (...args: any[]) => Promise<unknown>, options: PromisifyAllOptions) => (...args: any[]) => Promise<unknown>;
 export interface PromisifyAllOptions extends PromisifyOptions {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aveazul",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "Bluebird drop-in replacement built on native Promise",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -18,7 +18,7 @@
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",
     "test": "npm run vitest && npm run build && npm run demo:cjs && npm run demo:esm",
-    "ci:check": "tsc --noEmit -p tsconfig.json && npm test",
+    "ci:check": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.test.json && npm test && npm run test:bluebird",
     "vitest": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
@@ -80,11 +80,22 @@
     "directory": "packages/aveazul"
   },
   "dependencies": {
-    "@jchip/error": "^2.0.0",
-    "xaa": "^3.0.0"
+    "@jchip/error": "^2.1.1",
+    "xaa": "^3.1.1"
+  },
+  "devDependencies": {
+    "@fynjs/ts-resolve": "^1.0.1",
+    "@types/node": "^26.4.1",
+    "@vitest/coverage-v8": "^5.0.0",
+    "bluebird": "^3.7.2",
+    "publish-util": "^3.1.1",
+    "run-verify": "^2.1.1",
+    "typescript": "^7.0.2",
+    "vite": "^8.2.2",
+    "vitest": "^5.0.0"
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
   },
   "sideEffects": false
 }