es-toolkit 1.39.6 → 1.39.7-dev.1427

package/dist/compat/function/debounce.mjs

@@ -1,46 +1,93 @@
-import { debounce as debounce$1 } from '../../function/debounce.mjs';
-
-function debounce(func, debounceMs = 0, options = {}) {
+function debounce(func, wait = 0, options = {}) {
     if (typeof options !== 'object') {
         options = {};
     }
+    let pendingArgs = null;
+    let pendingThis = null;
+    let lastCallTime = null;
+    let debounceStartTime = 0;
+    let timeoutId = null;
+    let lastResult;
     const { leading = false, trailing = true, maxWait } = options;
-    const edges = Array(2);
-    if (leading) {
-        edges[0] = 'leading';
-    }
-    if (trailing) {
-        edges[1] = 'trailing';
-    }
-    let result = undefined;
-    let pendingAt = null;
-    const _debounced = debounce$1(function (...args) {
-        result = func.apply(this, args);
-        pendingAt = null;
-    }, debounceMs, { edges });
-    const debounced = function (...args) {
-        if (maxWait != null) {
-            if (pendingAt === null) {
-                pendingAt = Date.now();
+    const hasMaxWait = 'maxWait' in options;
+    const maxWaitMs = hasMaxWait ? Math.max(Number(maxWait) || 0, wait) : 0;
+    const invoke = (time) => {
+        if (pendingArgs !== null) {
+            lastResult = func.apply(pendingThis, pendingArgs);
+        }
+        pendingArgs = pendingThis = null;
+        debounceStartTime = time;
+        return lastResult;
+    };
+    const handleLeading = (time) => {
+        debounceStartTime = time;
+        timeoutId = setTimeout(handleTimeout, wait);
+        if (leading && pendingArgs !== null) {
+            return invoke(time);
+        }
+        return lastResult;
+    };
+    const handleTrailing = (time) => {
+        timeoutId = null;
+        if (trailing && pendingArgs !== null) {
+            return invoke(time);
+        }
+        return lastResult;
+    };
+    const checkCanInvoke = (time) => {
+        if (lastCallTime === null) {
+            return true;
+        }
+        const timeSinceLastCall = time - lastCallTime;
+        const hasDebounceDelayPassed = timeSinceLastCall >= wait || timeSinceLastCall < 0;
+        const hasMaxWaitPassed = hasMaxWait && time - debounceStartTime >= maxWaitMs;
+        return hasDebounceDelayPassed || hasMaxWaitPassed;
+    };
+    const calculateRemainingWait = (time) => {
+        const timeSinceLastCall = lastCallTime === null ? 0 : time - lastCallTime;
+        const remainingDebounceTime = wait - timeSinceLastCall;
+        const remainingMaxWaitTime = maxWaitMs - (time - debounceStartTime);
+        return hasMaxWait ? Math.min(remainingDebounceTime, remainingMaxWaitTime) : remainingDebounceTime;
+    };
+    const handleTimeout = () => {
+        const currentTime = Date.now();
+        if (checkCanInvoke(currentTime)) {
+            return handleTrailing(currentTime);
+        }
+        timeoutId = setTimeout(handleTimeout, calculateRemainingWait(currentTime));
+    };
+    const debouncedFunction = function (...args) {
+        const currentTime = Date.now();
+        const canInvoke = checkCanInvoke(currentTime);
+        pendingArgs = args;
+        pendingThis = this;
+        lastCallTime = currentTime;
+        if (canInvoke) {
+            if (timeoutId === null) {
+                return handleLeading(currentTime);
             }
-            if (Date.now() - pendingAt >= maxWait) {
-                result = func.apply(this, args);
-                pendingAt = Date.now();
-                _debounced.cancel();
-                _debounced.schedule();
-                return result;
+            if (hasMaxWait) {
+                clearTimeout(timeoutId);
+                timeoutId = setTimeout(handleTimeout, wait);
+                return invoke(currentTime);
             }
         }
-        _debounced.apply(this, args);
-        return result;
+        if (timeoutId === null) {
+            timeoutId = setTimeout(handleTimeout, wait);
+        }
+        return lastResult;
+    };
+    debouncedFunction.cancel = () => {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        debounceStartTime = 0;
+        lastCallTime = pendingArgs = pendingThis = timeoutId = null;
     };
-    const flush = () => {
-        _debounced.flush();
-        return result;
+    debouncedFunction.flush = () => {
+        return timeoutId === null ? lastResult : handleTrailing(Date.now());
     };
-    debounced.cancel = _debounced.cancel;
-    debounced.flush = flush;
-    return debounced;
+    return debouncedFunction;
 }
 
 export { debounce };

package/dist/compat/function/throttle.js

@@ -5,14 +5,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const debounce = require('./debounce.js');
 
 function throttle(func, throttleMs = 0, options = {}) {
-    if (typeof options !== 'object') {
-        options = {};
-    }
     const { leading = true, trailing = true } = options;
     return debounce.debounce(func, throttleMs, {
         leading,
-        trailing,
         maxWait: throttleMs,
+        trailing,
     });
 }
 

package/dist/compat/function/throttle.mjs

@@ -1,14 +1,11 @@
 import { debounce } from './debounce.mjs';
 
 function throttle(func, throttleMs = 0, options = {}) {
-    if (typeof options !== 'object') {
-        options = {};
-    }
     const { leading = true, trailing = true } = options;
     return debounce(func, throttleMs, {
         leading,
-        trailing,
         maxWait: throttleMs,
+        trailing,
     });
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "es-toolkit",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
-  "version": "1.39.6",
+  "version": "1.39.7-dev.1427+a3de4256",
   "homepage": "https://es-toolkit.dev",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {