@naturalcycles/js-lib 14.249.0 → 14.250.0

package/dist/array/array.util.js

@@ -39,7 +39,7 @@ exports._minBy = _minBy;
 exports._maxByOrUndefined = _maxByOrUndefined;
 exports._minByOrUndefined = _minByOrUndefined;
 exports._zip = _zip;
-const is_util_1 = require("../is.util");
+const assert_1 = require("../error/assert");
 const types_1 = require("../types");
 /**
  * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the
@@ -54,9 +54,11 @@ const types_1 = require("../types");
  * Based on: https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore#_chunk
  */
 function _chunk(array, size = 1) {
-    return array.reduce((arr, item, idx) => {
-        return idx % size === 0 ? [...arr, [item]] : [...arr.slice(0, -1), [...arr.slice(-1)[0], item]];
-    }, []);
+    const a = [];
+    for (let i = 0; i < array.length; i += size) {
+        a.push(array.slice(i, i + size));
+    }
+    return a;
 }
 /**
  * Removes duplicates from given array.
@@ -117,16 +119,13 @@ function _pushUniqBy(a, mapper, ...items) {
  * Based on: https://stackoverflow.com/a/40808569/4919972
  */
 function _uniqBy(arr, mapper) {
-    return [
-        ...arr
-            .reduce((map, item, index) => {
-            const key = item === null || item === undefined ? item : mapper(item, index);
-            if (!map.has(key))
-                map.set(key, item);
-            return map;
-        }, new Map())
-            .values(),
-    ];
+    const map = new Map();
+    for (const [i, item] of arr.entries()) {
+        const key = item === undefined || item === null ? item : mapper(item, i);
+        if (!map.has(key))
+            map.set(key, item);
+    }
+    return [...map.values()];
 }
 /**
  * const a = [
@@ -169,13 +168,14 @@ function _mapBy(items, mapper) {
  * Returning `undefined` from the Mapper will EXCLUDE the item.
  */
 function _groupBy(items, mapper) {
-    return items.reduce((map, item, index) => {
-        const res = mapper(item, index);
-        if (res !== undefined) {
-            map[res] = [...(map[res] || []), item];
-        }
-        return map;
-    }, {});
+    const map = {};
+    for (const [i, item] of items.entries()) {
+        const key = mapper(item, i);
+        if (key === undefined)
+            continue;
+        (map[key] ||= []).push(item);
+    }
+    return map;
 }
 /**
  * _sortBy([{age: 20}, {age: 10}], 'age')
@@ -323,7 +323,11 @@ function _intersectsWith(a1, a2) {
  * // [1]
  */
 function _difference(source, ...diffs) {
-    return diffs.reduce((a, b) => a.filter(c => !b.includes(c)), source);
+    let a = source;
+    for (const b of diffs) {
+        a = a.filter(c => !b.includes(c));
+    }
+    return a;
 }
 /**
  * Returns the sum of items, or 0 for empty array.
@@ -408,45 +412,51 @@ function _first(array) {
     return array[0];
 }
 function _minOrUndefined(array) {
-    const a = array.filter(is_util_1._isNotNullish);
-    if (!a.length)
-        return;
-    return a.reduce((min, item) => (min <= item ? min : item));
+    let min;
+    for (const item of array) {
+        if (item === undefined || item === null)
+            continue;
+        if (min === undefined || item < min) {
+            min = item;
+        }
+    }
+    return min;
 }
 /**
  * Filters out nullish values (undefined and null).
  */
 function _min(array) {
-    const a = array.filter(is_util_1._isNotNullish);
-    if (!a.length)
-        throw new Error('_min called on empty array');
-    return a.reduce((min, item) => (min <= item ? min : item));
+    const min = _minOrUndefined(array);
+    (0, assert_1._assert)(min !== undefined, '_min called on empty array');
+    return min;
 }
 function _maxOrUndefined(array) {
-    const a = array.filter(is_util_1._isNotNullish);
-    if (!a.length)
-        return;
-    return a.reduce((max, item) => (max >= item ? max : item));
+    let max;
+    for (const item of array) {
+        if (item === undefined || item === null)
+            continue;
+        if (max === undefined || item > max) {
+            max = item;
+        }
+    }
+    return max;
 }
 /**
  * Filters out nullish values (undefined and null).
  */
 function _max(array) {
-    const a = array.filter(is_util_1._isNotNullish);
-    if (!a.length)
-        throw new Error('_max called on empty array');
-    return a.reduce((max, item) => (max >= item ? max : item));
+    const max = _maxOrUndefined(array);
+    (0, assert_1._assert)(max !== undefined, '_max called on empty array');
+    return max;
 }
 function _maxBy(array, mapper) {
     const max = _maxByOrUndefined(array, mapper);
-    if (max === undefined)
-        throw new Error(`_maxBy returned undefined`);
+    (0, assert_1._assert)(max !== undefined, '_maxBy returned undefined');
     return max;
 }
 function _minBy(array, mapper) {
     const min = _minByOrUndefined(array, mapper);
-    if (min === undefined)
-        throw new Error(`_minBy returned undefined`);
+    (0, assert_1._assert)(min !== undefined, '_minBy returned undefined');
     return min;
 }
 // todo: looks like it _maxByOrUndefined/_minByOrUndefined can be DRYer

package/dist/datetime/localDate.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localDate = exports.LocalDate = void 0;
 const assert_1 = require("../error/assert");
-const is_util_1 = require("../is.util");
 const iterable2_1 = require("../iter/iterable2");
 const localTime_1 = require("./localTime");
 const MDAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
@@ -496,7 +495,7 @@ class LocalDateFactory {
         if (input instanceof LocalDate)
             return true;
         if (input instanceof Date)
-            return !isNaN(input.getDate());
+            return !Number.isNaN(input.getDate());
         return this.isValidString(input);
     }
     /**
@@ -516,7 +515,7 @@ class LocalDateFactory {
         if (input instanceof LocalDate)
             return input;
         if (input instanceof Date) {
-            if (isNaN(input.getDate()))
+            if (Number.isNaN(input.getDate()))
                 return;
             return new LocalDate(input.getFullYear(), input.getMonth() + 1, input.getDate());
         }
@@ -574,7 +573,7 @@ class LocalDateFactory {
      * Takes Date as-is, in its timezone - local or UTC.
      */
     fromDate(d) {
-        (0, assert_1._assert)(!isNaN(d.getDate()), `localDate.fromDate is called on Date object that is invalid`);
+        (0, assert_1._assert)(!Number.isNaN(d.getDate()), 'localDate.fromDate is called on Date object that is invalid');
         return new LocalDate(d.getFullYear(), d.getMonth() + 1, d.getDate());
     }
     /**
@@ -582,7 +581,7 @@ class LocalDateFactory {
      * Takes Date's year/month/day components in UTC, using getUTCFullYear, getUTCMonth, getUTCDate.
      */
     fromDateInUTC(d) {
-        (0, assert_1._assert)(!isNaN(d.getDate()), `localDate.fromDateInUTC is called on Date object that is invalid`);
+        (0, assert_1._assert)(!Number.isNaN(d.getDate()), 'localDate.fromDateInUTC is called on Date object that is invalid');
         return new LocalDate(d.getUTCFullYear(), d.getUTCMonth() + 1, d.getUTCDate());
     }
     fromDateObject(o) {
@@ -600,35 +599,49 @@ class LocalDateFactory {
      * Returns the earliest (min) LocalDate from the array, or undefined if the array is empty.
      */
     minOrUndefined(items) {
-        return items.length ? this.min(items) : undefined;
+        let min;
+        for (const item of items) {
+            if (!item)
+                continue;
+            const ld = this.fromInput(item);
+            if (!min || ld.isBefore(min)) {
+                min = ld;
+            }
+        }
+        return min;
     }
     /**
      * Returns the earliest LocalDate from the array.
      * Throws if the array is empty.
      */
     min(items) {
-        const items2 = items.filter(is_util_1._isTruthy);
-        (0, assert_1._assert)(items2.length, 'localDate.min called on empty array');
-        return items2
-            .map(i => this.fromInput(i))
-            .reduce((min, item) => (min.isSameOrBefore(item) ? min : item));
+        const min = this.minOrUndefined(items);
+        (0, assert_1._assert)(min, 'localDate.min called on empty array');
+        return min;
     }
     /**
      * Returns the latest (max) LocalDate from the array, or undefined if the array is empty.
      */
     maxOrUndefined(items) {
-        return items.length ? this.max(items) : undefined;
+        let max;
+        for (const item of items) {
+            if (!item)
+                continue;
+            const ld = this.fromInput(item);
+            if (!max || ld.isAfter(max)) {
+                max = ld;
+            }
+        }
+        return max;
     }
     /**
      * Returns the latest LocalDate from the array.
      * Throws if the array is empty.
      */
     max(items) {
-        const items2 = items.filter(is_util_1._isTruthy);
-        (0, assert_1._assert)(items2.length, 'localDate.max called on empty array');
-        return items2
-            .map(i => this.fromInput(i))
-            .reduce((max, item) => (max.isSameOrAfter(item) ? max : item));
+        const max = this.maxOrUndefined(items);
+        (0, assert_1._assert)(max, 'localDate.max called on empty array');
+        return max;
     }
     /**
      * Returns the range (array) of LocalDates between min and max.

package/dist/datetime/localTime.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localTime = exports.LocalTime = exports.ISODayOfWeek = void 0;
 const assert_1 = require("../error/assert");
-const is_util_1 = require("../is.util");
 const time_util_1 = require("../time/time.util");
 const localDate_1 = require("./localDate");
 const wallTime_1 = require("./wallTime");
@@ -677,7 +676,7 @@ class LocalTimeFactory {
         if (input instanceof LocalTime)
             return true;
         if (input instanceof Date)
-            return !isNaN(input.getDate());
+            return !Number.isNaN(input.getDate());
         // We currently don't validate Unixtimestamp input, treat it as always valid
         if (typeof input === 'number')
             return true;
@@ -698,7 +697,7 @@ class LocalTimeFactory {
         if (input instanceof LocalTime)
             return input;
         if (input instanceof Date) {
-            if (isNaN(input.getDate()))
+            if (Number.isNaN(input.getDate()))
                 return;
             return new LocalTime(input);
         }
@@ -762,7 +761,7 @@ class LocalTimeFactory {
                 return;
             // Attempt to parse with Date constructor
             const d = new Date(s);
-            return isNaN(d.getDate()) ? undefined : d;
+            return Number.isNaN(d.getDate()) ? undefined : d;
         }
         const o = {
             year: Number(m[1]),
@@ -790,7 +789,7 @@ class LocalTimeFactory {
         return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
     }
     fromDate(date) {
-        (0, assert_1._assert)(!isNaN(date.getDate()), `localTime.fromDate is called on Date object that is invalid`);
+        (0, assert_1._assert)(!Number.isNaN(date.getDate()), 'localTime.fromDate is called on Date object that is invalid');
         return new LocalTime(date);
     }
     fromUnix(ts) {
@@ -845,24 +844,38 @@ class LocalTimeFactory {
         });
     }
     minOrUndefined(items) {
-        return items.length ? this.min(items) : undefined;
+        let min;
+        for (const item of items) {
+            if (!item)
+                continue;
+            const lt = this.fromInput(item);
+            if (!min || lt.$date.valueOf() < min.$date.valueOf()) {
+                min = lt;
+            }
+        }
+        return min;
     }
     min(items) {
-        const items2 = items.filter(is_util_1._isTruthy);
-        (0, assert_1._assert)(items2.length, 'localTime.min called on empty array');
-        return items2
-            .map(i => this.fromInput(i))
-            .reduce((min, item) => (min.$date.valueOf() <= item.$date.valueOf() ? min : item));
+        const min = this.minOrUndefined(items);
+        (0, assert_1._assert)(min, 'localTime.min called on empty array');
+        return min;
     }
     maxOrUndefined(items) {
-        return items.length ? this.max(items) : undefined;
+        let max;
+        for (const item of items) {
+            if (!item)
+                continue;
+            const lt = this.fromInput(item);
+            if (!max || lt.$date.valueOf() > max.$date.valueOf()) {
+                max = lt;
+            }
+        }
+        return max;
     }
     max(items) {
-        const items2 = items.filter(is_util_1._isTruthy);
-        (0, assert_1._assert)(items2.length, 'localTime.max called on empty array');
-        return items2
-            .map(i => this.fromInput(i))
-            .reduce((max, item) => (max.$date.valueOf() >= item.$date.valueOf() ? max : item));
+        const max = this.maxOrUndefined(items);
+        (0, assert_1._assert)(max, 'localTime.max called on empty array');
+        return max;
     }
 }
 // based on: https://github.com/date-fns/date-fns/blob/master/src/getISOWeek/index.ts
@@ -898,7 +911,7 @@ function getWeekYear(date) {
     if (date.getTime() >= startOfNextYear.getTime()) {
         return year + 1;
     }
-    else if (date.getTime() >= startOfThisYear.getTime()) {
+    if (date.getTime() >= startOfThisYear.getTime()) {
         return year;
     }
     return year - 1;

package/dist/error/assert.js

@@ -60,7 +60,7 @@ function _assertEquals(actual, expected, message, errorData) {
 function _assertDeepEquals(actual, expected, message, errorData) {
     if (!(0, __1._deepEquals)(actual, expected)) {
         const msg = message ||
-            [`not deeply equal`, `expected: ${(0, __1._stringify)(expected)}`, `got     : ${(0, __1._stringify)(actual)}`]
+            ['not deeply equal', `expected: ${(0, __1._stringify)(expected)}`, `got     : ${(0, __1._stringify)(actual)}`]
                 .filter(Boolean)
                 .join('\n');
         throw new __1.AssertionError(msg, {
@@ -96,6 +96,7 @@ function _assertIsNumber(v, message) {
     _assertTypeOf(v, 'number', message);
 }
 function _assertTypeOf(v, expectedType, message) {
+    // biome-ignore lint/suspicious/useValidTypeof: ok
     if (typeof v !== expectedType) {
         const msg = message || `Expected typeof ${expectedType}, actual typeof: ${typeof v}`;
         throw new __1.AssertionError(msg);

package/dist/http/fetcher.js

@@ -45,7 +45,7 @@ class Fetcher {
     static { this.userAgent = (0, env_1.isServerSide)() ? `fetcher${this.VERSION}` : undefined; }
     constructor(cfg = {}) {
         if (typeof globalThis.fetch !== 'function') {
-            throw new TypeError(`globalThis.fetch is not available`);
+            throw new TypeError('globalThis.fetch is not available');
         }
         this.cfg = this.normalizeCfg(cfg);
         // Dynamically create all helper methods
@@ -289,7 +289,7 @@ class Fetcher {
             res.body = res.fetchResponse.body;
             if (res.body === null) {
                 // Error is to be handled upstream
-                throw new Error(`fetchResponse.body is null`);
+                throw new Error('fetchResponse.body is null');
             }
         }
         res.retryStatus.retryStopped = true;
@@ -418,13 +418,13 @@ class Fetcher {
                 }
                 else {
                     const date = new Date(retryAfterStr);
-                    if (!isNaN(date)) {
+                    if (!Number.isNaN(date)) {
                         timeout = Number(date) - Date.now();
                     }
                 }
                 this.cfg.logger.log(`retry-after: ${retryAfterStr}`);
                 if (!timeout) {
-                    this.cfg.logger.warn(`retry-after could not be parsed`);
+                    this.cfg.logger.warn('retry-after could not be parsed');
                 }
             }
         }
@@ -577,7 +577,7 @@ class Fetcher {
         const baseUrl = opt.baseUrl || this.cfg.baseUrl;
         if (baseUrl) {
             if (req.fullUrl.startsWith('/')) {
-                console.warn(`Fetcher: url should not start with / when baseUrl is specified`);
+                console.warn('Fetcher: url should not start with / when baseUrl is specified');
                 req.fullUrl = req.fullUrl.slice(1);
             }
             req.fullUrl = `${baseUrl}/${req.inputUrl}`;

package/dist/json-schema/jsonSchemaBuilder.js

@@ -144,7 +144,7 @@ class JsonSchemaAnyBuilder {
             this.schema.optionalField = true;
         }
         else {
-            delete this.schema.optionalField;
+            this.schema.optionalField = undefined;
         }
         return this;
     }
@@ -281,7 +281,7 @@ class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
                 this.schema.required.push(k);
             }
             else {
-                delete schema.optionalField;
+                schema.optionalField = undefined;
             }
             this.schema.properties[k] = schema;
         });

package/dist/math/math.util.js

@@ -6,6 +6,7 @@ exports._averageWeighted = _averageWeighted;
 exports._percentile = _percentile;
 exports._percentiles = _percentiles;
 exports._median = _median;
+const assert_1 = require("../error/assert");
 const number_util_1 = require("../number/number.util");
 /**
  * @returns Average of the array of numbers
@@ -16,20 +17,29 @@ const number_util_1 = require("../number/number.util");
  * // 2.5
  */
 function _average(values) {
-    return values.reduce((a, b) => a + b) / values.length;
+    (0, assert_1._assert)(values.length, '_average is called on empty array');
+    let total = 0;
+    for (const n of values)
+        total += n;
+    return total / values.length;
 }
 /**
  * Same as _average, but safely returns null if input array is empty or nullish.
  */
 function _averageOrNull(values) {
-    return values?.length ? values.reduce((a, b) => a + b) / values.length : null;
+    return values?.length ? _average(values) : null;
 }
 /**
  * valuesArray and weightsArray length is expected to be the same.
  */
 function _averageWeighted(values, weights) {
-    const numerator = values.map((value, i) => value * weights[i]).reduce((a, b) => a + b);
-    const denominator = weights.reduce((a, b) => a + b);
+    let numerator = 0;
+    let denominator = 0;
+    // eslint-disable-next-line unicorn/no-for-loop
+    for (let i = 0; i < values.length; i++) {
+        numerator += values[i] * weights[i];
+        denominator += weights[i];
+    }
     return numerator / denominator;
 }
 /**

package/dist/math/sma.js

@@ -20,7 +20,10 @@ class SimpleMovingAverage {
     get avg() {
         if (this.data.length === 0)
             return 0;
-        return this.data.reduce((total, n) => total + n, 0) / this.data.length;
+        let total = 0;
+        for (const n of this.data)
+            total += n;
+        return total / this.data.length;
     }
     /**
      * Push new value.

package/dist/number/createDeterministicRandom.js

@@ -9,7 +9,7 @@ exports._createDeterministicRandom = _createDeterministicRandom;
  */
 function _createDeterministicRandom() {
     let seed = 0x2f6e2b1;
-    return function () {
+    return () => {
         // Robert Jenkins’ 32 bit integer hash function
         seed = (seed + 0x7ed55d16 + (seed << 12)) & 0xffffffff;
         seed = (seed ^ 0xc761c23c ^ (seed >>> 19)) & 0xffffffff;

package/dist/number/number.util.js

@@ -47,10 +47,10 @@ function _isBetween(x, min, max, incl = '[)') {
     if (incl === '[)') {
         return x >= min && x < max;
     }
-    else if (incl === '[]') {
+    if (incl === '[]') {
         return x >= min && x <= max;
     }
-    else if (incl === '(]') {
+    if (incl === '(]') {
         return x > min && x <= max;
     }
     return x > min && x < max;

package/dist/object/object.util.d.ts

@@ -1,5 +1,4 @@
-import type { AnyObject, ObjectMapper, ObjectPredicate, ValueOf } from '../types';
-import { KeyValueTuple, Reviver, SKIP } from '../types';
+import { AnyObject, KeyValueTuple, ObjectMapper, ObjectPredicate, Reviver, SKIP, ValueOf } from '../types';
 /**
  * Returns clone of `obj` with only `props` preserved.
  * Opposite of Omit.