es-toolkit 1.0.3 → 1.0.4-dev.41

package/dist/function/once.js

@@ -0,0 +1,43 @@
+"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/function/once.ts
+var once_exports = {};
+__export(once_exports, {
+  once: () => once
+});
+module.exports = __toCommonJS(once_exports);
+function once(func) {
+  let called = false;
+  let cache;
+  return function() {
+    if (called) {
+      return cache;
+    }
+    const result = func();
+    called = true;
+    cache = result;
+    return result;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  once
+});
+//# sourceMappingURL=once.js.map

package/dist/function/once.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/function/once.ts"],"sourcesContent":["/**\n * Creates a function that is restricted to invoking the provided function `func` once.\n * Repeated calls to the function will return the value from the first invocation.\n *\n * @param {F} func - The function to restrict.\n * @returns {F} A new function that invokes `func` once and caches the result.\n *\n * @example\n * const initialize = once(() => {\n *   console.log('Initialized!');\n *   return true;\n * });\n *\n * initialize(); // Logs: 'Initialized!' and returns true\n * initialize(); // Returns true without logging\n */\nexport function once<F extends () => any>(func: F): F {\n  let called = false;\n  let cache: ReturnType<F> | undefined;\n\n  return function () {\n    if (called) {\n      return cache;\n    }\n\n    const result = func();\n\n    called = true;\n    cache = result;\n\n    return result;\n  } as F;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,SAAS,KAA0B,MAAY;AACpD,MAAI,SAAS;AACb,MAAI;AAEJ,SAAO,WAAY;AACjB,QAAI,QAAQ;AACV,aAAO;AAAA,IACT;AAEA,UAAM,SAAS,KAAK;AAEpB,aAAS;AACT,YAAQ;AAER,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/function/once.mjs

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

package/dist/function/once.mjs.map

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

package/{esm/function/throttle.mjs → dist/function/throttle.d.mts}

@@ -14,25 +14,15 @@
  *
  * // 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;
-}
+declare function throttle(func: () => void, throttleMs: number): () => void;
 
 export { throttle };

package/dist/function/throttle.d.ts

@@ -23,4 +23,6 @@
  *   throttledFunction(); // Will log 'Function executed'
  * }, 1000);
  */
-export declare function throttle(func: () => void, throttleMs: number): () => void;
+declare function throttle(func: () => void, throttleMs: number): () => void;
+
+export { throttle };

package/dist/function/throttle.js

@@ -0,0 +1,41 @@
+"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/function/throttle.ts
+var throttle_exports = {};
+__export(throttle_exports, {
+  throttle: () => throttle
+});
+module.exports = __toCommonJS(throttle_exports);
+function throttle(func, throttleMs) {
+  let lastCallTime;
+  const throttledFunction = function() {
+    const now = Date.now();
+    if (lastCallTime == null || now - lastCallTime >= throttleMs) {
+      lastCallTime = now;
+      func();
+    }
+  };
+  return throttledFunction;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  throttle
+});
+//# sourceMappingURL=throttle.js.map

package/dist/function/throttle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/function/throttle.ts"],"sourcesContent":["/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @param {() => void} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {() => void} A new throttled function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle(func: () => void, throttleMs: number) {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function () {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func();\n    }\n  };\n\n  return throttledFunction;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAyBO,SAAS,SAAS,MAAkB,YAAoB;AAC7D,MAAI;AAEJ,QAAM,oBAAoB,WAAY;AACpC,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK;AAAA,IACP;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/function/throttle.mjs

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

package/dist/function/throttle.mjs.map

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

package/dist/index.d.ts

@@ -1,6 +1,45 @@
-export * from './array';
-export * from './function';
-export * from './math';
-export * from './object';
-export * from './predicate';
-export * from './promise';
+export { chunk } from './array/chunk.js';
+export { difference } from './array/difference.js';
+export { differenceBy } from './array/differenceBy.js';
+export { differenceWith } from './array/differenceWith.js';
+export { drop } from './array/drop.js';
+export { dropRight } from './array/dropRight.js';
+export { dropRightWhile } from './array/dropRightWhile.js';
+export { dropWhile } from './array/dropWhile.js';
+export { groupBy } from './array/groupBy.js';
+export { intersection } from './array/intersection.js';
+export { intersectionBy } from './array/intersectionBy.js';
+export { intersectionWith } from './array/intersectionWith.js';
+export { partition } from './array/partition.js';
+export { sample } from './array/sample.js';
+export { shuffle } from './array/shuffle.js';
+export { take } from './array/take.js';
+export { takeRight } from './array/takeRight.js';
+export { takeRightWhile } from './array/takeRightWhile.js';
+export { takeWhile } from './array/takeWhile.js';
+export { union } from './array/union.js';
+export { unionBy } from './array/unionBy.js';
+export { unionWith } from './array/unionWith.js';
+export { uniq } from './array/uniq.js';
+export { uniqBy } from './array/uniqBy.js';
+export { uniqWith } from './array/uniqWith.js';
+export { xor } from './array/xor.js';
+export { xorBy } from './array/xorBy.js';
+export { xorWith } from './array/xorWith.js';
+export { zip } from './array/zip.js';
+export { zipWith } from './array/zipWith.js';
+export { debounce } from './function/debounce.js';
+export { once } from './function/once.js';
+export { throttle } from './function/throttle.js';
+export { clamp } from './math/clamp.js';
+export { round } from './math/round.js';
+export { sum } from './math/sum.js';
+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 { isNil } from './predicate/isNil.js';
+export { isNotNil } from './predicate/isNotNil.js';
+export { isNull } from './predicate/isNull.js';
+export { isUndefined } from './predicate/isUndefined.js';
+export { delay } from './promise/delay.js';