@naturalcycles/js-lib 14.70.2 → 14.71.0

package/dist/error/try.d.ts

@@ -21,4 +21,4 @@ export declare function _try<ERR = unknown, RETURN = void>(fn: () => RETURN): [e
  * Also, intentionally types second return item as non-optional,
  * but you should check for `err` presense first!
  */
-export declare function pTry<ERR = unknown, RETURN = void>(promise: Promise<RETURN>): Promise<[err: ERR | null, value: RETURN]>;
+export declare function pTry<ERR = unknown, RETURN = void>(promise: Promise<RETURN>): Promise<[err: ERR | null, value: Awaited<RETURN>]>;

package/dist/error/try.js

@@ -26,6 +26,8 @@ function _try(fn) {
     }
 }
 exports._try = _try;
+// todo: remove when eslint starts to know about Awaited
+/* eslint-disable no-undef */
 /**
  * Like _try, but for Promises.
  *

package/dist/index.d.ts

@@ -50,12 +50,13 @@ 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 { JsonStringifyFunction, StringifyAnyOptions, _stringifyAny } from './string/stringifyAny';
 import { _ms, _since } from './time/time.util';
-import { Class, ConditionalExcept, ConditionalPick, Merge, Promisable, PromiseValue, ReadonlyDeep, Simplify } from './typeFest';
-import { AsyncMapper, AsyncPredicate, BaseDBEntity, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, Saved, Unsaved, BatchResult, InstanceId, IsoDate, IsoDateTime, KeyValueTuple, Mapper, ObjectMapper, ObjectPredicate, Predicate, PromiseMap, AnyObject, AnyFunction, Reviver, SavedDBEntity, StringMap, UnixTimestamp, ValueOf, ValuesOf, _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues } from './types';
+import { Class, ConditionalExcept, ConditionalPick, Merge, Promisable, ReadonlyDeep, Simplify } from './typeFest';
+import { AsyncMapper, AsyncPredicate, BaseDBEntity, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, Saved, Unsaved, BatchResult, InstanceId, IsoDate, IsoDateTime, KeyValueTuple, Mapper, ObjectMapper, ObjectPredicate, Predicate, PromiseMap, AnyObject, AnyFunction, Reviver, SavedDBEntity, StringMap, UnixTimestamp, ValueOf, ValuesOf, AbortableMapper, AbortableAsyncPredicate, AbortableAsyncMapper, AbortablePredicate, 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 { CommonLogLevel, CommonLogFunction, CommonLogger, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, CommonLogWithLevelFunction, commonLoggerCreate } from './log/commonLogger';
 import { _safeJsonStringify } from './string/safeJsonStringify';
 import { PQueue, PQueueCfg } from './promise/pQueue';
-export type { PQueueCfg, MemoCache, PromiseDecoratorCfg, PromiseDecoratorResp, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Admin401ErrorData, Admin403ErrorData, StringMap, PromiseMap, AnyObject, AnyFunction, ValuesOf, ValueOf, KeyValueTuple, ObjectMapper, ObjectPredicate, InstanceId, IsoDate, IsoDateTime, Reviver, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, PromiseValue, Simplify, ConditionalPick, ConditionalExcept, Class, UnixTimestamp, BaseDBEntity, SavedDBEntity, Saved, Unsaved, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, JsonSchema, JsonSchemaAny, JsonSchemaOneOf, JsonSchemaAllOf, JsonSchemaAnyOf, JsonSchemaNot, JsonSchemaRef, JsonSchemaConst, JsonSchemaEnum, JsonSchemaString, JsonSchemaNumber, JsonSchemaBoolean, JsonSchemaNull, JsonSchemaRootObject, JsonSchemaObject, JsonSchemaArray, JsonSchemaTuple, JsonSchemaBuilder, CommonLogLevel, CommonLogWithLevelFunction, CommonLogFunction, CommonLogger, };
-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, };
+export * from './seq/seq';
+export type { AbortableMapper, AbortablePredicate, AbortableAsyncPredicate, AbortableAsyncMapper, PQueueCfg, MemoCache, PromiseDecoratorCfg, PromiseDecoratorResp, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Admin401ErrorData, Admin403ErrorData, StringMap, PromiseMap, AnyObject, AnyFunction, ValuesOf, ValueOf, KeyValueTuple, ObjectMapper, ObjectPredicate, InstanceId, IsoDate, IsoDateTime, Reviver, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, Simplify, ConditionalPick, ConditionalExcept, Class, UnixTimestamp, BaseDBEntity, SavedDBEntity, Saved, Unsaved, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, JsonSchema, JsonSchemaAny, JsonSchemaOneOf, JsonSchemaAllOf, JsonSchemaAnyOf, JsonSchemaNot, JsonSchemaRef, JsonSchemaConst, JsonSchemaEnum, JsonSchemaString, JsonSchemaNumber, JsonSchemaBoolean, JsonSchemaNull, JsonSchemaRootObject, JsonSchemaObject, JsonSchemaArray, JsonSchemaTuple, JsonSchemaBuilder, CommonLogLevel, CommonLogWithLevelFunction, CommonLogFunction, CommonLogger, };
+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/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._mapValues = exports._mapKeys = exports._isPrimitive = exports._isObject = exports._undefinedIfEmpty = exports._filterObject = exports._filterEmptyValues = exports._filterEmptyArrays = exports._filterNullishValues = exports._filterUndefinedValues = exports._filterFalsyValues = exports._omit = exports._pick = exports._truncateMiddle = exports._truncate = exports._nl2br = exports._replaceAll = exports._substringBetweenLast = exports._substringAfterLast = exports._substringAfter = exports._substringBeforeLast = exports._substringBefore = exports._removeWhitespace = exports._split = exports._lowerFirst = exports._upperFirst = exports._capitalize = exports._objectKeys = exports._stringMapEntries = exports._stringMapValues = exports._inRange = exports._createDeterministicRandom = exports._randomArrayItem = exports._randomInt = exports._assertTypeOf = exports._assertIsNumber = exports._assertIsString = exports._assertIsError = exports._assertDeepEquals = exports._assertEquals = exports._assert = exports.AssertionError = exports.HttpError = exports.AppError = exports._createPromiseDecorator = exports._getArgsSignature = exports._LogMethod = exports._memoFn = exports._Memo = exports.is = void 0;
 exports._Throttle = exports._Debounce = exports._throttle = exports._debounce = exports._median = exports._percentile = exports._averageWeighted = exports._average = exports.SimpleMovingAverage = exports._chunk = exports._flattenDeep = exports._flatten = exports._uniqBy = exports._uniq = exports._range = exports._findKeyByValue = exports._mapToObject = exports._shuffle = exports._difference = exports._intersection = exports._countBy = exports._dropRightWhile = exports._dropWhile = exports._takeRightWhile = exports._takeWhile = exports._findLast = exports._round = exports._toPrecision = exports._toFixed = exports._sortNumbers = exports._sortBy = exports._groupBy = exports._by = exports._invertMap = exports._invert = exports._mask = exports._unset = exports._has = exports._set = exports._get = exports._sortObject = exports._sortObjectDeep = exports._deepTrim = exports._merge = exports._isEmpty = exports._isEmptyObject = exports._deepCopy = exports._deepEquals = exports._objectNullValuesToUndefined = exports._mapObject = void 0;
 exports.commonLoggerNoop = exports.commonLoggerMinLevel = exports._lazyValue = exports._defineLazyProps = exports._defineLazyProperty = exports._parseQueryString = exports.generateJsonSchemaFromData = exports.JSON_SCHEMA_ORDER = exports.JsonSchemaAnyBuilder = exports.jsonSchema = exports.mergeJsonSchemaObjects = exports._last = exports._clamp = exports._sumBy = exports._sum = exports._kebabCase = exports._camelCase = exports._snakeCase = exports._kb = exports._mb = exports._gb = exports._hb = exports._since = exports._ms = exports._stringifyAny = exports._jsonParseIfPossible = exports.pTry = exports._try = exports._TryCatch = exports._tryCatch = exports._Timeout = exports._Retry = exports.pTuple = exports.pTimeout = exports.pRetry = exports.AggregatedError = exports.pState = exports.pHang = exports.pDefer = exports.pDelay = exports.pProps = exports.pFilter = exports.ErrorMode = exports.pBatch = exports._noop = exports._passNothingPredicate = exports._passthroughPredicate = exports._passUndefinedMapper = exports._passthroughMapper = exports.pMap = void 0;
-exports.PQueue = exports._safeJsonStringify = exports.commonLoggerCreate = exports.commonLoggerPrefix = exports.commonLoggerPipe = exports.commonLogLevelNumber = void 0;
+exports.SKIP = exports.END = exports.PQueue = exports._safeJsonStringify = exports.commonLoggerCreate = exports.commonLoggerPrefix = exports.commonLoggerPipe = exports.commonLogLevelNumber = void 0;
 const tslib_1 = require("tslib");
 const array_util_1 = require("./array/array.util");
 Object.defineProperty(exports, "_by", { enumerable: true, get: function () { return array_util_1._by; } });
@@ -190,6 +190,8 @@ const time_util_1 = require("./time/time.util");
 Object.defineProperty(exports, "_ms", { enumerable: true, get: function () { return time_util_1._ms; } });
 Object.defineProperty(exports, "_since", { enumerable: true, get: function () { return time_util_1._since; } });
 const types_1 = require("./types");
+Object.defineProperty(exports, "END", { enumerable: true, get: function () { return types_1.END; } });
+Object.defineProperty(exports, "SKIP", { enumerable: true, get: function () { return types_1.SKIP; } });
 Object.defineProperty(exports, "_noop", { enumerable: true, get: function () { return types_1._noop; } });
 Object.defineProperty(exports, "_objectKeys", { enumerable: true, get: function () { return types_1._objectKeys; } });
 Object.defineProperty(exports, "_passNothingPredicate", { enumerable: true, get: function () { return types_1._passNothingPredicate; } });
@@ -216,3 +218,4 @@ const safeJsonStringify_1 = require("./string/safeJsonStringify");
 Object.defineProperty(exports, "_safeJsonStringify", { enumerable: true, get: function () { return safeJsonStringify_1._safeJsonStringify; } });
 const pQueue_1 = require("./promise/pQueue");
 Object.defineProperty(exports, "PQueue", { enumerable: true, get: function () { return pQueue_1.PQueue; } });
+(0, tslib_1.__exportStar)(require("./seq/seq"), exports);

package/dist/promise/pBatch.d.ts

@@ -1,8 +1,7 @@
-import { BatchResult } from '..';
-import { AsyncMapper } from '../types';
+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: AsyncMapper<IN, OUT>, opt?: {
+export declare function pBatch<IN, OUT>(iterable: Iterable<IN | PromiseLike<IN>>, mapper: AbortableAsyncMapper<IN, OUT>, opt?: {
     concurrency?: number;
 }): Promise<BatchResult<OUT>>;

package/dist/promise/pFilter.d.ts

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

package/dist/promise/pMap.d.ts

@@ -1,5 +1,4 @@
-import { ErrorMode } from '..';
-import { AsyncMapper } from '../types';
+import { AbortableAsyncMapper, ErrorMode } from '..';
 export interface PMapOptions {
     /**
      * Number of concurrently pending promises returned by `mapper`.
@@ -42,4 +41,4 @@ export interface PMapOptions {
  * 	//=> ['http://ava.li/', 'http://todomvc.com/']
  * })();
  */
-export declare function pMap<IN, OUT>(iterable: Iterable<IN | PromiseLike<IN>>, mapper: AsyncMapper<IN, OUT>, opt?: PMapOptions): Promise<OUT[]>;
+export declare function pMap<IN, OUT>(iterable: Iterable<IN | PromiseLike<IN>>, mapper: AbortableAsyncMapper<IN, OUT>, opt?: PMapOptions): Promise<OUT[]>;

package/dist/promise/pMap.js

@@ -43,25 +43,27 @@ 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 !== __1.SKIP);
                     if (errors.length && errorMode === __1.ErrorMode.THROW_AGGREGATED) {
-                        reject(new AggregatedError_1.AggregatedError(errors, ret));
+                        reject(new AggregatedError_1.AggregatedError(errors, r));
                     }
                     else {
-                        resolve(ret);
+                        resolve(r);
                     }
                 }
                 return;
@@ -70,12 +72,16 @@ async function pMap(iterable, mapper, opt = {}) {
             Promise.resolve(nextItem.value)
                 .then(async (element) => await mapper(element, i))
                 .then(value => {
+                if (value === __1.END) {
+                    isSettled = true;
+                    return resolve(ret.filter(r => r !== __1.SKIP));
+                }
                 ret[i] = value;
                 resolvingCount--;
                 next();
             }, err => {
                 if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY) {
-                    isRejected = true;
+                    isSettled = true;
                     reject(err);
                 }
                 else {

package/dist/promise/pProps.d.ts

@@ -5,4 +5,6 @@ import { PMapOptions } from './pMap';
  */
 export declare function pProps<T>(input: {
     [K in keyof T]: T[K] | Promise<T[K]>;
-}, opt?: PMapOptions): Promise<T>;
+}, opt?: PMapOptions): Promise<{
+    [K in keyof T]: Awaited<T[K]>;
+}>;

package/dist/promise/pProps.js

@@ -11,17 +11,16 @@ Improvements:
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pProps = void 0;
 const pMap_1 = require("./pMap");
+// todo: remove when eslint starts to know about Awaited
+/* eslint-disable no-undef */
 /**
  * Promise.all for Object instead of Array.
  * Supports concurrency.
  */
 async function pProps(input, opt) {
-    const keys = Object.keys(input);
-    const values = await (0, pMap_1.pMap)(Object.values(input), r => r, opt);
     const r = {};
-    values.forEach((v, i) => {
-        r[keys[i]] = v;
-    });
+    const keys = Object.keys(input);
+    await (0, pMap_1.pMap)(Object.values(input), (v, i) => (r[keys[i]] = v), opt);
     return r;
 }
 exports.pProps = pProps;

package/dist/seq/seq.d.ts

@@ -0,0 +1,30 @@
+import { AbortableMapper, AbortablePredicate, END } 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 declare class Seq<T> implements Iterable<T> {
+    private nextFn;
+    private constructor();
+    [Symbol.iterator](): Iterator<T>;
+    static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T>;
+    static range(minIncl: number, maxExcl: number, step?: number): Seq<number>;
+    static from<T>(a: Iterable<T>): Seq<T>;
+    static empty<T = any>(): Seq<T>;
+    private currentValue;
+    private sentInitialValue;
+    private i;
+    next(): T | typeof END;
+    find(predicate: AbortablePredicate<T>): T | undefined;
+    some(predicate: AbortablePredicate<T>): boolean;
+    every(predicate: AbortablePredicate<T>): boolean;
+    toArray(): T[];
+}
+/**
+ * Convenience function to create a Sequence.
+ */
+export declare function _seq<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T>;

package/dist/seq/seq.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._seq = exports.Seq = void 0;
+const types_1 = require("../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
+ */
+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 === types_1.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 : types_1.END));
+    }
+    static from(a) {
+        const it = a[Symbol.iterator]();
+        const v = it.next();
+        if (v.done)
+            return new Seq(types_1.END, () => { });
+        return new Seq(v.value, () => {
+            const v = it.next();
+            if (v.done)
+                return types_1.END;
+            return v.value;
+        });
+    }
+    static empty() {
+        return new Seq(types_1.END, () => { });
+    }
+    next() {
+        if (this.currentValue === types_1.END)
+            return types_1.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 === types_1.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 === types_1.END)
+                return; // not found, end of sequence
+            const r = predicate(v, this.i);
+            if (r === types_1.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 === types_1.END)
+                return false;
+            const r = predicate(v, this.i);
+            if (r === types_1.END)
+                return false;
+            if (r)
+                return true;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    every(predicate) {
+        do {
+            const v = this.next();
+            if (v === types_1.END)
+                return true;
+            const r = predicate(v, this.i);
+            if (r === types_1.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 === types_1.END)
+                return a;
+            a.push(v);
+        }
+    }
+}
+exports.Seq = Seq;
+/**
+ * Convenience function to create a Sequence.
+ */
+function _seq(initialValue, nextFn) {
+    return Seq.create(initialValue, nextFn);
+}
+exports._seq = _seq;

package/dist/typeFest.d.ts

@@ -130,36 +130,6 @@ export declare type Merge<FirstType, SecondType> = Simplify<Merge_<FirstType, Se
  ```
  */
 export declare type Promisable<T> = T | PromiseLike<T>;
-/**
- Returns the type that is wrapped inside a `Promise` type.
- If the type is a nested Promise, it is unwrapped recursively until a non-Promise type is obtained.
- If the type is not a `Promise`, the type itself is returned.
-
- @example
- ```
- import {PromiseValue} from 'type-fest';
-
- type AsyncData = Promise<string>;
- let asyncData: PromiseValue<AsyncData> = Promise.resolve('ABC');
-
- type Data = PromiseValue<AsyncData>;
- let data: Data = await asyncData;
-
- // Here's an example that shows how this type reacts to non-Promise types.
- type SyncData = PromiseValue<string>;
- let syncData: SyncData = getSyncData();
-
- // Here's an example that shows how this type reacts to recursive Promise types.
- type RecursiveAsyncData = Promise<Promise<string> >;
- let recursiveAsyncData: PromiseValue<RecursiveAsyncData> = Promise.resolve(Promise.resolve('ABC'));
- ```
-
- @category Utilities
- */
-export declare type PromiseValue<PromiseType, Otherwise = PromiseType> = PromiseType extends Promise<infer Value> ? {
-    0: PromiseValue<Value>;
-    1: Value;
-}[PromiseType extends Promise<unknown> ? 0 : 1] : Otherwise;
 /**
  Extract the keys from a type where the value type of the key extends the given `Condition`.
  Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { Merge } from './typeFest';
+import { Merge, Promisable } from './typeFest';
 /**
  * Map from String to String (or <T>).
  *
@@ -37,6 +37,14 @@ export interface AnyObjectWithId extends AnyObject, ObjectWithId {
  * Because `Function` type is discouraged by eslint.
  */
 export declare type AnyFunction = (...args: any[]) => any;
+/**
+ * Symbol to indicate END of Sequence.
+ */
+export declare const END: unique symbol;
+/**
+ * Symbol to indicate SKIP of item (e.g in AbortableMapper)
+ */
+export declare const SKIP: unique symbol;
 /**
  * Function which is called for every item in `input`. Expected to return a `Promise` or value.
  */
@@ -50,6 +58,10 @@ export declare const _passUndefinedMapper: Mapper<any, void>;
 export declare const _noop: (..._args: any[]) => undefined;
 export declare type Predicate<T> = (item: T, index: number) => boolean;
 export declare type AsyncPredicate<T> = (item: T, index: number) => boolean | PromiseLike<boolean>;
+export declare type AbortablePredicate<T> = (item: T, i: number) => boolean | typeof END;
+export declare type AbortableAsyncPredicate<T> = (item: T, i: number) => Promisable<boolean | typeof END>;
+export declare type AbortableMapper<IN = any, OUT = any> = (input: IN, i: number) => OUT | typeof SKIP | typeof END;
+export declare type AbortableAsyncMapper<IN = any, OUT = any> = (input: IN, i: number) => Promisable<OUT | typeof SKIP | typeof END>;
 export declare const _passthroughPredicate: Predicate<any>;
 export declare const _passNothingPredicate: Predicate<any>;
 export interface BatchResult<RES = any, ERR = Error> {

package/dist/types.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._objectKeys = exports._stringMapEntries = exports._stringMapValues = exports._passNothingPredicate = exports._passthroughPredicate = exports._noop = exports._passUndefinedMapper = exports._passthroughMapper = void 0;
+exports._objectKeys = exports._stringMapEntries = exports._stringMapValues = exports._passNothingPredicate = exports._passthroughPredicate = exports._noop = exports._passUndefinedMapper = exports._passthroughMapper = exports.SKIP = exports.END = void 0;
+/**
+ * Symbol to indicate END of Sequence.
+ */
+exports.END = Symbol('END');
+/**
+ * Symbol to indicate SKIP of item (e.g in AbortableMapper)
+ */
+exports.SKIP = Symbol('SKIP');
 const _passthroughMapper = item => item;
 exports._passthroughMapper = _passthroughMapper;
 const _passUndefinedMapper = () => undefined;

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

@@ -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, _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, };
+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/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.70.2",
+  "version": "14.71.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

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

@@ -173,7 +173,6 @@ import {
   ConditionalPick,
   Merge,
   Promisable,
-  PromiseValue,
   ReadonlyDeep,
   Simplify,
 } from './typeFest'
@@ -205,6 +204,12 @@ import {
   UnixTimestamp,
   ValueOf,
   ValuesOf,
+  AbortableMapper,
+  AbortableAsyncPredicate,
+  AbortableAsyncMapper,
+  AbortablePredicate,
+  END,
+  SKIP,
   _noop,
   _objectKeys,
   _passNothingPredicate,
@@ -230,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,
@@ -270,7 +280,6 @@ export type {
   Merge,
   ReadonlyDeep,
   Promisable,
-  PromiseValue,
   Simplify,
   ConditionalPick,
   ConditionalExcept,
@@ -465,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(

package/src/promise/pMap.ts

@@ -7,8 +7,7 @@ Improvements:
 - Compatible with pProps (that had typings issues)
  */
 
-import { ErrorMode } from '..'
-import { AsyncMapper } from '../types'
+import { AbortableAsyncMapper, END, ErrorMode, SKIP } from '..'
 import { AggregatedError } from './AggregatedError'
 
 export interface PMapOptions {
@@ -57,37 +56,38 @@ export interface PMapOptions {
  */
 export async function pMap<IN, OUT>(
   iterable: Iterable<IN | PromiseLike<IN>>,
-  mapper: AsyncMapper<IN, OUT>,
+  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[] = []
+    const ret: (OUT | typeof SKIP)[] = []
     const iterator = iterable[Symbol.iterator]()
     const errors: Error[] = []
-    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) as OUT[]
           if (errors.length && errorMode === ErrorMode.THROW_AGGREGATED) {
-            reject(new AggregatedError(errors, ret))
+            reject(new AggregatedError(errors, r))
           } else {
-            resolve(ret)
+            resolve(r)
           }
         }
 
@@ -100,13 +100,18 @@ export async function pMap<IN, OUT>(
         .then(async element => await mapper(element, i))
         .then(
           value => {
+            if (value === END) {
+              isSettled = true
+              return resolve(ret.filter(r => r !== SKIP) as OUT[])
+            }
+
             ret[i] = value
             resolvingCount--
             next()
           },
           err => {
             if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
-              isRejected = true
+              isSettled = true
               reject(err)
             } else {
               errors.push(err)

package/src/promise/pProps.ts

@@ -10,6 +10,9 @@ Improvements:
 
 import { pMap, PMapOptions } from './pMap'
 
+// todo: remove when eslint starts to know about Awaited
+/* eslint-disable no-undef */
+
 /**
  * Promise.all for Object instead of Array.
  * Supports concurrency.
@@ -17,13 +20,9 @@ import { pMap, PMapOptions } from './pMap'
 export async function pProps<T>(
   input: { [K in keyof T]: T[K] | Promise<T[K]> },
   opt?: PMapOptions,
-): Promise<T> {
+): Promise<{ [K in keyof T]: Awaited<T[K]> }> {
+  const r = {} as { [K in keyof T]: Awaited<T[K]> }
   const keys = Object.keys(input) as (keyof T)[]
-  const values = await pMap(Object.values(input), r => r, opt)
-
-  const r = {} as T
-  values.forEach((v, i) => {
-    r[keys[i]!] = v
-  })
+  await pMap(Object.values(input), (v, i) => (r[keys[i]!] = v), opt)
   return r
 }

package/src/seq/seq.ts

@@ -0,0 +1,143 @@
+import { AbortableMapper, AbortablePredicate, 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<T> implements Iterable<T> {
+  private constructor(initialValue: T | typeof END, private nextFn: AbortableMapper<T, T>) {
+    this.currentValue = initialValue
+  }
+
+  [Symbol.iterator](): Iterator<T> {
+    return {
+      next: () => {
+        const value = this.next()
+        return value === END ? { done: true, value: undefined } : { value }
+      },
+    }
+  }
+
+  static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T> {
+    return new Seq(initialValue, nextFn)
+  }
+
+  static range(minIncl: number, maxExcl: number, step = 1): Seq<number> {
+    const max = maxExcl - step
+    return new Seq(minIncl, n => (n < max ? n + step : END))
+  }
+
+  static from<T>(a: Iterable<T>): Seq<T> {
+    const it = a[Symbol.iterator]()
+    const v = it.next()
+    if (v.done) return new Seq<any>(END, () => {})
+
+    return new Seq(v.value, () => {
+      const v = it.next()
+      if (v.done) return END
+      return v.value
+    })
+  }
+
+  static empty<T = any>(): Seq<T> {
+    return new Seq(END as any, () => {})
+  }
+
+  private currentValue: T | typeof END
+  private sentInitialValue = false
+  private i = -1
+
+  next(): T | typeof END {
+    if (this.currentValue === END) return END
+
+    this.i++
+
+    let v: T | typeof SKIP | typeof END
+
+    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: AbortablePredicate<T>): T | undefined {
+    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: AbortablePredicate<T>): boolean {
+    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: AbortablePredicate<T>): boolean {
+    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(): T[] {
+    const a: T[] = []
+
+    // 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<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T> {
+  return Seq.create(initialValue, nextFn)
+}

package/src/typeFest.ts

@@ -151,38 +151,6 @@ export type Merge<FirstType, SecondType> = Simplify<Merge_<FirstType, SecondType
  */
 export type Promisable<T> = T | PromiseLike<T>
 
-/**
- Returns the type that is wrapped inside a `Promise` type.
- If the type is a nested Promise, it is unwrapped recursively until a non-Promise type is obtained.
- If the type is not a `Promise`, the type itself is returned.
-
- @example
- ```
- import {PromiseValue} from 'type-fest';
-
- type AsyncData = Promise<string>;
- let asyncData: PromiseValue<AsyncData> = Promise.resolve('ABC');
-
- type Data = PromiseValue<AsyncData>;
- let data: Data = await asyncData;
-
- // Here's an example that shows how this type reacts to non-Promise types.
- type SyncData = PromiseValue<string>;
- let syncData: SyncData = getSyncData();
-
- // Here's an example that shows how this type reacts to recursive Promise types.
- type RecursiveAsyncData = Promise<Promise<string> >;
- let recursiveAsyncData: PromiseValue<RecursiveAsyncData> = Promise.resolve(Promise.resolve('ABC'));
- ```
-
- @category Utilities
- */
-export type PromiseValue<PromiseType, Otherwise = PromiseType> = PromiseType extends Promise<
-  infer Value
->
-  ? { 0: PromiseValue<Value>; 1: Value }[PromiseType extends Promise<unknown> ? 0 : 1]
-  : Otherwise
-
 /**
  Extract the keys from a type where the value type of the key extends the given `Condition`.
  Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.

package/src/types.ts

@@ -1,4 +1,4 @@
-import { Merge } from './typeFest'
+import { Merge, Promisable } from './typeFest'
 
 /**
  * Map from String to String (or <T>).
@@ -45,6 +45,16 @@ export interface AnyObjectWithId extends AnyObject, ObjectWithId {}
  */
 export type AnyFunction = (...args: any[]) => any
 
+/**
+ * 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')
+
 /**
  * Function which is called for every item in `input`. Expected to return a `Promise` or value.
  */
@@ -62,6 +72,17 @@ export const _noop = (..._args: any[]): undefined => undefined
 export type Predicate<T> = (item: T, index: number) => boolean
 export type AsyncPredicate<T> = (item: T, index: number) => boolean | PromiseLike<boolean>
 
+export type AbortablePredicate<T> = (item: T, i: number) => boolean | typeof END
+export type AbortableAsyncPredicate<T> = (item: T, i: number) => Promisable<boolean | typeof END>
+export type AbortableMapper<IN = any, OUT = any> = (
+  input: IN,
+  i: number,
+) => OUT | typeof SKIP | typeof END
+export type AbortableAsyncMapper<IN = any, OUT = any> = (
+  input: IN,
+  i: number,
+) => Promisable<OUT | typeof SKIP | typeof END>
+
 export const _passthroughPredicate: Predicate<any> = () => true
 export const _passNothingPredicate: Predicate<any> = () => false