@naturalcycles/js-lib 14.81.0 → 14.84.0

package/src/index.ts

@@ -12,7 +12,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'
@@ -67,7 +68,6 @@ 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'
@@ -161,6 +161,7 @@ export type {
   AbortableAsyncMapper,
   PQueueCfg,
   MemoCache,
+  AsyncMemoCache,
   PromiseDecoratorCfg,
   PromiseDecoratorResp,
   ErrorData,

package/src/promise/AggregatedError.ts

@@ -7,20 +7,15 @@ export class AggregatedError<RESULT = any> extends Error {
   errors!: Error[]
   results!: RESULT[]
 
-  constructor(errors: (Error | string)[], results: RESULT[] = []) {
-    const mappedErrors = errors.map(e => {
-      if (typeof e === 'string') return new Error(e)
-      return e
-    })
-
+  constructor(errors: Error[], results: RESULT[] = []) {
     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', {

package/src/promise/pFilter.ts

@@ -1,16 +1,7 @@
-import { AbortableAsyncPredicate } from '../types'
-import { pMap, PMapOptions } from './pMap'
+import { AsyncPredicate } from '../types'
 
-export async function pFilter<T>(
-  iterable: Iterable<T | PromiseLike<T>>,
-  filterFn: AbortableAsyncPredicate<T>,
-  opt?: PMapOptions,
-): Promise<T[]> {
-  const values = await pMap(
-    iterable,
-    async (item, index) => await Promise.all([filterFn(item, index), item]),
-    opt,
-  )
-
-  return values.filter(value => Boolean(value[0])).map(value => value[1])
+export async function pFilter<T>(iterable: Iterable<T>, filterFn: AsyncPredicate<T>): Promise<T[]> {
+  const items = [...iterable]
+  const predicates = await Promise.all(items.map((item, i) => filterFn(item, i)))
+  return items.filter((item, i) => predicates[i])
 }

package/src/promise/pMap.ts

@@ -55,36 +55,85 @@ export interface PMapOptions {
  * })();
  */
 export async function pMap<IN, OUT>(
-  iterable: Iterable<IN | PromiseLike<IN>>,
+  iterable: Iterable<IN>,
   mapper: AbortableAsyncMapper<IN, OUT>,
   opt: PMapOptions = {},
 ): Promise<OUT[]> {
-  return new Promise<OUT[]>((resolve, reject) => {
-    const { concurrency = Number.POSITIVE_INFINITY, errorMode = ErrorMode.THROW_IMMEDIATELY } = opt
+  const ret: (OUT | typeof SKIP)[] = []
+  // const iterator = iterable[Symbol.iterator]()
+  const items = [...iterable]
+  const itemsLength = items.length
+  if (itemsLength === 0) return [] // short circuit
+
+  const { concurrency = itemsLength, errorMode = ErrorMode.THROW_IMMEDIATELY } = opt
+
+  const errors: Error[] = []
+  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 === END) break
+        if (r !== SKIP) ret.push(r)
+      } catch (err) {
+        if (errorMode === ErrorMode.THROW_IMMEDIATELY) throw err
+        if (errorMode === ErrorMode.THROW_AGGREGATED) {
+          errors.push(err as Error)
+        }
+        // otherwise, suppress completely
+      }
+    }
+
+    if (errors.length) {
+      throw new AggregatedError(errors, ret)
+    }
+
+    return ret as OUT[]
+  } else if (!opt.concurrency || items.length <= opt.concurrency) {
+    // Special case for concurrency == infinity or iterable.length < concurrency
+
+    if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
+      return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(
+        r => r !== SKIP && r !== END,
+      ) as OUT[]
+    }
+
+    ;(await Promise.allSettled(items.map((item, i) => mapper(item, i)))).forEach(r => {
+      if (r.status === 'fulfilled') {
+        if (r.value !== SKIP && r.value !== END) ret.push(r.value)
+      } else if (errorMode === ErrorMode.THROW_AGGREGATED) {
+        errors.push(r.reason)
+      }
+    })
+
+    if (errors.length) {
+      throw new AggregatedError(errors, ret)
+    }
 
-    const ret: (OUT | typeof SKIP)[] = []
-    const iterator = iterable[Symbol.iterator]()
-    const errors: Error[] = []
-    let isSettled = false
-    let isIterableDone = false
-    let resolvingCount = 0
-    let currentIndex = 0
+    return ret as OUT[]
+  }
 
-    const next = (skipped = false) => {
+  return new Promise<OUT[]>((resolve, reject) => {
+    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 !== SKIP) as OUT[]
-          if (errors.length && errorMode === ErrorMode.THROW_AGGREGATED) {
+          if (errors.length) {
             reject(new AggregatedError(errors, r))
           } else {
             resolve(r)
@@ -96,7 +145,7 @@ export async function pMap<IN, OUT>(
 
       resolvingCount++
 
-      Promise.resolve(nextItem.value)
+      Promise.resolve(nextItem)
         .then(async element => await mapper(element, i))
         .then(
           value => {
@@ -114,7 +163,9 @@ export async function pMap<IN, OUT>(
               isSettled = true
               reject(err)
             } else {
-              errors.push(err)
+              if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                errors.push(err)
+              }
               resolvingCount--
               next()
             }
@@ -125,7 +176,7 @@ export async function pMap<IN, OUT>(
     for (let i = 0; i < concurrency; i++) {
       next()
 
-      if (isIterableDone) {
+      if (isSettled) {
         break
       }
     }

package/src/promise/pRetry.ts

@@ -1,4 +1,4 @@
-import { _since, _stringifyAny, AnyFunction, CommonLogger } from '..'
+import { _since, _stringifyAny, AnyFunction, AnyObject, AppError, CommonLogger } from '..'
 import { TimeoutError } from './pTimeout'
 
 export interface PRetryOptions {
@@ -11,7 +11,7 @@ export interface PRetryOptions {
   /**
    * Timeout for each Try, in milliseconds.
    *
-   * Defaults to 60_000
+   * Defaults to no timeout.
    */
   timeout?: number
 
@@ -91,6 +91,11 @@ export interface PRetryOptions {
    * @experimental
    */
   keepStackTrace?: boolean
+
+  /**
+   * Will be merged with `err.data` object.
+   */
+  errorData?: AnyObject
 }
 
 /**
@@ -139,7 +144,7 @@ export async function pRetry<T>(
   return await new Promise((resolve, reject) => {
     const rejectWithTimeout = () => {
       timedOut = true // to prevent more tries
-      const err = new TimeoutError(`"${fname}" timed out after ${timeout} ms`)
+      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')
@@ -199,6 +204,11 @@ export async function pRetry<T>(
             })
           }
 
+          ;(err as AppError).data = {
+            ...(err as AppError).data,
+            ...opt.errorData,
+          }
+
           reject(err)
         } else {
           // Retry after delay

package/src/promise/pTimeout.ts

@@ -1,5 +1,5 @@
 import { AppError } from '../error/app.error'
-import { AnyFunction } from '../types'
+import { AnyFunction, AnyObject } from '../types'
 
 export class TimeoutError extends AppError {}
 
@@ -29,6 +29,11 @@ export interface PTimeoutOptions {
    * @experimental
    */
   keepStackTrace?: boolean
+
+  /**
+   * Will be merged with `err.data` object.
+   */
+  errorData?: AnyObject
 }
 
 /**
@@ -63,12 +68,19 @@ export async function pTimeout<T>(promise: Promise<T>, opt: PTimeoutOptions): Pr
           resolve(onTimeout())
         } catch (err: any) {
           if (fakeError) err.stack = fakeError.stack // keep original stack
+          err.data = {
+            ...err.data,
+            ...opt.errorData,
+          }
           reject(err)
         }
         return
       }
 
-      const err = new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`)
+      const err = new TimeoutError(
+        `"${name || 'pTimeout function'}" timed out after ${timeout} ms`,
+        opt.errorData,
+      )
       if (fakeError) err.stack = fakeError.stack // keep original stack
       reject(err)
     }, timeout)

package/dist/promise/pBatch.d.ts

@@ -1,7 +0,0 @@
-import { AbortableAsyncMapper, BatchResult } from '..';
-/**
- * Like pMap, but doesn't fail on errors, instead returns both successful results and errors.
- */
-export declare function pBatch<IN, OUT>(iterable: Iterable<IN | PromiseLike<IN>>, mapper: AbortableAsyncMapper<IN, OUT>, opt?: {
-    concurrency?: number;
-}): Promise<BatchResult<OUT>>;

package/dist/promise/pBatch.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pBatch = void 0;
-const __1 = require("..");
-const pMap_1 = require("./pMap");
-/**
- * Like pMap, but doesn't fail on errors, instead returns both successful results and errors.
- */
-async function pBatch(iterable, mapper, opt) {
-    try {
-        const results = await (0, pMap_1.pMap)(iterable, mapper, {
-            ...opt,
-            errorMode: __1.ErrorMode.THROW_AGGREGATED,
-        });
-        return {
-            results,
-            errors: [],
-        };
-    }
-    catch (err) {
-        const { errors, results } = err;
-        if (!errors || !results)
-            throw err; // not an AggregatedError
-        return {
-            results,
-            errors,
-        };
-    }
-}
-exports.pBatch = pBatch;

package/dist-esm/promise/pBatch.js

@@ -1,23 +0,0 @@
-import { ErrorMode } from '..';
-import { pMap } from './pMap';
-/**
- * Like pMap, but doesn't fail on errors, instead returns both successful results and errors.
- */
-export async function pBatch(iterable, mapper, opt) {
-    try {
-        const results = await pMap(iterable, mapper, Object.assign(Object.assign({}, opt), { errorMode: ErrorMode.THROW_AGGREGATED }));
-        return {
-            results,
-            errors: [],
-        };
-    }
-    catch (err) {
-        const { errors, results } = err;
-        if (!errors || !results)
-            throw err; // not an AggregatedError
-        return {
-            results,
-            errors,
-        };
-    }
-}

package/src/promise/pBatch.ts

@@ -1,31 +0,0 @@
-import { AbortableAsyncMapper, BatchResult, ErrorMode } from '..'
-import { AggregatedError } from './AggregatedError'
-import { pMap } from './pMap'
-
-/**
- * Like pMap, but doesn't fail on errors, instead returns both successful results and errors.
- */
-export async function pBatch<IN, OUT>(
-  iterable: Iterable<IN | PromiseLike<IN>>,
-  mapper: AbortableAsyncMapper<IN, OUT>,
-  opt?: { concurrency?: number },
-): Promise<BatchResult<OUT>> {
-  try {
-    const results = await pMap(iterable, mapper, {
-      ...opt,
-      errorMode: ErrorMode.THROW_AGGREGATED,
-    })
-    return {
-      results,
-      errors: [],
-    }
-  } catch (err) {
-    const { errors, results } = err as AggregatedError<OUT>
-    if (!errors || !results) throw err // not an AggregatedError
-
-    return {
-      results,
-      errors,
-    }
-  }
-}