@naturalcycles/js-lib 14.80.1 → 14.83.1

package/dist/decorators/asyncMemo.decorator.d.ts

@@ -0,0 +1,22 @@
+import { Merge } from '../typeFest';
+import { MemoOptions } from './memo.decorator';
+import { AsyncMemoCache } from './memo.util';
+export declare type AsyncMemoOptions = Merge<MemoOptions, {
+    /**
+     * Provide a custom implementation of MemoCache.
+     * Function that creates an instance of `MemoCache`.
+     * e.g LRUMemoCache from `@naturalcycles/nodejs-lib`.
+     *
+     * It's an ARRAY of Caches, to allow multiple layers of Cache.
+     * It will check it one by one, starting from the first.
+     * HIT will be returned immediately, MISS will go one level deeper, or returned (if the end of the Cache stack is reached).
+     */
+    cacheFactory: () => AsyncMemoCache[];
+}>;
+/**
+ * Like @_Memo, but allowing async MemoCache implementation.
+ *
+ * Method CANNOT return `undefined`, as undefined will always be treated as cache MISS and retried.
+ * Return `null` instead (it'll be cached).
+ */
+export declare const _AsyncMemo: (opt: AsyncMemoOptions) => MethodDecorator;

package/dist/decorators/asyncMemo.decorator.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._AsyncMemo = void 0;
+const time_util_1 = require("../time/time.util");
+const decorator_util_1 = require("./decorator.util");
+const memo_decorator_1 = require("./memo.decorator");
+const memo_util_1 = require("./memo.util");
+/**
+ * Like @_Memo, but allowing async MemoCache implementation.
+ *
+ * Method CANNOT return `undefined`, as undefined will always be treated as cache MISS and retried.
+ * Return `null` instead (it'll be cached).
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const _AsyncMemo = (opt) => (target, key, descriptor) => {
+    if (typeof descriptor.value !== 'function') {
+        throw new TypeError('Memoization can be applied only to methods');
+    }
+    const originalFn = descriptor.value;
+    // Map from "instance" of the Class where @_AsyncMemo is applied to AsyncMemoCache instance.
+    const cache = new Map();
+    const { logHit = false, logMiss = false, noLogArgs = false, logger = console, cacheFactory, cacheKeyFn = memo_util_1.jsonMemoSerializer, noCacheRejected = false, noCacheResolved = false, } = opt;
+    const keyStr = String(key);
+    const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
+    descriptor.value = async function (...args) {
+        const ctx = this;
+        const cacheKey = cacheKeyFn(args);
+        if (!cache.has(ctx)) {
+            cache.set(ctx, cacheFactory());
+            // here, no need to check the cache. It's definitely a miss, because the cacheLayers is just created
+            // UPD: no! AsyncMemo supports "persistent caches" (e.g Database-backed cache)
+        }
+        if (args.length === 1 && args[0] === memo_decorator_1.CACHE_DROP) {
+            // Special event - CACHE_DROP
+            // Function will return undefined
+            logger.log(`${methodSignature} @_AsyncMemo.dropCache()`);
+            try {
+                await Promise.all(cache.get(ctx).map(c => c.clear()));
+            }
+            catch (err) {
+                logger.error(err);
+            }
+            return;
+        }
+        let value;
+        try {
+            for await (const cacheLayer of cache.get(ctx)) {
+                value = await cacheLayer.get(cacheKey);
+                if (value !== undefined) {
+                    // it's a hit!
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            // log error, but don't throw, treat it as a "miss"
+            logger.error(err);
+        }
+        if (value !== undefined) {
+            // hit!
+            if (logHit) {
+                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_AsyncMemo hit`);
+            }
+            return value instanceof Error ? Promise.reject(value) : Promise.resolve(value);
+        }
+        // Here we know it's a MISS, let's execute the real method
+        const started = Date.now();
+        try {
+            value = await originalFn.apply(ctx, args);
+            if (!noCacheResolved) {
+                Promise.all(cache.get(ctx).map(cacheLayer => cacheLayer.set(cacheKey, value))).catch(err => {
+                    // log and ignore the error
+                    logger.error(err);
+                });
+            }
+            return value;
+        }
+        catch (err) {
+            if (!noCacheRejected) {
+                // We put it to cache as raw Error, not Promise.reject(err)
+                Promise.all(cache.get(ctx).map(cacheLayer => cacheLayer.set(cacheKey, err))).catch(err => {
+                    // log and ignore the error
+                    logger.error(err);
+                });
+            }
+            throw err;
+        }
+        finally {
+            if (logMiss) {
+                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_AsyncMemo miss (${(0, time_util_1._since)(started)})`);
+            }
+        }
+    };
+    return descriptor;
+};
+exports._AsyncMemo = _AsyncMemo;

package/dist/decorators/memo.decorator.d.ts

@@ -1,5 +1,9 @@
 import { CommonLogger } from '../log/commonLogger';
 import { MemoCache } from './memo.util';
+/**
+ * Symbol to indicate that the Cache should be dropped.
+ */
+export declare const CACHE_DROP: unique symbol;
 export interface MemoOptions {
     /**
      * Default to false
@@ -30,11 +34,15 @@ export interface MemoOptions {
     /**
      * Don't cache resolved promises.
      * Setting this to `true` will make the decorator to await the result.
+     *
+     * Default false.
      */
     noCacheResolved?: boolean;
     /**
      * Don't cache rejected promises.
      * Setting this to `true` will make the decorator to await the result.
+     *
+     * Default false.
      */
     noCacheRejected?: boolean;
 }

package/dist/decorators/memo.decorator.js

@@ -5,10 +5,14 @@
 // http://inlehmansterms.net/2015/03/01/javascript-memoization/
 // https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._Memo = void 0;
+exports._Memo = exports.CACHE_DROP = void 0;
 const time_util_1 = require("../time/time.util");
 const decorator_util_1 = require("./decorator.util");
 const memo_util_1 = require("./memo.util");
+/**
+ * Symbol to indicate that the Cache should be dropped.
+ */
+exports.CACHE_DROP = Symbol('CACHE_DROP');
 /**
  * Memoizes the method of the class, so it caches the output and returns the cached version if the "key"
  * of the cache is the same. Key, by defaul, is calculated as `JSON.stringify(...args)`.
@@ -39,6 +43,12 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
     descriptor.value = function (...args) {
         const ctx = this;
+        if (args.length === 1 && args[0] === exports.CACHE_DROP) {
+            // Special event - CACHE_DROP
+            // Function will return undefined
+            logger.log(`${methodSignature} @_Memo.CACHE_DROP`);
+            return cache.get(ctx)?.clear();
+        }
         const cacheKey = cacheKeyFn(args);
         if (!cache.has(ctx)) {
             cache.set(ctx, cacheFactory());
@@ -91,11 +101,6 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
             return res;
         }
     };
-    descriptor.value.dropCache = () => {
-        logger.log(`${methodSignature} @_Memo.dropCache()`);
-        cache.forEach(memoCache => memoCache.clear());
-        cache.clear();
-    };
     return descriptor;
 };
 exports._Memo = _Memo;

package/dist/decorators/memo.util.d.ts

@@ -1,15 +1,34 @@
+import { Promisable } from '../typeFest';
 export declare type MemoSerializer = (args: any[]) => any;
 export declare const jsonMemoSerializer: MemoSerializer;
-export interface MemoCache {
-    has(k: any): boolean;
-    get(k: any): any;
-    set(k: any, v: any): void;
+export interface MemoCache<KEY = any, VALUE = any> {
+    has(k: KEY): boolean;
+    get(k: KEY): VALUE | undefined;
+    set(k: KEY, v: VALUE): void;
+    /**
+     * Clear is only called when `.dropCache()` is called.
+     * Otherwise the Cache is "persistent" (never cleared).
+     */
     clear(): void;
 }
-export declare class MapMemoCache implements MemoCache {
+export interface AsyncMemoCache<KEY = any, VALUE = any> {
+    /**
+     * `undefined` value returned indicates the ABSENCE of value in the Cache.
+     * This also means that you CANNOT store `undefined` value in the Cache, as it'll be treated as a MISS.
+     * You CAN store `null` value instead, it will be treated as a HIT.
+     */
+    get(k: KEY): Promisable<VALUE | undefined>;
+    set(k: KEY, v: VALUE): Promisable<void>;
+    /**
+     * Clear is only called when `.dropCache()` is called.
+     * Otherwise the Cache is "persistent" (never cleared).
+     */
+    clear(): Promisable<void>;
+}
+export declare class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE>, AsyncMemoCache<KEY, VALUE> {
     private m;
-    has(k: any): boolean;
-    get(k: any): any;
-    set(k: any, v: any): void;
+    has(k: KEY): boolean;
+    get(k: KEY): VALUE | undefined;
+    set(k: KEY, v: VALUE): void;
     clear(): void;
 }

package/dist/decorators/memo.util.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MapMemoCache = exports.jsonMemoSerializer = void 0;
 const object_util_1 = require("../object/object.util");
 const jsonMemoSerializer = args => {
-    if (!args.length)
+    if (args.length === 0)
         return undefined;
     if (args.length === 1 && (0, object_util_1._isPrimitive)(args[0]))
         return args[0];

package/dist/decorators/retry.decorator.js

@@ -6,7 +6,7 @@ const __1 = require("..");
 function _Retry(opt = {}) {
     return (target, key, descriptor) => {
         const originalFn = descriptor.value;
-        descriptor.value = (0, __1.pRetry)(originalFn, opt);
+        descriptor.value = (0, __1.pRetryFn)(originalFn, opt);
         return descriptor;
     };
 }

package/dist/error/error.model.d.ts

@@ -26,6 +26,12 @@ export interface ErrorData {
      * `originalMessage` is used to preserve the original `error.message` as it came from the backend.
      */
     originalMessage?: string;
+    /**
+     * Can be used by error-reporting tools (e.g Sentry).
+     * If fingerprint is defined - it'll be used INSTEAD of default fingerprint of a tool.
+     * Can be used to force-group errors that are NOT needed to be split by endpoint or calling function.
+     */
+    fingerprint?: string[];
     /**
      * Open-ended.
      */

package/dist/index.d.ts

@@ -8,7 +8,8 @@ export * from './decorators/debounce.decorator';
 export * from './decorators/decorator.util';
 export * from './decorators/logMethod.decorator';
 export * from './decorators/memo.decorator';
-import { MemoCache } from './decorators/memo.util';
+export * from './decorators/asyncMemo.decorator';
+import { MemoCache, AsyncMemoCache } from './decorators/memo.util';
 export * from './decorators/memoFn';
 export * from './decorators/retry.decorator';
 export * from './decorators/timeout.decorator';
@@ -34,14 +35,13 @@ export * from './object/object.util';
 export * from './object/sortObject';
 export * from './object/sortObjectDeep';
 import { AggregatedError } from './promise/AggregatedError';
-export * from './promise/pBatch';
 import { DeferredPromise, pDefer } from './promise/pDefer';
 export * from './promise/pDelay';
 export * from './promise/pFilter';
 export * from './promise/pHang';
 import { pMap, PMapOptions } from './promise/pMap';
 export * from './promise/pProps';
-import { pRetry, PRetryOptions } from './promise/pRetry';
+import { pRetry, pRetryFn, PRetryOptions } from './promise/pRetry';
 export * from './promise/pState';
 import { pTimeout, pTimeoutFn, PTimeoutOptions } from './promise/pTimeout';
 export * from './promise/pTuple';
@@ -59,5 +59,5 @@ export * from './string/safeJsonStringify';
 import { PQueue, PQueueCfg } from './promise/pQueue';
 export * from './seq/seq';
 export * from './math/stack.util';
-export type { AbortableMapper, AbortablePredicate, AbortableAsyncPredicate, AbortableAsyncMapper, PQueueCfg, MemoCache, PromiseDecoratorCfg, PromiseDecoratorResp, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Admin401ErrorData, Admin403ErrorData, StringMap, PromiseMap, AnyObject, AnyFunction, ValuesOf, ValueOf, KeyValueTuple, ObjectMapper, ObjectPredicate, InstanceId, IsoDate, IsoDateTime, Reviver, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, Simplify, ConditionalPick, ConditionalExcept, Class, UnixTimestamp, BaseDBEntity, SavedDBEntity, Saved, Unsaved, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, JsonSchema, JsonSchemaAny, JsonSchemaOneOf, JsonSchemaAllOf, JsonSchemaAnyOf, JsonSchemaNot, JsonSchemaRef, JsonSchemaConst, JsonSchemaEnum, JsonSchemaString, JsonSchemaNumber, JsonSchemaBoolean, JsonSchemaNull, JsonSchemaRootObject, JsonSchemaObject, JsonSchemaArray, JsonSchemaTuple, JsonSchemaBuilder, CommonLogLevel, CommonLogWithLevelFunction, CommonLogFunction, CommonLogger, };
-export { is, _createPromiseDecorator, _stringMapValues, _stringMapEntries, _objectKeys, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pTimeout, pTimeoutFn, _tryCatch, _TryCatch, _stringifyAny, jsonSchema, JsonSchemaAnyBuilder, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, PQueue, END, SKIP, };
+export type { AbortableMapper, AbortablePredicate, AbortableAsyncPredicate, AbortableAsyncMapper, PQueueCfg, MemoCache, AsyncMemoCache, PromiseDecoratorCfg, PromiseDecoratorResp, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Admin401ErrorData, Admin403ErrorData, StringMap, PromiseMap, AnyObject, AnyFunction, ValuesOf, ValueOf, KeyValueTuple, ObjectMapper, ObjectPredicate, InstanceId, IsoDate, IsoDateTime, Reviver, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, Simplify, ConditionalPick, ConditionalExcept, Class, UnixTimestamp, BaseDBEntity, SavedDBEntity, Saved, Unsaved, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, JsonSchema, JsonSchemaAny, JsonSchemaOneOf, JsonSchemaAllOf, JsonSchemaAnyOf, JsonSchemaNot, JsonSchemaRef, JsonSchemaConst, JsonSchemaEnum, JsonSchemaString, JsonSchemaNumber, JsonSchemaBoolean, JsonSchemaNull, JsonSchemaRootObject, JsonSchemaObject, JsonSchemaArray, JsonSchemaTuple, JsonSchemaBuilder, CommonLogLevel, CommonLogWithLevelFunction, CommonLogFunction, CommonLogger, };
+export { is, _createPromiseDecorator, _stringMapValues, _stringMapEntries, _objectKeys, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pRetryFn, pTimeout, pTimeoutFn, _tryCatch, _TryCatch, _stringifyAny, jsonSchema, JsonSchemaAnyBuilder, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, PQueue, END, SKIP, };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SKIP = exports.END = exports.PQueue = exports.commonLoggerCreate = exports.commonLoggerPrefix = exports.commonLoggerPipe = exports.commonLogLevelNumber = exports.commonLoggerNoop = exports.commonLoggerMinLevel = exports.JsonSchemaAnyBuilder = exports.jsonSchema = exports._stringifyAny = exports._TryCatch = exports._tryCatch = exports.pTimeoutFn = exports.pTimeout = exports.pRetry = exports.AggregatedError = exports.pDefer = exports.ErrorMode = exports._noop = exports._passNothingPredicate = exports._passthroughPredicate = exports._passUndefinedMapper = exports._passthroughMapper = exports.pMap = exports._objectKeys = exports._stringMapEntries = exports._stringMapValues = exports._createPromiseDecorator = exports.is = void 0;
+exports.SKIP = exports.END = exports.PQueue = exports.commonLoggerCreate = exports.commonLoggerPrefix = exports.commonLoggerPipe = exports.commonLogLevelNumber = exports.commonLoggerNoop = exports.commonLoggerMinLevel = exports.JsonSchemaAnyBuilder = exports.jsonSchema = exports._stringifyAny = exports._TryCatch = exports._tryCatch = exports.pTimeoutFn = exports.pTimeout = exports.pRetryFn = exports.pRetry = exports.AggregatedError = exports.pDefer = exports.ErrorMode = exports._noop = exports._passNothingPredicate = exports._passthroughPredicate = exports._passUndefinedMapper = exports._passthroughMapper = exports.pMap = exports._objectKeys = exports._stringMapEntries = exports._stringMapValues = exports._createPromiseDecorator = exports.is = void 0;
 const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./array/array.util"), exports);
 (0, tslib_1.__exportStar)(require("./lazy"), exports);
@@ -13,6 +13,7 @@ Object.defineProperty(exports, "_createPromiseDecorator", { enumerable: true, ge
 (0, tslib_1.__exportStar)(require("./decorators/decorator.util"), exports);
 (0, tslib_1.__exportStar)(require("./decorators/logMethod.decorator"), exports);
 (0, tslib_1.__exportStar)(require("./decorators/memo.decorator"), exports);
+(0, tslib_1.__exportStar)(require("./decorators/asyncMemo.decorator"), exports);
 (0, tslib_1.__exportStar)(require("./decorators/memoFn"), exports);
 (0, tslib_1.__exportStar)(require("./decorators/retry.decorator"), exports);
 (0, tslib_1.__exportStar)(require("./decorators/timeout.decorator"), exports);
@@ -42,7 +43,6 @@ Object.defineProperty(exports, "JsonSchemaAnyBuilder", { enumerable: true, get:
 (0, tslib_1.__exportStar)(require("./object/sortObjectDeep"), exports);
 const AggregatedError_1 = require("./promise/AggregatedError");
 Object.defineProperty(exports, "AggregatedError", { enumerable: true, get: function () { return AggregatedError_1.AggregatedError; } });
-(0, tslib_1.__exportStar)(require("./promise/pBatch"), exports);
 const pDefer_1 = require("./promise/pDefer");
 Object.defineProperty(exports, "pDefer", { enumerable: true, get: function () { return pDefer_1.pDefer; } });
 (0, tslib_1.__exportStar)(require("./promise/pDelay"), exports);
@@ -53,6 +53,7 @@ Object.defineProperty(exports, "pMap", { enumerable: true, get: function () { re
 (0, tslib_1.__exportStar)(require("./promise/pProps"), exports);
 const pRetry_1 = require("./promise/pRetry");
 Object.defineProperty(exports, "pRetry", { enumerable: true, get: function () { return pRetry_1.pRetry; } });
+Object.defineProperty(exports, "pRetryFn", { enumerable: true, get: function () { return pRetry_1.pRetryFn; } });
 (0, tslib_1.__exportStar)(require("./promise/pState"), exports);
 const pTimeout_1 = require("./promise/pTimeout");
 Object.defineProperty(exports, "pTimeout", { enumerable: true, get: function () { return pTimeout_1.pTimeout; } });

package/dist/promise/AggregatedError.d.ts

@@ -6,5 +6,5 @@
 export declare class AggregatedError<RESULT = any> extends Error {
     errors: Error[];
     results: RESULT[];
-    constructor(errors: (Error | string)[], results?: RESULT[]);
+    constructor(errors: Error[], results?: RESULT[]);
 }

package/dist/promise/AggregatedError.js

@@ -8,17 +8,12 @@ exports.AggregatedError = void 0;
  */
 class AggregatedError extends Error {
     constructor(errors, results = []) {
-        const mappedErrors = errors.map(e => {
-            if (typeof e === 'string')
-                return new Error(e);
-            return e;
-        });
         const message = [
             `${errors.length} errors:`,
-            ...mappedErrors.map((e, i) => `${i + 1}. ${e.message}`),
+            ...errors.map((e, i) => `${i + 1}. ${e.message}`),
         ].join('\n');
         super(message);
-        this.errors = mappedErrors;
+        this.errors = errors;
         this.results = results;
         Object.defineProperty(this, 'name', {
             value: this.constructor.name,

package/dist/promise/pFilter.d.ts

@@ -1,3 +1,2 @@
-import { AbortableAsyncPredicate } from '../types';
-import { PMapOptions } from './pMap';
-export declare function pFilter<T>(iterable: Iterable<T | PromiseLike<T>>, filterFn: AbortableAsyncPredicate<T>, opt?: PMapOptions): Promise<T[]>;
+import { AsyncPredicate } from '../types';
+export declare function pFilter<T>(iterable: Iterable<T>, filterFn: AsyncPredicate<T>): Promise<T[]>;

package/dist/promise/pFilter.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pFilter = void 0;
-const pMap_1 = require("./pMap");
-async function pFilter(iterable, filterFn, opt) {
-    const values = await (0, pMap_1.pMap)(iterable, async (item, index) => await Promise.all([filterFn(item, index), item]), opt);
-    return values.filter(value => Boolean(value[0])).map(value => value[1]);
+async function pFilter(iterable, filterFn) {
+    const items = [...iterable];
+    const predicates = await Promise.all(items.map((item, i) => filterFn(item, i)));
+    return items.filter((item, i) => predicates[i]);
 }
 exports.pFilter = pFilter;

package/dist/promise/pMap.d.ts

@@ -41,4 +41,4 @@ export interface PMapOptions {
  * 	//=> ['http://ava.li/', 'http://todomvc.com/']
  * })();
  */
-export declare function pMap<IN, OUT>(iterable: Iterable<IN | PromiseLike<IN>>, mapper: AbortableAsyncMapper<IN, OUT>, opt?: PMapOptions): Promise<OUT[]>;
+export declare function pMap<IN, OUT>(iterable: Iterable<IN>, mapper: AbortableAsyncMapper<IN, OUT>, opt?: PMapOptions): Promise<OUT[]>;

package/dist/promise/pMap.js

@@ -38,28 +38,74 @@ const AggregatedError_1 = require("./AggregatedError");
  * })();
  */
 async function pMap(iterable, mapper, opt = {}) {
+    const ret = [];
+    // const iterator = iterable[Symbol.iterator]()
+    const items = [...iterable];
+    const itemsLength = items.length;
+    if (itemsLength === 0)
+        return []; // short circuit
+    const { concurrency = itemsLength, errorMode = __1.ErrorMode.THROW_IMMEDIATELY } = opt;
+    const errors = [];
+    let isSettled = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
+    // Special cases that are able to preserve async stack traces
+    if (concurrency === 1) {
+        // Special case for concurrency == 1
+        for await (const item of items) {
+            try {
+                const r = await mapper(item, currentIndex++);
+                if (r === __1.END)
+                    break;
+                if (r !== __1.SKIP)
+                    ret.push(r);
+            }
+            catch (err) {
+                if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY)
+                    throw err;
+                if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+                    errors.push(err);
+                }
+                // otherwise, suppress completely
+            }
+        }
+        if (errors.length) {
+            throw new AggregatedError_1.AggregatedError(errors, ret);
+        }
+        return ret;
+    }
+    else if (!opt.concurrency || items.length <= opt.concurrency) {
+        // Special case for concurrency == infinity or iterable.length < concurrency
+        if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY) {
+            return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(r => r !== __1.SKIP && r !== __1.END);
+        }
+        ;
+        (await Promise.allSettled(items.map((item, i) => mapper(item, i)))).forEach(r => {
+            if (r.status === 'fulfilled') {
+                if (r.value !== __1.SKIP && r.value !== __1.END)
+                    ret.push(r.value);
+            }
+            else if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+                errors.push(r.reason);
+            }
+        });
+        if (errors.length) {
+            throw new AggregatedError_1.AggregatedError(errors, ret);
+        }
+        return ret;
+    }
     return new Promise((resolve, reject) => {
-        const { concurrency = Number.POSITIVE_INFINITY, errorMode = __1.ErrorMode.THROW_IMMEDIATELY } = opt;
-        const ret = [];
-        const iterator = iterable[Symbol.iterator]();
-        const errors = [];
-        let isSettled = false;
-        let isIterableDone = false;
-        let resolvingCount = 0;
-        let currentIndex = 0;
-        const next = (skipped = false) => {
+        const next = () => {
             if (isSettled) {
                 return;
             }
-            const nextItem = iterator.next();
-            const i = currentIndex;
-            if (!skipped)
-                currentIndex++;
-            if (nextItem.done) {
-                isIterableDone = true;
+            const nextItem = items[currentIndex];
+            const i = currentIndex++;
+            if (currentIndex > itemsLength) {
                 if (resolvingCount === 0) {
+                    isSettled = true;
                     const r = ret.filter(r => r !== __1.SKIP);
-                    if (errors.length && errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+                    if (errors.length) {
                         reject(new AggregatedError_1.AggregatedError(errors, r));
                     }
                     else {
@@ -69,7 +115,7 @@ async function pMap(iterable, mapper, opt = {}) {
                 return;
             }
             resolvingCount++;
-            Promise.resolve(nextItem.value)
+            Promise.resolve(nextItem)
                 .then(async (element) => await mapper(element, i))
                 .then(value => {
                 if (value === __1.END) {
@@ -85,7 +131,9 @@ async function pMap(iterable, mapper, opt = {}) {
                     reject(err);
                 }
                 else {
-                    errors.push(err);
+                    if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+                        errors.push(err);
+                    }
                     resolvingCount--;
                     next();
                 }
@@ -93,7 +141,7 @@ async function pMap(iterable, mapper, opt = {}) {
         };
         for (let i = 0; i < concurrency; i++) {
             next();
-            if (isIterableDone) {
+            if (isSettled) {
                 break;
             }
         }

package/dist/promise/pRetry.d.ts

@@ -5,6 +5,12 @@ export interface PRetryOptions {
      * Can be used to identify the place in the code that failed.
      */
     name?: string;
+    /**
+     * Timeout for each Try, in milliseconds.
+     *
+     * Defaults to no timeout.
+     */
+    timeout?: number;
     /**
      * How many attempts to try.
      * First attempt is not a retry, but "initial try". It still counts.
@@ -29,7 +35,7 @@ export interface PRetryOptions {
      *
      * @default () => true
      */
-    predicate?: (err: unknown, attempt: number, maxAttempts: number) => boolean;
+    predicate?: (err: Error, attempt: number, maxAttempts: number) => boolean;
     /**
      * Log the first attempt (which is not a "retry" yet).
      *
@@ -62,9 +68,18 @@ 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;
 }
 /**
  * Returns a Function (!), enhanced with retry capabilities.
  * Implements "Exponential back-off strategy" by multiplying the delay by `delayMultiplier` with each try.
  */
-export declare function pRetry<T extends AnyFunction>(fn: T, opt?: PRetryOptions): T;
+export declare function pRetryFn<T extends AnyFunction>(fn: T, opt?: PRetryOptions): T;
+export declare function pRetry<T>(fn: (attempt: number) => Promise<T>, opt?: PRetryOptions): Promise<T>;