es-toolkit 1.7.1-dev.153 → 1.7.1-dev.155

package/dist/array/orderBy.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/array/orderBy.ts
+var orderBy_exports = {};
+__export(orderBy_exports, {
+  orderBy: () => orderBy
+});
+module.exports = __toCommonJS(orderBy_exports);
+function orderBy(collection, keys, orders) {
+  const compareValues = (a, b, order) => {
+    if (a < b) {
+      return order === "asc" ? -1 : 1;
+    }
+    if (a > b) {
+      return order === "asc" ? 1 : -1;
+    }
+    return 0;
+  };
+  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);
+  return collection.slice().sort((a, b) => {
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const order = effectiveOrders[i];
+      const result = compareValues(a[key], b[key], order);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  orderBy
+});
+//# sourceMappingURL=orderBy.js.map

package/dist/array/orderBy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/orderBy.ts"],"sourcesContent":["type Order = 'asc' | 'desc';\n\n/**\n * Sorts an array of objects based on multiple properties and their corresponding order directions.\n *\n * This function takes an array of objects, an array of keys to sort by, and an array of order directions.\n * It returns the sorted array, ordering by each key according to its corresponding direction\n * ('asc' for ascending or 'desc' for descending). If values for a key are equal,\n * it moves to the next key to determine the order.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} collection - The array of objects to be sorted.\n * @param {Array<keyof T>} keys - An array of keys (properties) by which to sort.\n * @param {Order[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).\n * @returns {T[]} - The sorted array.\n *\n * @example\n * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.\n * const users = [\n *   { user: 'fred', age: 48 },\n *   { user: 'barney', age: 34 },\n *   { user: 'fred', age: 40 },\n *   { user: 'barney', age: 36 },\n * ];\n * const result = orderBy(users, ['user', 'age'], ['asc', 'desc']);\n * // result will be:\n * // [\n * //   { user: 'barney', age: 36 },\n * //   { user: 'barney', age: 34 },\n * //   { user: 'fred', age: 48 },\n * //   { user: 'fred', age: 40 },\n * // ]\n */\nexport function orderBy<T>(collection: T[], keys: Array<keyof T>, orders: Order[]): T[] {\n  const compareValues = (a: T[keyof T], b: T[keyof T], order: Order) => {\n    if (a < b) {\n      return order === 'asc' ? -1 : 1;\n    }\n    if (a > b) {\n      return order === 'asc' ? 1 : -1;\n    }\n    return 0;\n  };\n\n  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);\n\n  return collection.slice().sort((a, b) => {\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n      const order = effectiveOrders[i];\n      const result = compareValues(a[key], b[key], order);\n      if (result !== 0) {\n        return result;\n      }\n    }\n    return 0;\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCO,SAAS,QAAW,YAAiB,MAAsB,QAAsB;AACtF,QAAM,gBAAgB,CAAC,GAAe,GAAe,UAAiB;AACpE,QAAI,IAAI,GAAG;AACT,aAAO,UAAU,QAAQ,KAAK;AAAA,IAChC;AACA,QAAI,IAAI,GAAG;AACT,aAAO,UAAU,QAAQ,IAAI;AAAA,IAC/B;AACA,WAAO;AAAA,EACT;AAEA,QAAM,kBAAkB,KAAK,IAAI,CAAC,GAAG,UAAU,OAAO,KAAK,KAAK,OAAO,OAAO,SAAS,CAAC,CAAC;AAEzF,SAAO,WAAW,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM;AACvC,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAClB,YAAM,QAAQ,gBAAgB,CAAC;AAC/B,YAAM,SAAS,cAAc,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,KAAK;AAClD,UAAI,WAAW,GAAG;AAChB,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT,CAAC;AACH;","names":[]}

package/dist/array/orderBy.mjs

@@ -0,0 +1,8 @@
+import {
+  orderBy
+} from "../chunk-7B7W36UP.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  orderBy
+};
+//# sourceMappingURL=orderBy.mjs.map

package/dist/chunk-7B7W36UP.mjs

@@ -0,0 +1,29 @@
+// src/array/orderBy.ts
+function orderBy(collection, keys, orders) {
+  const compareValues = (a, b, order) => {
+    if (a < b) {
+      return order === "asc" ? -1 : 1;
+    }
+    if (a > b) {
+      return order === "asc" ? 1 : -1;
+    }
+    return 0;
+  };
+  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);
+  return collection.slice().sort((a, b) => {
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const order = effectiveOrders[i];
+      const result = compareValues(a[key], b[key], order);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  });
+}
+
+export {
+  orderBy
+};
+//# sourceMappingURL=chunk-7B7W36UP.mjs.map

package/dist/chunk-7B7W36UP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/orderBy.ts"],"sourcesContent":["type Order = 'asc' | 'desc';\n\n/**\n * Sorts an array of objects based on multiple properties and their corresponding order directions.\n *\n * This function takes an array of objects, an array of keys to sort by, and an array of order directions.\n * It returns the sorted array, ordering by each key according to its corresponding direction\n * ('asc' for ascending or 'desc' for descending). If values for a key are equal,\n * it moves to the next key to determine the order.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} collection - The array of objects to be sorted.\n * @param {Array<keyof T>} keys - An array of keys (properties) by which to sort.\n * @param {Order[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).\n * @returns {T[]} - The sorted array.\n *\n * @example\n * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.\n * const users = [\n *   { user: 'fred', age: 48 },\n *   { user: 'barney', age: 34 },\n *   { user: 'fred', age: 40 },\n *   { user: 'barney', age: 36 },\n * ];\n * const result = orderBy(users, ['user', 'age'], ['asc', 'desc']);\n * // result will be:\n * // [\n * //   { user: 'barney', age: 36 },\n * //   { user: 'barney', age: 34 },\n * //   { user: 'fred', age: 48 },\n * //   { user: 'fred', age: 40 },\n * // ]\n */\nexport function orderBy<T>(collection: T[], keys: Array<keyof T>, orders: Order[]): T[] {\n  const compareValues = (a: T[keyof T], b: T[keyof T], order: Order) => {\n    if (a < b) {\n      return order === 'asc' ? -1 : 1;\n    }\n    if (a > b) {\n      return order === 'asc' ? 1 : -1;\n    }\n    return 0;\n  };\n\n  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);\n\n  return collection.slice().sort((a, b) => {\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n      const order = effectiveOrders[i];\n      const result = compareValues(a[key], b[key], order);\n      if (result !== 0) {\n        return result;\n      }\n    }\n    return 0;\n  });\n}\n"],"mappings":";AAiCO,SAAS,QAAW,YAAiB,MAAsB,QAAsB;AACtF,QAAM,gBAAgB,CAAC,GAAe,GAAe,UAAiB;AACpE,QAAI,IAAI,GAAG;AACT,aAAO,UAAU,QAAQ,KAAK;AAAA,IAChC;AACA,QAAI,IAAI,GAAG;AACT,aAAO,UAAU,QAAQ,IAAI;AAAA,IAC/B;AACA,WAAO;AAAA,EACT;AAEA,QAAM,kBAAkB,KAAK,IAAI,CAAC,GAAG,UAAU,OAAO,KAAK,KAAK,OAAO,OAAO,SAAS,CAAC,CAAC;AAEzF,SAAO,WAAW,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM;AACvC,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAClB,YAAM,QAAQ,gBAAgB,CAAC;AAC/B,YAAM,SAAS,cAAc,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,KAAK;AAClD,UAAI,WAAW,GAAG;AAChB,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT,CAAC;AACH;","names":[]}

package/dist/chunk-FLTT2MGF.mjs

@@ -0,0 +1,14 @@
+// src/object/invert.ts
+function invert(obj) {
+  const result = {};
+  for (const key in obj) {
+    const value = obj[key];
+    result[value] = key;
+  }
+  return result;
+}
+
+export {
+  invert
+};
+//# sourceMappingURL=chunk-FLTT2MGF.mjs.map

package/dist/chunk-FLTT2MGF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/object/invert.ts"],"sourcesContent":["/**\n * Inverts the keys and values of an object. The keys of the input object become the values of the output object and vice versa.\n *\n * This function takes an object and creates a new object by inverting its keys and values. If the input object has duplicate values,\n * the key of the last occurrence will be used as the value for the new key in the output object. It effectively creates a reverse mapping\n * of the input object's key-value pairs.\n *\n * @template K - Type of the keys in the input object (string, number, symbol)\n * @template V - Type of the values in the input object (string, number, symbol)\n * @param {Record<K, V>} obj - The input object whose keys and values are to be inverted\n * @returns {{ [key in V]: K }} - A new object with keys and values inverted\n *\n * @example\n * invert({ a: 1, b: 2, c: 3 }); // { 1: 'a', 2: 'b', 3: 'c' }\n * invert({ 1: 'a', 2: 'b', 3: 'c' }); // { a: '1', b: '2', c: '3' }\n * invert({ a: 1, 2: 'b', c: 3, 4: 'd' }); // { 1: 'a', b: '2', 3: 'c', d: '4' }\n * invert({ a: Symbol('sym1'), b: Symbol('sym2') }); // { [Symbol('sym1')]: 'a', [Symbol('sym2')]: 'b' }\n */\n\ntype PropertyKey = string | number | symbol;\n\nexport function invert<K extends PropertyKey, V extends PropertyKey>(obj: Record<K, V>): { [key in V]: K } {\n  const result = {} as { [key in V]: K };\n\n  for (const key in obj) {\n    const value = obj[key as K] as V;\n    result[value] = key;\n  }\n\n  return result;\n}\n"],"mappings":";AAqBO,SAAS,OAAqD,KAAsC;AACzG,QAAM,SAAS,CAAC;AAEhB,aAAW,OAAO,KAAK;AACrB,UAAM,QAAQ,IAAI,GAAQ;AAC1B,WAAO,KAAK,IAAI;AAAA,EAClB;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-OC7ZNKWX.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-OC7ZNKWX.mjs.map

package/dist/chunk-PMHULJNL.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-PMHULJNL.mjs.map

package/dist/chunk-PMHULJNL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/function/index.mjs

@@ -1,7 +1,4 @@
 import "../chunk-N6EM6ETS.mjs";
-import {
-  debounce
-} from "../chunk-3IP4JVLL.mjs";
 import {
   noop
 } from "../chunk-LKXCOLNY.mjs";
@@ -11,6 +8,9 @@ import {
 import {
   throttle
 } from "../chunk-QOJGMVVR.mjs";
+import {
+  debounce
+} from "../chunk-3IP4JVLL.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   debounce,

package/dist/index.d.mts

@@ -17,6 +17,7 @@ export { intersectionWith } from './array/intersectionWith.mjs';
 export { keyBy } from './array/keyBy.mjs';
 export { maxBy } from './array/maxBy.mjs';
 export { minBy } from './array/minBy.mjs';
+export { orderBy } from './array/orderBy.mjs';
 export { partition } from './array/partition.mjs';
 export { sample } from './array/sample.mjs';
 export { sampleSize } from './array/sampleSize.mjs';
@@ -57,6 +58,7 @@ 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 { invert } from './object/invert.mjs';
 export { isNil } from './predicate/isNil.mjs';
 export { isNotNil } from './predicate/isNotNil.mjs';
 export { isNull } from './predicate/isNull.mjs';

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export { intersectionWith } from './array/intersectionWith.js';
 export { keyBy } from './array/keyBy.js';
 export { maxBy } from './array/maxBy.js';
 export { minBy } from './array/minBy.js';
+export { orderBy } from './array/orderBy.js';
 export { partition } from './array/partition.js';
 export { sample } from './array/sample.js';
 export { sampleSize } from './array/sampleSize.js';
@@ -57,6 +58,7 @@ export { omit } from './object/omit.js';
 export { omitBy } from './object/omitBy.js';
 export { pick } from './object/pick.js';
 export { pickBy } from './object/pickBy.js';
+export { invert } from './object/invert.js';
 export { isNil } from './predicate/isNil.js';
 export { isNotNil } from './predicate/isNotNil.js';
 export { isNull } from './predicate/isNull.js';

package/dist/index.js

@@ -55,6 +55,7 @@ __export(src_exports, {
   intersection: () => intersection,
   intersectionBy: () => intersectionBy,
   intersectionWith: () => intersectionWith,
+  invert: () => invert,
   isNil: () => isNil,
   isNotNil: () => isNotNil,
   isNull: () => isNull,
@@ -68,6 +69,7 @@ __export(src_exports, {
   omit: () => omit,
   omitBy: () => omitBy,
   once: () => once,
+  orderBy: () => orderBy,
   partition: () => partition,
   pick: () => pick,
   pickBy: () => pickBy,
@@ -279,6 +281,31 @@ function minBy(items, getValue) {
   return minElement;
 }
 
+// src/array/orderBy.ts
+function orderBy(collection, keys, orders) {
+  const compareValues = (a, b, order) => {
+    if (a < b) {
+      return order === "asc" ? -1 : 1;
+    }
+    if (a > b) {
+      return order === "asc" ? 1 : -1;
+    }
+    return 0;
+  };
+  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);
+  return collection.slice().sort((a, b) => {
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const order = effectiveOrders[i];
+      const result = compareValues(a[key], b[key], order);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  });
+}
+
 // src/array/partition.ts
 function partition(arr, isInTruthy) {
   const truthy = [];
@@ -684,6 +711,16 @@ function pickBy(obj, shouldPick) {
   return result;
 }
 
+// src/object/invert.ts
+function invert(obj) {
+  const result = {};
+  for (const key in obj) {
+    const value = obj[key];
+    result[value] = key;
+  }
+  return result;
+}
+
 // src/predicate/isNil.ts
 function isNil(x) {
   return x === null || x === void 0;
@@ -744,6 +781,7 @@ function delay(ms, { signal } = {}) {
   intersection,
   intersectionBy,
   intersectionWith,
+  invert,
   isNil,
   isNotNil,
   isNull,
@@ -757,6 +795,7 @@ function delay(ms, { signal } = {}) {
   omit,
   omitBy,
   once,
+  orderBy,
   partition,
   pick,
   pickBy,