@naturalcycles/js-lib 14.70.2 → 14.74.0

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

@@ -1,7 +1,7 @@
-import { _by, _chunk, _countBy, _difference, _dropRightWhile, _dropWhile, _findLast, _flatten, _flattenDeep, _groupBy, _intersection, _last, _mapToObject, _shuffle, _sortBy, _sum, _sumBy, _takeRightWhile, _takeWhile, _uniq, _uniqBy, } from './array/array.util';
-import { _defineLazyProperty, _defineLazyProps, _lazyValue } from './lazy';
-import { _parseQueryString } from './string/url.util';
-import { _range } from './array/range';
+export * from './array/array.util';
+export * from './lazy';
+export * from './string/url.util';
+export * from './array/range';
 import { _createPromiseDecorator, } from './decorators/createPromiseDecorator';
 import { _debounce, _throttle } from './decorators/debounce';
 import { _Debounce, _Throttle } from './decorators/debounce.decorator';
@@ -22,35 +22,37 @@ import { generateJsonSchemaFromData } from './json-schema/from-data/generateJson
 import { JSON_SCHEMA_ORDER } from './json-schema/jsonSchema.cnst';
 import { mergeJsonSchemaObjects } from './json-schema/jsonSchema.util';
 import { jsonSchema, JsonSchemaAnyBuilder, } from './json-schema/jsonSchemaBuilder';
-import { _average, _averageWeighted, _median, _percentile } from './math/math.util';
-import { SimpleMovingAverage } from './math/sma';
-import { _createDeterministicRandom } from './number/createDeterministicRandom';
-import { _clamp, _inRange, _randomInt, _randomArrayItem, _round, _sortNumbers, _toFixed, _toPrecision, } from './number/number.util';
-import { _deepEquals } from './object/deepEquals';
-import { _deepCopy, _deepTrim, _filterEmptyArrays, _filterEmptyValues, _filterFalsyValues, _filterNullishValues, _filterObject, _filterUndefinedValues, _findKeyByValue, _get, _has, _invert, _invertMap, _isEmpty, _isEmptyObject, _isObject, _isPrimitive, _mapKeys, _mapObject, _mapValues, _mask, _merge, _objectNullValuesToUndefined, _omit, _pick, _set, _undefinedIfEmpty, _unset, } from './object/object.util';
-import { _sortObject } from './object/sortObject';
-import { _sortObjectDeep } from './object/sortObjectDeep';
+export * from './math/math.util';
+export * from './math/sma';
+export * from './number/createDeterministicRandom';
+export * from './number/number.util';
+export * from './object/deepEquals';
+export * from './object/object.util';
+export * from './object/sortObject';
+export * from './object/sortObjectDeep';
 import { AggregatedError } from './promise/AggregatedError';
-import { pBatch } from './promise/pBatch';
+export * from './promise/pBatch';
 import { pDefer } from './promise/pDefer';
-import { pDelay } from './promise/pDelay';
-import { pFilter } from './promise/pFilter';
-import { pHang } from './promise/pHang';
+export * from './promise/pDelay';
+export * from './promise/pFilter';
+export * from './promise/pHang';
 import { pMap } from './promise/pMap';
-import { pProps } from './promise/pProps';
+export * from './promise/pProps';
 import { pRetry } from './promise/pRetry';
-import { pState } from './promise/pState';
+export * from './promise/pState';
 import { pTimeout } from './promise/pTimeout';
-import { pTuple } from './promise/pTuple';
-import { _camelCase, _kebabCase, _snakeCase } from './string/case';
-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';
+export * from './promise/pTuple';
+export * from './string/case';
+export * from './string/json.util';
+export * 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 * from './math/stack.util';
+export { is, _Memo, _memoFn, _LogMethod, _getArgsSignature, _createPromiseDecorator, AppError, HttpError, AssertionError, _assert, _assertEquals, _assertDeepEquals, _assertIsError, _assertIsString, _assertIsNumber, _assertTypeOf, _stringMapValues, _stringMapEntries, _objectKeys, _debounce, _throttle, _Debounce, _Throttle, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pTimeout, _Retry, _Timeout, _tryCatch, _TryCatch, _try, pTry, _stringifyAny, _ms, _since, _hb, _gb, _mb, _kb, mergeJsonSchemaObjects, jsonSchema, JsonSchemaAnyBuilder, JSON_SCHEMA_ORDER, generateJsonSchemaFromData, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, _safeJsonStringify, PQueue, END, SKIP, };

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

@@ -39,6 +39,22 @@ export function _percentile(values, pc) {
     const ceilPos = Math.ceil(pos);
     return _averageWeighted([sorted[floorPos], sorted[ceilPos]], [1 - dec, dec]);
 }
+/**
+ * A tiny bit more efficient function than calling _percentile individually.
+ */
+export function _percentiles(values, pcs) {
+    const r = {};
+    const sorted = _sortNumbers(values);
+    pcs.forEach(pc => {
+        // Floating pos in the range of [0; length - 1]
+        const pos = ((values.length - 1) * pc) / 100;
+        const dec = pos % 1;
+        const floorPos = Math.floor(pos);
+        const ceilPos = Math.ceil(pos);
+        r[pc] = _averageWeighted([sorted[floorPos], sorted[ceilPos]], [1 - dec, dec]);
+    });
+    return r;
+}
 /**
  * @example
  *

package/dist-esm/math/stack.util.js

@@ -0,0 +1,82 @@
+import { _average, _percentile, _percentiles, _range } from '../index';
+/**
+ * Implements a "round-robin" Stack ("first-in last-out" aka FILO) with a limited size.
+ * Like an array of a fixed size. When it runs out of space - it starts writing on top of itself
+ * from index 0.
+ *
+ *
+ */
+export class Stack {
+    constructor(size) {
+        this.size = size;
+        /**
+         * Index of a slot to get written TO next.
+         * Currently this slot contains OLDEST item (if any).
+         */
+        this.nextIndex = 0;
+        this.items = [];
+    }
+    push(item) {
+        this.items[this.nextIndex] = item;
+        this.nextIndex = this.nextIndex === this.size - 1 ? 0 : this.nextIndex + 1;
+        return this;
+    }
+    /**
+     * Fill (overwrite) the whole Stack (all its items) with the passed `item`.
+     */
+    fill(item) {
+        _range(this.size).forEach(i => (this.items[i] = item));
+        return this;
+    }
+    /**
+     * Returns last items in the right order.
+     * Unlike raw `items` property that returns "items buffer" as-is (not ordered properly).
+     */
+    get itemsOrdered() {
+        if (this.items.length < this.size) {
+            // Buffer is not filled yet, just return it as-is
+            return this.items;
+        }
+        // Buffer was filled and started to "overwrite itself", will need to return 2 slices
+        return [...this.items.slice(this.nextIndex), ...this.items.slice(0, this.nextIndex)];
+    }
+}
+/**
+ * Fixed-size FILO stack of Numbers.
+ * Has convenience stat methods, e.g percentile, avg, etc.
+ */
+export class NumberStack extends Stack {
+    avg() {
+        // _assert(this.items.length, 'NumberStack.avg cannot be called on empty stack')
+        return _average(this.items);
+    }
+    /**
+     * Returns null if Stack is empty.
+     */
+    avgOrNull() {
+        return this.items.length === 0 ? null : _average(this.items);
+    }
+    median() {
+        return _percentile(this.items, 50);
+    }
+    medianOrNull() {
+        return this.items.length === 0 ? null : _percentile(this.items, 50);
+    }
+    /**
+     * `pc` is a number from 0 to 100 inclusive.
+     */
+    percentile(pc) {
+        // _assert(this.items.length, 'NumberStack.percentile cannot be called on empty stack')
+        return _percentile(this.items, pc);
+    }
+    /**
+     * `pc` is a number from 0 to 100 inclusive.
+     * Returns null if Stack is empty.
+     */
+    percentileOrNull(pc) {
+        return this.items.length === 0 ? null : _percentile(this.items, pc);
+    }
+    percentiles(pcs) {
+        return _percentiles(this.items, pcs);
+    }
+}

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

@@ -58,7 +58,7 @@ export function _toFixed(n, fractionDigits) {
  * _toPrecision(1634.56, 1)
  * // 2000
  *
- * _toPrecision(1234.56, 2)
+ * _toPrecision(1634.56, 2)
  * // 1600
  */
 export function _toPrecision(n, precision) {

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