@naturalcycles/js-lib 14.249.0 → 14.251.0

package/dist-esm/datetime/localTime.js

@@ -1,5 +1,4 @@
 import { _assert } from '../error/assert';
-import { _isTruthy } from '../is.util';
 import { _ms } from '../time/time.util';
 import { localDate } from './localDate';
 import { WallTime } from './wallTime';
@@ -673,7 +672,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;
@@ -694,7 +693,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);
         }
@@ -758,7 +757,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]),
@@ -786,7 +785,7 @@ class LocalTimeFactory {
         return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
     }
     fromDate(date) {
-        _assert(!isNaN(date.getDate()), `localTime.fromDate is called on Date object that is invalid`);
+        _assert(!Number.isNaN(date.getDate()), 'localTime.fromDate is called on Date object that is invalid');
         return new LocalTime(date);
     }
     fromUnix(ts) {
@@ -841,24 +840,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(_isTruthy);
-        _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);
+        _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(_isTruthy);
-        _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);
+        _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
@@ -894,7 +907,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-esm/error/assert.js

@@ -49,7 +49,7 @@ export function _assertEquals(actual, expected, message, errorData) {
 export function _assertDeepEquals(actual, expected, message, errorData) {
     if (!_deepEquals(actual, expected)) {
         const msg = message ||
-            [`not deeply equal`, `expected: ${_stringify(expected)}`, `got     : ${_stringify(actual)}`]
+            ['not deeply equal', `expected: ${_stringify(expected)}`, `got     : ${_stringify(actual)}`]
                 .filter(Boolean)
                 .join('\n');
         throw new AssertionError(msg, {
@@ -85,6 +85,7 @@ export function _assertIsNumber(v, message) {
     _assertTypeOf(v, 'number', message);
 }
 export 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 AssertionError(msg);

package/dist-esm/http/fetcher.js

@@ -34,7 +34,7 @@ const defRetryOptions = {
 export class Fetcher {
     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
@@ -281,7 +281,7 @@ export 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;
@@ -410,13 +410,13 @@ export 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');
                 }
             }
         }
@@ -570,7 +570,7 @@ export 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-esm/json-schema/jsonSchemaBuilder.js

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

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

@@ -1,3 +1,4 @@
+import { _assert } from '../error/assert';
 import { _sortNumbers } from '../number/number.util';
 /**
  * @returns Average of the array of numbers
@@ -8,20 +9,29 @@ import { _sortNumbers } from '../number/number.util';
  * // 2.5
  */
 export function _average(values) {
-    return values.reduce((a, b) => a + b) / values.length;
+    _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.
  */
 export 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.
  */
 export 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-esm/math/sma.js

@@ -17,7 +17,10 @@ export 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-esm/number/createDeterministicRandom.js

@@ -6,7 +6,7 @@
  */
 export 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-esm/number/number.util.js

@@ -36,10 +36,10 @@ export 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-esm/object/object.util.js

@@ -1,5 +1,5 @@
 import { _isEmpty, _isObject } from '../is.util';
-import { _objectEntries, SKIP } from '../types';
+import { _objectEntries, SKIP, } from '../types';
 /**
  * Returns clone of `obj` with only `props` preserved.
  * Opposite of Omit.
@@ -7,28 +7,61 @@ import { _objectEntries, SKIP } from '../types';
 export function _pick(obj, props, mutate = false) {
     if (mutate) {
         // Start as original object (mutable), DELETE properties that are not whitelisted
-        return Object.keys(obj).reduce((r, prop) => {
-            if (!props.includes(prop))
-                delete r[prop];
-            return r;
-        }, obj);
+        for (const k of Object.keys(obj)) {
+            if (!props.includes(k))
+                delete obj[k];
+        }
+        return obj;
     }
     // Start as empty object, pick/add needed properties
-    return props.reduce((r, prop) => {
-        if (prop in obj)
-            r[prop] = obj[prop];
-        return r;
-    }, {});
+    const r = {};
+    for (const k of props) {
+        if (k in obj)
+            r[k] = obj[k];
+    }
+    return r;
+}
+/**
+ * Sets all properties of an object except passed ones to `undefined`.
+ * This is a more performant alternative to `_pick` that does picking/deleting.
+ */
+export function _pickWithUndefined(obj, props, mutate = false) {
+    const r = mutate ? obj : { ...obj };
+    for (const k of Object.keys(r)) {
+        if (!props.includes(k)) {
+            r[k] = undefined;
+        }
+    }
+    return r;
 }
 /**
  * Returns clone of `obj` with `props` omitted.
  * Opposite of Pick.
  */
 export function _omit(obj, props, mutate = false) {
-    return props.reduce((r, prop) => {
-        delete r[prop];
-        return r;
-    }, mutate ? obj : { ...obj });
+    if (mutate) {
+        for (const k of props) {
+            delete obj[k];
+        }
+        return obj;
+    }
+    const r = {};
+    for (const k of Object.keys(obj)) {
+        if (!props.includes(k))
+            r[k] = obj[k];
+    }
+    return r;
+}
+/**
+ * Sets all passed properties of an object to `undefined`.
+ * This is a more performant alternative to `_omit` that does picking/deleting.
+ */
+export function _omitWithUndefined(obj, props, mutate = false) {
+    const r = mutate ? obj : { ...obj };
+    for (const k of props) {
+        r[k] = undefined;
+    }
+    return r;
 }
 /**
  * Returns object with filtered keys from `props` array.
@@ -39,10 +72,11 @@ export function _omit(obj, props, mutate = false) {
  * ])
  */
 export function _mask(obj, props, mutate = false) {
-    return props.reduce((r, prop) => {
-        _unset(r, prop);
-        return r;
-    }, mutate ? obj : _deepCopy(obj));
+    const r = mutate ? obj : _deepCopy(obj);
+    for (const k of props) {
+        _unset(r, k);
+    }
+    return r;
 }
 /**
  * Removes "falsy" values from the object.
@@ -71,11 +105,21 @@ export function _filterEmptyArrays(obj, mutate = false) {
  * Allows filtering by both key and value.
  */
 export function _filterObject(obj, predicate, mutate = false) {
-    return Object.keys(obj).reduce((r, k) => {
-        if (!predicate(k, r[k], obj))
-            delete r[k];
-        return r;
-    }, mutate ? obj : { ...obj });
+    if (mutate) {
+        for (const [k, v] of _objectEntries(obj)) {
+            if (!predicate(k, v, obj)) {
+                delete obj[k];
+            }
+        }
+        return obj;
+    }
+    const r = {};
+    for (const [k, v] of _objectEntries(obj)) {
+        if (predicate(k, v, obj)) {
+            r[k] = v;
+        }
+    }
+    return r;
 }
 /**
  * var users = {
@@ -89,10 +133,11 @@ export function _filterObject(obj, predicate, mutate = false) {
  * To skip some key-value pairs - use _mapObject instead.
  */
 export function _mapValues(obj, mapper, mutate = false) {
-    return _objectEntries(obj).reduce((map, [k, v]) => {
+    const map = mutate ? obj : {};
+    for (const [k, v] of Object.entries(obj)) {
         map[k] = mapper(k, v, obj);
-        return map;
-    }, mutate ? obj : {});
+    }
+    return map;
 }
 /**
  * _.mapKeys({ 'a': 1, 'b': 2 }, (key, value) => key + value)
@@ -103,10 +148,11 @@ export function _mapValues(obj, mapper, mutate = false) {
  * To skip some key-value pairs - use _mapObject instead.
  */
 export function _mapKeys(obj, mapper) {
-    return _objectEntries(obj).reduce((map, [k, v]) => {
+    const map = {};
+    for (const [k, v] of Object.entries(obj)) {
         map[mapper(k, v, obj)] = v;
-        return map;
-    }, {});
+    }
+    return map;
 }
 /**
  * Maps object through predicate - a function that receives (k, v, obj)
@@ -125,13 +171,14 @@ export function _mapKeys(obj, mapper) {
  * Non-string keys are passed via String(...)
  */
 export function _mapObject(obj, mapper) {
-    return Object.entries(obj).reduce((map, [k, v]) => {
+    const map = {};
+    for (const [k, v] of Object.entries(obj)) {
         const r = mapper(k, v, obj);
-        if (r !== SKIP) {
-            map[r[0]] = r[1];
-        }
-        return map;
-    }, {});
+        if (r === SKIP)
+            continue;
+        map[r[0]] = r[1];
+    }
+    return map;
 }
 export function _findKeyByValue(obj, v) {
     return Object.entries(obj).find(([_, value]) => value === v)?.[0];
@@ -219,7 +266,7 @@ export function _deepTrim(o) {
     if (typeof o === 'string') {
         return o.trim();
     }
-    else if (typeof o === 'object') {
+    if (typeof o === 'object') {
         Object.keys(o).forEach(k => {
             o[k] = _deepTrim(o[k]);
         });
@@ -273,10 +320,11 @@ export function _invertMap(m) {
  * _get(obj, 'unknown.path') // undefined
  */
 export function _get(obj = {}, path = '') {
-    return path
+    return (path
         .replaceAll(/\[([^\]]+)]/g, '.$1')
         .split('.')
-        .reduce((o, p) => o?.[p], obj);
+        // eslint-disable-next-line unicorn/no-array-reduce
+        .reduce((o, p) => o?.[p], obj));
 }
 /**
  * Sets the value at path of object. If a portion of path doesn’t exist it’s created. Arrays are created for
@@ -299,6 +347,7 @@ export function _set(obj, path, value) {
     else if (!path.length) {
         return obj;
     }
+    // eslint-disable-next-line unicorn/no-array-reduce
     ;
     path.slice(0, -1).reduce((a, c, i) => Object(a[c]) === a[c] // Does the key exist and is its value an object?
         ? // Yes: then follow that path

package/dist-esm/object/sortObject.js

@@ -1,4 +1,3 @@
-import { _omit } from '../index';
 /**
  * Returns new object with keys sorder in the given order.
  * All keys that are not listed in `keyOrder` go last.
@@ -6,13 +5,17 @@ import { _omit } from '../index';
  */
 export function _sortObject(obj, keyOrder) {
     const r = {};
-    keyOrder.forEach(key => {
-        if (key in obj) {
-            r[key] = obj[key];
+    // First, go over ordered keys
+    for (const k of keyOrder) {
+        if (k in obj) {
+            r[k] = obj[k];
         }
-    });
-    Object.entries(_omit(obj, keyOrder)).forEach(([k, v]) => {
+    }
+    // Second, go over all other keys
+    for (const [k, v] of Object.entries(obj)) {
+        if (keyOrder.includes(k))
+            continue;
         r[k] = v;
-    });
+    }
     return r;
 }

package/dist-esm/object/sortObjectDeep.js

@@ -1,4 +1,3 @@
-import { _isObject } from '..';
 /**
  * based on: https://github.com/IndigoUnited/js-deep-sort-object
  */
@@ -7,14 +6,12 @@ export function _sortObjectDeep(o) {
     if (Array.isArray(o)) {
         return o.map(_sortObjectDeep);
     }
-    if (_isObject(o)) {
-        const out = {};
-        Object.keys(o)
-            .sort((a, b) => a.localeCompare(b))
-            .forEach(k => {
-            out[k] = _sortObjectDeep(o[k]);
-        });
-        return out;
+    if (o && typeof o === 'object') {
+        const r = {};
+        for (const k of Object.keys(o).sort((a, b) => a.localeCompare(b))) {
+            r[k] = _sortObjectDeep(o[k]);
+        }
+        return r;
     }
     return o;
 }

package/dist-esm/promise/pDelay.js

@@ -18,7 +18,7 @@ export async function pDelay(ms = 0, value) {
  *
  * On abort() - clears the Timeout and immediately resolves the Promise with void.
  */
-export function pDelayFn(ms = 0, fn) {
+export function pDelayFn(ms, fn) {
     const p = pDefer();
     const timer = setTimeout(async () => {
         try {

package/dist-esm/semver.js

@@ -1,6 +1,5 @@
 import { _range } from './array/range';
 import { _assert } from './error/assert';
-import { _isTruthy } from './is.util';
 /**
  * Simple Semver implementation.
  *
@@ -75,35 +74,45 @@ class SemverFactory {
      * Returns the highest (max) Semver 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) {
+            const input = this.fromInputOrUndefined(item);
+            if (!max || input?.isAfter(max)) {
+                max = input;
+            }
+        }
+        return max;
     }
     /**
      * Returns the highest Semver from the array.
      * Throws if the array is empty.
      */
     max(items) {
-        const items2 = items.filter(_isTruthy);
-        _assert(items2.length, 'semver.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);
+        _assert(max, 'semver.max called on empty array');
+        return max;
     }
     /**
      * Returns the lowest (min) Semver 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) {
+            const input = this.fromInputOrUndefined(item);
+            if (!min || input?.isBefore(min)) {
+                min = input;
+            }
+        }
+        return min;
     }
     /**
      * Returns the lowest Semver from the array.
      * Throws if the array is empty.
      */
     min(items) {
-        const items2 = items.filter(_isTruthy);
-        _assert(items2.length, 'semver.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);
+        _assert(min, 'semver.min called on empty array');
+        return min;
     }
     /**
      * Sorts an array of Semvers in `dir` order (ascending by default).

package/dist-esm/string/case.js

@@ -1,15 +1,24 @@
 import { words } from './lodash/words';
 import { _upperFirst } from './string.util';
 export function _camelCase(s) {
-    // return s.replace(/(_\w)/g, m => m[1]!.toUpperCase())
-    return words(s.replaceAll(/['\u2019]/g, '')).reduce((result, word, index) => {
+    let r = '';
+    for (let word of words(s.replaceAll(/['\u2019]/g, ''))) {
         word = word.toLowerCase();
-        return result + (index ? _upperFirst(word) : word);
-    }, '');
+        r += r ? _upperFirst(word) : word;
+    }
+    return r;
 }
 export function _snakeCase(s) {
-    return words(s.replaceAll(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '_' : '') + word.toLowerCase(), '');
+    let r = '';
+    for (const word of words(s.replaceAll(/['\u2019]/g, ''))) {
+        r += (r ? '_' : '') + word.toLowerCase();
+    }
+    return r;
 }
 export function _kebabCase(s) {
-    return words(s.replaceAll(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '-' : '') + word.toLowerCase(), '');
+    let r = '';
+    for (const word of words(s.replaceAll(/['\u2019]/g, ''))) {
+        r += (r ? '-' : '') + word.toLowerCase();
+    }
+    return r;
 }

package/dist-esm/string/lodash/words.js

@@ -3,6 +3,7 @@
 import { unicodeWords } from './unicodeWords';
 const hasUnicodeWord = RegExp.prototype.test.bind(/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/);
 /** Used to match words composed of alphanumeric characters. */
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ok
 const reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 function asciiWords(s) {
     return s.match(reAsciiWord);

package/dist-esm/string/safeJsonStringify.js

@@ -17,7 +17,7 @@ export function _safeJsonStringify(obj, replacer, spaces, cycleReplacer) {
 function serializer(replacer, cycleReplacer) {
     const stack = [];
     const keys = [];
-    cycleReplacer ?? (cycleReplacer = function (key, value) {
+    cycleReplacer ?? (cycleReplacer = (key, value) => {
         if (stack[0] === value)
             return '[Circular ~]';
         return '[Circular ~.' + keys.slice(0, stack.indexOf(value)).join('.') + ']';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.249.0",
+  "version": "14.251.0",
   "scripts": {
     "prepare": "husky",
     "build": "dev-lib build-esm-cjs",