@naturalcycles/js-lib 14.218.0 → 14.219.0

package/dist/promise/pMap.d.ts

@@ -4,7 +4,11 @@ export interface PMapOptions {
     /**
      * Number of concurrently pending promises returned by `mapper`.
      *
-     * @default Infinity
+     * Defaults to 16.
+     *
+     * It previously (and originally) defaulted to Infinity, which was later changed,
+     * because it's somewhat dangerous to run "infinite number of parallel promises".
+     * You can still emulate the old behavior by passing `Infinity`.
      */
     concurrency?: number;
     /**
@@ -23,6 +27,14 @@ export interface PMapOptions {
     logger?: CommonLogger | null;
 }
 /**
+ * Forked from https://github.com/sindresorhus/p-map
+ *
+ * Improvements:
+ * - Exported as { pMap }, so IDE auto-completion works
+ * - Included Typescript typings (no need for @types/p-map)
+ * - Compatible with pProps (that had typings issues)
+ * - Preserves async stack traces (in selected cases)
+ *
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
  * or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned
  * from `mapper` in `input` order.

package/dist/promise/pMap.js

@@ -1,16 +1,16 @@
 "use strict";
-/*
-Taken from https://github.com/sindresorhus/p-map
-
-Improvements:
-- Exported as { pMap }, so IDE auto-completion works
-- Included Typescript typings (no need for @types/p-map)
-- Compatible with pProps (that had typings issues)
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pMap = void 0;
 const __1 = require("..");
 /**
+ * Forked from https://github.com/sindresorhus/p-map
+ *
+ * Improvements:
+ * - Exported as { pMap }, so IDE auto-completion works
+ * - Included Typescript typings (no need for @types/p-map)
+ * - Compatible with pProps (that had typings issues)
+ * - Preserves async stack traces (in selected cases)
+ *
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
  * or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned
  * from `mapper` in `input` order.
@@ -37,70 +37,26 @@ const __1 = require("..");
  * })();
  */
 async function pMap(iterable, mapper, opt = {}) {
-    const { logger = console } = 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;
+    const { concurrency = 16, errorMode = __1.ErrorMode.THROW_IMMEDIATELY, logger = console } = opt;
     // Special cases that are able to preserve async stack traces
+    // Special case: serial execution
     if (concurrency === 1) {
-        // Special case for concurrency == 1
-        for (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);
-                }
-                else {
-                    // otherwise, suppress (but still log via logger)
-                    logger?.error(err);
-                }
-            }
-        }
-        if (errors.length) {
-            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
-        }
-        return ret;
+        return await pMap1(items, mapper, errorMode, logger);
     }
-    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);
-            }
-            else {
-                // otherwise, suppress (but still log via logger)
-                logger?.error(r.reason);
-            }
-        });
-        if (errors.length) {
-            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
-        }
-        return ret;
+    // Special case: concurrency === Infinity or items.length <= concurrency
+    if (concurrency === Infinity || items.length <= concurrency) {
+        return await pMapAll(items, mapper, errorMode, logger);
     }
+    // General case: execution with throttled concurrency
+    const ret = [];
+    const errors = [];
+    let isSettled = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
     return await new Promise((resolve, reject) => {
         const next = () => {
             if (isSettled) {
@@ -159,3 +115,64 @@ async function pMap(iterable, mapper, opt = {}) {
     });
 }
 exports.pMap = pMap;
+/**
+ pMap with serial (non-concurrent) execution.
+ */
+async function pMap1(items, mapper, errorMode, logger) {
+    let i = 0;
+    const ret = [];
+    const errors = [];
+    for (const item of items) {
+        try {
+            const r = await mapper(item, i++);
+            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);
+            }
+            else {
+                // otherwise, suppress (but still log via logger)
+                logger?.error(err);
+            }
+        }
+    }
+    if (errors.length) {
+        throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
+    }
+    return ret;
+}
+/**
+ pMap with fully concurrent execution, like Promise.all
+ */
+async function pMapAll(items, mapper, errorMode, logger) {
+    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);
+    }
+    const ret = [];
+    const errors = [];
+    for (const r of await Promise.allSettled(items.map((item, i) => mapper(item, i)))) {
+        if (r.status === 'fulfilled') {
+            if (r.value === __1.END)
+                break;
+            if (r.value !== __1.SKIP)
+                ret.push(r.value);
+        }
+        else if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+            errors.push(r.reason);
+        }
+        else {
+            // otherwise, suppress (but still log via logger)
+            logger?.error(r.reason);
+        }
+    }
+    if (errors.length) {
+        throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
+    }
+    return ret;
+}

package/dist-esm/promise/pMap.js

@@ -1,13 +1,13 @@
-/*
-Taken from https://github.com/sindresorhus/p-map
-
-Improvements:
-- Exported as { pMap }, so IDE auto-completion works
-- Included Typescript typings (no need for @types/p-map)
-- Compatible with pProps (that had typings issues)
- */
 import { END, ErrorMode, SKIP } from '..';
 /**
+ * Forked from https://github.com/sindresorhus/p-map
+ *
+ * Improvements:
+ * - Exported as { pMap }, so IDE auto-completion works
+ * - Included Typescript typings (no need for @types/p-map)
+ * - Compatible with pProps (that had typings issues)
+ * - Preserves async stack traces (in selected cases)
+ *
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
  * or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned
  * from `mapper` in `input` order.
@@ -34,70 +34,26 @@ import { END, ErrorMode, SKIP } from '..';
  * })();
  */
 export async function pMap(iterable, mapper, opt = {}) {
-    const { logger = console } = 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 = ErrorMode.THROW_IMMEDIATELY } = opt;
-    const errors = [];
-    let isSettled = false;
-    let resolvingCount = 0;
-    let currentIndex = 0;
+    const { concurrency = 16, errorMode = ErrorMode.THROW_IMMEDIATELY, logger = console } = opt;
     // Special cases that are able to preserve async stack traces
+    // Special case: serial execution
     if (concurrency === 1) {
-        // Special case for concurrency == 1
-        for (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);
-                }
-                else {
-                    // otherwise, suppress (but still log via logger)
-                    logger === null || logger === void 0 ? void 0 : logger.error(err);
-                }
-            }
-        }
-        if (errors.length) {
-            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
-        }
-        return ret;
+        return await pMap1(items, mapper, errorMode, logger);
     }
-    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);
-            }
-            else {
-                // otherwise, suppress (but still log via logger)
-                logger === null || logger === void 0 ? void 0 : logger.error(r.reason);
-            }
-        });
-        if (errors.length) {
-            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
-        }
-        return ret;
+    // Special case: concurrency === Infinity or items.length <= concurrency
+    if (concurrency === Infinity || items.length <= concurrency) {
+        return await pMapAll(items, mapper, errorMode, logger);
     }
+    // General case: execution with throttled concurrency
+    const ret = [];
+    const errors = [];
+    let isSettled = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
     return await new Promise((resolve, reject) => {
         const next = () => {
             if (isSettled) {
@@ -155,3 +111,64 @@ export async function pMap(iterable, mapper, opt = {}) {
         }
     });
 }
+/**
+ pMap with serial (non-concurrent) execution.
+ */
+async function pMap1(items, mapper, errorMode, logger) {
+    let i = 0;
+    const ret = [];
+    const errors = [];
+    for (const item of items) {
+        try {
+            const r = await mapper(item, i++);
+            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);
+            }
+            else {
+                // otherwise, suppress (but still log via logger)
+                logger === null || logger === void 0 ? void 0 : logger.error(err);
+            }
+        }
+    }
+    if (errors.length) {
+        throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
+    }
+    return ret;
+}
+/**
+ pMap with fully concurrent execution, like Promise.all
+ */
+async function pMapAll(items, mapper, errorMode, logger) {
+    if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
+        return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(r => r !== SKIP && r !== END);
+    }
+    const ret = [];
+    const errors = [];
+    for (const r of await Promise.allSettled(items.map((item, i) => mapper(item, i)))) {
+        if (r.status === 'fulfilled') {
+            if (r.value === END)
+                break;
+            if (r.value !== SKIP)
+                ret.push(r.value);
+        }
+        else if (errorMode === ErrorMode.THROW_AGGREGATED) {
+            errors.push(r.reason);
+        }
+        else {
+            // otherwise, suppress (but still log via logger)
+            logger === null || logger === void 0 ? void 0 : logger.error(r.reason);
+        }
+    }
+    if (errors.length) {
+        throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
+    }
+    return ret;
+}

package/package.json

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

package/src/promise/pMap.ts

@@ -1,12 +1,3 @@
-/*
-Taken from https://github.com/sindresorhus/p-map
-
-Improvements:
-- Exported as { pMap }, so IDE auto-completion works
-- Included Typescript typings (no need for @types/p-map)
-- Compatible with pProps (that had typings issues)
- */
-
 import type { AbortableAsyncMapper, CommonLogger } from '..'
 import { END, ErrorMode, SKIP } from '..'
 
@@ -14,7 +5,11 @@ export interface PMapOptions {
   /**
    * Number of concurrently pending promises returned by `mapper`.
    *
-   * @default Infinity
+   * Defaults to 16.
+   *
+   * It previously (and originally) defaulted to Infinity, which was later changed,
+   * because it's somewhat dangerous to run "infinite number of parallel promises".
+   * You can still emulate the old behavior by passing `Infinity`.
    */
   concurrency?: number
 
@@ -36,6 +31,14 @@ export interface PMapOptions {
 }
 
 /**
+ * Forked from https://github.com/sindresorhus/p-map
+ *
+ * Improvements:
+ * - Exported as { pMap }, so IDE auto-completion works
+ * - Included Typescript typings (no need for @types/p-map)
+ * - Compatible with pProps (that had typings issues)
+ * - Preserves async stack traces (in selected cases)
+ *
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
  * or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned
  * from `mapper` in `input` order.
@@ -66,73 +69,30 @@ export async function pMap<IN, OUT>(
   mapper: AbortableAsyncMapper<IN, OUT>,
   opt: PMapOptions = {},
 ): Promise<OUT[]> {
-  const { logger = console } = 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
+  const { concurrency = 16, errorMode = ErrorMode.THROW_IMMEDIATELY, logger = console } = opt
 
   // Special cases that are able to preserve async stack traces
-
+  // Special case: serial execution
   if (concurrency === 1) {
-    // Special case for concurrency == 1
-
-    for (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)
-        } else {
-          // otherwise, suppress (but still log via logger)
-          logger?.error(err)
-        }
-      }
-    }
-
-    if (errors.length) {
-      throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`)
-    }
-
-    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)
-      } else {
-        // otherwise, suppress (but still log via logger)
-        logger?.error(r.reason)
-      }
-    })
-
-    if (errors.length) {
-      throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`)
-    }
+    return await pMap1(items, mapper, errorMode, logger)
+  }
 
-    return ret as OUT[]
+  // Special case: concurrency === Infinity or items.length <= concurrency
+  if (concurrency === Infinity || items.length <= concurrency) {
+    return await pMapAll(items, mapper, errorMode, logger)
   }
 
+  // General case: execution with throttled concurrency
+  const ret: (OUT | typeof SKIP)[] = []
+  const errors: Error[] = []
+  let isSettled = false
+  let resolvingCount = 0
+  let currentIndex = 0
+
   return await new Promise<OUT[]>((resolve, reject) => {
     const next = (): void => {
       if (isSettled) {
@@ -198,3 +158,76 @@ export async function pMap<IN, OUT>(
     }
   })
 }
+
+/**
+ pMap with serial (non-concurrent) execution.
+ */
+async function pMap1<IN, OUT>(
+  items: IN[],
+  mapper: AbortableAsyncMapper<IN, OUT>,
+  errorMode: ErrorMode,
+  logger: CommonLogger | null,
+): Promise<OUT[]> {
+  let i = 0
+  const ret: OUT[] = []
+  const errors: Error[] = []
+
+  for (const item of items) {
+    try {
+      const r = await mapper(item, i++)
+      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)
+      } else {
+        // otherwise, suppress (but still log via logger)
+        logger?.error(err)
+      }
+    }
+  }
+
+  if (errors.length) {
+    throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`)
+  }
+
+  return ret
+}
+
+/**
+ pMap with fully concurrent execution, like Promise.all
+ */
+async function pMapAll<IN, OUT>(
+  items: IN[],
+  mapper: AbortableAsyncMapper<IN, OUT>,
+  errorMode: ErrorMode,
+  logger: CommonLogger | null,
+): Promise<OUT[]> {
+  if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
+    return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(
+      r => r !== SKIP && r !== END,
+    ) as OUT[]
+  }
+
+  const ret: OUT[] = []
+  const errors: Error[] = []
+
+  for (const r of await Promise.allSettled(items.map((item, i) => mapper(item, i)))) {
+    if (r.status === 'fulfilled') {
+      if (r.value === END) break
+      if (r.value !== SKIP) ret.push(r.value)
+    } else if (errorMode === ErrorMode.THROW_AGGREGATED) {
+      errors.push(r.reason)
+    } else {
+      // otherwise, suppress (but still log via logger)
+      logger?.error(r.reason)
+    }
+  }
+
+  if (errors.length) {
+    throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`)
+  }
+
+  return ret
+}