@catbee/utils 2.0.0-next.0 → 2.0.0

package/array/index.mjs

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,8 @@
  * SOFTWARE.
  */
 
-import { getValueByPath } from '@catbee/utils/obj';
+import { getValueByPath } from '@catbee/utils/object';
+import { randomBytes } from 'crypto';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -41,49 +42,64 @@ function unique(array, keyFn) {
   if (!Array.isArray(array) || array.length === 0) return [];
   if (!keyFn) return Array.from(new Set(array));
   const seen = /* @__PURE__ */ new Set();
-  return array.filter((item) => {
+  const result = [];
+  for (const item of array) {
     const key = keyFn(item);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(item);
+    }
+  }
+  return result;
 }
 __name(unique, "unique");
 function flattenDeep(array) {
   if (!Array.isArray(array)) return [];
   const result = [];
-  for (const val of array) {
+  const stack = [
+    ...array
+  ];
+  while (stack.length) {
+    const val = stack.pop();
     if (Array.isArray(val)) {
-      result.push(...flattenDeep(val));
+      stack.push(...val);
     } else {
       result.push(val);
     }
   }
-  return result;
+  return result.reverse();
 }
 __name(flattenDeep, "flattenDeep");
 function random(array) {
   if (!Array.isArray(array) || array.length === 0) return void 0;
-  const idx = Math.floor(Math.random() * array.length);
-  return array[idx];
+  return array[secureIndex(array.length)];
 }
 __name(random, "random");
 function groupBy(array, keyOrFn) {
   if (!Array.isArray(array) || array.length === 0) return {};
-  const keyFn = typeof keyOrFn === "function" ? keyOrFn : (item) => item[keyOrFn];
-  return array.reduce((acc, item) => {
-    const key = keyFn(item);
-    if (!acc[key]) acc[key] = [];
-    acc[key].push(item);
-    return acc;
-  }, {});
+  const keyFn = typeof keyOrFn === "function" ? keyOrFn : (item) => String(getValueByPath(item, keyOrFn));
+  const result = {};
+  for (const item of array) {
+    const key = String(keyFn(item));
+    if (Object.hasOwn(result, key)) {
+      result[key].push(item);
+    } else {
+      result[key] = [
+        item
+      ];
+    }
+  }
+  return Object.fromEntries(Object.entries(result).map(([k, v]) => [
+    k,
+    v
+  ]));
 }
 __name(groupBy, "groupBy");
 function shuffle(array) {
   if (!Array.isArray(array)) throw new TypeError("Expected an array");
   const copy = array.slice();
   for (let i = copy.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
+    const j = secureIndex(i + 1);
     [copy[i], copy[j]] = [
       copy[j],
       copy[i]
@@ -94,7 +110,7 @@ function shuffle(array) {
 __name(shuffle, "shuffle");
 function pluck(array, key) {
   if (!Array.isArray(array)) return [];
-  return array.map((item) => item[key]);
+  return array.map((item) => item?.[key]);
 }
 __name(pluck, "pluck");
 function difference(a, b) {
@@ -109,35 +125,41 @@ function intersect(a, b) {
   return a.filter((item) => setB.has(item));
 }
 __name(intersect, "intersect");
-function mergeSort(array, key, direction = "asc") {
+function mergeSort(array, key, direction = "asc", compareFn) {
   if (!Array.isArray(array)) throw new TypeError("Expected array");
-  if (array.length <= 1) return array.slice();
+  const arr = array.slice();
+  if (arr.length <= 1) return arr;
   const keyFn = typeof key === "function" ? key : (item) => getValueByPath(item, key);
-  const compare = /* @__PURE__ */ __name((a, b) => {
+  const collator = new Intl.Collator("en", {
+    numeric: true
+  });
+  const compare = compareFn ?? function(a, b) {
     const aVal = keyFn(a);
     const bVal = keyFn(b);
     if (aVal === bVal) return 0;
     if (aVal == null) return direction === "asc" ? 1 : -1;
     if (bVal == null) return direction === "asc" ? -1 : 1;
-    return direction === "asc" ? aVal < bVal ? -1 : 1 : aVal > bVal ? -1 : 1;
-  }, "compare");
+    return direction === "asc" ? collator.compare(String(aVal), String(bVal)) : collator.compare(String(bVal), String(aVal));
+  };
   const merge = /* @__PURE__ */ __name((left, right) => {
     const result = [];
     let i = 0, j = 0;
     while (i < left.length && j < right.length) {
-      if (compare(left[i], right[j]) <= 0) result.push(left[i++]);
-      else result.push(right[j++]);
+      result.push(compare(left[i], right[j]) <= 0 ? left[i++] : right[j++]);
     }
-    return result.concat(left.slice(i)).concat(right.slice(j));
+    while (i < left.length) result.push(left[i++]);
+    while (j < right.length) result.push(right[j++]);
+    return result;
   }, "merge");
-  const sort = /* @__PURE__ */ __name((arr) => {
-    if (arr.length <= 1) return arr;
-    const mid = Math.floor(arr.length / 2);
-    const left = sort(arr.slice(0, mid));
-    const right = sort(arr.slice(mid));
+  const sort = /* @__PURE__ */ __name((input) => {
+    const len = input.length;
+    if (len <= 1) return input;
+    const mid = len >> 1;
+    const left = sort(input.slice(0, mid));
+    const right = sort(input.slice(mid));
     return merge(left, right);
   }, "sort");
-  return sort(array);
+  return sort(arr);
 }
 __name(mergeSort, "mergeSort");
 function zip(...arrays) {
@@ -154,28 +176,20 @@ function zip(...arrays) {
 }
 __name(zip, "zip");
 function partition(array, predicate) {
+  const pass = [];
+  const fail = [];
   if (!Array.isArray(array)) return [
-    [],
-    []
+    pass,
+    fail
+  ];
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+    (predicate(item, i, array) ? pass : fail).push(item);
+  }
+  return [
+    pass,
+    fail
   ];
-  return array.reduce(([pass, fail], item, index) => {
-    return predicate(item, index, array) ? [
-      [
-        ...pass,
-        item
-      ],
-      fail
-    ] : [
-      pass,
-      [
-        ...fail,
-        item
-      ]
-    ];
-  }, [
-    [],
-    []
-  ]);
 }
 __name(partition, "partition");
 function range(start, end, step = 1) {
@@ -183,46 +197,159 @@ function range(start, end, step = 1) {
     throw new TypeError("Arguments must be finite numbers");
   }
   if (step === 0) throw new Error("Step cannot be zero");
-  const isAscending = step > 0;
-  if (isAscending && start >= end || !isAscending && start <= end) {
-    return [];
-  }
-  const length = Math.max(Math.ceil((end - start) / step), 0);
-  const result = new Array(length);
-  for (let i = 0, value = start; i < length; i++, value += step) {
-    result[i] = value;
+  const result = [];
+  if (step > 0) {
+    for (let i = start; i < end; i += step) result.push(i);
+  } else {
+    for (let i = start; i > end; i += step) result.push(i);
   }
   return result;
 }
 __name(range, "range");
 function take(array, n = 1) {
   if (!Array.isArray(array) || n <= 0) return [];
-  return array.slice(0, n);
+  return n >= array.length ? array.slice() : array.slice(0, n);
 }
 __name(take, "take");
 function takeWhile(array, predicate) {
-  if (!Array.isArray(array)) return [];
   const result = [];
-  for (let i = 0; i < array.length; i++) {
-    if (!predicate(array[i], i)) break;
-    result.push(array[i]);
+  if (!Array.isArray(array)) return result;
+  const len = array.length;
+  for (let i = 0; i < len; i++) {
+    const item = array[i];
+    if (!predicate(item, i)) break;
+    result.push(item);
   }
   return result;
 }
 __name(takeWhile, "takeWhile");
 function compact(array) {
   if (!Array.isArray(array)) return [];
-  return array.filter(Boolean);
+  const result = [];
+  for (const v of array) {
+    if (v) result.push(v);
+  }
+  return result;
 }
 __name(compact, "compact");
 function countBy(array, keyFn) {
   if (!Array.isArray(array)) return {};
-  return array.reduce((acc, item) => {
+  const result = {};
+  for (const item of array) {
     const key = String(keyFn(item));
-    acc[key] = (acc[key] || 0) + 1;
-    return acc;
-  }, {});
+    result[key] = (result[key] ?? 0) + 1;
+  }
+  return result;
 }
 __name(countBy, "countBy");
+function toggle(array, item) {
+  if (!Array.isArray(array)) return [
+    item
+  ];
+  const exists = array.includes(item);
+  if (exists) return array.filter((x) => x !== item);
+  return [
+    ...array,
+    item
+  ];
+}
+__name(toggle, "toggle");
+function secureIndex(max) {
+  if (!Number.isInteger(max) || max <= 0) throw new RangeError("Max must be a positive integer");
+  const limit = 4294967295 - 4294967295 % max;
+  let rand;
+  do {
+    rand = randomBytes(4).readUInt32BE(0);
+  } while (rand >= limit);
+  return rand % max;
+}
+__name(secureIndex, "secureIndex");
+var secureRandom = /* @__PURE__ */ __name((array) => {
+  if (!Array.isArray(array) || array.length === 0) return void 0;
+  const idx = secureIndex(array.length);
+  return array[idx];
+}, "secureRandom");
+function findLast(array, predicate) {
+  if (!Array.isArray(array)) return void 0;
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i], i, array)) return array[i];
+  }
+  return void 0;
+}
+__name(findLast, "findLast");
+function findLastIndex(array, predicate) {
+  if (!Array.isArray(array)) return -1;
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i], i, array)) return i;
+  }
+  return -1;
+}
+__name(findLastIndex, "findLastIndex");
+function chunkBy(array, predicate) {
+  if (!Array.isArray(array) || array.length === 0) return [];
+  const result = [];
+  let chunk2 = [];
+  for (let i = 0; i < array.length; i++) {
+    if (predicate(array[i], i, array) && chunk2.length) {
+      result.push(chunk2);
+      chunk2 = [];
+    }
+    chunk2.push(array[i]);
+  }
+  if (chunk2.length) result.push(chunk2);
+  return result;
+}
+__name(chunkBy, "chunkBy");
+function remove(array, value) {
+  if (!Array.isArray(array)) return [];
+  return array.filter((item) => item !== value);
+}
+__name(remove, "remove");
+function isSorted(array, direction = "asc", compareFn) {
+  if (!Array.isArray(array) || array.length <= 1) return true;
+  const cmp = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  for (let i = 1; i < array.length; i++) {
+    const res = cmp(array[i - 1], array[i]);
+    if (direction === "asc" && res > 0 || direction === "desc" && res < 0) return false;
+  }
+  return true;
+}
+__name(isSorted, "isSorted");
+function headOfArr(array) {
+  return Array.isArray(array) && array.length > 0 ? array[0] : void 0;
+}
+__name(headOfArr, "headOfArr");
+function lastOfArr(array) {
+  return Array.isArray(array) && array.length > 0 ? array.at(-1) : void 0;
+}
+__name(lastOfArr, "lastOfArr");
+function drop(array, n) {
+  if (!Array.isArray(array) || n <= 0) return [
+    ...array
+  ];
+  return array.slice(n);
+}
+__name(drop, "drop");
+function dropWhile(array, predicate) {
+  if (!Array.isArray(array)) return [];
+  let i = 0;
+  while (i < array.length && predicate(array[i], i)) {
+    i++;
+  }
+  return array.slice(i);
+}
+__name(dropWhile, "dropWhile");
+function maxBy(array, keyOrFn) {
+  if (!Array.isArray(array) || array.length === 0) return void 0;
+  const fn = typeof keyOrFn === "function" ? keyOrFn : (item) => item[keyOrFn];
+  return array.reduce((max, item) => fn(item) > fn(max) ? item : max, array[0]);
+}
+__name(maxBy, "maxBy");
+function minBy(array, keyOrFn) {
+  if (!Array.isArray(array) || array.length === 0) return void 0;
+  const fn = typeof keyOrFn === "function" ? keyOrFn : (item) => item[keyOrFn];
+  return array.reduce((min, item) => fn(item) < fn(min) ? item : min, array[0]);
+}
+__name(minBy, "minBy");
 
-export { chunk, compact, countBy, difference, flattenDeep, groupBy, intersect, mergeSort, partition, pluck, random, range, shuffle, take, takeWhile, unique, zip };
+export { chunk, chunkBy, compact, countBy, difference, drop, dropWhile, findLast, findLastIndex, flattenDeep, groupBy, headOfArr, intersect, isSorted, lastOfArr, maxBy, mergeSort, minBy, partition, pluck, random, range, remove, secureIndex, secureRandom, shuffle, take, takeWhile, toggle, unique, zip };

package/async/index.cjs

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -45,7 +45,13 @@ function debounce(fn, delay) {
     pendingArgs = args;
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      fn(...pendingArgs);
+      try {
+        fn(...pendingArgs);
+      } catch (err) {
+        logger.getLogger().error({
+          err
+        }, "Error in debounced function");
+      }
       timer = null;
     }, delay);
   }
@@ -58,7 +64,13 @@ function debounce(fn, delay) {
   debounced.flush = () => {
     if (timer) {
       clearTimeout(timer);
-      fn(...pendingArgs);
+      try {
+        fn(...pendingArgs);
+      } catch (err) {
+        logger.getLogger().error({
+          err
+        }, "Error in debounced.flush");
+      }
       timer = null;
       pendingArgs = null;
     }
@@ -66,10 +78,11 @@ function debounce(fn, delay) {
   return debounced;
 }
 __name(debounce, "debounce");
-function throttle(fn, limit, opts = {
+var DEFAULT_THROTTLE_OPTS = {
   leading: true,
   trailing: false
-}) {
+};
+function throttle(fn, limit, opts = DEFAULT_THROTTLE_OPTS) {
   let lastCall = 0;
   let timer = null;
   let savedArgs = null;
@@ -84,14 +97,28 @@ function throttle(fn, limit, opts = {
         timer = null;
       }
       lastCall = now;
-      fn(...args);
+      try {
+        fn(...args);
+      } catch (err) {
+        logger.getLogger().error({
+          err
+        }, "Error in throttled function");
+      }
     } else if (trailing) {
       savedArgs = args;
       if (!timer) {
         timer = setTimeout(() => {
           lastCall = leading ? Date.now() : 0;
           timer = null;
-          if (savedArgs) fn(...savedArgs);
+          if (savedArgs) {
+            try {
+              fn(...savedArgs);
+            } catch (err) {
+              logger.getLogger().error({
+                err
+              }, "Error in throttled trailing call");
+            }
+          }
         }, remaining);
       }
     }
@@ -142,7 +169,7 @@ function singletonAsync(fn, drop = false) {
         promise = null;
       });
     } else if (drop) {
-      return Promise.reject(new Error("Busy: function already running"));
+      throw new Error("Function is already in progress");
     }
     return promise;
   };
@@ -213,11 +240,19 @@ async function runInSeries(tasks) {
 __name(runInSeries, "runInSeries");
 function memoizeAsync(fn, options = {}) {
   const cache = /* @__PURE__ */ new Map();
-  const { ttl, keyFn = JSON.stringify } = options;
-  return async function(...args) {
-    const key = keyFn(args);
+  const { ttl } = options;
+  const generateKey = /* @__PURE__ */ __name((args) => {
+    try {
+      return options.keyFn?.(args) ?? JSON.stringify(args);
+    } catch {
+      logger.getLogger().warn("memoizeAsync: key generation failed, falling back to JSON.stringify");
+      return JSON.stringify(args);
+    }
+  }, "generateKey");
+  return async (...args) => {
+    const key = generateKey(args);
     const cached = cache.get(key);
-    if (cached && (!ttl || Date.now() < cached.expires)) {
+    if (cached && Date.now() < cached.expires) {
       return cached.value;
     }
     const result = await fn(...args);
@@ -236,7 +271,10 @@ function abortable(promise, signal, abortValue = new Error("Operation aborted"))
   return Promise.race([
     promise,
     new Promise((_, reject) => {
-      const abort = /* @__PURE__ */ __name(() => reject(abortValue), "abort");
+      const abort = /* @__PURE__ */ __name(() => {
+        reject(abortValue);
+        signal.removeEventListener("abort", abort);
+      }, "abort");
       signal.addEventListener("abort", abort, {
         once: true
       });
@@ -305,39 +343,53 @@ var CircuitBreakerState = /* @__PURE__ */ (function(CircuitBreakerState2) {
 function circuitBreaker(fn, options = {}) {
   const { failureThreshold = 5, resetTimeout = 1e4, successThreshold = 1, onOpen, onClose, onHalfOpen } = options;
   let state = "CLOSED";
-  let failureCount = 0;
-  let successCount = 0;
-  let nextAttempt = Date.now();
-  return async function(...args) {
-    if (state === "OPEN") {
-      if (Date.now() < nextAttempt) {
-        throw new CircuitBreakerOpenError();
-      }
-      state = "HALF_OPEN";
-      if (onHalfOpen) onHalfOpen();
+  let fails = 0;
+  let halfSuccess = 0;
+  let unlockAt = 0;
+  const reset = /* @__PURE__ */ __name(() => {
+    fails = 0;
+    halfSuccess = 0;
+    state = "CLOSED";
+    onClose?.();
+  }, "reset");
+  const open = /* @__PURE__ */ __name(() => {
+    state = "OPEN";
+    unlockAt = Date.now() + resetTimeout;
+    onOpen?.();
+  }, "open");
+  const halfOpen = /* @__PURE__ */ __name(() => {
+    state = "HALF_OPEN";
+    onHalfOpen?.();
+  }, "halfOpen");
+  return async (...args) => {
+    const now = Date.now();
+    if (state === "OPEN" && now < unlockAt) {
+      throw new CircuitBreakerOpenError();
+    }
+    if (state === "OPEN" && now >= unlockAt) {
+      halfOpen();
     }
     try {
-      const result = await fn(...args);
+      const res = await fn(...args);
       if (state === "HALF_OPEN") {
-        successCount++;
-        if (successCount >= successThreshold) {
-          successCount = 0;
-          failureCount = 0;
-          state = "CLOSED";
-          if (onClose) onClose();
+        halfSuccess++;
+        if (halfSuccess >= successThreshold) {
+          reset();
+        } else {
+          state = "HALF_OPEN";
         }
       } else {
-        failureCount = 0;
+        fails = 0;
       }
-      return result;
-    } catch (error) {
-      failureCount++;
-      if ((state === "CLOSED" || state === "HALF_OPEN") && failureCount >= failureThreshold) {
-        state = "OPEN";
-        nextAttempt = Date.now() + resetTimeout;
-        if (onOpen) onOpen();
+      return res;
+    } catch (err) {
+      fails++;
+      if (state === "HALF_OPEN" || state === "CLOSED") {
+        if (fails >= failureThreshold) {
+          open();
+        }
       }
-      throw error;
+      throw err;
     }
   };
 }
@@ -353,12 +405,15 @@ async function runWithConcurrency(tasks, options = {}) {
   }
   return new Promise((resolve, reject) => {
     let taskIndex = 0;
+    let rejected = false;
     const processNext = /* @__PURE__ */ __name(async () => {
+      if (rejected) return;
       const currentTaskIndex = taskIndex++;
       if (currentTaskIndex >= totalTasks) return;
       try {
         const result = await tasks[currentTaskIndex]();
         if (signal?.aborted) {
+          rejected = true;
           reject(new Error("Aborted"));
           return;
         }
@@ -374,6 +429,7 @@ async function runWithConcurrency(tasks, options = {}) {
           }
         }
       } catch (error) {
+        rejected = true;
         reject(error);
         return;
       }
@@ -389,6 +445,7 @@ async function runWithConcurrency(tasks, options = {}) {
     }
     if (signal) {
       signal.addEventListener("abort", () => {
+        rejected = true;
         reject(new Error("Aborted"));
       }, {
         once: true
@@ -405,6 +462,25 @@ function optionalRequire(name) {
   }
 }
 __name(optionalRequire, "optionalRequire");
+async function raceWithValue(promises) {
+  return new Promise((resolve, reject) => {
+    let rejectedCount = 0;
+    let lastError;
+    promises.forEach((p, index) => {
+      p.then((value) => resolve({
+        value,
+        index
+      })).catch((err) => {
+        rejectedCount++;
+        lastError = err;
+        if (rejectedCount === promises.length) {
+          reject(lastError);
+        }
+      });
+    });
+  });
+}
+__name(raceWithValue, "raceWithValue");
 
 exports.CircuitBreakerOpenError = CircuitBreakerOpenError;
 exports.CircuitBreakerState = CircuitBreakerState;
@@ -415,6 +491,7 @@ exports.createTaskQueue = createTaskQueue;
 exports.debounce = debounce;
 exports.memoizeAsync = memoizeAsync;
 exports.optionalRequire = optionalRequire;
+exports.raceWithValue = raceWithValue;
 exports.rateLimit = rateLimit;
 exports.retry = retry;
 exports.runInBatches = runInBatches;