es-toolkit 1.10.1 → 1.11.0-dev.263

package/dist/compat/index.js

@@ -30,11 +30,32 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 
 // src/compat/index.ts
 var compat_exports = {};
 __export(compat_exports, {
   AbortError: () => AbortError,
+  TimeoutError: () => TimeoutError,
   camelCase: () => camelCase,
   capitalize: () => capitalize,
   chunk: () => chunk2,
@@ -51,10 +72,13 @@ __export(compat_exports, {
   dropRight: () => dropRight,
   dropRightWhile: () => dropRightWhile,
   dropWhile: () => dropWhile,
+  endsWith: () => endsWith,
   fill: () => fill,
+  flatMap: () => flatMap,
   flatten: () => flatten,
   flattenDeep: () => flattenDeep,
   forEachRight: () => forEachRight,
+  get: () => get,
   groupBy: () => groupBy,
   head: () => head,
   inRange: () => inRange,
@@ -72,9 +96,11 @@ __export(compat_exports, {
   keyBy: () => keyBy,
   last: () => last,
   lowerCase: () => lowerCase,
+  max: () => max,
   maxBy: () => maxBy,
   mean: () => mean,
   meanBy: () => meanBy,
+  min: () => min,
   minBy: () => minBy,
   negate: () => negate,
   noop: () => noop,
@@ -91,8 +117,11 @@ __export(compat_exports, {
   round: () => round,
   sample: () => sample,
   sampleSize: () => sampleSize,
+  set: () => set,
   shuffle: () => shuffle,
   snakeCase: () => snakeCase,
+  startCase: () => startCase,
+  startsWith: () => startsWith,
   sum: () => sum,
   sumBy: () => sumBy,
   tail: () => tail,
@@ -110,12 +139,14 @@ __export(compat_exports, {
   uniqWith: () => uniqWith,
   unzip: () => unzip,
   unzipWith: () => unzipWith,
+  withTimeout: () => withTimeout,
   without: () => without,
   xor: () => xor,
   xorBy: () => xorBy,
   xorWith: () => xorWith,
   zip: () => zip,
   zipObject: () => zipObject,
+  zipObjectDeep: () => zipObjectDeep,
   zipWith: () => zipWith
 });
 module.exports = __toCommonJS(compat_exports);
@@ -182,12 +213,27 @@ function differenceWith(firstArr, secondArr, areItemsEqual) {
 
 // src/array/drop.ts
 function drop(arr, itemsCount) {
+  itemsCount = Math.max(itemsCount, 0);
   return arr.slice(itemsCount);
 }
 
 // src/array/dropRight.ts
 function dropRight(arr, itemsCount) {
-  return arr.slice(0, -itemsCount);
+  itemsCount = Math.min(-itemsCount, 0);
+  if (itemsCount === 0) {
+    return arr.slice();
+  }
+  return arr.slice(0, itemsCount);
+}
+
+// src/array/dropRightWhile.ts
+function dropRightWhile(arr, canContinueDropping) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (!canContinueDropping(arr[i])) {
+      return arr.slice(0, i + 1);
+    }
+  }
+  return [];
 }
 
 // src/array/dropWhile.ts
@@ -199,21 +245,15 @@ function dropWhile(arr, canContinueDropping) {
   return arr.slice(dropEndIndex);
 }
 
-// src/array/dropRightWhile.ts
-function dropRightWhile(arr, canContinueDropping) {
-  const reversed = arr.slice().reverse();
-  const dropped = dropWhile(reversed, canContinueDropping);
-  return dropped.slice().reverse();
-}
-
 // src/array/fill.ts
-function fill(arr, value, start = 0, end = arr.length) {
-  start = Math.max(start, 0);
-  end = Math.min(end, arr.length);
-  for (let i = start; i < end; i++) {
-    arr[i] = value;
+function fill(array, value, start = 0, end = array.length) {
+  const length = array.length;
+  const finalStart = Math.max(start >= 0 ? start : length + start, 0);
+  const finalEnd = Math.min(end >= 0 ? end : length + end, length);
+  for (let i = finalStart; i < finalEnd; i++) {
+    array[i] = value;
   }
-  return arr;
+  return array;
 }
 
 // src/array/flatten.ts
@@ -233,6 +273,11 @@ function flatten(arr, depth = 1) {
   return result;
 }
 
+// src/array/flatMap.ts
+function flatMap(arr, iteratee, depth = 1) {
+  return flatten(arr.map((item) => iteratee(item)), depth);
+}
+
 // src/array/flattenDeep.ts
 function flattenDeep(arr) {
   return flatten(arr, Infinity);
@@ -295,11 +340,11 @@ function keyBy(arr, getKeyFromItem) {
 // src/array/maxBy.ts
 function maxBy(items, getValue) {
   let maxElement = items[0];
-  let max = -Infinity;
+  let max2 = -Infinity;
   for (const element of items) {
     const value = getValue(element);
-    if (value > max) {
-      max = value;
+    if (value > max2) {
+      max2 = value;
       maxElement = element;
     }
   }
@@ -309,11 +354,11 @@ function maxBy(items, getValue) {
 // src/array/minBy.ts
 function minBy(items, getValue) {
   let minElement = items[0];
-  let min = Infinity;
+  let min2 = Infinity;
   for (const element of items) {
     const value = getValue(element);
-    if (value < min) {
-      min = value;
+    if (value < min2) {
+      min2 = value;
       minElement = element;
     }
   }
@@ -640,6 +685,14 @@ var AbortError = class extends Error {
   }
 };
 
+// src/error/TimeoutError.ts
+var TimeoutError = class extends Error {
+  constructor(message = "The operation was timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+
 // src/function/debounce.ts
 function debounce(func, debounceMs, { signal } = {}) {
   let timeoutId = null;
@@ -825,7 +878,9 @@ function pickBy(obj, shouldPick) {
 // src/object/invert.ts
 function invert(obj) {
   const result = {};
-  for (const key in obj) {
+  const keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
     const value = obj[key];
     result[value] = key;
   }
@@ -940,6 +995,21 @@ function delay(ms, { signal } = {}) {
   });
 }
 
+// src/promise/timeout.ts
+function timeout(ms) {
+  return __async(this, null, function* () {
+    yield delay(ms);
+    throw new TimeoutError();
+  });
+}
+
+// src/promise/withTimeout.ts
+function withTimeout(run, ms) {
+  return __async(this, null, function* () {
+    return Promise.race([run(), timeout(ms)]);
+  });
+}
+
 // src/string/capitalize.ts
 var capitalize = (str) => {
   return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
@@ -980,6 +1050,23 @@ var lowerCase = (str) => {
   return words.map((word) => word.toLowerCase()).join(" ");
 };
 
+// src/string/startCase.ts
+function startCase(str) {
+  const words = getWords(str.trim());
+  let result = "";
+  for (const word of words) {
+    if (result) {
+      result += " ";
+    }
+    if (word === word.toUpperCase()) {
+      result += word;
+    } else {
+      result += word[0].toUpperCase() + word.slice(1).toLowerCase();
+    }
+  }
+  return result;
+}
+
 // src/compat/array/chunk.ts
 function chunk2(arr, size = 1) {
   size = Math.max(Math.floor(size), 0);
@@ -988,9 +1075,167 @@ function chunk2(arr, size = 1) {
   }
   return chunk(arr, size);
 }
+
+// src/compat/_internal/isIndex.ts
+var IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value) {
+  switch (typeof value) {
+    case "number": {
+      return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
+    }
+    case "symbol": {
+      return false;
+    }
+    case "string": {
+      return IS_UNSIGNED_INTEGER.test(value);
+    }
+  }
+}
+
+// src/compat/_internal/toPath.ts
+function toPath(deepKey) {
+  const ESCAPE_REGEXP = /\\(\\)?/g;
+  const PROPERTY_REGEXP = RegExp(
+    // Match anything that isn't a dot or bracket.
+    `[^.[\\]]+|\\[(?:([^"'][^[]*)|(["'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))`,
+    "g"
+  );
+  const result = [];
+  if (deepKey[0] === ".") {
+    result.push("");
+  }
+  let match;
+  let lastIndex = 0;
+  let count = 0;
+  while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {
+    let [key, expr, quote, substr] = match;
+    if (quote) {
+      key = substr.replace(ESCAPE_REGEXP, "$1");
+    } else if (expr) {
+      key = expr;
+    }
+    result.push(key);
+    if (PROPERTY_REGEXP.lastIndex === lastIndex) {
+      PROPERTY_REGEXP.lastIndex++;
+    } else {
+      lastIndex = PROPERTY_REGEXP.lastIndex;
+    }
+  }
+  return result;
+}
+
+// src/compat/object/set.ts
+function set(obj, path, value) {
+  const resolvedPath = Array.isArray(path) ? path : typeof path === "string" ? toPath(path) : [path];
+  let current = obj;
+  for (let i = 0; i < resolvedPath.length - 1; i++) {
+    const key = resolvedPath[i];
+    const nextKey = resolvedPath[i + 1];
+    if (current[key] == null) {
+      current[key] = isIndex(nextKey) ? [] : {};
+    }
+    current = current[key];
+  }
+  const lastKey = resolvedPath[resolvedPath.length - 1];
+  current[lastKey] = value;
+  return obj;
+}
+
+// src/compat/array/zipObjectDeep.ts
+function zipObjectDeep(keys, values) {
+  const result = {};
+  const zipped = zip(keys, values);
+  for (let i = 0; i < zipped.length; i++) {
+    const [key, value] = zipped[i];
+    if (key != null) {
+      set(result, key, value);
+    }
+  }
+  return result;
+}
+
+// src/compat/_internal/isDeepKey.ts
+var IS_PLAIN = /^\w*$/;
+var IS_DEEP = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+function isDeepKey(key) {
+  switch (typeof key) {
+    case "number":
+    case "symbol": {
+      return false;
+    }
+    case "string": {
+      return !IS_PLAIN.test(key) && IS_DEEP.test(key);
+    }
+  }
+}
+
+// src/compat/object/get.ts
+function get(object, path, defaultValue) {
+  let resolvedPath;
+  if (Array.isArray(path)) {
+    resolvedPath = path;
+  } else if (typeof path === "string" && isDeepKey(path) && (object == null ? void 0 : object[path]) == null) {
+    resolvedPath = toPath(path);
+  } else {
+    resolvedPath = [path];
+  }
+  if (resolvedPath.length === 0) {
+    return defaultValue;
+  }
+  let current = object;
+  let index;
+  for (index = 0; index < resolvedPath.length && current != null; index++) {
+    let key = resolvedPath[index];
+    if (Object.is(key.valueOf(), -0)) {
+      key = "-0";
+    }
+    current = current[key];
+  }
+  if (current === null && index === resolvedPath.length) {
+    return current;
+  }
+  return current != null ? current : defaultValue;
+}
+
+// src/compat/string/startsWith.ts
+var startsWith = (str, target, position = 0) => {
+  return str.startsWith(target, position);
+};
+
+// src/compat/string/endsWith.ts
+var endsWith = (str, target, position = str.length) => {
+  return str.endsWith(target, position);
+};
+
+// src/compat/math/max.ts
+function max(items = []) {
+  let maxElement = items[0];
+  let max2 = void 0;
+  for (const element of items) {
+    if (max2 == null || element > max2) {
+      max2 = element;
+      maxElement = element;
+    }
+  }
+  return maxElement;
+}
+
+// src/compat/math/min.ts
+function min(items = []) {
+  let minElement = items[0];
+  let min2 = void 0;
+  for (const element of items) {
+    if (min2 == null || element < min2) {
+      min2 = element;
+      minElement = element;
+    }
+  }
+  return minElement;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbortError,
+  TimeoutError,
   camelCase,
   capitalize,
   chunk,
@@ -1007,10 +1252,13 @@ function chunk2(arr, size = 1) {
   dropRight,
   dropRightWhile,
   dropWhile,
+  endsWith,
   fill,
+  flatMap,
   flatten,
   flattenDeep,
   forEachRight,
+  get,
   groupBy,
   head,
   inRange,
@@ -1028,9 +1276,11 @@ function chunk2(arr, size = 1) {
   keyBy,
   last,
   lowerCase,
+  max,
   maxBy,
   mean,
   meanBy,
+  min,
   minBy,
   negate,
   noop,
@@ -1047,8 +1297,11 @@ function chunk2(arr, size = 1) {
   round,
   sample,
   sampleSize,
+  set,
   shuffle,
   snakeCase,
+  startCase,
+  startsWith,
   sum,
   sumBy,
   tail,
@@ -1066,12 +1319,14 @@ function chunk2(arr, size = 1) {
   uniqWith,
   unzip,
   unzipWith,
+  withTimeout,
   without,
   xor,
   xorBy,
   xorWith,
   zip,
   zipObject,
+  zipObjectDeep,
   zipWith
 });
 //# sourceMappingURL=index.js.map