@alwatr/debounce 1.0.0-rc.0

package/dist/main.cjs

@@ -0,0 +1,145 @@
+/* @alwatr/debounce v1.0.0-rc.0 */
+"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/main.ts
+var main_exports = {};
+__export(main_exports, {
+  Debouncer: () => Debouncer,
+  createDebouncer: () => createDebouncer
+});
+module.exports = __toCommonJS(main_exports);
+
+// src/debounce.ts
+var Debouncer = class {
+  constructor(config__) {
+    this.config__ = config__;
+    this.config__.trailing ??= true;
+  }
+  /**
+   * Checks if there is a pending execution scheduled.
+   * Returns true if a timer is active, indicating a debounced call is waiting.
+   */
+  get isPending() {
+    return this.timerId__ !== void 0;
+  }
+  /**
+   * Triggers the debounced function with the stored `thisContext`.
+   * @param args The arguments to pass to the callback.
+   * 
+   * @example
+   * ```typescript
+   * const debouncer = new Debouncer({
+   *   callback: (value: number) => console.log('Value:', value),
+   *   delay: 500,
+   * });
+   * debouncer.trigger(42); // Logs after 500ms if not triggered again
+   * 
+   * // Edge case: Rapid triggers only execute the last one
+   * debouncer.trigger(1);
+   * debouncer.trigger(2); // Only 2 will execute after delay
+   * ```
+   */
+  trigger(...args) {
+    this.lastArgs__ = args;
+    const wasPending = this.isPending;
+    if (wasPending) {
+      clearTimeout(this.timerId__);
+    }
+    if (this.config__.leading === true && !wasPending) {
+      this.invoke__();
+    }
+    this.timerId__ = setTimeout(() => {
+      if (this.config__.trailing === true && wasPending) {
+        this.invoke__();
+      }
+      this.cleanup__();
+    }, this.config__.delay);
+  }
+  /**
+   * Cancels any pending debounced execution and cleans up internal state.
+   * Useful for stopping execution when the operation is no longer needed (e.g., component unmount).
+   * 
+   * @example
+   * ```typescript
+   * const debouncer = new Debouncer({
+   *   callback: () => console.log('Executed'),
+   *   delay: 1000,
+   * });
+   * debouncer.trigger();
+   * debouncer.cancel(); // Prevents execution
+   * 
+   * // Note: After cancel, isPending becomes false
+   * ```
+   */
+  cancel() {
+    if (this.isPending) {
+      clearTimeout(this.timerId__);
+    }
+    this.cleanup__();
+  }
+  /**
+   * Cleans up internal state by deleting timer and arguments.
+   */
+  cleanup__() {
+    delete this.timerId__;
+    delete this.lastArgs__;
+  }
+  /**
+   * Immediately executes the pending function if one exists.
+   * Bypasses the delay and cleans up state. If no pending call, does nothing.
+   * 
+   * @example
+   * ```typescript
+   * const debouncer = new Debouncer({
+   *   callback: () => console.log('Flushed'),
+   *   delay: 1000,
+   * });
+   * debouncer.trigger();
+   * setTimeout(() => debouncer.flush(), 500); // Executes immediately
+   * 
+   * // Edge case: Flush after cancel does nothing
+   * debouncer.cancel();
+   * debouncer.flush(); // No execution
+   * ```
+   */
+  flush() {
+    if (this.isPending) {
+      this.cancel();
+      this.invoke__();
+    }
+  }
+  /**
+   * The core execution logic.
+   */
+  invoke__() {
+    if (this.lastArgs__) {
+      this.config__.callback.apply(this.config__.thisContext, this.lastArgs__);
+    }
+  }
+};
+function createDebouncer(config) {
+  return new Debouncer(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Debouncer,
+  createDebouncer
+});
+//# sourceMappingURL=main.cjs.map

package/dist/main.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/main.ts", "../src/debounce.ts"],
+  "sourcesContent": ["export * from './debounce.js';\nexport type * from './type.js';\n", "import type {DebouncerConfig} from './type.ts';\n\n/**\n * A powerful and type-safe Debouncer class.\n * \n * It encapsulates the debouncing logic, state, and provides a rich control API.\n * Debouncing delays function execution until after a specified delay has passed since the last invocation.\n * Useful for optimizing performance in scenarios like search inputs, resize events, or API calls.\n * \n * @example\n * ```typescript\n * const debouncer = new Debouncer({\n *   callback: (text: string) => console.log('Searching:', text),\n *   delay: 300,\n *   leading: false,\n *   trailing: true,\n * });\n * \n * // Debounce search input\n * debouncer.trigger('hello');\n * debouncer.trigger('hello world'); // Only 'hello world' will log after 300ms\n * \n * // Advanced: With leading edge\n * const leadingDebouncer = new Debouncer({\n *   callback: () => console.log('Immediate and delayed'),\n *   delay: 500,\n *   leading: true,\n *   trailing: true,\n * });\n * leadingDebouncer.trigger(); // Logs immediately, then again after 500ms if not cancelled\n * ```\n */\nexport class Debouncer<F extends AnyFunction> {\n  private timerId__?: number | NodeJS.Timeout;\n  private lastArgs__?: Parameters<F>;\n\n  public constructor(private readonly config__: DebouncerConfig<F>) {\n    this.config__.trailing ??= true;\n  }\n\n  /**\n   * Checks if there is a pending execution scheduled.\n   * Returns true if a timer is active, indicating a debounced call is waiting.\n   */\n  public get isPending(): boolean {\n    return this.timerId__ !== undefined;\n  }\n\n  /**\n   * Triggers the debounced function with the stored `thisContext`.\n   * @param args The arguments to pass to the callback.\n   * \n   * @example\n   * ```typescript\n   * const debouncer = new Debouncer({\n   *   callback: (value: number) => console.log('Value:', value),\n   *   delay: 500,\n   * });\n   * debouncer.trigger(42); // Logs after 500ms if not triggered again\n   * \n   * // Edge case: Rapid triggers only execute the last one\n   * debouncer.trigger(1);\n   * debouncer.trigger(2); // Only 2 will execute after delay\n   * ```\n   */\n  public trigger(...args: Parameters<F>): void {\n    this.lastArgs__ = args;\n    const wasPending = this.isPending;\n\n    if (wasPending) {\n      clearTimeout(this.timerId__!);\n    }\n\n    if (this.config__.leading === true && !wasPending) {\n      this.invoke__();\n    }\n\n    this.timerId__ = setTimeout(() => {\n      if (this.config__.trailing === true && wasPending) {\n        this.invoke__();\n      }\n      this.cleanup__();\n    }, this.config__.delay);\n  }\n\n  /**\n   * Cancels any pending debounced execution and cleans up internal state.\n   * Useful for stopping execution when the operation is no longer needed (e.g., component unmount).\n   * \n   * @example\n   * ```typescript\n   * const debouncer = new Debouncer({\n   *   callback: () => console.log('Executed'),\n   *   delay: 1000,\n   * });\n   * debouncer.trigger();\n   * debouncer.cancel(); // Prevents execution\n   * \n   * // Note: After cancel, isPending becomes false\n   * ```\n   */\n  public cancel(): void {\n    if (this.isPending) {\n      clearTimeout(this.timerId__!);\n    }\n    this.cleanup__();\n  }\n\n  /**\n   * Cleans up internal state by deleting timer and arguments.\n   */\n  private cleanup__(): void {\n    delete this.timerId__;\n    delete this.lastArgs__;\n  }\n\n  /**\n   * Immediately executes the pending function if one exists.\n   * Bypasses the delay and cleans up state. If no pending call, does nothing.\n   * \n   * @example\n   * ```typescript\n   * const debouncer = new Debouncer({\n   *   callback: () => console.log('Flushed'),\n   *   delay: 1000,\n   * });\n   * debouncer.trigger();\n   * setTimeout(() => debouncer.flush(), 500); // Executes immediately\n   * \n   * // Edge case: Flush after cancel does nothing\n   * debouncer.cancel();\n   * debouncer.flush(); // No execution\n   * ```\n   */\n  public flush(): void {\n    if (this.isPending) {\n      this.cancel();\n      this.invoke__();\n    }\n  }\n\n  /**\n   * The core execution logic.\n   */\n  private invoke__(): void {\n    if (this.lastArgs__) {\n      // `thisContext` is now read directly from the stored config.\n      this.config__.callback.apply(this.config__.thisContext, this.lastArgs__);\n    }\n  }\n}\n\n/**\n * Factory function for creating a Debouncer instance for better type inference.\n * @param config Configuration for the debouncer.\n * \n * @example\n * ```typescript\n * const debouncer = createDebouncer({\n *   callback: (text: string) => console.log('Searching:', text),\n *   delay: 300,\n *   leading: false,\n *   trailing: true,\n * });\n * \n * // Debounce search input\n * debouncer.trigger('hello');\n * debouncer.trigger('hello world'); // Only 'hello world' will log after 300ms\n * \n * // With custom thisContext\n * const obj = { log: (msg: string) => console.log('Obj:', msg) };\n * const debouncerWithContext = createDebouncer({\n *   callback: obj.log,\n *   thisContext: obj,\n *   delay: 200,\n * });\n * debouncerWithContext.trigger('test'); // Logs 'Obj: test'\n * ```\n */\nexport function createDebouncer<F extends AnyFunction>(config: DebouncerConfig<F>): Debouncer<F> {\n  return new Debouncer(config);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgCO,IAAM,YAAN,MAAuC;AAAA,EAIrC,YAA6B,UAA8B;AAA9B;AAClC,SAAK,SAAS,aAAa;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAW,YAAqB;AAC9B,WAAO,KAAK,cAAc;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBO,WAAW,MAA2B;AAC3C,SAAK,aAAa;AAClB,UAAM,aAAa,KAAK;AAExB,QAAI,YAAY;AACd,mBAAa,KAAK,SAAU;AAAA,IAC9B;AAEA,QAAI,KAAK,SAAS,YAAY,QAAQ,CAAC,YAAY;AACjD,WAAK,SAAS;AAAA,IAChB;AAEA,SAAK,YAAY,WAAW,MAAM;AAChC,UAAI,KAAK,SAAS,aAAa,QAAQ,YAAY;AACjD,aAAK,SAAS;AAAA,MAChB;AACA,WAAK,UAAU;AAAA,IACjB,GAAG,KAAK,SAAS,KAAK;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBO,SAAe;AACpB,QAAI,KAAK,WAAW;AAClB,mBAAa,KAAK,SAAU;AAAA,IAC9B;AACA,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAKQ,YAAkB;AACxB,WAAO,KAAK;AACZ,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBO,QAAc;AACnB,QAAI,KAAK,WAAW;AAClB,WAAK,OAAO;AACZ,WAAK,SAAS;AAAA,IAChB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,WAAiB;AACvB,QAAI,KAAK,YAAY;AAEnB,WAAK,SAAS,SAAS,MAAM,KAAK,SAAS,aAAa,KAAK,UAAU;AAAA,IACzE;AAAA,EACF;AACF;AA6BO,SAAS,gBAAuC,QAA0C;AAC/F,SAAO,IAAI,UAAU,MAAM;AAC7B;",
+  "names": []
+}

package/dist/main.d.ts

@@ -0,0 +1,3 @@
+export * from './debounce.js';
+export type * from './type.js';
+//# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,mBAAmB,WAAW,CAAC"}

package/dist/main.mjs

@@ -0,0 +1,118 @@
+/* @alwatr/debounce v1.0.0-rc.0 */
+
+// src/debounce.ts
+var Debouncer = class {
+  constructor(config__) {
+    this.config__ = config__;
+    this.config__.trailing ??= true;
+  }
+  /**
+   * Checks if there is a pending execution scheduled.
+   * Returns true if a timer is active, indicating a debounced call is waiting.
+   */
+  get isPending() {
+    return this.timerId__ !== void 0;
+  }
+  /**
+   * Triggers the debounced function with the stored `thisContext`.
+   * @param args The arguments to pass to the callback.
+   * 
+   * @example
+   * ```typescript
+   * const debouncer = new Debouncer({
+   *   callback: (value: number) => console.log('Value:', value),
+   *   delay: 500,
+   * });
+   * debouncer.trigger(42); // Logs after 500ms if not triggered again
+   * 
+   * // Edge case: Rapid triggers only execute the last one
+   * debouncer.trigger(1);
+   * debouncer.trigger(2); // Only 2 will execute after delay
+   * ```
+   */
+  trigger(...args) {
+    this.lastArgs__ = args;
+    const wasPending = this.isPending;
+    if (wasPending) {
+      clearTimeout(this.timerId__);
+    }
+    if (this.config__.leading === true && !wasPending) {
+      this.invoke__();
+    }
+    this.timerId__ = setTimeout(() => {
+      if (this.config__.trailing === true && wasPending) {
+        this.invoke__();
+      }
+      this.cleanup__();
+    }, this.config__.delay);
+  }
+  /**
+   * Cancels any pending debounced execution and cleans up internal state.
+   * Useful for stopping execution when the operation is no longer needed (e.g., component unmount).
+   * 
+   * @example
+   * ```typescript
+   * const debouncer = new Debouncer({
+   *   callback: () => console.log('Executed'),
+   *   delay: 1000,
+   * });
+   * debouncer.trigger();
+   * debouncer.cancel(); // Prevents execution
+   * 
+   * // Note: After cancel, isPending becomes false
+   * ```
+   */
+  cancel() {
+    if (this.isPending) {
+      clearTimeout(this.timerId__);
+    }
+    this.cleanup__();
+  }
+  /**
+   * Cleans up internal state by deleting timer and arguments.
+   */
+  cleanup__() {
+    delete this.timerId__;
+    delete this.lastArgs__;
+  }
+  /**
+   * Immediately executes the pending function if one exists.
+   * Bypasses the delay and cleans up state. If no pending call, does nothing.
+   * 
+   * @example
+   * ```typescript
+   * const debouncer = new Debouncer({
+   *   callback: () => console.log('Flushed'),
+   *   delay: 1000,
+   * });
+   * debouncer.trigger();
+   * setTimeout(() => debouncer.flush(), 500); // Executes immediately
+   * 
+   * // Edge case: Flush after cancel does nothing
+   * debouncer.cancel();
+   * debouncer.flush(); // No execution
+   * ```
+   */
+  flush() {
+    if (this.isPending) {
+      this.cancel();
+      this.invoke__();
+    }
+  }
+  /**
+   * The core execution logic.
+   */
+  invoke__() {
+    if (this.lastArgs__) {
+      this.config__.callback.apply(this.config__.thisContext, this.lastArgs__);
+    }
+  }
+};
+function createDebouncer(config) {
+  return new Debouncer(config);
+}
+export {
+  Debouncer,
+  createDebouncer
+};
+//# sourceMappingURL=main.mjs.map

package/dist/main.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/debounce.ts"],
+  "sourcesContent": ["import type {DebouncerConfig} from './type.ts';\n\n/**\n * A powerful and type-safe Debouncer class.\n * \n * It encapsulates the debouncing logic, state, and provides a rich control API.\n * Debouncing delays function execution until after a specified delay has passed since the last invocation.\n * Useful for optimizing performance in scenarios like search inputs, resize events, or API calls.\n * \n * @example\n * ```typescript\n * const debouncer = new Debouncer({\n *   callback: (text: string) => console.log('Searching:', text),\n *   delay: 300,\n *   leading: false,\n *   trailing: true,\n * });\n * \n * // Debounce search input\n * debouncer.trigger('hello');\n * debouncer.trigger('hello world'); // Only 'hello world' will log after 300ms\n * \n * // Advanced: With leading edge\n * const leadingDebouncer = new Debouncer({\n *   callback: () => console.log('Immediate and delayed'),\n *   delay: 500,\n *   leading: true,\n *   trailing: true,\n * });\n * leadingDebouncer.trigger(); // Logs immediately, then again after 500ms if not cancelled\n * ```\n */\nexport class Debouncer<F extends AnyFunction> {\n  private timerId__?: number | NodeJS.Timeout;\n  private lastArgs__?: Parameters<F>;\n\n  public constructor(private readonly config__: DebouncerConfig<F>) {\n    this.config__.trailing ??= true;\n  }\n\n  /**\n   * Checks if there is a pending execution scheduled.\n   * Returns true if a timer is active, indicating a debounced call is waiting.\n   */\n  public get isPending(): boolean {\n    return this.timerId__ !== undefined;\n  }\n\n  /**\n   * Triggers the debounced function with the stored `thisContext`.\n   * @param args The arguments to pass to the callback.\n   * \n   * @example\n   * ```typescript\n   * const debouncer = new Debouncer({\n   *   callback: (value: number) => console.log('Value:', value),\n   *   delay: 500,\n   * });\n   * debouncer.trigger(42); // Logs after 500ms if not triggered again\n   * \n   * // Edge case: Rapid triggers only execute the last one\n   * debouncer.trigger(1);\n   * debouncer.trigger(2); // Only 2 will execute after delay\n   * ```\n   */\n  public trigger(...args: Parameters<F>): void {\n    this.lastArgs__ = args;\n    const wasPending = this.isPending;\n\n    if (wasPending) {\n      clearTimeout(this.timerId__!);\n    }\n\n    if (this.config__.leading === true && !wasPending) {\n      this.invoke__();\n    }\n\n    this.timerId__ = setTimeout(() => {\n      if (this.config__.trailing === true && wasPending) {\n        this.invoke__();\n      }\n      this.cleanup__();\n    }, this.config__.delay);\n  }\n\n  /**\n   * Cancels any pending debounced execution and cleans up internal state.\n   * Useful for stopping execution when the operation is no longer needed (e.g., component unmount).\n   * \n   * @example\n   * ```typescript\n   * const debouncer = new Debouncer({\n   *   callback: () => console.log('Executed'),\n   *   delay: 1000,\n   * });\n   * debouncer.trigger();\n   * debouncer.cancel(); // Prevents execution\n   * \n   * // Note: After cancel, isPending becomes false\n   * ```\n   */\n  public cancel(): void {\n    if (this.isPending) {\n      clearTimeout(this.timerId__!);\n    }\n    this.cleanup__();\n  }\n\n  /**\n   * Cleans up internal state by deleting timer and arguments.\n   */\n  private cleanup__(): void {\n    delete this.timerId__;\n    delete this.lastArgs__;\n  }\n\n  /**\n   * Immediately executes the pending function if one exists.\n   * Bypasses the delay and cleans up state. If no pending call, does nothing.\n   * \n   * @example\n   * ```typescript\n   * const debouncer = new Debouncer({\n   *   callback: () => console.log('Flushed'),\n   *   delay: 1000,\n   * });\n   * debouncer.trigger();\n   * setTimeout(() => debouncer.flush(), 500); // Executes immediately\n   * \n   * // Edge case: Flush after cancel does nothing\n   * debouncer.cancel();\n   * debouncer.flush(); // No execution\n   * ```\n   */\n  public flush(): void {\n    if (this.isPending) {\n      this.cancel();\n      this.invoke__();\n    }\n  }\n\n  /**\n   * The core execution logic.\n   */\n  private invoke__(): void {\n    if (this.lastArgs__) {\n      // `thisContext` is now read directly from the stored config.\n      this.config__.callback.apply(this.config__.thisContext, this.lastArgs__);\n    }\n  }\n}\n\n/**\n * Factory function for creating a Debouncer instance for better type inference.\n * @param config Configuration for the debouncer.\n * \n * @example\n * ```typescript\n * const debouncer = createDebouncer({\n *   callback: (text: string) => console.log('Searching:', text),\n *   delay: 300,\n *   leading: false,\n *   trailing: true,\n * });\n * \n * // Debounce search input\n * debouncer.trigger('hello');\n * debouncer.trigger('hello world'); // Only 'hello world' will log after 300ms\n * \n * // With custom thisContext\n * const obj = { log: (msg: string) => console.log('Obj:', msg) };\n * const debouncerWithContext = createDebouncer({\n *   callback: obj.log,\n *   thisContext: obj,\n *   delay: 200,\n * });\n * debouncerWithContext.trigger('test'); // Logs 'Obj: test'\n * ```\n */\nexport function createDebouncer<F extends AnyFunction>(config: DebouncerConfig<F>): Debouncer<F> {\n  return new Debouncer(config);\n}\n"],
+  "mappings": ";;;AAgCO,IAAM,YAAN,MAAuC;AAAA,EAIrC,YAA6B,UAA8B;AAA9B;AAClC,SAAK,SAAS,aAAa;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAW,YAAqB;AAC9B,WAAO,KAAK,cAAc;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBO,WAAW,MAA2B;AAC3C,SAAK,aAAa;AAClB,UAAM,aAAa,KAAK;AAExB,QAAI,YAAY;AACd,mBAAa,KAAK,SAAU;AAAA,IAC9B;AAEA,QAAI,KAAK,SAAS,YAAY,QAAQ,CAAC,YAAY;AACjD,WAAK,SAAS;AAAA,IAChB;AAEA,SAAK,YAAY,WAAW,MAAM;AAChC,UAAI,KAAK,SAAS,aAAa,QAAQ,YAAY;AACjD,aAAK,SAAS;AAAA,MAChB;AACA,WAAK,UAAU;AAAA,IACjB,GAAG,KAAK,SAAS,KAAK;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBO,SAAe;AACpB,QAAI,KAAK,WAAW;AAClB,mBAAa,KAAK,SAAU;AAAA,IAC9B;AACA,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAKQ,YAAkB;AACxB,WAAO,KAAK;AACZ,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBO,QAAc;AACnB,QAAI,KAAK,WAAW;AAClB,WAAK,OAAO;AACZ,WAAK,SAAS;AAAA,IAChB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,WAAiB;AACvB,QAAI,KAAK,YAAY;AAEnB,WAAK,SAAS,SAAS,MAAM,KAAK,SAAS,aAAa,KAAK,UAAU;AAAA,IACzE;AAAA,EACF;AACF;AA6BO,SAAS,gBAAuC,QAA0C;AAC/F,SAAO,IAAI,UAAU,MAAM;AAC7B;",
+  "names": []
+}

package/dist/type.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A single configuration object for creating a Debouncer.
+ * This groups all settings for a cleaner API.
+ *
+ * Key notes:
+ * - `leading` and `trailing` control execution timing: leading executes immediately on first trigger, trailing after delay.
+ * - If both are true, execution happens on first trigger and last trigger (after delay).
+ * - `thisContext` ensures the callback is bound to the correct `this` value, useful in class methods or event handlers.
+ * - `delay` must be a positive number.
+ */
+export interface DebouncerConfig<F extends AnyFunction> {
+    /**
+     * The function to be executed after the delay.
+     * Can be any function type, with type safety enforced by generics.
+     */
+    callback: F;
+    /**
+     * The `this` context to be used when invoking the callback.
+     * If provided, it will be stored and used for all invocations.
+     * Omit if the callback doesn't rely on `this` or uses arrow functions.
+     */
+    thisContext?: ThisParameterType<F>;
+    /**
+     * The delay in milliseconds before the function is executed.
+     * Must be a positive integer; affects performance and responsiveness.
+     */
+    delay: number;
+    /**
+     * If `true`, the function is called on the leading edge of the timeout.
+     * Useful for immediate feedback (e.g., button press).
+     * @default false
+     */
+    leading?: boolean;
+    /**
+     * If `true`, the function is called on the trailing edge of the timeout.
+     * Ensures the last call is executed after inactivity.
+     * @default true
+     */
+    trailing?: boolean;
+}
+//# sourceMappingURL=type.d.ts.map

package/dist/type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../src/type.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,WAAW;IACpD;;;OAGG;IACH,QAAQ,EAAE,CAAC,CAAC;IAEZ;;;;OAIG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAEnC;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@alwatr/debounce",
+  "description": "A powerful, modern, and type-safe debouncer utility designed for high-performance applications. It's framework-agnostic, works seamlessly in both Node.js and browsers, and provides a rich API for fine-grained control over function execution.",
+  "version": "1.0.0-rc.0",
+  "author": "S. Ali Mihandoost <ali.mihandoost@gmail.com>",
+  "bugs": "https://github.com/Alwatr/nanolib/issues",
+  "devDependencies": {
+    "@alwatr/nano-build": "6.1.2",
+    "@alwatr/prettier-config": "5.0.3",
+    "@alwatr/tsconfig-base": "6.0.1",
+    "@alwatr/type-helper": "6.0.2",
+    "@types/node": "^22.18.3",
+    "typescript": "^5.9.2"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "import": "./dist/main.mjs",
+      "require": "./dist/main.cjs"
+    }
+  },
+  "files": [
+    "**/*.{js,mjs,cjs,map,d.ts,html,md,LEGAL.txt}",
+    "LICENSE",
+    "!demo/**/*"
+  ],
+  "homepage": "https://github.com/Alwatr/nanolib/tree/next/packages/debounce#readme",
+  "keywords": [
+    "debounce",
+    "debouncing",
+    "typescript",
+    "type-safe",
+    "javascript",
+    "esm",
+    "module",
+    "browser",
+    "node",
+    "nodejs",
+    "cross-platform",
+    "universal",
+    "utility",
+    "util",
+    "leading",
+    "trailing",
+    "lifecycle",
+    "memory-leak",
+    "tree-shakable",
+    "framework-agnostic",
+    "alwatr",
+    "nanolib"
+  ],
+  "license": "MPL-2.0",
+  "main": "./dist/main.cjs",
+  "module": "./dist/main.mjs",
+  "prettier": "@alwatr/prettier-config",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Alwatr/nanolib",
+    "directory": "packages/debounce"
+  },
+  "scripts": {
+    "b": "yarn run build",
+    "build": "yarn run build:ts && yarn run build:es",
+    "build:es": "nano-build --preset=module",
+    "build:ts": "tsc --build",
+    "c": "yarn run clean",
+    "cb": "yarn run clean && yarn run build",
+    "clean": "rm -rfv dist *.tsbuildinfo",
+    "d": "yarn run build:es && yarn node --enable-source-maps --trace-warnings",
+    "w": "yarn run watch",
+    "watch": "yarn run watch:ts & yarn run watch:es",
+    "watch:es": "yarn run build:es --watch",
+    "watch:ts": "yarn run build:ts --watch --preserveWatchOutput"
+  },
+  "type": "module",
+  "types": "./dist/main.d.ts",
+  "gitHead": "4da18811162df49c118acd71086cdbe38b27f250"
+}