@naturalcycles/js-lib 14.135.0 → 14.136.0

package/dist/decorators/logMethod.decorator.js

@@ -80,10 +80,10 @@ function logFinished(logger, callSignature, started, sma, logResultFn, res, err)
         t.push(`(avg ${(0, time_util_1._ms)(sma.push(millis))})`);
     }
     if (err !== undefined) {
-        t.push('ERROR:', (0, __1._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/error/error.util.d.ts

@@ -36,4 +36,4 @@ export declare function _isErrorObject(o: any): o is ErrorObject;
  *   })
  * }
  */
-export declare function _errorDataAppend(err: any, data: ErrorData): void;
+export declare function _errorDataAppend(err: any, data?: ErrorData): void;

package/dist/error/error.util.js

@@ -155,6 +155,8 @@ exports._isErrorObject = _isErrorObject;
  * }
  */
 function _errorDataAppend(err, data) {
+    if (!data)
+        return;
     err.data = {
         ...err.data,
         ...data,

package/dist/error/tryCatch.js

@@ -24,9 +24,7 @@ function _tryCatch(fn, opt = {}) {
         }
         catch (err) {
             if (logError) {
-                logger.warn(`tryCatch.${fname} error in ${(0, index_1._since)(started)}:\n${(0, index_1._stringifyAny)(err, {
-                    includeErrorData: true,
-                })}`);
+                logger.warn(`tryCatch.${fname} error in ${(0, index_1._since)(started)}:`, err);
             }
             if (onError) {
                 try {

package/dist/index.d.ts

@@ -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';

package/dist/index.js

@@ -65,6 +65,7 @@ tslib_1.__exportStar(require("./unit/size.util"), exports);
 tslib_1.__exportStar(require("./log/commonLogger"), exports);
 tslib_1.__exportStar(require("./string/safeJsonStringify"), exports);
 tslib_1.__exportStar(require("./promise/pQueue"), exports);
+tslib_1.__exportStar(require("./promise/abortable"), exports);
 tslib_1.__exportStar(require("./seq/seq"), exports);
 tslib_1.__exportStar(require("./math/stack.util"), exports);
 tslib_1.__exportStar(require("./string/leven"), exports);

package/dist/promise/abortable.d.ts

@@ -0,0 +1,20 @@
+import { AnyFunction } from '../types';
+/**
+ * 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 declare class Abortable {
+    onAbort?: AnyFunction<any> | undefined;
+    constructor(onAbort?: AnyFunction<any> | undefined);
+    aborted: boolean;
+    abort(): void;
+    clear(): void;
+}
+export declare function abortable(onAbort?: AnyFunction): Abortable;

package/dist/promise/abortable.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortable = exports.Abortable = void 0;
+/**
+ * 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
+ */
+class Abortable {
+    constructor(onAbort) {
+        this.onAbort = onAbort;
+        this.aborted = false;
+    }
+    abort() {
+        if (this.aborted)
+            return;
+        this.aborted = true;
+        this.onAbort?.();
+        this.onAbort = undefined; // cleanup listener
+    }
+    clear() {
+        this.onAbort = undefined;
+    }
+}
+exports.Abortable = Abortable;
+// convenience function
+function abortable(onAbort) {
+    return new Abortable(onAbort);
+}
+exports.abortable = abortable;

package/dist/promise/pDefer.d.ts

@@ -3,7 +3,20 @@
  */
 export interface DeferredPromise<T = void> extends Promise<T> {
     resolve: (a?: T) => void;
-    reject: (e?: Error) => void;
+    reject: (err?: Error) => void;
+    /**
+     * Can be overridden.
+     * Otherwise will reject with "Aborted" or "Aborted: $reason" on abort().
+     *
+     * @experimental
+     */
+    abort: (reason?: string) => void;
+    /**
+     * Rejects the promise with `new Error('Aborted: $reason')`.
+     *
+     * @experimental
+     */
+    rejectAborted: (reason?: string) => void;
 }
 /**
  * Returns DeferredPromise - a Promise that has .resolve() and .reject() methods.

package/dist/promise/pDefer.js

@@ -14,6 +14,8 @@ 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;
 }
 exports.pDefer = pDefer;

package/dist/promise/pDelay.d.ts

@@ -1 +1,19 @@
+import type { PromisableFunction } from '../types';
+import { DeferredPromise } from './pDefer';
+/**
+ * Promisified version of setTimeout.
+ *
+ * Can return a value.
+ * If value is instanceof Error - rejects the Promise instead of resolving.
+ */
 export declare function pDelay<T>(ms?: number, value?: T): Promise<T>;
+/**
+ * Promisified version of setTimeout.
+ *
+ * Wraps the passed function with try/catch,
+ * catch will propagate to pDelayFn rejection,
+ * otherwise pDelayFn will resolve with returned value.
+ *
+ * On abort() - clears the Timeout and immediately resolves the Promise with void.
+ */
+export declare function pDelayFn<T>(ms: number | undefined, fn: PromisableFunction<T>): DeferredPromise<T>;

package/dist/promise/pDelay.js

@@ -1,7 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pDelay = void 0;
+exports.pDelayFn = exports.pDelay = void 0;
+const pDefer_1 = require("./pDefer");
+/**
+ * Promisified version of setTimeout.
+ *
+ * Can return a value.
+ * If value is instanceof Error - rejects the Promise instead of resolving.
+ */
 async function pDelay(ms = 0, value) {
-    return await new Promise(resolve => setTimeout(() => resolve(value), ms));
+    return await new Promise((resolve, reject) => setTimeout(value instanceof Error ? reject : resolve, ms, value));
 }
 exports.pDelay = pDelay;
+/* eslint-disable @typescript-eslint/promise-function-async */
+/**
+ * Promisified version of setTimeout.
+ *
+ * Wraps the passed function with try/catch,
+ * catch will propagate to pDelayFn rejection,
+ * otherwise pDelayFn will resolve with returned value.
+ *
+ * On abort() - clears the Timeout and immediately resolves the Promise with void.
+ */
+function pDelayFn(ms = 0, fn) {
+    const p = (0, pDefer_1.pDefer)();
+    const timer = setTimeout(async () => {
+        try {
+            p.resolve(await fn());
+        }
+        catch (err) {
+            p.reject(err);
+        }
+    }, ms);
+    p.abort = () => {
+        clearTimeout(timer);
+        // p.rejectAborted(reason) // nope
+        p.resolve();
+    };
+    return p;
+}
+exports.pDelayFn = pDelayFn;

package/dist/promise/pRetry.d.ts

@@ -68,14 +68,6 @@ export interface PRetryOptions {
      * Default to `console`
      */
     logger?: CommonLogger;
-    /**
-     * Defaults to true.
-     * If true - preserves the stack trace in case of a Timeout (usually - very useful!).
-     * It has a certain perf cost.
-     *
-     * @experimental
-     */
-    keepStackTrace?: boolean;
     /**
      * Will be merged with `err.data` object.
      */

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-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/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/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';

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;
 }

package/dist-esm/promise/pDelay.js

@@ -1,3 +1,37 @@
+import { pDefer } from './pDefer';
+/**
+ * Promisified version of setTimeout.
+ *
+ * Can return a value.
+ * If value is instanceof Error - rejects the Promise instead of resolving.
+ */
 export async function pDelay(ms = 0, value) {
-    return await new Promise(resolve => setTimeout(() => resolve(value), ms));
+    return await new Promise((resolve, reject) => setTimeout(value instanceof Error ? reject : resolve, ms, value));
+}
+/* eslint-disable @typescript-eslint/promise-function-async */
+/**
+ * Promisified version of setTimeout.
+ *
+ * Wraps the passed function with try/catch,
+ * catch will propagate to pDelayFn rejection,
+ * otherwise pDelayFn will resolve with returned value.
+ *
+ * On abort() - clears the Timeout and immediately resolves the Promise with void.
+ */
+export function pDelayFn(ms = 0, fn) {
+    const p = pDefer();
+    const timer = setTimeout(async () => {
+        try {
+            p.resolve(await fn());
+        }
+        catch (err) {
+            p.reject(err);
+        }
+    }, ms);
+    p.abort = () => {
+        clearTimeout(timer);
+        // p.rejectAborted(reason) // nope
+        p.resolve();
+    };
+    return p;
 }

package/dist-esm/promise/pRetry.js

@@ -1,5 +1,4 @@
-import { _since, _stringifyAny } from '..';
-import { TimeoutError } from './pTimeout';
+import { _errorDataAppend, _since, pDelay, pTimeout } from '..';
 /**
  * Returns a Function (!), enhanced with retry capabilities.
  * Implements "Exponential back-off strategy" by multiplying the delay by `delayMultiplier` with each try.
@@ -10,8 +9,8 @@ export function pRetryFn(fn, opt = {}) {
     };
 }
 export 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;
@@ -22,66 +21,44 @@ export 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 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 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 ${_since(started)}`);
-                }
-                resolve(r);
+            else {
+                result = await fn(attempt);
             }
-            catch (err) {
-                clearTimeout(timer);
-                if (logFailures) {
-                    logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:`, _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 = Object.assign(Object.assign({}, err.data), opt.errorData);
-                    reject(err);
-                }
-                else {
-                    // Retry after delay
-                    delay *= delayMultiplier;
-                    setTimeout(next, delay);
-                }
+            if (logSuccess) {
+                logger.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`);
             }
-        };
-        void next();
-    });
+            return result;
+        }
+        catch (err) {
+            if (logFailures) {
+                logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:`, err);
+            }
+            if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
+                // Give up
+                _errorDataAppend(err, opt.errorData);
+                throw err;
+            }
+            // Retry after delay
+            delay *= delayMultiplier;
+            await pDelay(delay);
+            // back to while(true) loop
+        }
+    }
 }

package/dist-esm/promise/pTimeout.js

@@ -1,4 +1,5 @@
 import { AppError } from '../error/app.error';
+import { _errorDataAppend } from '../error/error.util';
 export class TimeoutError extends AppError {
     constructor(message, data = {}, opt) {
         super(message, data, opt, 'TimeoutError');
@@ -24,23 +25,23 @@ export function pTimeoutFn(fn, opt) {
  * If the Function rejects - passes this rejection further.
  */
 export 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 = Object.assign(Object.assign({}, err.data), opt.errorData);
+                    // keep original stack
+                    err.stack = fakeError.stack.replace('Error: TimeoutError', err.name + ': ' + err.message);
+                    _errorDataAppend(err, opt.errorData);
                     reject(err);
                 }
                 return;

package/dist-esm/string/stringifyAny.js

@@ -82,11 +82,6 @@ export 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.135.0",
+  "version": "14.136.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/decorators/logMethod.decorator.ts

@@ -155,10 +155,10 @@ function logFinished(
   }
 
   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/src/error/error.util.ts

@@ -181,7 +181,9 @@ export function _isErrorObject(o: any): o is ErrorObject {
  *   })
  * }
  */
-export function _errorDataAppend(err: any, data: ErrorData): void {
+export function _errorDataAppend(err: any, data?: ErrorData): void {
+  if (!data) return
+
   err.data = {
     ...err.data,
     ...data,

package/src/error/tryCatch.ts

@@ -1,5 +1,5 @@
 import type { CommonLogger } from '../index'
-import { _anyToError, _since, _stringifyAny } from '../index'
+import { _anyToError, _since } from '../index'
 import type { AnyFunction } from '../types'
 
 export interface TryCatchOptions {
@@ -51,11 +51,7 @@ export function _tryCatch<T extends AnyFunction>(fn: T, opt: TryCatchOptions = {
       return r
     } 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) {

package/src/index.ts

@@ -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'

package/src/promise/abortable.ts

@@ -0,0 +1,34 @@
+import { AnyFunction } from '../types'
+
+/**
+ * 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(public onAbort?: AnyFunction) {}
+
+  aborted = false
+
+  abort(): void {
+    if (this.aborted) return
+    this.aborted = true
+    this.onAbort?.()
+    this.onAbort = undefined // cleanup listener
+  }
+
+  clear(): void {
+    this.onAbort = undefined
+  }
+}
+
+// convenience function
+export function abortable(onAbort?: AnyFunction): Abortable {
+  return new Abortable(onAbort)
+}

package/src/promise/pDefer.ts

@@ -3,7 +3,22 @@
  */
 export interface DeferredPromise<T = void> extends Promise<T> {
   resolve: (a?: T) => void
-  reject: (e?: Error) => void
+  reject: (err?: Error) => void
+
+  /**
+   * Can be overridden.
+   * Otherwise will reject with "Aborted" or "Aborted: $reason" on abort().
+   *
+   * @experimental
+   */
+  abort: (reason?: string) => void
+
+  /**
+   * Rejects the promise with `new Error('Aborted: $reason')`.
+   *
+   * @experimental
+   */
+  rejectAborted: (reason?: string) => void
 }
 
 /* eslint-disable @typescript-eslint/promise-function-async */
@@ -22,6 +37,9 @@ export function pDefer<T = void>(): DeferredPromise<T> {
 
   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
 }

package/src/promise/pDelay.ts

@@ -1,3 +1,45 @@
-export async function pDelay<T>(ms: number = 0, value?: T): Promise<T> {
-  return await new Promise<T>(resolve => setTimeout(() => resolve(value as T), ms))
+import type { PromisableFunction } from '../types'
+import { DeferredPromise, pDefer } from './pDefer'
+
+/**
+ * Promisified version of setTimeout.
+ *
+ * Can return a value.
+ * If value is instanceof Error - rejects the Promise instead of resolving.
+ */
+export async function pDelay<T>(ms = 0, value?: T): Promise<T> {
+  return await new Promise<T>((resolve, reject) =>
+    setTimeout(value instanceof Error ? reject : resolve, ms, value),
+  )
+}
+
+/* eslint-disable @typescript-eslint/promise-function-async */
+
+/**
+ * Promisified version of setTimeout.
+ *
+ * Wraps the passed function with try/catch,
+ * catch will propagate to pDelayFn rejection,
+ * otherwise pDelayFn will resolve with returned value.
+ *
+ * On abort() - clears the Timeout and immediately resolves the Promise with void.
+ */
+export function pDelayFn<T>(ms = 0, fn: PromisableFunction<T>): DeferredPromise<T> {
+  const p = pDefer<T>()
+
+  const timer = setTimeout(async () => {
+    try {
+      p.resolve(await fn())
+    } catch (err) {
+      p.reject(err as Error)
+    }
+  }, ms)
+
+  p.abort = () => {
+    clearTimeout(timer)
+    // p.rejectAborted(reason) // nope
+    p.resolve()
+  }
+
+  return p
 }

package/src/promise/pRetry.ts

@@ -1,6 +1,5 @@
-import type { AnyFunction, AppError, CommonLogger, ErrorData } from '..'
-import { _since, _stringifyAny } from '..'
-import { TimeoutError } from './pTimeout'
+import type { AnyFunction, CommonLogger, ErrorData } from '..'
+import { _errorDataAppend, _since, pDelay, pTimeout } from '..'
 
 export interface PRetryOptions {
   /**
@@ -84,15 +83,6 @@ export interface PRetryOptions {
    */
   logger?: CommonLogger
 
-  /**
-   * Defaults to true.
-   * If true - preserves the stack trace in case of a Timeout (usually - very useful!).
-   * It has a certain perf cost.
-   *
-   * @experimental
-   */
-  keepStackTrace?: boolean
-
   /**
    * Will be merged with `err.data` object.
    */
@@ -120,12 +110,10 @@ export async function pRetry<T>(
     predicate,
     logger = console,
     name,
-    keepStackTrace = true,
     timeout,
   } = opt
 
-  const fakeError = keepStackTrace ? new Error('RetryError') : undefined
-
+  const fakeError = timeout ? new Error('TimeoutError') : undefined
   let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt
 
   if (opt.logAll) {
@@ -139,86 +127,50 @@ export async function pRetry<T>(
 
   let delay = initialDelay
   let attempt = 0
-  let timer: NodeJS.Timeout | undefined
-  let timedOut = false
-
-  return await new Promise((resolve, reject) => {
-    const rejectWithTimeout = () => {
-      timedOut = true // to prevent more tries
-      const err = new 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: any
 
       if (timeout) {
-        timer = setTimeout(rejectWithTimeout, timeout)
+        await pTimeout(async () => await fn(attempt), {
+          timeout,
+          name: fname,
+          errorData: opt.errorData,
+          fakeError,
+        })
+      } else {
+        result = await fn(attempt)
       }
 
-      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 ${_since(started)}`)
-        }
-
-        resolve(r)
-      } catch (err) {
-        clearTimeout(timer)
-
-        if (logFailures) {
-          logger.warn(
-            `${fname} attempt #${attempt} error in ${_since(started)}:`,
-            _stringifyAny(err, {
-              includeErrorData: true,
-            }),
-          )
-        }
-
-        if (
-          attempt >= maxAttempts ||
-          (predicate && !predicate(err as Error, attempt, maxAttempts))
-        ) {
-          // Give up
-
-          if (fakeError) {
-            // Preserve the original call stack
-            Object.defineProperty(err, 'stack', {
-              value:
-                (err as Error).stack +
-                '\n    --' +
-                fakeError.stack!.replace('Error: RetryError', ''),
-            })
-          }
-
-          ;(err as AppError).data = {
-            ...(err as AppError).data,
-            ...opt.errorData,
-          }
-
-          reject(err)
-        } else {
-          // Retry after delay
-          delay *= delayMultiplier
-          setTimeout(next, delay)
-        }
+      if (logSuccess) {
+        logger.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`)
+      }
+
+      return result
+    } catch (err) {
+      if (logFailures) {
+        logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:`, err)
       }
-    }
 
-    void next()
-  })
+      if (attempt >= maxAttempts || (predicate && !predicate(err as Error, attempt, maxAttempts))) {
+        // Give up
+        _errorDataAppend(err, opt.errorData)
+        throw err
+      }
+
+      // Retry after delay
+      delay *= delayMultiplier
+      await pDelay(delay)
+      // back to while(true) loop
+    }
+  }
 }

package/src/promise/pState.ts

@@ -13,6 +13,6 @@ export async function pState(p: Promise<any>): Promise<'resolved' | 'rejected' |
     v => {
       return v === UNIQUE_VALUE ? 'pending' : 'resolved'
     },
-    () => 'rejected' as const,
+    () => 'rejected',
   )
 }

package/src/promise/pTimeout.ts

@@ -1,5 +1,6 @@
 import { AppError } from '../error/app.error'
 import type { ErrorData } from '../error/error.model'
+import { _errorDataAppend } from '../error/error.util'
 import type { AnyAsyncFunction } from '../types'
 
 export class TimeoutError extends AppError {
@@ -30,13 +31,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.
@@ -66,25 +65,24 @@ export function pTimeoutFn<T extends AnyAsyncFunction>(fn: T, opt: PTimeoutOptio
  * If the Function rejects - passes this rejection further.
  */
 export async function pTimeout<T>(fn: AnyAsyncFunction<T>, opt: PTimeoutOptions): Promise<T> {
-  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: any) {
-          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)
+          _errorDataAppend(err, opt.errorData)
           reject(err)
         }
         return

package/src/string/stringifyAny.ts

@@ -33,13 +33,6 @@ export interface StringifyAnyOptions {
    */
   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.
    *
@@ -130,12 +123,6 @@ export function _stringifyAny(obj: any, opt: StringifyAnyOptions = {}): string {
         // `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 as any).code === 'string') {
       // Error that has no `data`, but has `code` property
       s = [s, `code: ${(obj as any).code}`].join('\n')

package/src/types.ts

@@ -80,6 +80,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.