@naturalcycles/js-lib 14.248.0 → 14.250.0

package/dist/object/object.util.js

@@ -35,28 +35,37 @@ const types_1 = require("../types");
 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) => {
+        for (const prop of Object.keys(obj)) {
             if (!props.includes(prop))
-                delete r[prop];
-            return r;
-        }, obj);
+                delete obj[prop];
+        }
+        return obj;
     }
     // Start as empty object, pick/add needed properties
-    return props.reduce((r, prop) => {
+    const r = {};
+    for (const prop of props) {
         if (prop in obj)
             r[prop] = obj[prop];
-        return r;
-    }, {});
+    }
+    return r;
 }
 /**
  * Returns clone of `obj` with `props` omitted.
  * Opposite of Pick.
  */
 function _omit(obj, props, mutate = false) {
-    return props.reduce((r, prop) => {
-        delete r[prop];
-        return r;
-    }, mutate ? obj : { ...obj });
+    if (mutate) {
+        for (const prop of props) {
+            delete obj[prop];
+        }
+        return obj;
+    }
+    const r = {};
+    for (const prop of Object.keys(obj)) {
+        if (!props.includes(prop))
+            r[prop] = obj[prop];
+    }
+    return r;
 }
 /**
  * Returns object with filtered keys from `props` array.
@@ -67,10 +76,11 @@ function _omit(obj, props, mutate = false) {
  * ])
  */
 function _mask(obj, props, mutate = false) {
-    return props.reduce((r, prop) => {
+    const r = mutate ? obj : _deepCopy(obj);
+    for (const prop of props) {
         _unset(r, prop);
-        return r;
-    }, mutate ? obj : _deepCopy(obj));
+    }
+    return r;
 }
 /**
  * Removes "falsy" values from the object.
@@ -99,11 +109,21 @@ function _filterEmptyArrays(obj, mutate = false) {
  * Allows filtering by both key and value.
  */
 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 (0, types_1._objectEntries)(obj)) {
+            if (!predicate(k, v, obj)) {
+                delete obj[k];
+            }
+        }
+        return obj;
+    }
+    const r = {};
+    for (const [k, v] of (0, types_1._objectEntries)(obj)) {
+        if (predicate(k, v, obj)) {
+            r[k] = v;
+        }
+    }
+    return r;
 }
 /**
  * var users = {
@@ -117,10 +137,11 @@ function _filterObject(obj, predicate, mutate = false) {
  * To skip some key-value pairs - use _mapObject instead.
  */
 function _mapValues(obj, mapper, mutate = false) {
-    return (0, types_1._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)
@@ -131,10 +152,11 @@ function _mapValues(obj, mapper, mutate = false) {
  * To skip some key-value pairs - use _mapObject instead.
  */
 function _mapKeys(obj, mapper) {
-    return (0, types_1._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)
@@ -153,13 +175,14 @@ function _mapKeys(obj, mapper) {
  * Non-string keys are passed via String(...)
  */
 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 !== types_1.SKIP) {
-            map[r[0]] = r[1];
-        }
-        return map;
-    }, {});
+        if (r === types_1.SKIP)
+            continue;
+        map[r[0]] = r[1];
+    }
+    return map;
 }
 function _findKeyByValue(obj, v) {
     return Object.entries(obj).find(([_, value]) => value === v)?.[0];
@@ -246,7 +269,7 @@ 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]);
         });
@@ -300,10 +323,11 @@ function _invertMap(m) {
  * _get(obj, 'unknown.path') // undefined
  */
 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
@@ -326,6 +350,7 @@ 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/promise/pDelay.d.ts

@@ -1,4 +1,4 @@
-import type { PromisableFunction } from '../types';
+import type { NumberOfMilliseconds, PromisableFunction } from '../types';
 import { DeferredPromise } from './pDefer';
 /**
  * Promisified version of setTimeout.
@@ -6,7 +6,7 @@ import { DeferredPromise } from './pDefer';
  * Can return a value.
  * If value is instanceof Error - rejects the Promise instead of resolving.
  */
-export declare function pDelay<T>(ms?: number, value?: T): Promise<T>;
+export declare function pDelay<T>(ms?: NumberOfMilliseconds, value?: T): Promise<T>;
 /**
  * Promisified version of setTimeout.
  *
@@ -16,4 +16,4 @@ export declare function pDelay<T>(ms?: number, value?: T): Promise<T>;
  *
  * On abort() - clears the Timeout and immediately resolves the Promise with void.
  */
-export declare function pDelayFn<T>(ms: number | undefined, fn: PromisableFunction<T>): DeferredPromise<T>;
+export declare function pDelayFn<T>(ms: NumberOfMilliseconds, fn: PromisableFunction<T>): DeferredPromise<T>;

package/dist/promise/pDelay.js

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

package/dist/promise/pRetry.js

@@ -51,7 +51,9 @@ async function pRetry(fn, opt = {}) {
         }
         catch (err) {
             if (logFailures) {
-                logger.error(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:`, err);
+                // Logger at warn (not error) level, because it's not a fatal error, but a retriable one
+                // Fatal one is not logged either, because it's been thrown instead
+                logger.warn(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:`, err);
             }
             if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
                 // Give up

package/dist/semver.js

@@ -4,7 +4,6 @@ exports.semver2 = exports.Semver = void 0;
 exports._quickSemverCompare = _quickSemverCompare;
 const range_1 = require("./array/range");
 const assert_1 = require("./error/assert");
-const is_util_1 = require("./is.util");
 /**
  * Simple Semver implementation.
  *
@@ -80,35 +79,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(is_util_1._isTruthy);
-        (0, assert_1._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);
+        (0, assert_1._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(is_util_1._isTruthy);
-        (0, assert_1._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);
+        (0, assert_1._assert)(min, 'semver.min called on empty array');
+        return min;
     }
     /**
      * Sorts an array of Semvers in `dir` order (ascending by default).

package/dist/string/case.js

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

package/dist/string/lodash/words.js

@@ -6,6 +6,7 @@ exports.words = words;
 const unicodeWords_1 = require("./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/string/safeJsonStringify.js

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

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

@@ -1,4 +1,4 @@
-import { _isNotNullish } from '../is.util';
+import { _assert } from '../error/assert';
 import { END, } from '../types';
 /**
  * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the
@@ -13,9 +13,11 @@ import { END, } from '../types';
  * Based on: https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore#_chunk
  */
 export 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.
@@ -76,16 +78,13 @@ export function _pushUniqBy(a, mapper, ...items) {
  * Based on: https://stackoverflow.com/a/40808569/4919972
  */
 export 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 = [
@@ -128,13 +127,14 @@ export function _mapBy(items, mapper) {
  * Returning `undefined` from the Mapper will EXCLUDE the item.
  */
 export 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] || (map[key] = [])).push(item);
+    }
+    return map;
 }
 /**
  * _sortBy([{age: 20}, {age: 10}], 'age')
@@ -282,7 +282,11 @@ export function _intersectsWith(a1, a2) {
  * // [1]
  */
 export 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.
@@ -367,45 +371,51 @@ export function _first(array) {
     return array[0];
 }
 export function _minOrUndefined(array) {
-    const a = array.filter(_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).
  */
 export function _min(array) {
-    const a = array.filter(_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);
+    _assert(min !== undefined, '_min called on empty array');
+    return min;
 }
 export function _maxOrUndefined(array) {
-    const a = array.filter(_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).
  */
 export function _max(array) {
-    const a = array.filter(_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);
+    _assert(max !== undefined, '_max called on empty array');
+    return max;
 }
 export function _maxBy(array, mapper) {
     const max = _maxByOrUndefined(array, mapper);
-    if (max === undefined)
-        throw new Error(`_maxBy returned undefined`);
+    _assert(max !== undefined, '_maxBy returned undefined');
     return max;
 }
 export function _minBy(array, mapper) {
     const min = _minByOrUndefined(array, mapper);
-    if (min === undefined)
-        throw new Error(`_minBy returned undefined`);
+    _assert(min !== undefined, '_minBy returned undefined');
     return min;
 }
 // todo: looks like it _maxByOrUndefined/_minByOrUndefined can be DRYer

package/dist-esm/datetime/localDate.js

@@ -1,5 +1,4 @@
 import { _assert } from '../error/assert';
-import { _isTruthy } from '../is.util';
 import { Iterable2 } from '../iter/iterable2';
 import { localTime } from './localTime';
 const MDAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
@@ -492,7 +491,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);
     }
     /**
@@ -512,7 +511,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());
         }
@@ -570,7 +569,7 @@ class LocalDateFactory {
      * Takes Date as-is, in its timezone - local or UTC.
      */
     fromDate(d) {
-        _assert(!isNaN(d.getDate()), `localDate.fromDate is called on Date object that is invalid`);
+        _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());
     }
     /**
@@ -578,7 +577,7 @@ class LocalDateFactory {
      * Takes Date's year/month/day components in UTC, using getUTCFullYear, getUTCMonth, getUTCDate.
      */
     fromDateInUTC(d) {
-        _assert(!isNaN(d.getDate()), `localDate.fromDateInUTC is called on Date object that is invalid`);
+        _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) {
@@ -596,35 +595,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(_isTruthy);
-        _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);
+        _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(_isTruthy);
-        _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);
+        _assert(max, 'localDate.max called on empty array');
+        return max;
     }
     /**
      * Returns the range (array) of LocalDates between min and max.