@naturalcycles/js-lib 14.200.0 → 14.201.1

package/dist/abort.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Like AbortSignal, but it can "abort itself" via the `.abort()` method.
+ *
+ * Similar to how DeferredPromise is both a Promise and has `.resolve()` and `.reject()` methods.
+ *
+ * This is to simplify the AbortController/AbortSignal usage.
+ *
+ * Before this - you need to keep track of 2 things: AbortController and AbortSignal.
+ *
+ * After - you are good with only AbortableSignal, which can do both.
+ * And it's compatible with AbortSignal (because it extends it).
+ *
+ * @experimental
+ */
+export interface AbortableSignal extends AbortSignal {
+    abort: AbortController['abort'];
+}
+/**
+ * Creates AbortableSignal,
+ * which is like AbortSignal, but can "abort itself" with `.abort()` method.
+ *
+ * @experimental
+ */
+export declare function createAbortableSignal(): AbortableSignal;

package/dist/abort.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAbortableSignal = void 0;
+/**
+ * Creates AbortableSignal,
+ * which is like AbortSignal, but can "abort itself" with `.abort()` method.
+ *
+ * @experimental
+ */
+function createAbortableSignal() {
+    const ac = new AbortController();
+    return Object.assign(ac.signal, {
+        abort: ac.abort.bind(ac),
+    });
+}
+exports.createAbortableSignal = createAbortableSignal;

package/dist/index.d.ts

@@ -81,6 +81,7 @@ export * from './env/buildInfo';
 export * from './form.util';
 export * from './semver';
 export * from './web';
+export * from './abort';
 export * from './polyfill';
 export * from './zod/zod.util';
 export * from './zod/zod.shared.schemas';

package/dist/index.js

@@ -85,6 +85,7 @@ tslib_1.__exportStar(require("./env/buildInfo"), exports);
 tslib_1.__exportStar(require("./form.util"), exports);
 tslib_1.__exportStar(require("./semver"), exports);
 tslib_1.__exportStar(require("./web"), exports);
+tslib_1.__exportStar(require("./abort"), exports);
 tslib_1.__exportStar(require("./polyfill"), exports);
 tslib_1.__exportStar(require("./zod/zod.util"), exports);
 tslib_1.__exportStar(require("./zod/zod.shared.schemas"), exports);

package/dist/promise/pMap.d.ts

@@ -1,4 +1,4 @@
-import type { AbortableAsyncMapper } from '..';
+import type { AbortableAsyncMapper, CommonLogger } from '..';
 import { ErrorMode } from '..';
 export interface PMapOptions {
     /**
@@ -13,8 +13,14 @@ export interface PMapOptions {
      * When set to THROW_AGGREGATED, instead of stopping when a promise rejects, it will wait for all the promises to settle and then reject with an Aggregated error.
      *
      * When set to SUPPRESS - will ignore errors and return results from successful operations.
+     * When in SUPPRESS - errors are still logged via the `logger` (which defaults to console).
      */
     errorMode?: ErrorMode;
+    /**
+     * Default to `console`.
+     * Pass `null` to skip logging completely.
+     */
+    logger?: CommonLogger | null;
 }
 /**
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,

package/dist/promise/pMap.js

@@ -37,6 +37,7 @@ const __1 = require("..");
  * })();
  */
 async function pMap(iterable, mapper, opt = {}) {
+    const { logger = console } = opt;
     const ret = [];
     // const iterator = iterable[Symbol.iterator]()
     const items = [...iterable];
@@ -65,7 +66,10 @@ async function pMap(iterable, mapper, opt = {}) {
                 if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
                     errors.push(err);
                 }
-                // otherwise, suppress completely
+                else {
+                    // otherwise, suppress (but still log via logger)
+                    logger?.error(err);
+                }
             }
         }
         if (errors.length) {
@@ -87,6 +91,10 @@ async function pMap(iterable, mapper, opt = {}) {
             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)`);
@@ -133,6 +141,10 @@ async function pMap(iterable, mapper, opt = {}) {
                     if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
                         errors.push(err);
                     }
+                    else {
+                        // otherwise, suppress (but still log via logger)
+                        logger?.error(err);
+                    }
                     resolvingCount--;
                     next();
                 }

package/dist-esm/abort.js

@@ -0,0 +1,12 @@
+/**
+ * Creates AbortableSignal,
+ * which is like AbortSignal, but can "abort itself" with `.abort()` method.
+ *
+ * @experimental
+ */
+export function createAbortableSignal() {
+    const ac = new AbortController();
+    return Object.assign(ac.signal, {
+        abort: ac.abort.bind(ac),
+    });
+}

package/dist-esm/index.js

@@ -81,6 +81,7 @@ export * from './env/buildInfo';
 export * from './form.util';
 export * from './semver';
 export * from './web';
+export * from './abort';
 export * from './polyfill';
 export * from './zod/zod.util';
 export * from './zod/zod.shared.schemas';

package/dist-esm/promise/pMap.js

@@ -34,6 +34,7 @@ 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];
@@ -62,7 +63,10 @@ export async function pMap(iterable, mapper, opt = {}) {
                 if (errorMode === ErrorMode.THROW_AGGREGATED) {
                     errors.push(err);
                 }
-                // otherwise, suppress completely
+                else {
+                    // otherwise, suppress (but still log via logger)
+                    logger === null || logger === void 0 ? void 0 : logger.error(err);
+                }
             }
         }
         if (errors.length) {
@@ -84,6 +88,10 @@ export async function pMap(iterable, mapper, opt = {}) {
             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)`);
@@ -130,6 +138,10 @@ export async function pMap(iterable, mapper, opt = {}) {
                     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);
+                    }
                     resolvingCount--;
                     next();
                 }

package/package.json

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

package/src/abort.ts

@@ -0,0 +1,30 @@
+/**
+ * Like AbortSignal, but it can "abort itself" via the `.abort()` method.
+ *
+ * Similar to how DeferredPromise is both a Promise and has `.resolve()` and `.reject()` methods.
+ *
+ * This is to simplify the AbortController/AbortSignal usage.
+ *
+ * Before this - you need to keep track of 2 things: AbortController and AbortSignal.
+ *
+ * After - you are good with only AbortableSignal, which can do both.
+ * And it's compatible with AbortSignal (because it extends it).
+ *
+ * @experimental
+ */
+export interface AbortableSignal extends AbortSignal {
+  abort: AbortController['abort']
+}
+
+/**
+ * Creates AbortableSignal,
+ * which is like AbortSignal, but can "abort itself" with `.abort()` method.
+ *
+ * @experimental
+ */
+export function createAbortableSignal(): AbortableSignal {
+  const ac = new AbortController()
+  return Object.assign(ac.signal, {
+    abort: ac.abort.bind(ac),
+  })
+}

package/src/index.ts

@@ -81,6 +81,7 @@ export * from './env/buildInfo'
 export * from './form.util'
 export * from './semver'
 export * from './web'
+export * from './abort'
 export * from './polyfill'
 export * from './zod/zod.util'
 export * from './zod/zod.shared.schemas'

package/src/promise/pMap.ts

@@ -7,7 +7,7 @@ Improvements:
 - Compatible with pProps (that had typings issues)
  */
 
-import type { AbortableAsyncMapper } from '..'
+import type { AbortableAsyncMapper, CommonLogger } from '..'
 import { END, ErrorMode, SKIP } from '..'
 
 export interface PMapOptions {
@@ -24,8 +24,15 @@ export interface PMapOptions {
    * When set to THROW_AGGREGATED, instead of stopping when a promise rejects, it will wait for all the promises to settle and then reject with an Aggregated error.
    *
    * When set to SUPPRESS - will ignore errors and return results from successful operations.
+   * When in SUPPRESS - errors are still logged via the `logger` (which defaults to console).
    */
   errorMode?: ErrorMode
+
+  /**
+   * Default to `console`.
+   * Pass `null` to skip logging completely.
+   */
+  logger?: CommonLogger | null
 }
 
 /**
@@ -59,6 +66,7 @@ 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]
@@ -86,8 +94,10 @@ export async function pMap<IN, OUT>(
         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)
         }
-        // otherwise, suppress completely
       }
     }
 
@@ -110,6 +120,9 @@ export async function pMap<IN, OUT>(
         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)
       }
     })
 
@@ -165,6 +178,9 @@ export async function pMap<IN, OUT>(
             } else {
               if (errorMode === ErrorMode.THROW_AGGREGATED) {
                 errors.push(err)
+              } else {
+                // otherwise, suppress (but still log via logger)
+                logger?.error(err)
               }
               resolvingCount--
               next()