@ls-stack/utils 1.1.0 → 1.2.0

package/dist/debounce.d.ts

@@ -0,0 +1,45 @@
+type DebounceOptions = {
+    /**
+     * @see _.leading
+     */
+    leading?: boolean;
+    /**
+     * @see _.maxWait
+     */
+    maxWait?: number;
+    /**
+     * @see _.trailing
+     */
+    trailing?: boolean;
+};
+interface DebouncedFunc<T extends (...args: any[]) => void> {
+    /**
+     * Call the original function, but applying the debounce rules.
+     *
+     * If the debounced function can be run immediately, this calls it and returns its return
+     * value.
+     *
+     * Otherwise, it returns the return value of the last invocation, or undefined if the debounced
+     * function was not invoked yet.
+     */
+    (...args: Parameters<T>): ReturnType<T> | undefined;
+    /**
+     * Throw away any pending invocation of the debounced function.
+     */
+    cancel: () => void;
+    /**
+     * If there is a pending invocation of the debounced function, invoke it immediately and return
+     * its return value.
+     *
+     * Otherwise, return the value from the last invocation, or undefined if the debounced function
+     * was never invoked.
+     */
+    flush: () => ReturnType<T> | undefined;
+}
+declare function debounce<T extends (...args: any[]) => void>(func: T, wait: number, options?: DebounceOptions): DebouncedFunc<T>;
+declare function isDebouncedFn<T extends (...args: any[]) => void>(fn: T): fn is T & {
+    cancel: () => void;
+    flush: () => ReturnType<T> | undefined;
+};
+
+export { type DebounceOptions, type DebouncedFunc, debounce, isDebouncedFn };

package/dist/debounce.js

@@ -0,0 +1,100 @@
+// src/debounce.ts
+function debounce(func, wait, options) {
+  let lastArgs;
+  let lastThis;
+  let maxWait;
+  let result;
+  let timerId;
+  let lastCallTime;
+  let lastInvokeTime = 0;
+  let leading = false;
+  let maxing = false;
+  let trailing = true;
+  if (options) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    const timeSinceLastCall = time - (lastCallTime ?? 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    const timeWaiting = wait - timeSinceLastCall;
+    return maxing ? Math.min(timeWaiting, (maxWait ?? 0) - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    const timeSinceLastCall = time - (lastCallTime ?? 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= (maxWait ?? 0);
+  }
+  function timerExpired() {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(Date.now());
+  }
+  function debounced() {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+function isDebouncedFn(fn) {
+  return typeof fn === "function" && "cancel" in fn && "flush" in fn;
+}
+export {
+  debounce,
+  isDebouncedFn
+};
+//# sourceMappingURL=debounce.js.map

package/dist/debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/debounce.ts"],"sourcesContent":["export type DebounceOptions = {\n  /**\n   * @see _.leading\n   */\n  leading?: boolean;\n  /**\n   * @see _.maxWait\n   */\n  maxWait?: number;\n  /**\n   * @see _.trailing\n   */\n  trailing?: boolean;\n};\n\nexport interface DebouncedFunc<T extends (...args: any[]) => void> {\n  /**\n   * Call the original function, but applying the debounce rules.\n   *\n   * If the debounced function can be run immediately, this calls it and returns its return\n   * value.\n   *\n   * Otherwise, it returns the return value of the last invocation, or undefined if the debounced\n   * function was not invoked yet.\n   */\n  (...args: Parameters<T>): ReturnType<T> | undefined;\n\n  /**\n   * Throw away any pending invocation of the debounced function.\n   */\n  cancel: () => void;\n\n  /**\n   * If there is a pending invocation of the debounced function, invoke it immediately and return\n   * its return value.\n   *\n   * Otherwise, return the value from the last invocation, or undefined if the debounced function\n   * was never invoked.\n   */\n  flush: () => ReturnType<T> | undefined;\n}\n\n// forked from lodash/debounce\nexport function debounce<T extends (...args: any[]) => void>(\n  func: T,\n  wait: number,\n  options?: DebounceOptions,\n): DebouncedFunc<T> {\n  let lastArgs: IArguments | undefined;\n  let lastThis: undefined;\n  let maxWait: number | undefined;\n  let result: any;\n  let timerId: NodeJS.Timeout | undefined;\n  let lastCallTime: number | undefined;\n  let lastInvokeTime = 0;\n  let leading = false;\n  let maxing = false;\n  let trailing = true;\n\n  if (options) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time: number) {\n    const args = lastArgs;\n    const thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n    result = func.apply(thisArg, args as any);\n    return result;\n  }\n\n  function leadingEdge(time: number) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time: number) {\n    const timeSinceLastCall = time - (lastCallTime ?? 0);\n    const timeSinceLastInvoke = time - lastInvokeTime;\n    const timeWaiting = wait - timeSinceLastCall;\n\n    return maxing ?\n        Math.min(timeWaiting, (maxWait ?? 0) - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time: number) {\n    const timeSinceLastCall = time - (lastCallTime ?? 0);\n    const timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (\n      lastCallTime === undefined ||\n      timeSinceLastCall >= wait ||\n      timeSinceLastCall < 0 ||\n      (maxing && timeSinceLastInvoke >= (maxWait ?? 0))\n    );\n  }\n\n  function timerExpired() {\n    const time = Date.now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time: number) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(Date.now());\n  }\n\n  function debounced(this: any) {\n    const time = Date.now();\n    const isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias -- this is a forked code, so a refactor is not worth it\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n\n  return debounced;\n}\n\nexport function isDebouncedFn<T extends (...args: any[]) => void>(\n  fn: T,\n): fn is T & {\n  cancel: () => void;\n  flush: () => ReturnType<T> | undefined;\n} {\n  return typeof fn === 'function' && 'cancel' in fn && 'flush' in fn;\n}\n"],"mappings":";AA2CO,SAAS,SACd,MACA,MACA,SACkB;AAClB,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI,iBAAiB;AACrB,MAAI,UAAU;AACd,MAAI,SAAS;AACb,MAAI,WAAW;AAEf,MAAI,SAAS;AACX,cAAU,CAAC,CAAC,QAAQ;AACpB,aAAS,aAAa;AACtB,cAAU,SAAS,KAAK,IAAI,QAAQ,WAAW,GAAG,IAAI,IAAI;AAC1D,eAAW,cAAc,UAAU,CAAC,CAAC,QAAQ,WAAW;AAAA,EAC1D;AAEA,WAAS,WAAW,MAAc;AAChC,UAAM,OAAO;AACb,UAAM,UAAU;AAEhB,eAAW,WAAW;AACtB,qBAAiB;AAEjB,aAAS,KAAK,MAAM,SAAS,IAAW;AACxC,WAAO;AAAA,EACT;AAEA,WAAS,YAAY,MAAc;AAEjC,qBAAiB;AAEjB,cAAU,WAAW,cAAc,IAAI;AAEvC,WAAO,UAAU,WAAW,IAAI,IAAI;AAAA,EACtC;AAEA,WAAS,cAAc,MAAc;AACnC,UAAM,oBAAoB,QAAQ,gBAAgB;AAClD,UAAM,sBAAsB,OAAO;AACnC,UAAM,cAAc,OAAO;AAE3B,WAAO,SACH,KAAK,IAAI,cAAc,WAAW,KAAK,mBAAmB,IAC1D;AAAA,EACN;AAEA,WAAS,aAAa,MAAc;AAClC,UAAM,oBAAoB,QAAQ,gBAAgB;AAClD,UAAM,sBAAsB,OAAO;AAKnC,WACE,iBAAiB,UACjB,qBAAqB,QACrB,oBAAoB,KACnB,UAAU,wBAAwB,WAAW;AAAA,EAElD;AAEA,WAAS,eAAe;AACtB,UAAM,OAAO,KAAK,IAAI;AACtB,QAAI,aAAa,IAAI,GAAG;AACtB,aAAO,aAAa,IAAI;AAAA,IAC1B;AAEA,cAAU,WAAW,cAAc,cAAc,IAAI,CAAC;AAAA,EACxD;AAEA,WAAS,aAAa,MAAc;AAClC,cAAU;AAIV,QAAI,YAAY,UAAU;AACxB,aAAO,WAAW,IAAI;AAAA,IACxB;AACA,eAAW,WAAW;AACtB,WAAO;AAAA,EACT;AAEA,WAAS,SAAS;AAChB,QAAI,YAAY,QAAW;AACzB,mBAAa,OAAO;AAAA,IACtB;AACA,qBAAiB;AACjB,eAAW,eAAe,WAAW,UAAU;AAAA,EACjD;AAEA,WAAS,QAAQ;AACf,WAAO,YAAY,SAAY,SAAS,aAAa,KAAK,IAAI,CAAC;AAAA,EACjE;AAEA,WAAS,YAAqB;AAC5B,UAAM,OAAO,KAAK,IAAI;AACtB,UAAM,aAAa,aAAa,IAAI;AAEpC,eAAW;AAEX,eAAW;AACX,mBAAe;AAEf,QAAI,YAAY;AACd,UAAI,YAAY,QAAW;AACzB,eAAO,YAAY,YAAY;AAAA,MACjC;AACA,UAAI,QAAQ;AAEV,qBAAa,OAAO;AACpB,kBAAU,WAAW,cAAc,IAAI;AACvC,eAAO,WAAW,YAAY;AAAA,MAChC;AAAA,IACF;AACA,QAAI,YAAY,QAAW;AACzB,gBAAU,WAAW,cAAc,IAAI;AAAA,IACzC;AACA,WAAO;AAAA,EACT;AACA,YAAU,SAAS;AACnB,YAAU,QAAQ;AAElB,SAAO;AACT;AAEO,SAAS,cACd,IAIA;AACA,SAAO,OAAO,OAAO,cAAc,YAAY,MAAM,WAAW;AAClE;","names":[]}

package/dist/main.d.ts

@@ -4,6 +4,7 @@
 ///<reference path="consoleFmt.d.ts" />
 ///<reference path="conversions.d.ts" />
 ///<reference path="createThrottleController.d.ts" />
+///<reference path="debounce.d.ts" />
 ///<reference path="dedent.d.ts" />
 ///<reference path="deepEqual.d.ts" />
 ///<reference path="enhancedMap.d.ts" />

package/dist/parallelAsyncResultCalls.js

@@ -1,10 +1,10 @@
-import {
-  sleep
-} from "./chunk-HLFWWIDK.js";
 import {
   Result,
   normalizeError
 } from "./chunk-HYFUWQ2E.js";
+import {
+  sleep
+} from "./chunk-HLFWWIDK.js";
 import "./chunk-4DRNU53E.js";
 import {
   invariant,

package/dist/testUtils.js

@@ -1,3 +1,6 @@
+import {
+  deepEqual
+} from "./chunk-JZUOIOMU.js";
 import {
   clampMin
 } from "./chunk-J66LUDLH.js";
@@ -12,9 +15,6 @@ import {
 import {
   isObject
 } from "./chunk-JT3EBBCA.js";
-import {
-  deepEqual
-} from "./chunk-JZUOIOMU.js";
 
 // src/testUtils.ts
 function createLoggerStore({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Typescript utils",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "license": "MIT",
   "files": [
     "dist"
@@ -40,6 +40,10 @@
       "import": "./dist/createThrottleController.js",
       "types": "./dist/createThrottleController.d.ts"
     },
+    "./debounce": {
+      "import": "./dist/debounce.js",
+      "types": "./dist/debounce.d.ts"
+    },
     "./dedent": {
       "import": "./dist/dedent.js",
       "types": "./dist/dedent.d.ts"
@@ -159,6 +163,9 @@
       "createThrottleController": [
         "./dist/createThrottleController.d.ts"
       ],
+      "debounce": [
+        "./dist/debounce.d.ts"
+      ],
       "dedent": [
         "./dist/dedent.d.ts"
       ],