aveazul 1.0.2 → 2.0.0

package/dist/not-implemented.js

@@ -0,0 +1,101 @@
+function createNotImplemented(name) {
+    return function () {
+        const msg = name + " Not implemented in aveazul";
+        console.error(msg);
+        throw new Error(msg);
+    };
+}
+export function createInstanceNotImplemented(AveAzul) {
+    const methods = [
+        "then",
+        "spread",
+        "catch",
+        "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;
+}
+export 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 = [];
+    const aveazul = AveAzul;
+    for (const method of methods) {
+        if (!aveazul[method]) {
+            ret.push(method);
+            aveazul[method] = createNotImplemented("static " + method);
+        }
+    }
+    return ret;
+}
+export function setupNotImplemented(AveAzul) {
+    const instanceMethods = createInstanceNotImplemented(AveAzul);
+    const staticMethods = createStaticNotImplemented(AveAzul);
+    AveAzul.__notImplementedInstance =
+        instanceMethods;
+    AveAzul.__notImplementedStatic =
+        staticMethods;
+}

package/dist/operational-error.d.ts

@@ -0,0 +1,20 @@
+/**
+ * OperationalError class for representing errors that are expected during normal operation
+ * Similar to Bluebird's OperationalError
+ */
+export declare class OperationalError extends Error {
+    isOperational: boolean;
+    constructor(message: string);
+}
+/**
+ * Check if an error is an operational error
+ * @param error - Error to check
+ * @returns True if the error is operational
+ */
+export declare function isOperationalError(error: unknown): boolean;
+/**
+ * Check if an error is a programmer error (unexpected, likely a bug)
+ * @param error - Error to check
+ * @returns True if the error is a programmer error
+ */
+export declare function isProgrammerError(error: unknown): boolean;

package/dist/operational-error.js

@@ -0,0 +1,36 @@
+/**
+ * OperationalError class for representing errors that are expected during normal operation
+ * Similar to Bluebird's OperationalError
+ */
+export 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 True if the error is operational
+ */
+export 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 True if the error is a programmer error
+ */
+export function isProgrammerError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    return !isOperationalError(error);
+}

package/dist/promisify-all.d.ts

@@ -0,0 +1,10 @@
+import { 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 {
+    suffix?: string;
+    filter?: FilterFunction;
+    promisifier?: PromisifierFunction;
+}
+export declare function promisifyAll<T extends object>(target: T, _options?: PromisifyAllOptions): T;
+export {};

package/dist/promisify-all.js

@@ -0,0 +1,69 @@
+import { promisify } from "./promisify.js";
+import { isIdentifier, isClass, isPromisified, getObjectDataKeys } from "./util.js";
+const defaultSuffix = "Async";
+const defaultFilter = function (name) {
+    return (isIdentifier(name) &&
+        name.charAt(0) !== "_" &&
+        name !== "constructor" &&
+        !name.endsWith("Sync"));
+};
+const defaultPromisifier = (fn, _defaultPromisifier, options) => {
+    return promisify(fn, {
+        ...options,
+        copyProps: false,
+    });
+};
+function promisifyAll2(obj, options) {
+    const allKeys = getObjectDataKeys(obj);
+    for (const key of allKeys) {
+        const value = obj[key];
+        const promisifiedKey = key + options.suffix;
+        const passesDefaultFilter = options.filter === defaultFilter ? true : defaultFilter(key, value, obj);
+        if (typeof value !== "function" ||
+            isPromisified(value) ||
+            obj[promisifiedKey] ||
+            !options.filter(key, value, obj, passesDefaultFilter)) {
+            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, // promisified function should get the binded object using this
+            copyProps: false,
+            ...options,
+        });
+    }
+}
+export function promisifyAll(target, _options) {
+    if (typeof target !== "function" && typeof target !== "object") {
+        throw new TypeError("the target of promisifyAll must be an object or a function");
+    }
+    const options = {
+        suffix: defaultSuffix,
+        filter: defaultFilter,
+        promisifier: defaultPromisifier,
+        Promise: globalThis.Promise,
+        multiArgs: false,
+        copyProps: true,
+        context: undefined,
+        ..._options,
+    };
+    const suffix = options.suffix;
+    if (!isIdentifier(suffix)) {
+        throw new RangeError("suffix must be a valid identifier\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
+    }
+    const allKeys = getObjectDataKeys(target);
+    for (const key of allKeys) {
+        const value = target[key];
+        if (value &&
+            key !== "constructor" &&
+            !key.startsWith("_") &&
+            isClass(value)) {
+            promisifyAll2(value.prototype, options);
+            promisifyAll2(value, options);
+        }
+    }
+    promisifyAll2(target, options);
+    return target;
+}

package/dist/promisify.d.ts

@@ -0,0 +1,11 @@
+export interface PromisifyOptions {
+    Promise?: PromiseConstructor;
+    multiArgs?: boolean;
+    copyProps?: boolean;
+    suffix?: string;
+    context?: unknown;
+}
+type NodeStyleFunction = (...args: unknown[]) => void;
+type PromisifiedFunction<T> = (...args: unknown[]) => Promise<T>;
+export declare function promisify<T = unknown>(fn: NodeStyleFunction, _options?: PromisifyOptions): PromisifiedFunction<T>;
+export {};

package/dist/promisify.js

@@ -0,0 +1,59 @@
+import { copyOwnProperties, isPromisified } from "./util.js";
+export function promisify(fn, _options) {
+    if (typeof fn !== "function") {
+        throw new TypeError("expecting a function but got " + {}.toString.call(fn));
+    }
+    if (isPromisified(fn)) {
+        return fn;
+    }
+    const options = {
+        Promise: globalThis.Promise,
+        multiArgs: false,
+        copyProps: true,
+        suffix: "",
+        context: undefined,
+        ..._options,
+    };
+    const PromiseCtor = options.Promise;
+    const multiArgs = !!options.multiArgs;
+    const promisifiedFn = function (...args) {
+        return new PromiseCtor((resolve, reject) => {
+            // add a callback to the end of the arguments to transfer the result to the promise
+            args.push(((err, ...values) => {
+                if (err) {
+                    return reject(err);
+                }
+                if (multiArgs) {
+                    resolve(values);
+                }
+                else {
+                    resolve(values[0]);
+                }
+            }));
+            // call the original function with the updated args
+            fn.call(options.context || this, ...args);
+        });
+    };
+    if (options.copyProps) {
+        copyOwnProperties(fn, promisifiedFn);
+    }
+    Object.defineProperty(promisifiedFn, "__isPromisified__", {
+        value: true,
+        writable: false,
+        enumerable: false,
+        configurable: true,
+    });
+    Object.defineProperty(promisifiedFn, "length", {
+        value: fn.length,
+        writable: false,
+        enumerable: false,
+        configurable: false,
+    });
+    Object.defineProperty(promisifiedFn, "name", {
+        value: fn.name + options.suffix,
+        writable: false,
+        enumerable: false,
+        configurable: false,
+    });
+    return promisifiedFn;
+}

package/dist/using.d.ts

@@ -0,0 +1,12 @@
+import type { AveAzulClass } from "./aveazul.js";
+/**
+ * The using function is a utility function that allows you to acquire resources,
+ * process them, and then dispose of them in an error-safe manner.
+ *
+ * @param resources - An array of resources to acquire.
+ * @param handler - A function that will be called with the acquired resources.
+ * @param PromiseCtor - The Promise implementation to use. AveAzul or Bluebird.
+ * @param asArray - Whether to return the result as an array.
+ * @returns A promise that resolves to the result of the handler function.
+ */
+export declare function using<R>(resources: any[], handler: (...args: any[]) => R, PromiseCtor: AveAzulClass, asArray: boolean): any;

package/dist/using.js

@@ -0,0 +1,124 @@
+import { Disposer } from "./disposer.js";
+import { isPromise } from "./util.js";
+import { AggregateError } from "@jchip/error";
+const SYM_FN_DISPOSE = Symbol("fnDispose");
+/**
+ * The using function is a utility function that allows you to acquire resources,
+ * process them, and then dispose of them in an error-safe manner.
+ *
+ * @param resources - An array of resources to acquire.
+ * @param handler - A function that will be called with the acquired resources.
+ * @param PromiseCtor - The Promise implementation to use. AveAzul or Bluebird.
+ * @param asArray - Whether to return the result as an array.
+ * @returns A promise that resolves to the result of the handler function.
+ */
+export function using(resources, handler, PromiseCtor, asArray) {
+    if (typeof handler !== "function") {
+        throw new TypeError("handler must be a function");
+    }
+    // resources is guaranateed to be an array of disposer, promise like, or any value
+    // first process all resources by mapping the resources array:
+    // 1. if it's a disposer, get its promise and resolve its value
+    // 2. if it's a promise like, get its value
+    // 3. otherwise, return the value
+    // 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 != null &&
+        (obj instanceof Disposer ||
+            (obj._promise !== undefined &&
+                typeof obj._data === "function"));
+    const acquireResources = () => {
+        const promiseRes = resources.map((resource) => {
+            // if it's a promise-like, wait for its resolved value
+            if (isPromise(resource)) {
+                return { ___promise: resource };
+            }
+            return resource;
+        });
+        return PromiseCtor.map(promiseRes, async (resource) => {
+            // If it's directly a disposer
+            if (isDisposer(resource)) {
+                return processDisposer({}, resource);
+            }
+            // if it's a promise like, wait for its resolved value
+            if (resource && resource.___promise) {
+                try {
+                    const res = await resource.___promise;
+                    // 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;
+                }
+                return resource;
+            }
+            return { _result: resource };
+        });
+    };
+    const disposeResources = (processedResources) => {
+        const errors = [];
+        return (PromiseCtor.each(processedResources, async (resource) => {
+            // dispose all resources that were acquired without errors
+            if (resource && resource[SYM_FN_DISPOSE]) {
+                try {
+                    await resource[SYM_FN_DISPOSE](resource._result);
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+        })).finally(() => {
+            if (errors.length > 0) {
+                PromiseCtor.___throwUncaughtError(new AggregateError(errors, "cleanup resources failed"));
+            }
+        });
+    };
+    return acquireResources().then((processedResources) => {
+        if (acquisitionErrors.length > 0) {
+            return disposeResources(processedResources).tap(() => {
+                throw acquisitionErrors[0];
+            });
+        }
+        // now collect all the results into an array
+        const results = [];
+        for (const resource of processedResources) {
+            results.push(resource._result);
+        }
+        let handlerPromise;
+        try {
+            // now call the handler with the results
+            handlerPromise = PromiseCtor.resolve(asArray ? handler(results) : handler(...results));
+        }
+        catch (error) {
+            // catch sync error from handler
+            handlerPromise = PromiseCtor.reject(error);
+        }
+        return handlerPromise
+            .tap(() => {
+            return disposeResources(processedResources);
+        })
+            .tapCatch(() => {
+            return disposeResources(processedResources);
+        });
+    });
+}

package/dist/util.d.ts

@@ -0,0 +1,29 @@
+export declare function isClass(fn: unknown): fn is Function;
+export declare function isIdentifier(str: string): boolean;
+export declare function copyOwnProperties(source: object, target: object, filter?: (key: string) => boolean): void;
+/**
+ * Copied from bluebird/js/release/util.js
+ */
+export declare function isPromisified(fn: unknown): boolean;
+/**
+ * Determines if an object is a Promise instance
+ * @param obj - The object to check
+ * @returns True if the object is a Promise instance, false otherwise
+ */
+export declare function isPromise(obj: unknown): obj is Promise<unknown>;
+/**
+ * Gets all property keys from an object and its prototype chain, excluding standard
+ * prototypes like Object.prototype, Array.prototype, and Function.prototype
+ *
+ * @param obj - The target object to get keys from
+ * @param excludedProtos - An array of prototype objects to exclude keys from
+ * @returns Array of property keys
+ */
+export declare function getObjectDataKeys(obj: object | null, excludedProtos?: object[]): string[];
+/**
+ * Triggers an uncaught exception in a safe way by scheduling it on the next event loop tick
+ * This is used for fatal errors that should crash the process
+ * @param error - The error to throw
+ */
+export declare function triggerUncaughtException(error: unknown): void;
+export declare function toArray<T>(args: Iterable<T> | ArrayLike<T>): T[];

package/dist/util.js

@@ -0,0 +1,173 @@
+/**
+ * Determines if a function is a class (either ES6 class or ES5 constructor function)
+ * This function performs several checks to identify different class patterns:
+ * 1. ES6 classes with the 'class' keyword
+ * 2. Constructor functions (ES5 classes) with prototype methods
+ *
+ * @param fn - The value to check
+ * @returns True if the function is a class, false otherwise
+ */
+const thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
+export function isClass(fn) {
+    try {
+        if (typeof fn === "function") {
+            const keys = Object.getOwnPropertyNames(fn.prototype);
+            const hasMethods = keys.length > 1;
+            const hasMethodsOtherThanConstructor = keys.length > 0 && !(keys.length === 1 && keys[0] === "constructor");
+            const hasThisAssignmentAndStaticMethods = thisAssignmentPattern.test(fn + "") &&
+                Object.getOwnPropertyNames(fn).length > 0;
+            if (hasMethods ||
+                hasMethodsOtherThanConstructor ||
+                hasThisAssignmentAndStaticMethods) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+const rident = /^[a-z$_][a-z$_0-9]*$/i;
+export function isIdentifier(str) {
+    return rident.test(str);
+}
+/**
+ * Prop filtering code copied from bluebird/js/release
+ */
+const noCopyProps = [
+    "arity",
+    "length",
+    "name",
+    "arguments",
+    "caller",
+    "callee",
+    "prototype",
+    "__isPromisified__",
+];
+const noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$");
+function propsFilter(key) {
+    return !noCopyPropsPattern.test(key);
+}
+export function copyOwnProperties(source, target, filter = propsFilter) {
+    const names = Object.getOwnPropertyNames(source);
+    for (const name of names) {
+        if (filter(name)) {
+            Object.defineProperty(target, name, Object.getOwnPropertyDescriptor(source, name));
+        }
+    }
+}
+/**
+ * Copied from bluebird/js/release/util.js
+ */
+export function isPromisified(fn) {
+    try {
+        return fn.__isPromisified__ === true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Determines if an object is a Promise instance
+ * @param obj - The object to check
+ * @returns True if the object is a Promise instance, false otherwise
+ */
+export function isPromise(obj) {
+    return (obj instanceof Promise ||
+        (obj != null &&
+            typeof obj === "object" &&
+            typeof obj.then === "function" &&
+            typeof obj.catch === "function"));
+}
+/**
+ * Gets all property keys from an object and its prototype chain, excluding standard
+ * prototypes like Object.prototype, Array.prototype, and Function.prototype
+ *
+ * @param obj - The target object to get keys from
+ * @param excludedProtos - An array of prototype objects to exclude keys from
+ * @returns Array of property keys
+ */
+export function getObjectDataKeys(obj, excludedProtos = []) {
+    const excludedPrototypes = [
+        Array.prototype,
+        Object.prototype,
+        Function.prototype,
+        ...excludedProtos,
+    ];
+    const isExcludedProto = function (val) {
+        for (const protoVal of excludedPrototypes) {
+            if (protoVal === val) {
+                return true;
+            }
+        }
+        return false;
+    };
+    const ret = [];
+    const visitedKeys = Object.create(null);
+    /* copied from bluebird/js/release/util.js and modified */
+    while (obj && !isExcludedProto(obj)) {
+        let keys;
+        try {
+            keys = Object.getOwnPropertyNames(obj);
+        }
+        catch (_a) {
+            /* istanbul ignore next */
+            return ret;
+        }
+        for (const key of keys) {
+            /* istanbul ignore if */
+            if (visitedKeys[key]) {
+                /* istanbul ignore next */
+                continue;
+            }
+            visitedKeys[key] = true;
+            const desc = Object.getOwnPropertyDescriptor(obj, key);
+            /**
+             * When desc.get && desc.set are falsy, it means the property is a data
+             * property that holds an actual value, rather than being computed dynamically
+             * through getter/setter functions.
+             */
+            /* istanbul ignore next */
+            if (desc && !desc.get && !desc.set) {
+                ret.push(key);
+            }
+        }
+        obj = Object.getPrototypeOf(obj);
+    }
+    return ret;
+}
+/**
+ * Triggers an uncaught exception in a safe way by scheduling it on the next event loop tick
+ * This is used for fatal errors that should crash the process
+ * @param error - The error to throw
+ */
+export function triggerUncaughtException(error) {
+    let err;
+    if (!(error instanceof Error)) {
+        err = new Error(String(error));
+    }
+    else {
+        err = error;
+    }
+    // Use setTimeout with 0ms delay to throw on the next event loop tick
+    // This ensures the current execution context completes first
+    setTimeout(() => {
+        throw err;
+    }, 0);
+}
+export 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;
+}