es-toolkit 0.0.1

package/esm/array/uniqBy.mjs

@@ -0,0 +1,20 @@
+import { uniqWith } from './uniqWith.mjs';
+
+/**
+ * The `uniqBy` function takes an array as its first argument and a 'converter' function as the second. It maps the array elements using the converter function, then removes any duplicates.
+ *
+ * It filters out elements with the same value, meaning it does not check for duplicates in data types like Objects.
+ *
+ * @example
+ * ```ts
+ * uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);
+ * // [1.2, 2.1, 3.3, 5.7, 7.19]
+ * ```
+ */
+function uniqBy(arr, converter) {
+  return uniqWith(arr, function (item1, item2) {
+    return converter(item1) === converter(item2);
+  });
+}
+
+export { uniqBy };

package/esm/array/uniqWith.mjs

@@ -0,0 +1,39 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * The `uniqWith` function takes an array as its first argument and a 'comparator' function as the second.
+ *
+ * It evaluates the elements of the array using the comparator function, and if true is returned, it considers those elements as duplicates and removes them.
+ *
+ * @example
+ * ```ts
+ * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => );
+ * // [1, 2, 3, 5, 7]
+ * ```
+ */
+function uniqWith(arr, areItemsEqual) {
+  var result = [];
+  var _iterator = _createForOfIteratorHelper(arr),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var item = _step.value;
+      var isUniq = result.every(function (v) {
+        return !areItemsEqual(v, item);
+      });
+      if (isUniq) {
+        result.push(item);
+      }
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+
+export { uniqWith };

package/esm/array/xor.mjs

@@ -0,0 +1,27 @@
+import { difference } from './difference.mjs';
+import { intersection } from './intersection.mjs';
+import { union } from './union.mjs';
+
+/**
+ * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements
+ * which are in either of the arrays, but not in their intersection.
+ *
+ * @template T - Type of elements in the input arrays.
+ * 
+ * @param {T[]} arr1 - The first array.
+ * @param {T[]} arr2 - The second array.
+ * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both.
+ * 
+ * @example
+ * // Returns [1, 2, 5, 6]
+ * xor([1, 2, 3, 4], [3, 4, 5, 6]);
+ * 
+ * @example
+ * // Returns ['a', 'c']
+ * xor(['a', 'b'], ['b', 'c']);
+ */
+function xor(arr1, arr2) {
+  return difference(union(arr1, arr2), intersection(arr1, arr2));
+}
+
+export { xor };

package/esm/array/xorBy.mjs

@@ -0,0 +1,30 @@
+import { differenceBy } from './differenceBy.mjs';
+import { intersectionBy } from './intersectionBy.mjs';
+import { unionBy } from './unionBy.mjs';
+
+/**
+ * Computes the symmetric difference between two arrays using a custom mapping function. 
+ * The symmetric difference is the set of elements which are in either of the arrays, 
+ * but not in their intersection, determined by the result of the mapping function.
+ *
+ * @template T - Type of elements in the input arrays.
+ * @template U - Type of the values returned by the mapping function.
+ * 
+ * @param {T[]} arr1 - The first array.
+ * @param {T[]} arr2 - The second array.
+ * @param {function(item: T): U} mapper - The function to map array elements to comparison values.
+ * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function.
+ * 
+ * @example
+ * // Custom mapping function for objects with an 'id' property
+ * const idMapper = obj => obj.id;
+ * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
+ * // Returns [{ id: 1 }, { id: 3 }]
+ */
+function xorBy(arr1, arr2, mapper) {
+  var union = unionBy(arr1, arr2, mapper);
+  var intersection = intersectionBy(arr1, arr2, mapper);
+  return differenceBy(union, intersection, mapper);
+}
+
+export { xorBy };

package/esm/array/xorWith.mjs

@@ -0,0 +1,29 @@
+import { differenceWith } from './differenceWith.mjs';
+import { intersectionWith } from './intersectionWith.mjs';
+import { unionWith } from './unionWith.mjs';
+
+/**
+ * Computes the symmetric difference between two arrays using a custom equality function. 
+ * The symmetric difference is the set of elements which are in either of the arrays, 
+ * but not in their intersection.
+ *
+ * @template T - Type of elements in the input arrays.
+ * 
+ * @param {T[]} arr1 - The first array.
+ * @param {T[]} arr2 - The second array.
+ * @param {(item1: T, item2: T) => boolean} areElementsEqual - The custom equality function to compare elements.
+ * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the custom equality function.
+ * 
+ * @example
+ * // Custom equality function for objects with an 'id' property
+ * const areObjectsEqual = (a, b) => a.id === b.id;
+ * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual);
+ * // Returns [{ id: 1 }, { id: 3 }]
+ */
+function xorWith(arr1, arr2, areElementsEqual) {
+  var union = unionWith(arr1, arr2, areElementsEqual);
+  var intersection = intersectionWith(arr1, arr2, areElementsEqual);
+  return differenceWith(union, intersection, areElementsEqual);
+}
+
+export { xorWith };

package/esm/array/zip.mjs

@@ -0,0 +1,40 @@
+import { toConsumableArray as _toConsumableArray, createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * Merges multiple arrays element-wise. Returns an array where each element is an array containing
+ * elements from the input arrays at the corresponding index.
+ * 
+ * @param {T[]} arr1 - The first array to be zipped.
+ * @param {T[]} arr2 - The second array to be zipped.
+ * @param {T[]} arr3 - The third array to be zipped.
+ * @param {T[]} arr4 - The fourth array to be zipped.
+ */
+
+function zip() {
+  var result = [];
+  for (var _len = arguments.length, arrs = new Array(_len), _key = 0; _key < _len; _key++) {
+    arrs[_key] = arguments[_key];
+  }
+  var maxIndex = Math.max.apply(Math, _toConsumableArray(arrs.map(function (x) {
+    return x.length;
+  })));
+  for (var i = 0; i < maxIndex; i++) {
+    var element = [];
+    var _iterator = _createForOfIteratorHelper(arrs),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var arr = _step.value;
+        element.push(arr[i]);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    result.push(element);
+  }
+  return result;
+}
+
+export { zip };

package/esm/array/zipWith.mjs

@@ -0,0 +1,31 @@
+import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * Combines multiple arrays element-wise using a provided combining function. 
+ * Returns an array where each element is the result of applying the combining function 
+ * to the corresponding elements from the input arrays.
+ */
+
+function zipWith(arr1) {
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  var arrs = [arr1].concat(_toConsumableArray(rest.slice(0, -1)));
+  var combine = rest[rest.length - 1];
+  var result = [];
+  var maxIndex = Math.max.apply(Math, _toConsumableArray(arrs.map(function (arr) {
+    return arr.length;
+  })));
+  var _loop = function _loop(i) {
+    var elements = arrs.map(function (arr) {
+      return arr[i];
+    });
+    result.push(combine.apply(void 0, _toConsumableArray(elements)));
+  };
+  for (var i = 0; i < maxIndex; i++) {
+    _loop(i);
+  }
+  return result;
+}
+
+export { zipWith };

package/esm/function/debounce.mjs

@@ -0,0 +1,39 @@
+/**
+ * Creates a debounced function that delays invoking the provided function until after `waitMs` milliseconds
+ * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+ * method to cancel any pending execution.
+ *
+ * @param {() => void} func - The function to debounce.
+ * @param {number} waitMs - The number of milliseconds to delay.
+ * @returns {{ (): void; cancel: () => void }} A new debounced function with a `cancel` method.
+ *
+ * @example
+ * const debouncedFunction = debounce(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' after 1 second if not called again in that time
+ * debouncedFunction();
+ * 
+ * // Will not log anything as the previous call is canceled
+ * debouncedFunction.cancel();
+ */
+function debounce(func, waitMs) {
+  var timeoutId = null;
+  var debounced = function debounced() {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(function () {
+      func();
+    }, waitMs);
+  };
+  debounced.cancel = function () {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+  };
+  return debounced;
+}
+
+export { debounce };

package/esm/function/index.mjs

@@ -0,0 +1,3 @@
+export { debounce } from './debounce.mjs';
+export { once } from './once.mjs';
+export { throttle } from './throttle.mjs';

package/esm/function/once.mjs

@@ -0,0 +1,32 @@
+/**
+ * Creates a function that is restricted to invoking the provided function `func` once.
+ * Repeated calls to the function will return the value from the first invocation.
+ *
+ * @template F - The type of the function to be invoked once.
+ * @param {F} func - The function to restrict.
+ * @returns {F} A new function that invokes `func` once and caches the result.
+ *
+ * @example
+ * const initialize = once(() => {
+ *   console.log('Initialized!');
+ *   return true;
+ * });
+ * 
+ * initialize(); // Logs: 'Initialized!' and returns true
+ * initialize(); // Returns true without logging
+ */
+function once(func) {
+  var called = false;
+  var cache;
+  return function () {
+    if (called) {
+      return cache;
+    }
+    var result = func();
+    called = true;
+    cache = result;
+    return result;
+  };
+}
+
+export { once };

package/esm/function/throttle.mjs

@@ -0,0 +1,38 @@
+/**
+ * Creates a throttled function that only invokes the provided function at most once
+ * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+ * within the wait time will not trigger the execution of the original function.
+ *
+ * @param {() => void} func - The function to throttle.
+ * @param {number} throttleMs - The number of milliseconds to throttle executions to.
+ * @returns {() => void} A new throttled function.
+ *
+ * @example
+ * const throttledFunction = throttle(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' immediately
+ * throttledFunction();
+ * 
+ * // Will not log anything as it is within the throttle time
+ * throttledFunction();
+ * 
+ * // After 1 second
+ * setTimeout(() => {
+ *   throttledFunction(); // Will log 'Function executed'
+ * }, 1000);
+ */
+function throttle(func, throttleMs) {
+  var lastCallTime;
+  var throttledFunction = function throttledFunction() {
+    var now = Date.now();
+    if (lastCallTime == null || now - lastCallTime >= throttleMs) {
+      lastCallTime = now;
+      func();
+    }
+  };
+  return throttledFunction;
+}
+
+export { throttle };

package/esm/index.mjs

@@ -0,0 +1,45 @@
+export { chunk } from './array/chunk.mjs';
+export { difference } from './array/difference.mjs';
+export { differenceBy } from './array/differenceBy.mjs';
+export { differenceWith } from './array/differenceWith.mjs';
+export { drop } from './array/drop.mjs';
+export { dropRight } from './array/dropRight.mjs';
+export { dropRightWhile } from './array/dropRightWhile.mjs';
+export { dropWhile } from './array/dropWhile.mjs';
+export { groupBy } from './array/groupBy.mjs';
+export { intersection } from './array/intersection.mjs';
+export { intersectionBy } from './array/intersectionBy.mjs';
+export { intersectionWith } from './array/intersectionWith.mjs';
+export { partition } from './array/partition.mjs';
+export { sample } from './array/sample.mjs';
+export { shuffle } from './array/shuffle.mjs';
+export { take } from './array/take.mjs';
+export { takeRight } from './array/takeRight.mjs';
+export { takeRightWhile } from './array/takeRightWhile.mjs';
+export { takeWhile } from './array/takeWhile.mjs';
+export { union } from './array/union.mjs';
+export { unionBy } from './array/unionBy.mjs';
+export { unionWith } from './array/unionWith.mjs';
+export { uniq } from './array/uniq.mjs';
+export { uniqBy } from './array/uniqBy.mjs';
+export { uniqWith } from './array/uniqWith.mjs';
+export { xor } from './array/xor.mjs';
+export { xorBy } from './array/xorBy.mjs';
+export { xorWith } from './array/xorWith.mjs';
+export { zip } from './array/zip.mjs';
+export { zipWith } from './array/zipWith.mjs';
+export { debounce } from './function/debounce.mjs';
+export { once } from './function/once.mjs';
+export { throttle } from './function/throttle.mjs';
+export { clamp } from './math/clamp.mjs';
+export { round } from './math/round.mjs';
+export { sum } from './math/sum.mjs';
+export { omit } from './object/omit.mjs';
+export { omitBy } from './object/omitBy.mjs';
+export { pick } from './object/pick.mjs';
+export { pickBy } from './object/pickBy.mjs';
+export { isNil } from './predicate/isNil.mjs';
+export { isNotNil } from './predicate/isNotNil.mjs';
+export { isNull } from './predicate/isNull.mjs';
+export { isUndefined } from './predicate/isUndefined.mjs';
+export { delay } from './promise/delay.mjs';

package/esm/math/clamp.mjs

@@ -0,0 +1,18 @@
+/**
+ * @name clamp
+ * @description Checks if `value` is within the bounds, if not return the closest bound (bound1: min, bound2: max)
+ * function clamp(value: number, bound1: number, bound2?: number): number
+ * @example
+ * clamp(3, 1) // 3
+ * clamp(3, 1, 5) // 3
+ * clamp(3, 5) // 5
+ * clamp(7, 3, 5) // 5
+ */
+function clamp(value, bound1, bound2) {
+  if (bound2 == null) {
+    return Math.min(value, bound1);
+  }
+  return Math.min(Math.max(value, bound1), bound2);
+}
+
+export { clamp };

package/esm/math/index.mjs

@@ -0,0 +1,3 @@
+export { clamp } from './clamp.mjs';
+export { round } from './round.mjs';
+export { sum } from './sum.mjs';

package/esm/math/round.mjs

@@ -0,0 +1,19 @@
+/**
+ * @name round
+ * @description Rounds given number to given precision
+ * ```typescript
+ * function round(value: number, precision: number = 0): number
+ * ```
+ * 
+ * @example
+ * round(1.2) === 1
+ * round(3.9) === 4
+ * round(8.5) === 9
+ */
+function round(value) {
+  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var multiplier = Math.pow(10, precision);
+  return Math.round(value * multiplier) / multiplier;
+}
+
+export { round };

package/esm/math/sum.mjs

@@ -0,0 +1,22 @@
+/**
+ * @name sum
+ * @description Return the sum of given values.
+ * ```typescript
+ * function sum(...nums: number[] | number[][]): number;
+ * ```
+ *
+ * @example
+ * sum(1, 2, 3) === 6
+ * sum(...[1, 2, 3]) === 6
+ * sum([1, 2, 3]) === 6
+ */
+function sum() {
+  for (var _len = arguments.length, nums = new Array(_len), _key = 0; _key < _len; _key++) {
+    nums[_key] = arguments[_key];
+  }
+  return nums.flat().reduce(function (acc, curr) {
+    return acc + curr;
+  }, 0);
+}
+
+export { sum };

package/esm/object/_virtual/_rollupPluginBabelHelpers.mjs

@@ -0,0 +1,115 @@
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function () {};
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+export { _arrayLikeToArray as arrayLikeToArray, _createForOfIteratorHelper as createForOfIteratorHelper, _defineProperty as defineProperty, _objectSpread2 as objectSpread2, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey, _unsupportedIterableToArray as unsupportedIterableToArray };

package/esm/object/index.mjs

@@ -0,0 +1,4 @@
+export { omit } from './omit.mjs';
+export { omitBy } from './omitBy.mjs';
+export { pick } from './pick.mjs';
+export { pickBy } from './pickBy.mjs';

package/esm/object/omit.mjs

@@ -0,0 +1,26 @@
+import { objectSpread2 as _objectSpread2, createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * @name omit
+ * Omit properties from an object.
+ * @param obj The object to omit properties from
+ * @param keys The keys to omit from an object
+ */
+function omit(obj, keys) {
+  var result = _objectSpread2({}, obj);
+  var _iterator = _createForOfIteratorHelper(keys),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      delete result[key];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+
+export { omit };

package/esm/object/omitBy.mjs

@@ -0,0 +1,5 @@
+function omitBy() {
+  throw new Error('Not implemented');
+}
+
+export { omitBy };

package/esm/object/pick.mjs

@@ -0,0 +1,26 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * @name pick
+ * Pick properties from an given object.
+ * @param obj The object to pick properties from
+ * @param keys The keys to pick from an object
+ */
+function pick(obj, keys) {
+  var result = {};
+  var _iterator = _createForOfIteratorHelper(keys),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      result[key] = obj[key];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+
+export { pick };

package/esm/object/pickBy.mjs

@@ -0,0 +1,5 @@
+function pickBy() {
+  throw new Error('Not implemented');
+}
+
+export { pickBy };

package/esm/predicate/index.mjs

@@ -0,0 +1,4 @@
+export { isNil } from './isNil.mjs';
+export { isNotNil } from './isNotNil.mjs';
+export { isNull } from './isNull.mjs';
+export { isUndefined } from './isUndefined.mjs';

package/esm/predicate/isNil.mjs

@@ -0,0 +1,10 @@
+/**
+ * @name isNil
+ * Checks if the given value is null or undefined.
+ * @param x The value to test if it is null or undefined
+ */
+function isNil(x) {
+  return x == null || x == undefined;
+}
+
+export { isNil };