@naturalcycles/js-lib 14.71.0 → 14.75.0

package/dist/seq/seq.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._seq = exports.Seq = void 0;
+exports.AsyncSequence = exports._seq = exports.Sequence = void 0;
 const types_1 = require("../types");
 /**
  * Inspired by Kotlin Sequences.
@@ -10,7 +10,7 @@ const types_1 = require("../types");
  *
  * @experimental
  */
-class Seq {
+class Sequence {
     constructor(initialValue, nextFn) {
         this.nextFn = nextFn;
         this.sentInitialValue = false;
@@ -26,18 +26,18 @@ class Seq {
         };
     }
     static create(initialValue, nextFn) {
-        return new Seq(initialValue, nextFn);
+        return new Sequence(initialValue, nextFn);
     }
     static range(minIncl, maxExcl, step = 1) {
         const max = maxExcl - step;
-        return new Seq(minIncl, n => (n < max ? n + step : types_1.END));
+        return new Sequence(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, () => {
+            return new Sequence(types_1.END, () => { });
+        return new Sequence(v.value, () => {
             const v = it.next();
             if (v.done)
                 return types_1.END;
@@ -45,7 +45,7 @@ class Seq {
         });
     }
     static empty() {
-        return new Seq(types_1.END, () => { });
+        return new Sequence(types_1.END, () => { });
     }
     next() {
         if (this.currentValue === types_1.END)
@@ -131,11 +131,118 @@ class Seq {
         }
     }
 }
-exports.Seq = Seq;
+exports.Sequence = Sequence;
 /**
  * Convenience function to create a Sequence.
  */
 function _seq(initialValue, nextFn) {
-    return Seq.create(initialValue, nextFn);
+    return Sequence.create(initialValue, nextFn);
 }
 exports._seq = _seq;
+/* eslint-disable no-await-in-loop */
+/**
+ * Experimental.
+ * Feasibility to be proven.
+ *
+ * @experimental
+ */
+class AsyncSequence {
+    constructor(initialValue, nextFn) {
+        this.nextFn = nextFn;
+        this.sentInitialValue = false;
+        this.i = -1;
+        this.currentValue = initialValue;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                const value = await this.next();
+                return value === types_1.END ? { done: true, value: undefined } : { value };
+            },
+        };
+    }
+    static create(initialValue, nextFn) {
+        return new AsyncSequence(initialValue, nextFn);
+    }
+    static async from(a) {
+        const it = a[Symbol.asyncIterator]();
+        const v = await it.next();
+        if (v.done)
+            return new AsyncSequence(types_1.END, () => { });
+        return new AsyncSequence(v.value, async () => {
+            const v = await it.next();
+            if (v.done)
+                return types_1.END;
+            return v.value;
+        });
+    }
+    static empty() {
+        return new AsyncSequence(types_1.END, () => { });
+    }
+    async 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 = await this.nextFn(this.currentValue, this.i);
+        }
+        // console.log(`_seq`, v)
+        if (v === types_1.SKIP)
+            return await this.next();
+        return (this.currentValue = v);
+    }
+    // Final functions - return final value, not a chained sequence
+    async find(predicate) {
+        do {
+            const v = await this.next();
+            if (v === types_1.END)
+                return; // not found, end of sequence
+            const r = await predicate(v, this.i);
+            if (r === types_1.END)
+                return;
+            if (r)
+                return v;
+            // otherwise proceed
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async some(predicate) {
+        do {
+            const v = await this.next();
+            if (v === types_1.END)
+                return false;
+            const r = await predicate(v, this.i);
+            if (r === types_1.END)
+                return false;
+            if (r)
+                return true;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async every(predicate) {
+        do {
+            const v = await this.next();
+            if (v === types_1.END)
+                return true;
+            const r = await predicate(v, this.i);
+            if (r === types_1.END)
+                return true;
+            if (!r)
+                return false;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async toArray() {
+        const a = [];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const v = await this.next();
+            if (v === types_1.END)
+                return a;
+            a.push(v);
+        }
+    }
+}
+exports.AsyncSequence = AsyncSequence;

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,29 +22,29 @@ 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 { END, SKIP, _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues, } from './types';
@@ -54,4 +54,5 @@ import { commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLog
 import { _safeJsonStringify } from './string/safeJsonStringify';
 import { PQueue } from './promise/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, };
+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/seq/seq.js

@@ -1,4 +1,4 @@
-import { END, SKIP } from '../types';
+import { END, SKIP, } from '../types';
 /**
  * Inspired by Kotlin Sequences.
  * Similar to arrays, but with lazy evaluation, abortable.
@@ -7,7 +7,7 @@ import { END, SKIP } from '../types';
  *
  * @experimental
  */
-export class Seq {
+export class Sequence {
     constructor(initialValue, nextFn) {
         this.nextFn = nextFn;
         this.sentInitialValue = false;
@@ -23,18 +23,18 @@ export class Seq {
         };
     }
     static create(initialValue, nextFn) {
-        return new Seq(initialValue, nextFn);
+        return new Sequence(initialValue, nextFn);
     }
     static range(minIncl, maxExcl, step = 1) {
         const max = maxExcl - step;
-        return new Seq(minIncl, n => (n < max ? n + step : END));
+        return new Sequence(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, () => {
+            return new Sequence(END, () => { });
+        return new Sequence(v.value, () => {
             const v = it.next();
             if (v.done)
                 return END;
@@ -42,7 +42,7 @@ export class Seq {
         });
     }
     static empty() {
-        return new Seq(END, () => { });
+        return new Sequence(END, () => { });
     }
     next() {
         if (this.currentValue === END)
@@ -132,5 +132,111 @@ export class Seq {
  * Convenience function to create a Sequence.
  */
 export function _seq(initialValue, nextFn) {
-    return Seq.create(initialValue, nextFn);
+    return Sequence.create(initialValue, nextFn);
+}
+/* eslint-disable no-await-in-loop */
+/**
+ * Experimental.
+ * Feasibility to be proven.
+ *
+ * @experimental
+ */
+export class AsyncSequence {
+    constructor(initialValue, nextFn) {
+        this.nextFn = nextFn;
+        this.sentInitialValue = false;
+        this.i = -1;
+        this.currentValue = initialValue;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                const value = await this.next();
+                return value === END ? { done: true, value: undefined } : { value };
+            },
+        };
+    }
+    static create(initialValue, nextFn) {
+        return new AsyncSequence(initialValue, nextFn);
+    }
+    static async from(a) {
+        const it = a[Symbol.asyncIterator]();
+        const v = await it.next();
+        if (v.done)
+            return new AsyncSequence(END, () => { });
+        return new AsyncSequence(v.value, async () => {
+            const v = await it.next();
+            if (v.done)
+                return END;
+            return v.value;
+        });
+    }
+    static empty() {
+        return new AsyncSequence(END, () => { });
+    }
+    async next() {
+        if (this.currentValue === END)
+            return END;
+        this.i++;
+        let v;
+        if (!this.sentInitialValue) {
+            this.sentInitialValue = true;
+            v = this.currentValue;
+        }
+        else {
+            v = await this.nextFn(this.currentValue, this.i);
+        }
+        // console.log(`_seq`, v)
+        if (v === SKIP)
+            return await this.next();
+        return (this.currentValue = v);
+    }
+    // Final functions - return final value, not a chained sequence
+    async find(predicate) {
+        do {
+            const v = await this.next();
+            if (v === END)
+                return; // not found, end of sequence
+            const r = await predicate(v, this.i);
+            if (r === END)
+                return;
+            if (r)
+                return v;
+            // otherwise proceed
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async some(predicate) {
+        do {
+            const v = await this.next();
+            if (v === END)
+                return false;
+            const r = await predicate(v, this.i);
+            if (r === END)
+                return false;
+            if (r)
+                return true;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async every(predicate) {
+        do {
+            const v = await this.next();
+            if (v === END)
+                return true;
+            const r = await predicate(v, this.i);
+            if (r === END)
+                return true;
+            if (!r)
+                return false;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async toArray() {
+        const a = [];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const v = await this.next();
+            if (v === END)
+                return a;
+            a.push(v);
+        }
+    }
 }

package/package.json

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