fragile-promise/dist/index.d.ts

A modern Promise implementation with timeout and cancellation using AbortController.

export declare class TimeoutError extends Error {
    constructor(message?: string);
}
export declare class CancellationError extends Error {
    constructor(message?: string);
}
export interface FragilePromiseWithResolvers<T> {
    promise: FragilePromise<T>;
    resolve: (value: T | PromiseLike<T>) => void;
    reject: (reason?: unknown) => void;
}
export declare class FragilePromise<T = unknown> extends Promise<T> {
    #private;
    abortController: AbortController;
    abortSignal: AbortSignal;
    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: unknown) => void) => void);
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): FragilePromise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null | undefined): FragilePromise<T | TResult>;
    finally(onfinally?: (() => void) | null | undefined): FragilePromise<T>;
    cancel(): void;
    timeout(milliseconds: number): this;
    delay(milliseconds: number): FragilePromise<T>;
    isCancelled(): boolean;
    isTimedOut(): boolean;
    static isCancellationError(error: unknown): error is CancellationError;
    static isTimeoutError(error: unknown): error is TimeoutError;
    static withResolvers<T>(): FragilePromiseWithResolvers<T>;
    static all<T extends readonly unknown[] | []>(values: T): FragilePromise<{
        -readonly [P in keyof T]: Awaited<T[P]>;
    }>;
    static reject<T = never>(reason?: any): FragilePromise<T>;
    static resolve(value?: never): FragilePromise<void>;
    static resolve<T>(value: T): FragilePromise<Awaited<T>>;
}
//# sourceMappingURL=index.d.ts.map