@naturalcycles/js-lib 14.69.4 → 14.71.0

package/dist-esm/error/error.util.js

@@ -7,13 +7,12 @@ import { AppError, _jsonParseIfPossible, _stringifyAny, } from '..';
  *
  * Alternatively, if you're sure it's Error - you can use `_assertIsError(err)`.
  */
-export function _anyToError(o, opt) {
-    if (o instanceof Error) {
-        // Already an Error - return as-is
+export function _anyToError(o, errorClass = Error, opt) {
+    if (o instanceof errorClass)
         return o;
-    }
-    const message = _stringifyAny(o, opt);
-    return new Error(message);
+    // If it's an instance of Error, but ErrorClass is something else (e.g AppError) - it'll be "repacked" into AppError
+    const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, opt);
+    return _errorObjectToError(errorObject, errorClass);
 }
 /**
  * Converts "anything" to ErrorObject.
@@ -22,8 +21,9 @@ export function _anyToError(o, opt) {
  * Objects (not Errors) get converted to prettified JSON string (via `_stringifyAny`).
  */
 export function _anyToErrorObject(o, opt) {
+    var _a;
     if (o instanceof Error) {
-        return _errorToErrorObject(o, opt === null || opt === void 0 ? void 0 : opt.includeErrorStack);
+        return _errorToErrorObject(o, (_a = opt === null || opt === void 0 ? void 0 : opt.includeErrorStack) !== null && _a !== void 0 ? _a : true);
     }
     o = _jsonParseIfPossible(o);
     if (_isHttpErrorResponse(o)) {
@@ -43,7 +43,7 @@ export function _anyToErrorObject(o, opt) {
         data: {}, // empty
     };
 }
-export function _errorToErrorObject(e, includeErrorStack = false) {
+export function _errorToErrorObject(e, includeErrorStack = true) {
     const obj = {
         name: e.name,
         message: e.message,
@@ -55,17 +55,29 @@ export function _errorToErrorObject(e, includeErrorStack = false) {
     return obj;
 }
 export function _errorObjectToAppError(o) {
-    const err = Object.assign(new AppError(o.message, o.data), {
+    return _errorObjectToError(o, AppError);
+}
+export function _errorObjectToError(o, errorClass = Error) {
+    if (o instanceof errorClass)
+        return o;
+    const err = new errorClass(o.message);
     // name: err.name, // cannot be assigned to a readonly property like this
     // stack: o.stack, // also readonly e.g in Firefox
-    });
     Object.defineProperty(err, 'name', {
         value: o.name,
         configurable: true,
     });
-    Object.defineProperty(err, 'stack', {
-        value: o.stack,
+    Object.defineProperty(err, 'data', {
+        value: o.data,
+        writable: true,
+        configurable: true,
+        enumerable: false,
     });
+    if (o.stack) {
+        Object.defineProperty(err, 'stack', {
+            value: o.stack,
+        });
+    }
     return err;
 }
 export function _isHttpErrorResponse(o) {
@@ -73,10 +85,14 @@ export function _isHttpErrorResponse(o) {
 }
 export function _isHttpErrorObject(o) {
     var _a;
-    return (typeof (o === null || o === void 0 ? void 0 : o.name) === 'string' &&
-        typeof (o === null || o === void 0 ? void 0 : o.message) === 'string' &&
-        typeof ((_a = o === null || o === void 0 ? void 0 : o.data) === null || _a === void 0 ? void 0 : _a.httpStatusCode) === 'number');
+    return (!!o &&
+        typeof o.name === 'string' &&
+        typeof o.message === 'string' &&
+        typeof ((_a = o.data) === null || _a === void 0 ? void 0 : _a.httpStatusCode) === 'number');
 }
+/**
+ * Note: any instance of AppError is also automatically an ErrorObject
+ */
 export function _isErrorObject(o) {
-    return (typeof (o === null || o === void 0 ? void 0 : o.name) === 'string' && typeof (o === null || o === void 0 ? void 0 : o.message) === 'string' && typeof (o === null || o === void 0 ? void 0 : o.data) === 'object');
+    return (!!o && typeof o.name === 'string' && typeof o.message === 'string' && typeof o.data === 'object');
 }

package/dist-esm/error/try.js

@@ -22,6 +22,8 @@ export function _try(fn) {
         return [err, undefined];
     }
 }
+// todo: remove when eslint starts to know about Awaited
+/* eslint-disable no-undef */
 /**
  * Like _try, but for Promises.
  *

package/dist-esm/index.js

@@ -13,7 +13,7 @@ import { _Retry } from './decorators/retry.decorator';
 import { _Timeout } from './decorators/timeout.decorator';
 import { AppError } from './error/app.error';
 import { AssertionError, _assert, _assertDeepEquals, _assertEquals, _assertIsError, _assertIsNumber, _assertIsString, _assertTypeOf, } from './error/assert';
-import { _anyToError, _anyToErrorObject, _errorObjectToAppError, _errorToErrorObject, _isErrorObject, _isHttpErrorObject, _isHttpErrorResponse, } from './error/error.util';
+export * from './error/error.util';
 import { ErrorMode } from './error/errorMode';
 import { HttpError } from './error/http.error';
 import { _try, pTry } from './error/try';
@@ -47,10 +47,11 @@ import { _jsonParseIfPossible } from './string/json.util';
 import { _capitalize, _lowerFirst, _nl2br, _removeWhitespace, _replaceAll, _split, _substringAfter, _substringAfterLast, _substringBefore, _substringBeforeLast, _substringBetweenLast, _truncate, _truncateMiddle, _upperFirst, } from './string/string.util';
 import { _stringifyAny } from './string/stringifyAny';
 import { _ms, _since } from './time/time.util';
-import { _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues, } from './types';
+import { END, SKIP, _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues, } from './types';
 import { _gb, _hb, _kb, _mb } from './unit/size.util';
 import { is } from './vendor/is';
 import { commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, } from './log/commonLogger';
 import { _safeJsonStringify } from './string/safeJsonStringify';
 import { PQueue } from './promise/pQueue';
-export { is, _Memo, _memoFn, _LogMethod, _getArgsSignature, _createPromiseDecorator, AppError, HttpError, AssertionError, _isErrorObject, _isHttpErrorObject, _isHttpErrorResponse, _assert, _assertEquals, _assertDeepEquals, _assertIsError, _assertIsString, _assertIsNumber, _assertTypeOf, _randomInt, _randomArrayItem, _createDeterministicRandom, _inRange, _stringMapValues, _stringMapEntries, _objectKeys, _capitalize, _upperFirst, _lowerFirst, _split, _removeWhitespace, _substringBefore, _substringBeforeLast, _substringAfter, _substringAfterLast, _substringBetweenLast, _replaceAll, _nl2br, _truncate, _truncateMiddle, _pick, _omit, _filterFalsyValues, _filterUndefinedValues, _filterNullishValues, _filterEmptyArrays, _filterEmptyValues, _filterObject, _undefinedIfEmpty, _isObject, _isPrimitive, _mapKeys, _mapValues, _mapObject, _objectNullValuesToUndefined, _deepEquals, _deepCopy, _isEmptyObject, _isEmpty, _merge, _deepTrim, _sortObjectDeep, _sortObject, _get, _set, _has, _unset, _mask, _invert, _invertMap, _by, _groupBy, _sortBy, _sortNumbers, _toFixed, _toPrecision, _round, _findLast, _takeWhile, _takeRightWhile, _dropWhile, _dropRightWhile, _countBy, _intersection, _difference, _shuffle, _mapToObject, _findKeyByValue, _anyToError, _anyToErrorObject, _errorToErrorObject, _errorObjectToAppError, _range, _uniq, _uniqBy, _flatten, _flattenDeep, _chunk, SimpleMovingAverage, _average, _averageWeighted, _percentile, _median, _debounce, _throttle, _Debounce, _Throttle, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, pBatch, ErrorMode, pFilter, pProps, pDelay, pDefer, pHang, pState, AggregatedError, pRetry, pTimeout, pTuple, _Retry, _Timeout, _tryCatch, _TryCatch, _try, pTry, _jsonParseIfPossible, _stringifyAny, _ms, _since, _hb, _gb, _mb, _kb, _snakeCase, _camelCase, _kebabCase, _sum, _sumBy, _clamp, _last, mergeJsonSchemaObjects, jsonSchema, JsonSchemaAnyBuilder, JSON_SCHEMA_ORDER, generateJsonSchemaFromData, _parseQueryString, _defineLazyProperty, _defineLazyProps, _lazyValue, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, _safeJsonStringify, PQueue, };
+export * from './seq/seq';
+export { is, _Memo, _memoFn, _LogMethod, _getArgsSignature, _createPromiseDecorator, AppError, HttpError, AssertionError, _assert, _assertEquals, _assertDeepEquals, _assertIsError, _assertIsString, _assertIsNumber, _assertTypeOf, _randomInt, _randomArrayItem, _createDeterministicRandom, _inRange, _stringMapValues, _stringMapEntries, _objectKeys, _capitalize, _upperFirst, _lowerFirst, _split, _removeWhitespace, _substringBefore, _substringBeforeLast, _substringAfter, _substringAfterLast, _substringBetweenLast, _replaceAll, _nl2br, _truncate, _truncateMiddle, _pick, _omit, _filterFalsyValues, _filterUndefinedValues, _filterNullishValues, _filterEmptyArrays, _filterEmptyValues, _filterObject, _undefinedIfEmpty, _isObject, _isPrimitive, _mapKeys, _mapValues, _mapObject, _objectNullValuesToUndefined, _deepEquals, _deepCopy, _isEmptyObject, _isEmpty, _merge, _deepTrim, _sortObjectDeep, _sortObject, _get, _set, _has, _unset, _mask, _invert, _invertMap, _by, _groupBy, _sortBy, _sortNumbers, _toFixed, _toPrecision, _round, _findLast, _takeWhile, _takeRightWhile, _dropWhile, _dropRightWhile, _countBy, _intersection, _difference, _shuffle, _mapToObject, _findKeyByValue, _range, _uniq, _uniqBy, _flatten, _flattenDeep, _chunk, SimpleMovingAverage, _average, _averageWeighted, _percentile, _median, _debounce, _throttle, _Debounce, _Throttle, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, pBatch, ErrorMode, pFilter, pProps, pDelay, pDefer, pHang, pState, AggregatedError, pRetry, pTimeout, pTuple, _Retry, _Timeout, _tryCatch, _TryCatch, _try, pTry, _jsonParseIfPossible, _stringifyAny, _ms, _since, _hb, _gb, _mb, _kb, _snakeCase, _camelCase, _kebabCase, _sum, _sumBy, _clamp, _last, mergeJsonSchemaObjects, jsonSchema, JsonSchemaAnyBuilder, JSON_SCHEMA_ORDER, generateJsonSchemaFromData, _parseQueryString, _defineLazyProperty, _defineLazyProps, _lazyValue, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, _safeJsonStringify, PQueue, END, SKIP, };

package/dist-esm/promise/pMap.js

@@ -6,7 +6,7 @@ Improvements:
 - Included Typescript typings (no need for @types/p-map)
 - Compatible with pProps (that had typings issues)
  */
-import { ErrorMode } from '..';
+import { END, ErrorMode, SKIP } from '..';
 import { AggregatedError } from './AggregatedError';
 /**
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
@@ -40,25 +40,27 @@ export async function pMap(iterable, mapper, opt = {}) {
         const ret = [];
         const iterator = iterable[Symbol.iterator]();
         const errors = [];
-        let isRejected = false;
+        let isSettled = false;
         let isIterableDone = false;
         let resolvingCount = 0;
         let currentIndex = 0;
-        const next = () => {
-            if (isRejected) {
+        const next = (skipped = false) => {
+            if (isSettled) {
                 return;
             }
             const nextItem = iterator.next();
             const i = currentIndex;
-            currentIndex++;
+            if (!skipped)
+                currentIndex++;
             if (nextItem.done) {
                 isIterableDone = true;
                 if (resolvingCount === 0) {
+                    const r = ret.filter(r => r !== SKIP);
                     if (errors.length && errorMode === ErrorMode.THROW_AGGREGATED) {
-                        reject(new AggregatedError(errors, ret));
+                        reject(new AggregatedError(errors, r));
                     }
                     else {
-                        resolve(ret);
+                        resolve(r);
                     }
                 }
                 return;
@@ -67,12 +69,16 @@ export async function pMap(iterable, mapper, opt = {}) {
             Promise.resolve(nextItem.value)
                 .then(async (element) => await mapper(element, i))
                 .then(value => {
+                if (value === END) {
+                    isSettled = true;
+                    return resolve(ret.filter(r => r !== SKIP));
+                }
                 ret[i] = value;
                 resolvingCount--;
                 next();
             }, err => {
                 if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
-                    isRejected = true;
+                    isSettled = true;
                     reject(err);
                 }
                 else {

package/dist-esm/promise/pProps.js

@@ -8,16 +8,15 @@ Improvements:
 - Included Typescript typings (no need for @types/p-props)
  */
 import { pMap } from './pMap';
+// todo: remove when eslint starts to know about Awaited
+/* eslint-disable no-undef */
 /**
  * Promise.all for Object instead of Array.
  * Supports concurrency.
  */
 export async function pProps(input, opt) {
-    const keys = Object.keys(input);
-    const values = await pMap(Object.values(input), r => r, opt);
     const r = {};
-    values.forEach((v, i) => {
-        r[keys[i]] = v;
-    });
+    const keys = Object.keys(input);
+    await pMap(Object.values(input), (v, i) => (r[keys[i]] = v), opt);
     return r;
 }

package/dist-esm/seq/seq.js

@@ -0,0 +1,136 @@
+import { END, SKIP } from '../types';
+/**
+ * Inspired by Kotlin Sequences.
+ * Similar to arrays, but with lazy evaluation, abortable.
+ * Can be useful when it's not feasible/performant to create an array of values to iterate upfront
+ * (e.g to construct 1000 Dayjs instances only to find that 2 of them were needed).
+ *
+ * @experimental
+ */
+export class Seq {
+    constructor(initialValue, nextFn) {
+        this.nextFn = nextFn;
+        this.sentInitialValue = false;
+        this.i = -1;
+        this.currentValue = initialValue;
+    }
+    [Symbol.iterator]() {
+        return {
+            next: () => {
+                const value = this.next();
+                return value === END ? { done: true, value: undefined } : { value };
+            },
+        };
+    }
+    static create(initialValue, nextFn) {
+        return new Seq(initialValue, nextFn);
+    }
+    static range(minIncl, maxExcl, step = 1) {
+        const max = maxExcl - step;
+        return new Seq(minIncl, n => (n < max ? n + step : END));
+    }
+    static from(a) {
+        const it = a[Symbol.iterator]();
+        const v = it.next();
+        if (v.done)
+            return new Seq(END, () => { });
+        return new Seq(v.value, () => {
+            const v = it.next();
+            if (v.done)
+                return END;
+            return v.value;
+        });
+    }
+    static empty() {
+        return new Seq(END, () => { });
+    }
+    next() {
+        if (this.currentValue === END)
+            return END;
+        this.i++;
+        let v;
+        if (!this.sentInitialValue) {
+            this.sentInitialValue = true;
+            v = this.currentValue;
+        }
+        else {
+            v = this.nextFn(this.currentValue, this.i);
+        }
+        // console.log(`_seq`, v)
+        if (v === SKIP)
+            return this.next();
+        return (this.currentValue = v);
+    }
+    // Chainable functions - return another (chained) Sequence
+    // map<OUT>(mapper: Mapper<T, OUT | typeof SKIP | typeof END>): Seq<OUT> {
+    //   if (this.currentValue === END) return this as any
+    //
+    //   // Iterate until first valid value, to have as `initialValue` of the new Sequence
+    //   let v: OUT | typeof SKIP | typeof END
+    //
+    //   while (true) {
+    //     v = mapper(this.currentValue, ++this.i)
+    //     if (v === SKIP) continue
+    //     if (v === END) return this as any
+    //   }
+    //
+    //   return new Seq<OUT>(v as OUT, (current, i) => {
+    //     const v = mapper(current, i)
+    //
+    //   })
+    // }
+    // Final functions - return final value, not a chained sequence
+    find(predicate) {
+        do {
+            const v = this.next();
+            if (v === END)
+                return; // not found, end of sequence
+            const r = predicate(v, this.i);
+            if (r === END)
+                return;
+            if (r)
+                return v;
+            // otherwise proceed
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    some(predicate) {
+        do {
+            const v = this.next();
+            if (v === END)
+                return false;
+            const r = predicate(v, this.i);
+            if (r === END)
+                return false;
+            if (r)
+                return true;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    every(predicate) {
+        do {
+            const v = this.next();
+            if (v === END)
+                return true;
+            const r = predicate(v, this.i);
+            if (r === END)
+                return true;
+            if (!r)
+                return false;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    toArray() {
+        const a = [];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const v = this.next();
+            if (v === END)
+                return a;
+            a.push(v);
+        }
+    }
+}
+/**
+ * Convenience function to create a Sequence.
+ */
+export function _seq(initialValue, nextFn) {
+    return Seq.create(initialValue, nextFn);
+}

package/dist-esm/string/json.util.js

@@ -1,9 +1,12 @@
+// const possibleJsonStartTokens = ['{', '[', '"']
+const DETECT_JSON = /^\s*[{["\-\d]/;
 /**
  * Attempts to parse object as JSON.
  * Returns original object if JSON parse failed (silently).
  */
 export function _jsonParseIfPossible(obj, reviver) {
-    if (typeof obj === 'string' && obj) {
+    // Optimization: only try to parse if it looks like JSON: starts with a json possible character
+    if (typeof obj === 'string' && obj && DETECT_JSON.test(obj)) {
         try {
             return JSON.parse(obj, reviver);
         }

package/dist-esm/types.js

@@ -1,3 +1,11 @@
+/**
+ * Symbol to indicate END of Sequence.
+ */
+export const END = Symbol('END');
+/**
+ * Symbol to indicate SKIP of item (e.g in AbortableMapper)
+ */
+export const SKIP = Symbol('SKIP');
 export const _passthroughMapper = item => item;
 export const _passUndefinedMapper = () => undefined;
 /**

package/package.json

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

package/src/error/error.util.ts

@@ -7,6 +7,7 @@ import {
   StringifyAnyOptions,
   _jsonParseIfPossible,
   _stringifyAny,
+  Class,
 } from '..'
 
 /**
@@ -17,14 +18,17 @@ import {
  *
  * Alternatively, if you're sure it's Error - you can use `_assertIsError(err)`.
  */
-export function _anyToError(o: any, opt?: StringifyAnyOptions): Error {
-  if (o instanceof Error) {
-    // Already an Error - return as-is
-    return o
-  }
+export function _anyToError<ERROR_TYPE extends Error = Error>(
+  o: any,
+  errorClass: Class<ERROR_TYPE> = Error as any,
+  opt?: StringifyAnyOptions,
+): ERROR_TYPE {
+  if (o instanceof errorClass) return o
 
-  const message = _stringifyAny(o, opt)
-  return new Error(message)
+  // If it's an instance of Error, but ErrorClass is something else (e.g AppError) - it'll be "repacked" into AppError
+
+  const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, opt)
+  return _errorObjectToError(errorObject, errorClass)
 }
 
 /**
@@ -38,7 +42,7 @@ export function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   opt?: StringifyAnyOptions,
 ): ErrorObject<DATA_TYPE> {
   if (o instanceof Error) {
-    return _errorToErrorObject<DATA_TYPE>(o, opt?.includeErrorStack)
+    return _errorToErrorObject<DATA_TYPE>(o, opt?.includeErrorStack ?? true)
   }
 
   o = _jsonParseIfPossible(o)
@@ -70,7 +74,7 @@ export function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
 
 export function _errorToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   e: AppError<DATA_TYPE> | Error,
-  includeErrorStack = false,
+  includeErrorStack = true,
 ): ErrorObject<DATA_TYPE> {
   const obj: ErrorObject<DATA_TYPE> = {
     name: e.name,
@@ -86,20 +90,37 @@ export function _errorToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
 }
 
 export function _errorObjectToAppError<DATA_TYPE>(o: ErrorObject<DATA_TYPE>): AppError<DATA_TYPE> {
-  const err = Object.assign(new AppError(o.message, o.data), {
-    // name: err.name, // cannot be assigned to a readonly property like this
-    // stack: o.stack, // also readonly e.g in Firefox
-  })
+  return _errorObjectToError(o, AppError)
+}
+
+export function _errorObjectToError<DATA_TYPE, ERROR_TYPE extends Error>(
+  o: ErrorObject<DATA_TYPE>,
+  errorClass: Class<ERROR_TYPE> = Error as any,
+): ERROR_TYPE {
+  if (o instanceof errorClass) return o
+
+  const err = new errorClass(o.message)
+  // name: err.name, // cannot be assigned to a readonly property like this
+  // stack: o.stack, // also readonly e.g in Firefox
 
   Object.defineProperty(err, 'name', {
     value: o.name,
     configurable: true,
   })
 
-  Object.defineProperty(err, 'stack', {
-    value: o.stack,
+  Object.defineProperty(err, 'data', {
+    value: o.data,
+    writable: true,
+    configurable: true,
+    enumerable: false,
   })
 
+  if (o.stack) {
+    Object.defineProperty(err, 'stack', {
+      value: o.stack,
+    })
+  }
+
   return err
 }
 
@@ -109,14 +130,18 @@ export function _isHttpErrorResponse(o: any): o is HttpErrorResponse {
 
 export function _isHttpErrorObject(o: any): o is ErrorObject<HttpErrorData> {
   return (
-    typeof o?.name === 'string' &&
-    typeof o?.message === 'string' &&
-    typeof o?.data?.httpStatusCode === 'number'
+    !!o &&
+    typeof o.name === 'string' &&
+    typeof o.message === 'string' &&
+    typeof o.data?.httpStatusCode === 'number'
   )
 }
 
+/**
+ * Note: any instance of AppError is also automatically an ErrorObject
+ */
 export function _isErrorObject(o: any): o is ErrorObject {
   return (
-    typeof o?.name === 'string' && typeof o?.message === 'string' && typeof o?.data === 'object'
+    !!o && typeof o.name === 'string' && typeof o.message === 'string' && typeof o.data === 'object'
   )
 }

package/src/error/try.ts

@@ -24,6 +24,9 @@ export function _try<ERR = unknown, RETURN = void>(
   }
 }
 
+// todo: remove when eslint starts to know about Awaited
+/* eslint-disable no-undef */
+
 /**
  * Like _try, but for Promises.
  *
@@ -32,7 +35,7 @@ export function _try<ERR = unknown, RETURN = void>(
  */
 export async function pTry<ERR = unknown, RETURN = void>(
   promise: Promise<RETURN>,
-): Promise<[err: ERR | null, value: RETURN]> {
+): Promise<[err: ERR | null, value: Awaited<RETURN>]> {
   try {
     return [null, await promise]
   } catch (err) {

package/src/index.ts

@@ -57,15 +57,7 @@ import {
   HttpErrorData,
   HttpErrorResponse,
 } from './error/error.model'
-import {
-  _anyToError,
-  _anyToErrorObject,
-  _errorObjectToAppError,
-  _errorToErrorObject,
-  _isErrorObject,
-  _isHttpErrorObject,
-  _isHttpErrorResponse,
-} from './error/error.util'
+export * from './error/error.util'
 import { ErrorMode } from './error/errorMode'
 import { HttpError } from './error/http.error'
 import { _try, pTry } from './error/try'
@@ -181,7 +173,6 @@ import {
   ConditionalPick,
   Merge,
   Promisable,
-  PromiseValue,
   ReadonlyDeep,
   Simplify,
 } from './typeFest'
@@ -213,6 +204,12 @@ import {
   UnixTimestamp,
   ValueOf,
   ValuesOf,
+  AbortableMapper,
+  AbortableAsyncPredicate,
+  AbortableAsyncMapper,
+  AbortablePredicate,
+  END,
+  SKIP,
   _noop,
   _objectKeys,
   _passNothingPredicate,
@@ -238,8 +235,13 @@ import {
 } from './log/commonLogger'
 import { _safeJsonStringify } from './string/safeJsonStringify'
 import { PQueue, PQueueCfg } from './promise/pQueue'
+export * from './seq/seq'
 
 export type {
+  AbortableMapper,
+  AbortablePredicate,
+  AbortableAsyncPredicate,
+  AbortableAsyncMapper,
   PQueueCfg,
   MemoCache,
   PromiseDecoratorCfg,
@@ -278,7 +280,6 @@ export type {
   Merge,
   ReadonlyDeep,
   Promisable,
-  PromiseValue,
   Simplify,
   ConditionalPick,
   ConditionalExcept,
@@ -326,9 +327,6 @@ export {
   AppError,
   HttpError,
   AssertionError,
-  _isErrorObject,
-  _isHttpErrorObject,
-  _isHttpErrorResponse,
   _assert,
   _assertEquals,
   _assertDeepEquals,
@@ -405,10 +403,6 @@ export {
   _shuffle,
   _mapToObject,
   _findKeyByValue,
-  _anyToError,
-  _anyToErrorObject,
-  _errorToErrorObject,
-  _errorObjectToAppError,
   _range,
   _uniq,
   _uniqBy,
@@ -480,4 +474,6 @@ export {
   commonLoggerCreate,
   _safeJsonStringify,
   PQueue,
+  END,
+  SKIP,
 }

package/src/promise/pBatch.ts

@@ -1,5 +1,4 @@
-import { BatchResult, ErrorMode } from '..'
-import { AsyncMapper } from '../types'
+import { AbortableAsyncMapper, BatchResult, ErrorMode } from '..'
 import { AggregatedError } from './AggregatedError'
 import { pMap } from './pMap'
 
@@ -8,7 +7,7 @@ import { pMap } from './pMap'
  */
 export async function pBatch<IN, OUT>(
   iterable: Iterable<IN | PromiseLike<IN>>,
-  mapper: AsyncMapper<IN, OUT>,
+  mapper: AbortableAsyncMapper<IN, OUT>,
   opt?: { concurrency?: number },
 ): Promise<BatchResult<OUT>> {
   try {

package/src/promise/pFilter.ts

@@ -1,9 +1,9 @@
-import { AsyncPredicate } from '../types'
+import { AbortableAsyncPredicate } from '../types'
 import { pMap, PMapOptions } from './pMap'
 
 export async function pFilter<T>(
   iterable: Iterable<T | PromiseLike<T>>,
-  filterFn: AsyncPredicate<T>,
+  filterFn: AbortableAsyncPredicate<T>,
   opt?: PMapOptions,
 ): Promise<T[]> {
   const values = await pMap(