@naturalcycles/js-lib 14.134.0 → 14.136.0

package/dist/promise/pRetry.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pRetry = exports.pRetryFn = void 0;
 const __1 = require("..");
-const pTimeout_1 = require("./pTimeout");
 /**
  * Returns a Function (!), enhanced with retry capabilities.
  * Implements "Exponential back-off strategy" by multiplying the delay by `delayMultiplier` with each try.
@@ -14,8 +13,8 @@ function pRetryFn(fn, opt = {}) {
 }
 exports.pRetryFn = pRetryFn;
 async function pRetry(fn, opt = {}) {
-    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, name, keepStackTrace = true, timeout, } = opt;
-    const fakeError = keepStackTrace ? new Error('RetryError') : undefined;
+    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, name, timeout, } = opt;
+    const fakeError = timeout ? new Error('TimeoutError') : undefined;
     let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt;
     if (opt.logAll) {
         logSuccess = logFirstAttempt = logRetries = logFailures = true;
@@ -26,70 +25,45 @@ async function pRetry(fn, opt = {}) {
     const fname = name || fn.name || 'pRetry function';
     let delay = initialDelay;
     let attempt = 0;
-    let timer;
-    let timedOut = false;
-    return await new Promise((resolve, reject) => {
-        const rejectWithTimeout = () => {
-            timedOut = true; // to prevent more tries
-            const err = new pTimeout_1.TimeoutError(`"${fname}" timed out after ${timeout} ms`, opt.errorData);
-            if (fakeError) {
-                // keep original stack
-                err.stack = fakeError.stack.replace('Error: RetryError', 'TimeoutError');
+    /* eslint-disable no-await-in-loop, no-constant-condition */
+    while (true) {
+        const started = Date.now();
+        try {
+            attempt++;
+            if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {
+                logger.log(`${fname} attempt #${attempt}...`);
             }
-            reject(err);
-        };
-        const next = async () => {
-            if (timedOut)
-                return;
+            let result;
             if (timeout) {
-                timer = setTimeout(rejectWithTimeout, timeout);
+                await (0, __1.pTimeout)(async () => await fn(attempt), {
+                    timeout,
+                    name: fname,
+                    errorData: opt.errorData,
+                    fakeError,
+                });
             }
-            const started = Date.now();
-            try {
-                attempt++;
-                if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {
-                    logger.log(`${fname} attempt #${attempt}...`);
-                }
-                const r = await fn(attempt);
-                clearTimeout(timer);
-                if (logSuccess) {
-                    logger.log(`${fname} attempt #${attempt} succeeded in ${(0, __1._since)(started)}`);
-                }
-                resolve(r);
+            else {
+                result = await fn(attempt);
             }
-            catch (err) {
-                clearTimeout(timer);
-                if (logFailures) {
-                    logger.warn(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:`, (0, __1._stringifyAny)(err, {
-                        includeErrorData: true,
-                    }));
-                }
-                if (attempt >= maxAttempts ||
-                    (predicate && !predicate(err, attempt, maxAttempts))) {
-                    // Give up
-                    if (fakeError) {
-                        // Preserve the original call stack
-                        Object.defineProperty(err, 'stack', {
-                            value: err.stack +
-                                '\n    --' +
-                                fakeError.stack.replace('Error: RetryError', ''),
-                        });
-                    }
-                    ;
-                    err.data = {
-                        ...err.data,
-                        ...opt.errorData,
-                    };
-                    reject(err);
-                }
-                else {
-                    // Retry after delay
-                    delay *= delayMultiplier;
-                    setTimeout(next, delay);
-                }
+            if (logSuccess) {
+                logger.log(`${fname} attempt #${attempt} succeeded in ${(0, __1._since)(started)}`);
             }
-        };
-        void next();
-    });
+            return result;
+        }
+        catch (err) {
+            if (logFailures) {
+                logger.warn(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:`, err);
+            }
+            if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
+                // Give up
+                (0, __1._errorDataAppend)(err, opt.errorData);
+                throw err;
+            }
+            // Retry after delay
+            delay *= delayMultiplier;
+            await (0, __1.pDelay)(delay);
+            // back to while(true) loop
+        }
+    }
 }
 exports.pRetry = pRetry;

package/dist/promise/pTimeout.d.ts

@@ -23,13 +23,11 @@ export interface PTimeoutOptions {
      */
     onTimeout?: (err: TimeoutError) => any;
     /**
-     * Defaults to true.
-     * If true - preserves the stack trace in case of a Timeout (usually - very useful!).
-     * It has a certain perf cost.
-     *
-     * @experimental
+     * If passed - fakeError.stack will be used as a stacktrace.
+     * This is to "keep stacktrace" when pTimeout is called from another
+     * function (like pRetry).
      */
-    keepStackTrace?: boolean;
+    fakeError?: Error;
     /**
      * Will be merged with `err.data` object.
      */

package/dist/promise/pTimeout.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pTimeout = exports.pTimeoutFn = exports.TimeoutError = void 0;
 const app_error_1 = require("../error/app.error");
+const error_util_1 = require("../error/error.util");
 class TimeoutError extends app_error_1.AppError {
     constructor(message, data = {}, opt) {
         super(message, data, opt, 'TimeoutError');
@@ -29,26 +30,23 @@ exports.pTimeoutFn = pTimeoutFn;
  * If the Function rejects - passes this rejection further.
  */
 async function pTimeout(fn, opt) {
-    const { timeout, name = fn.name || 'pTimeout function', onTimeout, keepStackTrace = true } = opt;
-    const fakeError = keepStackTrace ? new Error('TimeoutError') : undefined;
+    const { timeout, name = fn.name || 'pTimeout function', onTimeout } = opt;
+    const fakeError = opt.fakeError || new Error('TimeoutError');
     // eslint-disable-next-line no-async-promise-executor
     return await new Promise(async (resolve, reject) => {
         // Prepare the timeout timer
         const timer = setTimeout(() => {
             const err = new TimeoutError(`"${name}" timed out after ${timeout} ms`, opt.errorData);
-            if (fakeError)
-                err.stack = fakeError.stack; // keep original stack
+            // keep original stack
+            err.stack = fakeError.stack.replace('Error: TimeoutError', 'TimeoutError: ' + err.message);
             if (onTimeout) {
                 try {
                     resolve(onTimeout(err));
                 }
                 catch (err) {
-                    if (fakeError)
-                        err.stack = fakeError.stack; // keep original stack
-                    err.data = {
-                        ...err.data,
-                        ...opt.errorData,
-                    };
+                    // keep original stack
+                    err.stack = fakeError.stack.replace('Error: TimeoutError', err.name + ': ' + err.message);
+                    (0, error_util_1._errorDataAppend)(err, opt.errorData);
                     reject(err);
                 }
                 return;

package/dist/string/stringifyAny.d.ts

@@ -20,12 +20,6 @@ export interface StringifyAnyOptions {
      * Default limit is less than in Node, cause it's likely to be used e.g in Browser alert()
      */
     maxLen?: number;
-    /**
-     * Pass true to include "stringified" `error.data` in the output.
-     *
-     * @default false
-     */
-    includeErrorData?: boolean;
     /**
      * Set to true to print Error.stack instead of just Error.message.
      *

package/dist/string/stringifyAny.js

@@ -86,11 +86,6 @@ function _stringifyAny(obj, opt = {}) {
                 // `replace` here works ONCE, exactly as we need it
                 s = s.replace('HttpError', `HttpError(${obj.data.httpStatusCode})`);
             }
-            // Here we ensure it has `data`
-            const { data } = obj;
-            if (opt.includeErrorData && Object.keys(data).length > 0) {
-                s = [s, _stringifyAny(data, opt)].join('\n');
-            }
         }
         else if (typeof obj.code === 'string') {
             // Error that has no `data`, but has `code` property

package/dist/types.d.ts

@@ -59,6 +59,9 @@ export type UnsavedId<T extends Partial<ObjectWithId>> = Omit<T, 'id'> & {
  */
 export type AnyFunction<T = any> = (...args: any[]) => T;
 export type AnyAsyncFunction<T = any> = (...args: any[]) => Promise<T>;
+export type AsyncFunction<T = any> = () => Promise<T>;
+export type AnyPromisableFunction<T = any> = (...args: any[]) => Promisable<T>;
+export type PromisableFunction<T = any> = () => Promisable<T>;
 /**
  * Symbol to indicate END of Sequence.
  */

package/dist/vendor/is.d.ts

@@ -5,9 +5,9 @@
 /// <reference lib="dom" />
 import { Class, ObservableLike, Primitive, TypedArray } from '../typeFest';
 declare const objectTypeNames: readonly ["Function", "Generator", "AsyncGenerator", "GeneratorFunction", "AsyncGeneratorFunction", "AsyncFunction", "Observable", "Array", "Buffer", "Object", "RegExp", "Date", "Error", "Map", "Set", "WeakMap", "WeakSet", "ArrayBuffer", "SharedArrayBuffer", "DataView", "Promise", "URL", "FormData", "URLSearchParams", "HTMLElement", "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array"];
-type ObjectTypeName = typeof objectTypeNames[number];
+type ObjectTypeName = (typeof objectTypeNames)[number];
 declare const primitiveTypeNames: readonly ["null", "undefined", "string", "number", "bigint", "boolean", "symbol"];
-type PrimitiveTypeName = typeof primitiveTypeNames[number];
+type PrimitiveTypeName = (typeof primitiveTypeNames)[number];
 export type TypeName = ObjectTypeName | PrimitiveTypeName;
 export declare function is(value: unknown): TypeName;
 export declare namespace is {

package/dist-esm/decorators/logMethod.decorator.js

@@ -76,10 +76,10 @@ function logFinished(logger, callSignature, started, sma, logResultFn, res, err)
         t.push(`(avg ${_ms(sma.push(millis))})`);
     }
     if (err !== undefined) {
-        t.push('ERROR:', _stringifyAny(err, { includeErrorData: true }));
+        t.push('ERROR:', err);
     }
     else if (logResultFn) {
         t.push(...logResultFn(res));
     }
-    logger.log(t.filter(Boolean).join(' '));
+    logger.log(...t.filter(Boolean));
 }

package/dist-esm/env.js

@@ -0,0 +1,18 @@
+/**
+ * Use it to detect SSR/Node.js environment.
+ *
+ * Will return `true` in Node.js.
+ * Will return `false` in the Browser.
+ */
+export function isServerSide() {
+    return typeof window === 'undefined';
+}
+/**
+ * Use it to detect Browser (not SSR/Node) environment.
+ *
+ * Will return `true` in the Browser.
+ * Will return `false` in Node.js.
+ */
+export function isClientSide() {
+    return typeof window !== 'undefined';
+}

package/dist-esm/error/error.util.js

@@ -143,5 +143,7 @@ export function _isErrorObject(o) {
  * }
  */
 export function _errorDataAppend(err, data) {
+    if (!data)
+        return;
     err.data = Object.assign(Object.assign({}, err.data), data);
 }

package/dist-esm/error/tryCatch.js

@@ -1,4 +1,4 @@
-import { _anyToError, _since, _stringifyAny } from '../index';
+import { _anyToError, _since } from '../index';
 /**
  * Decorates a function with "try/catch", so it'll never reject/throw.
  * Only applies to async functions (or, turns sync function into async).
@@ -21,9 +21,7 @@ export function _tryCatch(fn, opt = {}) {
         }
         catch (err) {
             if (logError) {
-                logger.warn(`tryCatch.${fname} error in ${_since(started)}:\n${_stringifyAny(err, {
-                    includeErrorData: true,
-                })}`);
+                logger.warn(`tryCatch.${fname} error in ${_since(started)}:`, err);
             }
             if (onError) {
                 try {

package/dist-esm/http/fetcher.js

@@ -1,5 +1,6 @@
 /// <reference lib="dom"/>
 import { __asyncValues } from "tslib";
+import { isServerSide } from '../env';
 import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util';
 import { HttpError } from '../error/http.error';
 import { _clamp } from '../number/number.util';
@@ -82,10 +83,10 @@ export class Fetcher {
      */
     async rawFetch(url, rawOpt = {}) {
         var _a, e_1, _b, _c, _d, e_2, _e, _f;
-        var _g, _h, _j;
+        var _g;
         const { logger } = this.cfg;
         const req = this.normalizeOptions(url, rawOpt);
-        const { timeoutSeconds, mode, init: { method }, } = req;
+        const { timeoutSeconds, init: { method }, } = req;
         // setup timeout
         let timeout;
         if (timeoutSeconds) {
@@ -96,25 +97,29 @@ export class Fetcher {
             }, timeoutSeconds * 1000);
         }
         try {
-            for (var _k = true, _l = __asyncValues(this.cfg.hooks.beforeRequest || []), _m; _m = await _l.next(), _a = _m.done, !_a;) {
-                _c = _m.value;
-                _k = false;
+            for (var _h = true, _j = __asyncValues(this.cfg.hooks.beforeRequest || []), _k; _k = await _j.next(), _a = _k.done, !_a;) {
+                _c = _k.value;
+                _h = false;
                 try {
                     const hook = _c;
                     await hook(req);
                 }
                 finally {
-                    _k = true;
+                    _h = true;
                 }
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (!_k && !_a && (_b = _l.return)) await _b.call(_l);
+                if (!_h && !_a && (_b = _j.return)) await _b.call(_j);
             }
             finally { if (e_1) throw e_1.error; }
         }
+        const isFullUrl = req.url.includes('://');
+        const fullUrl = isFullUrl ? new URL(req.url) : undefined;
+        const shortUrl = fullUrl ? this.getShortUrl(fullUrl) : req.url;
+        const signature = [method, shortUrl].join(' ');
         const res = {
             req,
             retryStatus: {
@@ -122,10 +127,8 @@ export class Fetcher {
                 retryStopped: false,
                 retryTimeout: req.retry.timeout,
             },
+            signature,
         };
-        const fullUrl = new URL(req.url);
-        const shortUrl = this.getShortUrl(fullUrl);
-        const signature = [method, shortUrl].join(' ');
         /* eslint-disable no-await-in-loop */
         while (!res.retryStatus.retryStopped) {
             const started = Date.now();
@@ -149,114 +152,124 @@ export class Fetcher {
             }
             res.statusFamily = this.getStatusFamily(res);
             if ((_g = res.fetchResponse) === null || _g === void 0 ? void 0 : _g.ok) {
-                if (mode === 'json') {
-                    if (res.fetchResponse.body) {
-                        const text = await res.fetchResponse.text();
-                        if (text) {
-                            try {
-                                res.body = text;
-                                res.body = JSON.parse(text, req.jsonReviver);
-                            }
-                            catch (err) {
-                                const { message } = _anyToError(err);
-                                res.err = new HttpError([signature, message].join('\n'), {
-                                    httpStatusCode: 0,
-                                    url: req.url,
-                                });
-                                res.ok = false;
-                            }
-                        }
-                        else {
-                            // Body had a '' (empty string)
-                            res.body = {};
-                        }
-                    }
-                    else {
-                        // if no body: set responseBody as {}
-                        // do not throw a "cannot parse null as Json" error
-                        res.body = {};
-                    }
-                }
-                else if (mode === 'text') {
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
-                }
-                else if (mode === 'arrayBuffer') {
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : {};
-                }
-                else if (mode === 'blob') {
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {};
-                }
-                clearTimeout(timeout);
-                res.retryStatus.retryStopped = true;
-                // res.err can happen on JSON.parse error
-                if (!res.err && this.cfg.logResponse) {
-                    const { retryAttempt } = res.retryStatus;
-                    logger.log([
-                        ' <<',
-                        res.fetchResponse.status,
-                        signature,
-                        retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
-                        _since(started),
-                    ]
-                        .filter(Boolean)
-                        .join(' '));
-                    if (this.cfg.logResponseBody) {
-                        logger.log(res.body);
-                    }
-                }
+                await this.onOkResponse(res, started, timeout);
             }
             else {
                 // !res.ok
-                clearTimeout(timeout);
-                let errObj;
-                if (res.fetchResponse) {
-                    const body = _jsonParseIfPossible(await res.fetchResponse.text());
-                    errObj = _anyToErrorObject(body);
-                }
-                else if (res.err) {
-                    errObj = _errorToErrorObject(res.err);
-                }
-                else {
-                    errObj = {};
-                }
-                const originalMessage = errObj.message;
-                errObj.message = [
-                    [(_h = res.fetchResponse) === null || _h === void 0 ? void 0 : _h.status, signature].filter(Boolean).join(' '),
-                    originalMessage,
-                ]
-                    .filter(Boolean)
-                    .join('\n');
-                res.err = new HttpError(errObj.message, _filterNullishValues(Object.assign(Object.assign({}, errObj.data), { originalMessage, httpStatusCode: ((_j = res.fetchResponse) === null || _j === void 0 ? void 0 : _j.status) || 0, 
-                    // These properties are provided to be used in e.g custom Sentry error grouping
-                    // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
-                    // Enabled, cause `data` is not printed by default when error is HttpError
-                    // method: req.method,
-                    url: req.url })));
-                await this.processRetry(res);
+                await this.onNotOkResponse(res, timeout);
             }
         }
         try {
-            for (var _o = true, _p = __asyncValues(this.cfg.hooks.afterResponse || []), _q; _q = await _p.next(), _d = _q.done, !_d;) {
-                _f = _q.value;
-                _o = false;
+            for (var _l = true, _m = __asyncValues(this.cfg.hooks.afterResponse || []), _o; _o = await _m.next(), _d = _o.done, !_d;) {
+                _f = _o.value;
+                _l = false;
                 try {
                     const hook = _f;
                     await hook(res);
                 }
                 finally {
-                    _o = true;
+                    _l = true;
                 }
             }
         }
         catch (e_2_1) { e_2 = { error: e_2_1 }; }
         finally {
             try {
-                if (!_o && !_d && (_e = _p.return)) await _e.call(_p);
+                if (!_l && !_d && (_e = _m.return)) await _e.call(_m);
             }
             finally { if (e_2) throw e_2.error; }
         }
         return res;
     }
+    async onOkResponse(res, started, timeout) {
+        const { req } = res;
+        const { mode } = res.req;
+        if (mode === 'json') {
+            if (res.fetchResponse.body) {
+                const text = await res.fetchResponse.text();
+                if (text) {
+                    try {
+                        res.body = text;
+                        res.body = JSON.parse(text, req.jsonReviver);
+                    }
+                    catch (err) {
+                        const { message } = _anyToError(err);
+                        res.err = new HttpError([res.signature, message].join('\n'), {
+                            httpStatusCode: 0,
+                            url: req.url,
+                        });
+                        res.ok = false;
+                    }
+                }
+                else {
+                    // Body had a '' (empty string)
+                    res.body = {};
+                }
+            }
+            else {
+                // if no body: set responseBody as {}
+                // do not throw a "cannot parse null as Json" error
+                res.body = {};
+            }
+        }
+        else if (mode === 'text') {
+            res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
+        }
+        else if (mode === 'arrayBuffer') {
+            res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : {};
+        }
+        else if (mode === 'blob') {
+            res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {};
+        }
+        clearTimeout(timeout);
+        res.retryStatus.retryStopped = true;
+        // res.err can happen on JSON.parse error
+        if (!res.err && this.cfg.logResponse) {
+            const { retryAttempt } = res.retryStatus;
+            const { logger } = this.cfg;
+            logger.log([
+                ' <<',
+                res.fetchResponse.status,
+                res.signature,
+                retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
+                _since(started),
+            ]
+                .filter(Boolean)
+                .join(' '));
+            if (this.cfg.logResponseBody) {
+                logger.log(res.body);
+            }
+        }
+    }
+    async onNotOkResponse(res, timeout) {
+        var _a, _b;
+        clearTimeout(timeout);
+        let errObj;
+        if (res.fetchResponse) {
+            const body = _jsonParseIfPossible(await res.fetchResponse.text());
+            errObj = _anyToErrorObject(body);
+        }
+        else if (res.err) {
+            errObj = _errorToErrorObject(res.err);
+        }
+        else {
+            errObj = {};
+        }
+        const originalMessage = errObj.message;
+        errObj.message = [
+            [(_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status, res.signature].filter(Boolean).join(' '),
+            originalMessage,
+        ]
+            .filter(Boolean)
+            .join('\n');
+        res.err = new HttpError(errObj.message, _filterNullishValues(Object.assign(Object.assign({}, errObj.data), { originalMessage, httpStatusCode: ((_b = res.fetchResponse) === null || _b === void 0 ? void 0 : _b.status) || 0, 
+            // These properties are provided to be used in e.g custom Sentry error grouping
+            // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
+            // Enabled, cause `data` is not printed by default when error is HttpError
+            // method: req.method,
+            url: res.req.url })));
+        await this.processRetry(res);
+    }
     async processRetry(res) {
         var _a, e_3, _b, _c;
         const { retryStatus } = res;
@@ -347,7 +360,7 @@ export class Fetcher {
         if (!this.cfg.logWithSearchParams) {
             shortUrl = shortUrl.split('?')[0];
         }
-        if (!this.cfg.logWithPrefixUrl && baseUrl && shortUrl.startsWith(baseUrl)) {
+        if (!this.cfg.logWithBaseUrl && baseUrl && shortUrl.startsWith(baseUrl)) {
             shortUrl = shortUrl.slice(baseUrl.length);
         }
         return shortUrl;
@@ -375,7 +388,7 @@ export class Fetcher {
             logRequestBody: debug,
             logResponse: debug,
             logResponseBody: debug,
-            logWithPrefixUrl: true,
+            logWithBaseUrl: isServerSide(),
             logWithSearchParams: true,
             retry: Object.assign({}, defRetryOptions),
             init: {

package/dist-esm/index.js

@@ -61,6 +61,7 @@ export * from './unit/size.util';
 export * from './log/commonLogger';
 export * from './string/safeJsonStringify';
 export * from './promise/pQueue';
+export * from './promise/abortable';
 export * from './seq/seq';
 export * from './math/stack.util';
 export * from './string/leven';
@@ -72,6 +73,7 @@ export * from './datetime/localDate';
 export * from './datetime/localTime';
 export * from './datetime/dateInterval';
 export * from './datetime/timeInterval';
+export * from './env';
 export * from './http/http.model';
 export * from './http/fetcher';
 export * from './http/fetcher.model';

package/dist-esm/promise/abortable.js

@@ -0,0 +1,32 @@
+/**
+ * Similar to AbortController and AbortSignal.
+ * Similar to pDefer and Promise.
+ * Similar to Subject and Observable.
+ *
+ * Minimal interface for something that can be aborted in the future,
+ * but not necessary.
+ * Allows to listen to `onAbort` event.
+ *
+ * @experimental
+ */
+export class Abortable {
+    constructor(onAbort) {
+        this.onAbort = onAbort;
+        this.aborted = false;
+    }
+    abort() {
+        var _a;
+        if (this.aborted)
+            return;
+        this.aborted = true;
+        (_a = this.onAbort) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.onAbort = undefined; // cleanup listener
+    }
+    clear() {
+        this.onAbort = undefined;
+    }
+}
+// convenience function
+export function abortable(onAbort) {
+    return new Abortable(onAbort);
+}

package/dist-esm/promise/pDefer.js

@@ -11,5 +11,7 @@ export function pDefer() {
     });
     promise.resolve = resolve;
     promise.reject = reject;
+    promise.rejectAborted = reason => reject(new Error(['Aborted', reason].filter(Boolean).join(': ')));
+    promise.abort = reason => promise.rejectAborted(reason);
     return promise;
 }