@naturalcycles/js-lib 14.81.0 → 14.82.0

package/dist/index.d.ts

@@ -34,7 +34,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';

package/dist/index.js

@@ -42,7 +42,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);

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

@@ -8,7 +8,7 @@ export interface PRetryOptions {
     /**
      * Timeout for each Try, in milliseconds.
      *
-     * Defaults to 60_000
+     * Defaults to no timeout.
      */
     timeout?: number;
     /**

package/dist-esm/index.js

@@ -31,7 +31,6 @@ export * from './object/object.util';
 export * from './object/sortObject';
 export * from './object/sortObjectDeep';
 import { AggregatedError } from './promise/AggregatedError';
-export * from './promise/pBatch';
 import { pDefer } from './promise/pDefer';
 export * from './promise/pDelay';
 export * from './promise/pFilter';

package/dist-esm/promise/AggregatedError.js

@@ -5,17 +5,12 @@
  */
 export 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-esm/promise/pFilter.js

@@ -1,5 +1,5 @@
-import { pMap } from './pMap';
-export async function pFilter(iterable, filterFn, opt) {
-    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(iterable, filterFn) {
+    const items = [...iterable];
+    const predicates = await Promise.all(items.map((item, i) => filterFn(item, i)));
+    return items.filter((item, i) => predicates[i]);
 }

package/dist-esm/promise/pMap.js

@@ -6,6 +6,7 @@ Improvements:
 - Included Typescript typings (no need for @types/p-map)
 - Compatible with pProps (that had typings issues)
  */
+import { __asyncValues } from "tslib";
 import { END, ErrorMode, SKIP } from '..';
 import { AggregatedError } from './AggregatedError';
 /**
@@ -35,28 +36,85 @@ import { AggregatedError } from './AggregatedError';
  * })();
  */
 export async function pMap(iterable, mapper, opt = {}) {
+    var e_1, _a;
+    const ret = [];
+    // 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 = [];
+    let isSettled = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
+    // Special cases that are able to preserve async stack traces
+    if (concurrency === 1) {
+        try {
+            // Special case for concurrency == 1
+            for (var items_1 = __asyncValues(items), items_1_1; items_1_1 = await items_1.next(), !items_1_1.done;) {
+                const item = items_1_1.value;
+                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);
+                    }
+                    // otherwise, suppress completely
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) await _a.call(items_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (errors.length) {
+            throw new AggregatedError(errors, ret);
+        }
+        return ret;
+    }
+    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);
+        }
+        ;
+        (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);
+        }
+        return ret;
+    }
     return new Promise((resolve, reject) => {
-        const { concurrency = Number.POSITIVE_INFINITY, errorMode = 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 !== SKIP);
-                    if (errors.length && errorMode === ErrorMode.THROW_AGGREGATED) {
+                    if (errors.length) {
                         reject(new AggregatedError(errors, r));
                     }
                     else {
@@ -66,7 +124,7 @@ export 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 === END) {
@@ -82,7 +140,9 @@ export async function pMap(iterable, mapper, opt = {}) {
                     reject(err);
                 }
                 else {
-                    errors.push(err);
+                    if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                        errors.push(err);
+                    }
                     resolvingCount--;
                     next();
                 }
@@ -90,7 +150,7 @@ export async function pMap(iterable, mapper, opt = {}) {
         };
         for (let i = 0; i < concurrency; i++) {
             next();
-            if (isIterableDone) {
+            if (isSettled) {
                 break;
             }
         }

package/package.json

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

package/src/index.ts

@@ -67,7 +67,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'

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

@@ -11,7 +11,7 @@ export interface PRetryOptions {
   /**
    * Timeout for each Try, in milliseconds.
    *
-   * Defaults to 60_000
+   * Defaults to no timeout.
    */
   timeout?: number
 

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