@zelgadis87/utils-core 5.3.7 → 5.3.9

package/.rollup/index.cjs

@@ -362,6 +362,13 @@ class Optional {
     static ofNullable(t) {
         return new Optional(t);
     }
+    static findInArray(arr, predicate) {
+        return Optional.ofNullable(arr.find(predicate));
+    }
+    static findIndexInArray(arr, predicate) {
+        const idx = arr.findIndex(predicate);
+        return idx === -1 ? Optional.empty() : Optional.of(idx);
+    }
 }
 class ErrorGetEmptyOptional extends Error {
     constructor() {
@@ -461,22 +468,82 @@ function sum(arr) {
 function sumBy(arr, getter) {
     return sum(arr.map(getter));
 }
+/**
+ * Finds the minimum value in an array of numbers.
+ * @param arr - The array of numbers to search
+ * @returns The minimum value, or null if the array is empty
+ */
 function min(arr) {
     if (arr.length === 0)
         return null;
     return arr.reduce((min, cur) => cur < min ? cur : min);
 }
+/**
+ * Finds the minimum numeric value extracted from array elements using a getter function.
+ * @param arr - The array of elements to search
+ * @param getter - Function to extract a numeric value from each element
+ * @returns The minimum extracted value, or null if the array is empty
+ */
 function minBy(arr, getter) {
     return min(arr.map(getter));
 }
+/**
+ * Finds the maximum value in an array of numbers.
+ * @param arr - The array of numbers to search
+ * @returns The maximum value, or null if the array is empty
+ */
 function max(arr) {
     if (arr.length === 0)
         return null;
     return arr.reduce((max, cur) => cur > max ? cur : max);
 }
+/**
+ * Finds the maximum numeric value extracted from array elements using a getter function.
+ * @param arr - The array of elements to search
+ * @param getter - Function to extract a numeric value from each element
+ * @returns The maximum extracted value, or null if the array is empty
+ */
 function maxBy(arr, getter) {
     return max(arr.map(getter));
 }
+/**
+ * Finds the element with the maximum numeric value extracted using a getter function.
+ * @param arr - The array of elements to search
+ * @param getter - Function to extract a numeric value from each element
+ * @returns The element with the maximum value, or null if the array is empty
+ */
+function havingMaxBy(arr, getter) {
+    if (arr.length === 0)
+        return null;
+    return arr.reduce((ret, cur) => {
+        const curValue = getter(cur);
+        if (curValue > ret.max) {
+            return { value: cur, max: curValue };
+        }
+        else {
+            return ret;
+        }
+    }, { value: null, max: -Infinity }).value;
+}
+/**
+ * Finds the element with the minimum numeric value extracted using a getter function.
+ * @param arr - The array of elements to search
+ * @param getter - Function to extract a numeric value from each element
+ * @returns The element with the minimum value, or null if the array is empty
+ */
+function havingMinBy(arr, getter) {
+    if (arr.length === 0)
+        return null;
+    return arr.reduce((ret, cur) => {
+        const curValue = getter(cur);
+        if (curValue < ret.min) {
+            return { value: cur, min: curValue };
+        }
+        else {
+            return ret;
+        }
+    }, { value: null, min: +Infinity }).value;
+}
 
 function constant(v) { return () => v; }
 function identity(t) { return t; }
@@ -747,12 +814,13 @@ function shallowArrayEquals(a, b) {
     }
     return true;
 }
+/** @deprecated[2026.03.01]: Use {@link Optional.findInArray} instead. */
 function findInArray(arr, predicate) {
-    return Optional.ofNullable(arr.find(predicate));
+    return Optional.findInArray(arr, predicate);
 }
+/** @deprecated[2026.03.01]: Use {@link Optional.findIndexInArray} instead. */
 function findIndexInArray(arr, predicate) {
-    const idx = arr.findIndex(predicate);
-    return idx === -1 ? Optional.empty() : Optional.of(idx);
+    return Optional.findIndexInArray(arr, predicate);
 }
 function zip(ts, rs) {
     if (ts.length !== rs.length)
@@ -1074,11 +1142,38 @@ async function awaitAtMost(promise, duration) {
 }
 const NEVER = new Promise(_resolve => { });
 
+/**
+ * Returns a random integer in the range [min, max].
+ * @deprecated Use randomIntegerInInterval or randomDecimalInInterval instead
+ */
 function randomNumberInInterval(min, max) {
     return Math.floor(Math.random() * (max - min + 1) + min);
 }
+/**
+ * Returns a random integer in the range [min, max].
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (inclusive)
+ * @returns A random integer between min and max
+ */
+function randomIntegerInInterval(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+/**
+ * Returns a random decimal in the range [min, max).
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (exclusive)
+ * @returns A random decimal between min and max
+ */
+function randomDecimalInInterval(min, max) {
+    return Math.random() * (max - min) + min;
+}
 const randomId = (length) => {
-    return Math.random().toString(36).substring(2, length + 2);
+    const characters = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(randomIntegerInInterval(0, characters.length - 1));
+    }
+    return result;
 };
 function randomPick(arr) {
     return first$1(randomPicks(arr, 1));
@@ -1087,7 +1182,7 @@ function randomPicks(arr, count) {
     const available = [...arr];
     const result = [];
     while (available.length > 0 && count > 0) {
-        const randomIndex = randomNumberInInterval(0, available.length - 1);
+        const randomIndex = randomIntegerInInterval(0, available.length - 1);
         result.push(available[randomIndex]);
         available.splice(randomIndex, 1);
         count--;
@@ -3392,7 +3487,7 @@ const Sorter = {
 
 function randomize(unit) {
     return (a, b) => {
-        return TimeDuration.fromMs(randomNumberInInterval(unit.toMs(a), unit.toMs(b)));
+        return TimeDuration.fromMs(randomIntegerInInterval(unit.toMs(a), unit.toMs(b)));
     };
 }
 class RandomTimeDuration {
@@ -3664,6 +3759,8 @@ exports.groupByStringWith = groupByStringWith;
 exports.groupBySymbol = groupBySymbol;
 exports.groupBySymbolWith = groupBySymbolWith;
 exports.hashCode = hashCode;
+exports.havingMaxBy = havingMaxBy;
+exports.havingMinBy = havingMinBy;
 exports.head = head;
 exports.identity = identity;
 exports.ifDefined = ifDefined;
@@ -3724,7 +3821,9 @@ exports.pipedInvoke = pipedInvoke;
 exports.pipedInvokeFromArray = pipedInvokeFromArray;
 exports.pluralize = pluralize;
 exports.promiseSequence = promiseSequence;
+exports.randomDecimalInInterval = randomDecimalInInterval;
 exports.randomId = randomId;
+exports.randomIntegerInInterval = randomIntegerInInterval;
 exports.randomNumberInInterval = randomNumberInInterval;
 exports.randomPick = randomPick;
 exports.randomPicks = randomPicks;