@tanstack/pacer-lite 0.1.0 → 0.1.1

package/dist/lite-batcher.js

@@ -0,0 +1,173 @@
+//#region src/lite-batcher.ts
+/**
+* A lightweight class that collects items and processes them in batches.
+*
+* This is an alternative to the Batcher in the core @tanstack/pacer package, but is more
+* suitable for libraries and npm packages that need minimal overhead. Unlike the core Batcher,
+* this version does not use TanStack Store for state management, has no devtools integration,
+* no callbacks, and provides only essential batching functionality.
+*
+* Batching is a technique for grouping multiple operations together to be processed as a single unit.
+* This synchronous version is lighter weight and often all you need.
+*
+* The Batcher provides a flexible way to implement batching with configurable:
+* - Maximum batch size (number of items per batch)
+* - Time-based batching (process after X milliseconds)
+* - Custom batch processing logic via getShouldExecute
+*
+* Features included:
+* - Core batching functionality (addItem, flush, clear, cancel)
+* - Size-based batching (maxSize)
+* - Time-based batching (wait timeout)
+* - Custom condition batching (getShouldExecute)
+* - Manual processing controls
+* - Public mutable options
+* - Callback support for monitoring batch execution and state changes
+*
+* Features NOT included (compared to core Batcher):
+* - No TanStack Store state management
+* - No devtools integration
+* - No complex state tracking (execution counts, etc.)
+* - No reactive state management
+*
+* @example
+* ```ts
+* // Basic batching
+* const batcher = new LiteBatcher<number>(
+*   (items) => console.log('Processing batch:', items),
+*   {
+*     maxSize: 5,
+*     wait: 2000,
+*     onExecute: (batch, batcher) => {
+*       console.log('Batch executed with', batch.length, 'items');
+*     },
+*     onItemsChange: (batcher) => {
+*       console.log('Batch size changed to:', batcher.size);
+*     }
+*   }
+* );
+*
+* batcher.addItem(1);
+* batcher.addItem(2);
+* // After 2 seconds or when 5 items are added, whichever comes first,
+* // the batch will be processed
+* ```
+*
+* @example
+* ```ts
+* // Custom condition batching
+* const batcher = new LiteBatcher<Task>(
+*   (items) => processTasks(items),
+*   {
+*     getShouldExecute: (items) => items.some(task => task.urgent),
+*     maxSize: 10,
+*   }
+* );
+*
+* batcher.addItem({ name: 'normal', urgent: false });
+* batcher.addItem({ name: 'urgent', urgent: true }); // Triggers immediate processing
+* ```
+*/
+var LiteBatcher = class {
+	constructor(fn, options = {}) {
+		this.fn = fn;
+		this.options = options;
+		this.items = [];
+		this.timeoutId = null;
+		this._isPending = false;
+		this.addItem = (item) => {
+			this.items.push(item);
+			this._isPending = this.options.wait !== Infinity;
+			this.options.onItemsChange?.(this);
+			if (this.items.length >= this.options.maxSize || this.options.getShouldExecute(this.items, this)) this.execute();
+			else if (this.options.wait !== Infinity) {
+				this.clearTimeout();
+				this.timeoutId = setTimeout(() => this.execute(), this.getWait());
+			}
+		};
+		this.execute = () => {
+			if (this.items.length === 0) return;
+			const batch = this.peekAllItems();
+			this.clear();
+			this.fn(batch);
+			this.options.onExecute?.(batch, this);
+		};
+		this.flush = () => {
+			this.clearTimeout();
+			this.execute();
+		};
+		this.peekAllItems = () => {
+			return [...this.items];
+		};
+		this.clearTimeout = () => {
+			if (this.timeoutId) {
+				clearTimeout(this.timeoutId);
+				this.timeoutId = null;
+			}
+		};
+		this.clear = () => {
+			const hadItems = this.items.length > 0;
+			this.items = [];
+			this._isPending = false;
+			if (hadItems) this.options.onItemsChange?.(this);
+		};
+		this.cancel = () => {
+			this.clearTimeout();
+			this._isPending = false;
+		};
+		this.options.maxSize = this.options.maxSize ?? Infinity;
+		this.options.started = this.options.started ?? true;
+		this.options.wait = this.options.wait ?? Infinity;
+		this.options.getShouldExecute = this.options.getShouldExecute ?? (() => false);
+	}
+	/**
+	* Number of items currently in the batch
+	*/
+	get size() {
+		return this.items.length;
+	}
+	/**
+	* Whether the batch has no items to process (items array is empty)
+	*/
+	get isEmpty() {
+		return this.items.length === 0;
+	}
+	/**
+	* Whether the batcher is waiting for the timeout to trigger batch processing
+	*/
+	get isPending() {
+		return this._isPending;
+	}
+	getWait() {
+		if (typeof this.options.wait === "function") return this.options.wait(this);
+		return this.options.wait;
+	}
+};
+/**
+* Creates a batcher that processes items in batches.
+*
+* This is an alternative to the batch function in the core @tanstack/pacer package, but is more
+* suitable for libraries and npm packages that need minimal overhead. Unlike the core version,
+* this function creates a batcher with no external dependencies, devtools integration, or reactive state.
+*
+* @example
+* ```ts
+* const batchItems = liteBatch<number>(
+*   (items) => console.log('Processing:', items),
+*   {
+*     maxSize: 3,
+*   }
+* );
+*
+* batchItems(1);
+* batchItems(2);
+* batchItems(3); // Triggers batch processing
+* ```
+*/
+function liteBatch(fn, options = {}) {
+	return new LiteBatcher(fn, options).addItem;
+}
+
+//#endregion
+export { LiteBatcher, liteBatch };
+//# sourceMappingURL=lite-batcher.js.map

package/dist/lite-batcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lite-batcher.js","names":["fn: (items: Array<TValue>) => void","options: LiteBatcherOptions<TValue>"],"sources":["../src/lite-batcher.ts"],"sourcesContent":["/**\n * Options for configuring a lite batcher instance\n */\nexport interface LiteBatcherOptions<TValue> {\n  /**\n   * Custom function to determine if a batch should be processed\n   * Return true to process the batch immediately\n   */\n  getShouldExecute?: (\n    items: Array<TValue>,\n    batcher: LiteBatcher<TValue>,\n  ) => boolean\n  /**\n   * Maximum number of items in a batch\n   * @default Infinity\n   */\n  maxSize?: number\n  /**\n   * Callback fired after a batch is processed\n   */\n  onExecute?: (batch: Array<TValue>, batcher: LiteBatcher<TValue>) => void\n  /**\n   * Callback fired after items are added to the batcher\n   */\n  onItemsChange?: (batcher: LiteBatcher<TValue>) => void\n  /**\n   * Whether the batcher should start processing immediately\n   * @default true\n   */\n  started?: boolean\n  /**\n   * Maximum time in milliseconds to wait before processing a batch.\n   * If the wait duration has elapsed, the batch will be processed.\n   * If not provided, the batch will not be triggered by a timeout.\n   * @default Infinity\n   */\n  wait?: number | ((batcher: LiteBatcher<TValue>) => number)\n}\n\n/**\n * A lightweight class that collects items and processes them in batches.\n *\n * This is an alternative to the Batcher in the core @tanstack/pacer package, but is more\n * suitable for libraries and npm packages that need minimal overhead. Unlike the core Batcher,\n * this version does not use TanStack Store for state management, has no devtools integration,\n * no callbacks, and provides only essential batching functionality.\n *\n * Batching is a technique for grouping multiple operations together to be processed as a single unit.\n * This synchronous version is lighter weight and often all you need.\n *\n * The Batcher provides a flexible way to implement batching with configurable:\n * - Maximum batch size (number of items per batch)\n * - Time-based batching (process after X milliseconds)\n * - Custom batch processing logic via getShouldExecute\n *\n * Features included:\n * - Core batching functionality (addItem, flush, clear, cancel)\n * - Size-based batching (maxSize)\n * - Time-based batching (wait timeout)\n * - Custom condition batching (getShouldExecute)\n * - Manual processing controls\n * - Public mutable options\n * - Callback support for monitoring batch execution and state changes\n *\n * Features NOT included (compared to core Batcher):\n * - No TanStack Store state management\n * - No devtools integration\n * - No complex state tracking (execution counts, etc.)\n * - No reactive state management\n *\n * @example\n * ```ts\n * // Basic batching\n * const batcher = new LiteBatcher<number>(\n *   (items) => console.log('Processing batch:', items),\n *   {\n *     maxSize: 5,\n *     wait: 2000,\n *     onExecute: (batch, batcher) => {\n *       console.log('Batch executed with', batch.length, 'items');\n *     },\n *     onItemsChange: (batcher) => {\n *       console.log('Batch size changed to:', batcher.size);\n *     }\n *   }\n * );\n *\n * batcher.addItem(1);\n * batcher.addItem(2);\n * // After 2 seconds or when 5 items are added, whichever comes first,\n * // the batch will be processed\n * ```\n *\n * @example\n * ```ts\n * // Custom condition batching\n * const batcher = new LiteBatcher<Task>(\n *   (items) => processTasks(items),\n *   {\n *     getShouldExecute: (items) => items.some(task => task.urgent),\n *     maxSize: 10,\n *   }\n * );\n *\n * batcher.addItem({ name: 'normal', urgent: false });\n * batcher.addItem({ name: 'urgent', urgent: true }); // Triggers immediate processing\n * ```\n */\nexport class LiteBatcher<TValue> {\n  private items: Array<TValue> = []\n  private timeoutId: NodeJS.Timeout | null = null\n  private _isPending = false\n\n  constructor(\n    public fn: (items: Array<TValue>) => void,\n    public options: LiteBatcherOptions<TValue> = {},\n  ) {\n    // Set defaults\n    this.options.maxSize = this.options.maxSize ?? Infinity\n    this.options.started = this.options.started ?? true\n    this.options.wait = this.options.wait ?? Infinity\n    this.options.getShouldExecute =\n      this.options.getShouldExecute ?? (() => false)\n  }\n\n  /**\n   * Number of items currently in the batch\n   */\n  get size(): number {\n    return this.items.length\n  }\n\n  /**\n   * Whether the batch has no items to process (items array is empty)\n   */\n  get isEmpty(): boolean {\n    return this.items.length === 0\n  }\n\n  /**\n   * Whether the batcher is waiting for the timeout to trigger batch processing\n   */\n  get isPending(): boolean {\n    return this._isPending\n  }\n\n  private getWait(): number {\n    if (typeof this.options.wait === 'function') {\n      return this.options.wait(this)\n    }\n    return this.options.wait!\n  }\n\n  /**\n   * Adds an item to the batcher\n   * If the batch size is reached, timeout occurs, or getShouldExecute returns true, the batch will be processed\n   */\n  addItem = (item: TValue): void => {\n    this.items.push(item)\n    this._isPending = this.options.wait !== Infinity\n    this.options.onItemsChange?.(this)\n\n    const shouldProcess =\n      this.items.length >= this.options.maxSize! ||\n      this.options.getShouldExecute!(this.items, this)\n\n    if (shouldProcess) {\n      this.execute()\n    } else if (this.options.wait !== Infinity) {\n      this.clearTimeout() // clear any pending timeout to replace it with a new one\n      this.timeoutId = setTimeout(() => this.execute(), this.getWait())\n    }\n  }\n\n  /**\n   * Processes the current batch of items.\n   * This method will automatically be triggered if the batcher is running and any of these conditions are met:\n   * - The number of items reaches maxSize\n   * - The wait duration has elapsed\n   * - The getShouldExecute function returns true upon adding an item\n   *\n   * You can also call this method manually to process the current batch at any time.\n   */\n  private execute = (): void => {\n    if (this.items.length === 0) {\n      return\n    }\n\n    const batch = this.peekAllItems() // copy of the items to be processed (to prevent race conditions)\n    this.clear() // Clear items before processing to prevent race conditions\n\n    this.fn(batch) // EXECUTE\n    this.options.onExecute?.(batch, this)\n  }\n\n  /**\n   * Processes the current batch of items immediately\n   */\n  flush = (): void => {\n    this.clearTimeout() // clear any pending timeout\n    this.execute() // execute immediately\n  }\n\n  /**\n   * Returns a copy of all items in the batcher\n   */\n  peekAllItems = (): Array<TValue> => {\n    return [...this.items]\n  }\n\n  private clearTimeout = (): void => {\n    if (this.timeoutId) {\n      clearTimeout(this.timeoutId)\n      this.timeoutId = null\n    }\n  }\n\n  /**\n   * Removes all items from the batcher\n   */\n  clear = (): void => {\n    const hadItems = this.items.length > 0\n    this.items = []\n    this._isPending = false\n    if (hadItems) {\n      this.options.onItemsChange?.(this)\n    }\n  }\n\n  /**\n   * Cancels any pending execution that was scheduled.\n   * Does NOT clear out the items.\n   */\n  cancel = (): void => {\n    this.clearTimeout()\n    this._isPending = false\n  }\n}\n\n/**\n * Creates a batcher that processes items in batches.\n *\n * This is an alternative to the batch function in the core @tanstack/pacer package, but is more\n * suitable for libraries and npm packages that need minimal overhead. Unlike the core version,\n * this function creates a batcher with no external dependencies, devtools integration, or reactive state.\n *\n * @example\n * ```ts\n * const batchItems = liteBatch<number>(\n *   (items) => console.log('Processing:', items),\n *   {\n *     maxSize: 3,\n *   }\n * );\n *\n * batchItems(1);\n * batchItems(2);\n * batchItems(3); // Triggers batch processing\n * ```\n */\nexport function liteBatch<TValue>(\n  fn: (items: Array<TValue>) => void,\n  options: LiteBatcherOptions<TValue> = {},\n): (item: TValue) => void {\n  const batcher = new LiteBatcher<TValue>(fn, options)\n  return batcher.addItem\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4GA,IAAa,cAAb,MAAiC;CAK/B,YACE,AAAOA,IACP,AAAOC,UAAsC,EAAE,EAC/C;EAFO;EACA;eANsB,EAAE;mBACU;oBACtB;kBA8CV,SAAuB;AAChC,QAAK,MAAM,KAAK,KAAK;AACrB,QAAK,aAAa,KAAK,QAAQ,SAAS;AACxC,QAAK,QAAQ,gBAAgB,KAAK;AAMlC,OAHE,KAAK,MAAM,UAAU,KAAK,QAAQ,WAClC,KAAK,QAAQ,iBAAkB,KAAK,OAAO,KAAK,CAGhD,MAAK,SAAS;YACL,KAAK,QAAQ,SAAS,UAAU;AACzC,SAAK,cAAc;AACnB,SAAK,YAAY,iBAAiB,KAAK,SAAS,EAAE,KAAK,SAAS,CAAC;;;uBAavC;AAC5B,OAAI,KAAK,MAAM,WAAW,EACxB;GAGF,MAAM,QAAQ,KAAK,cAAc;AACjC,QAAK,OAAO;AAEZ,QAAK,GAAG,MAAM;AACd,QAAK,QAAQ,YAAY,OAAO,KAAK;;qBAMnB;AAClB,QAAK,cAAc;AACnB,QAAK,SAAS;;4BAMoB;AAClC,UAAO,CAAC,GAAG,KAAK,MAAM;;4BAGW;AACjC,OAAI,KAAK,WAAW;AAClB,iBAAa,KAAK,UAAU;AAC5B,SAAK,YAAY;;;qBAOD;GAClB,MAAM,WAAW,KAAK,MAAM,SAAS;AACrC,QAAK,QAAQ,EAAE;AACf,QAAK,aAAa;AAClB,OAAI,SACF,MAAK,QAAQ,gBAAgB,KAAK;;sBAQjB;AACnB,QAAK,cAAc;AACnB,QAAK,aAAa;;AArHlB,OAAK,QAAQ,UAAU,KAAK,QAAQ,WAAW;AAC/C,OAAK,QAAQ,UAAU,KAAK,QAAQ,WAAW;AAC/C,OAAK,QAAQ,OAAO,KAAK,QAAQ,QAAQ;AACzC,OAAK,QAAQ,mBACX,KAAK,QAAQ,2BAA2B;;;;;CAM5C,IAAI,OAAe;AACjB,SAAO,KAAK,MAAM;;;;;CAMpB,IAAI,UAAmB;AACrB,SAAO,KAAK,MAAM,WAAW;;;;;CAM/B,IAAI,YAAqB;AACvB,SAAO,KAAK;;CAGd,AAAQ,UAAkB;AACxB,MAAI,OAAO,KAAK,QAAQ,SAAS,WAC/B,QAAO,KAAK,QAAQ,KAAK,KAAK;AAEhC,SAAO,KAAK,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;AA8GxB,SAAgB,UACd,IACA,UAAsC,EAAE,EAChB;AAExB,QADgB,IAAI,YAAoB,IAAI,QAAQ,CACrC"}

package/dist/lite-debouncer.cjs

@@ -0,0 +1,125 @@
+
+//#region src/lite-debouncer.ts
+/**
+* A lightweight class that creates a debounced function.
+*
+* This is an alternative to the Debouncer in the core @tanstack/pacer package, but is more
+* suitable for libraries and npm packages that need minimal overhead. Unlike the core Debouncer,
+* this version does not use TanStack Store for state management, has no devtools integration,
+* and provides only essential debouncing functionality.
+*
+* Debouncing ensures that a function is only executed after a certain amount of time has passed
+* since its last invocation. This is useful for handling frequent events like window resizing,
+* scroll events, or input changes where you want to limit the rate of execution.
+*
+* The debounced function can be configured to execute either at the start of the delay period
+* (leading edge) or at the end (trailing edge, default). Each new call during the wait period
+* will reset the timer.
+*
+* Features:
+* - Zero dependencies - no external libraries required
+* - Minimal API surface - only essential methods (maybeExecute, flush, cancel)
+* - Simple state management - uses basic private properties instead of reactive stores
+* - Callback support for monitoring execution events
+* - Lightweight - designed for use in npm packages where bundle size matters
+*
+* @example
+* ```ts
+* const debouncer = new LiteDebouncer((value: string) => {
+*   saveToDatabase(value);
+* }, {
+*   wait: 500,
+*   onExecute: (args, debouncer) => {
+*     console.log('Saved value:', args[0]);
+*   }
+* });
+*
+* // Will only save after 500ms of no new input
+* inputElement.addEventListener('input', () => {
+*   debouncer.maybeExecute(inputElement.value);
+* });
+* ```
+*/
+var LiteDebouncer = class {
+	constructor(fn, options) {
+		this.fn = fn;
+		this.options = options;
+		this.canLeadingExecute = true;
+		this.maybeExecute = (...args) => {
+			let didLeadingExecute = false;
+			if (this.options.leading && this.canLeadingExecute) {
+				this.canLeadingExecute = false;
+				didLeadingExecute = true;
+				this.fn(...args);
+				this.options.onExecute?.(args, this);
+			}
+			this.lastArgs = args;
+			if (this.timeoutId) clearTimeout(this.timeoutId);
+			this.timeoutId = setTimeout(() => {
+				this.canLeadingExecute = true;
+				if (this.options.trailing && !didLeadingExecute && this.lastArgs) {
+					this.fn(...this.lastArgs);
+					this.options.onExecute?.(this.lastArgs, this);
+				}
+				this.lastArgs = void 0;
+			}, this.options.wait);
+		};
+		this.flush = () => {
+			if (this.timeoutId && this.lastArgs) {
+				clearTimeout(this.timeoutId);
+				this.timeoutId = void 0;
+				const args = this.lastArgs;
+				this.fn(...args);
+				this.options.onExecute?.(args, this);
+				this.lastArgs = void 0;
+				this.canLeadingExecute = true;
+			}
+		};
+		this.cancel = () => {
+			if (this.timeoutId) {
+				clearTimeout(this.timeoutId);
+				this.timeoutId = void 0;
+			}
+			this.lastArgs = void 0;
+			this.canLeadingExecute = true;
+		};
+		if (this.options.leading === void 0 && this.options.trailing === void 0) this.options.trailing = true;
+	}
+};
+/**
+* Creates a lightweight debounced function that delays invoking the provided function until after a specified wait time.
+* Multiple calls during the wait period will cancel previous pending invocations and reset the timer.
+*
+* This is an alternative to the debounce function in the core @tanstack/pacer package, but is more
+* suitable for libraries and npm packages that need minimal overhead. Unlike the core version,
+* this function creates a debouncer with no external dependencies, devtools integration, or reactive state.
+*
+* If leading option is true, the function will execute immediately on the first call, then wait the delay
+* before allowing another execution.
+*
+* @example
+* ```ts
+* const debouncedSave = liteDebounce(() => {
+*   saveChanges();
+* }, { wait: 1000 });
+*
+* // Called repeatedly but executes at most once per second
+* inputElement.addEventListener('input', debouncedSave);
+* ```
+*
+* @example
+* ```ts
+* // Leading edge execution - fires immediately then waits
+* const debouncedSearch = liteDebounce((query: string) => {
+*   performSearch(query);
+* }, { wait: 300, leading: true });
+* ```
+*/
+function liteDebounce(fn, options) {
+	return new LiteDebouncer(fn, options).maybeExecute;
+}
+
+//#endregion
+exports.LiteDebouncer = LiteDebouncer;
+exports.liteDebounce = liteDebounce;
+//# sourceMappingURL=lite-debouncer.cjs.map

package/dist/lite-debouncer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lite-debouncer.cjs","names":["fn: TFn","options: LiteDebouncerOptions<TFn>"],"sources":["../src/lite-debouncer.ts"],"sourcesContent":["import type { AnyFunction } from '@tanstack/pacer/types'\n\n/**\n * Options for configuring a lite debounced function\n */\nexport interface LiteDebouncerOptions<TFn extends AnyFunction = AnyFunction> {\n  /**\n   * Whether to execute on the leading edge of the timeout.\n   * The first call will execute immediately and the rest will wait the delay.\n   * Defaults to false.\n   */\n  leading?: boolean\n  /**\n   * Callback function that is called after the function is executed\n   */\n  onExecute?: (args: Parameters<TFn>, debouncer: LiteDebouncer<TFn>) => void\n  /**\n   * Whether to execute on the trailing edge of the timeout.\n   * Defaults to true.\n   */\n  trailing?: boolean\n  /**\n   * Delay in milliseconds before executing the function.\n   */\n  wait: number\n}\n\n/**\n * A lightweight class that creates a debounced function.\n *\n * This is an alternative to the Debouncer in the core @tanstack/pacer package, but is more\n * suitable for libraries and npm packages that need minimal overhead. Unlike the core Debouncer,\n * this version does not use TanStack Store for state management, has no devtools integration,\n * and provides only essential debouncing functionality.\n *\n * Debouncing ensures that a function is only executed after a certain amount of time has passed\n * since its last invocation. This is useful for handling frequent events like window resizing,\n * scroll events, or input changes where you want to limit the rate of execution.\n *\n * The debounced function can be configured to execute either at the start of the delay period\n * (leading edge) or at the end (trailing edge, default). Each new call during the wait period\n * will reset the timer.\n *\n * Features:\n * - Zero dependencies - no external libraries required\n * - Minimal API surface - only essential methods (maybeExecute, flush, cancel)\n * - Simple state management - uses basic private properties instead of reactive stores\n * - Callback support for monitoring execution events\n * - Lightweight - designed for use in npm packages where bundle size matters\n *\n * @example\n * ```ts\n * const debouncer = new LiteDebouncer((value: string) => {\n *   saveToDatabase(value);\n * }, {\n *   wait: 500,\n *   onExecute: (args, debouncer) => {\n *     console.log('Saved value:', args[0]);\n *   }\n * });\n *\n * // Will only save after 500ms of no new input\n * inputElement.addEventListener('input', () => {\n *   debouncer.maybeExecute(inputElement.value);\n * });\n * ```\n */\nexport class LiteDebouncer<TFn extends AnyFunction> {\n  private timeoutId: NodeJS.Timeout | undefined\n  private lastArgs: Parameters<TFn> | undefined\n  private canLeadingExecute = true\n\n  constructor(\n    public fn: TFn,\n    public options: LiteDebouncerOptions<TFn>,\n  ) {\n    // Default trailing to true if neither leading nor trailing is specified\n    if (\n      this.options.leading === undefined &&\n      this.options.trailing === undefined\n    ) {\n      this.options.trailing = true\n    }\n  }\n\n  /**\n   * Attempts to execute the debounced function.\n   * If leading is true and this is the first call, executes immediately.\n   * Otherwise, queues the execution for after the wait time.\n   * Each new call resets the timer.\n   */\n  maybeExecute = (...args: Parameters<TFn>): void => {\n    let didLeadingExecute = false\n\n    if (this.options.leading && this.canLeadingExecute) {\n      this.canLeadingExecute = false\n      didLeadingExecute = true\n      this.fn(...args)\n      this.options.onExecute?.(args, this)\n    }\n\n    this.lastArgs = args\n\n    if (this.timeoutId) {\n      clearTimeout(this.timeoutId)\n    }\n\n    this.timeoutId = setTimeout(() => {\n      this.canLeadingExecute = true\n      if (this.options.trailing && !didLeadingExecute && this.lastArgs) {\n        this.fn(...this.lastArgs)\n        this.options.onExecute?.(this.lastArgs, this)\n      }\n      this.lastArgs = undefined\n    }, this.options.wait)\n  }\n\n  /**\n   * Processes the current pending execution immediately.\n   * If there's a pending execution, it will be executed right away\n   * and the timeout will be cleared.\n   */\n  flush = (): void => {\n    if (this.timeoutId && this.lastArgs) {\n      clearTimeout(this.timeoutId)\n      this.timeoutId = undefined\n      const args = this.lastArgs\n      this.fn(...args)\n      this.options.onExecute?.(args, this)\n      this.lastArgs = undefined\n      this.canLeadingExecute = true\n    }\n  }\n\n  /**\n   * Cancels any pending execution.\n   * Clears the timeout and resets the internal state.\n   */\n  cancel = (): void => {\n    if (this.timeoutId) {\n      clearTimeout(this.timeoutId)\n      this.timeoutId = undefined\n    }\n    this.lastArgs = undefined\n    this.canLeadingExecute = true\n  }\n}\n\n/**\n * Creates a lightweight debounced function that delays invoking the provided function until after a specified wait time.\n * Multiple calls during the wait period will cancel previous pending invocations and reset the timer.\n *\n * This is an alternative to the debounce function in the core @tanstack/pacer package, but is more\n * suitable for libraries and npm packages that need minimal overhead. Unlike the core version,\n * this function creates a debouncer with no external dependencies, devtools integration, or reactive state.\n *\n * If leading option is true, the function will execute immediately on the first call, then wait the delay\n * before allowing another execution.\n *\n * @example\n * ```ts\n * const debouncedSave = liteDebounce(() => {\n *   saveChanges();\n * }, { wait: 1000 });\n *\n * // Called repeatedly but executes at most once per second\n * inputElement.addEventListener('input', debouncedSave);\n * ```\n *\n * @example\n * ```ts\n * // Leading edge execution - fires immediately then waits\n * const debouncedSearch = liteDebounce((query: string) => {\n *   performSearch(query);\n * }, { wait: 300, leading: true });\n * ```\n */\nexport function liteDebounce<TFn extends AnyFunction>(\n  fn: TFn,\n  options: LiteDebouncerOptions<TFn>,\n): (...args: Parameters<TFn>) => void {\n  const debouncer = new LiteDebouncer(fn, options)\n  return debouncer.maybeExecute\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,IAAa,gBAAb,MAAoD;CAKlD,YACE,AAAOA,IACP,AAAOC,SACP;EAFO;EACA;2BAJmB;uBAqBZ,GAAG,SAAgC;GACjD,IAAI,oBAAoB;AAExB,OAAI,KAAK,QAAQ,WAAW,KAAK,mBAAmB;AAClD,SAAK,oBAAoB;AACzB,wBAAoB;AACpB,SAAK,GAAG,GAAG,KAAK;AAChB,SAAK,QAAQ,YAAY,MAAM,KAAK;;AAGtC,QAAK,WAAW;AAEhB,OAAI,KAAK,UACP,cAAa,KAAK,UAAU;AAG9B,QAAK,YAAY,iBAAiB;AAChC,SAAK,oBAAoB;AACzB,QAAI,KAAK,QAAQ,YAAY,CAAC,qBAAqB,KAAK,UAAU;AAChE,UAAK,GAAG,GAAG,KAAK,SAAS;AACzB,UAAK,QAAQ,YAAY,KAAK,UAAU,KAAK;;AAE/C,SAAK,WAAW;MACf,KAAK,QAAQ,KAAK;;qBAQH;AAClB,OAAI,KAAK,aAAa,KAAK,UAAU;AACnC,iBAAa,KAAK,UAAU;AAC5B,SAAK,YAAY;IACjB,MAAM,OAAO,KAAK;AAClB,SAAK,GAAG,GAAG,KAAK;AAChB,SAAK,QAAQ,YAAY,MAAM,KAAK;AACpC,SAAK,WAAW;AAChB,SAAK,oBAAoB;;;sBAQR;AACnB,OAAI,KAAK,WAAW;AAClB,iBAAa,KAAK,UAAU;AAC5B,SAAK,YAAY;;AAEnB,QAAK,WAAW;AAChB,QAAK,oBAAoB;;AAnEzB,MACE,KAAK,QAAQ,YAAY,UACzB,KAAK,QAAQ,aAAa,OAE1B,MAAK,QAAQ,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgG9B,SAAgB,aACd,IACA,SACoC;AAEpC,QADkB,IAAI,cAAc,IAAI,QAAQ,CAC/B"}

package/dist/{cjs/lite-debouncer.d.cts → lite-debouncer.d.cts}

@@ -1,27 +1,30 @@
-import { AnyFunction } from '@tanstack/pacer/types';
+import { AnyFunction } from "@tanstack/pacer/types";
+
+//#region src/lite-debouncer.d.ts
+
 /**
  * Options for configuring a lite debounced function
  */
-export interface LiteDebouncerOptions<TFn extends AnyFunction = AnyFunction> {
-    /**
-     * Whether to execute on the leading edge of the timeout.
-     * The first call will execute immediately and the rest will wait the delay.
-     * Defaults to false.
-     */
-    leading?: boolean;
-    /**
-     * Callback function that is called after the function is executed
-     */
-    onExecute?: (args: Parameters<TFn>, debouncer: LiteDebouncer<TFn>) => void;
-    /**
-     * Whether to execute on the trailing edge of the timeout.
-     * Defaults to true.
-     */
-    trailing?: boolean;
-    /**
-     * Delay in milliseconds before executing the function.
-     */
-    wait: number;
+interface LiteDebouncerOptions<TFn extends AnyFunction = AnyFunction> {
+  /**
+   * Whether to execute on the leading edge of the timeout.
+   * The first call will execute immediately and the rest will wait the delay.
+   * Defaults to false.
+   */
+  leading?: boolean;
+  /**
+   * Callback function that is called after the function is executed
+   */
+  onExecute?: (args: Parameters<TFn>, debouncer: LiteDebouncer<TFn>) => void;
+  /**
+   * Whether to execute on the trailing edge of the timeout.
+   * Defaults to true.
+   */
+  trailing?: boolean;
+  /**
+   * Delay in milliseconds before executing the function.
+   */
+  wait: number;
 }
 /**
  * A lightweight class that creates a debounced function.
@@ -63,31 +66,31 @@ export interface LiteDebouncerOptions<TFn extends AnyFunction = AnyFunction> {
  * });
  * ```
  */
-export declare class LiteDebouncer<TFn extends AnyFunction> {
-    fn: TFn;
-    options: LiteDebouncerOptions<TFn>;
-    private timeoutId;
-    private lastArgs;
-    private canLeadingExecute;
-    constructor(fn: TFn, options: LiteDebouncerOptions<TFn>);
-    /**
-     * Attempts to execute the debounced function.
-     * If leading is true and this is the first call, executes immediately.
-     * Otherwise, queues the execution for after the wait time.
-     * Each new call resets the timer.
-     */
-    maybeExecute: (...args: Parameters<TFn>) => void;
-    /**
-     * Processes the current pending execution immediately.
-     * If there's a pending execution, it will be executed right away
-     * and the timeout will be cleared.
-     */
-    flush: () => void;
-    /**
-     * Cancels any pending execution.
-     * Clears the timeout and resets the internal state.
-     */
-    cancel: () => void;
+declare class LiteDebouncer<TFn extends AnyFunction> {
+  fn: TFn;
+  options: LiteDebouncerOptions<TFn>;
+  private timeoutId;
+  private lastArgs;
+  private canLeadingExecute;
+  constructor(fn: TFn, options: LiteDebouncerOptions<TFn>);
+  /**
+   * Attempts to execute the debounced function.
+   * If leading is true and this is the first call, executes immediately.
+   * Otherwise, queues the execution for after the wait time.
+   * Each new call resets the timer.
+   */
+  maybeExecute: (...args: Parameters<TFn>) => void;
+  /**
+   * Processes the current pending execution immediately.
+   * If there's a pending execution, it will be executed right away
+   * and the timeout will be cleared.
+   */
+  flush: () => void;
+  /**
+   * Cancels any pending execution.
+   * Clears the timeout and resets the internal state.
+   */
+  cancel: () => void;
 }
 /**
  * Creates a lightweight debounced function that delays invoking the provided function until after a specified wait time.
@@ -118,4 +121,7 @@ export declare class LiteDebouncer<TFn extends AnyFunction> {
  * }, { wait: 300, leading: true });
  * ```
  */
-export declare function liteDebounce<TFn extends AnyFunction>(fn: TFn, options: LiteDebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;
+declare function liteDebounce<TFn extends AnyFunction>(fn: TFn, options: LiteDebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;
+//#endregion
+export { LiteDebouncer, LiteDebouncerOptions, liteDebounce };
+//# sourceMappingURL=lite-debouncer.d.cts.map

package/dist/{esm/lite-debouncer.d.ts → lite-debouncer.d.ts}

@@ -1,27 +1,30 @@
-import { AnyFunction } from '@tanstack/pacer/types';
+import { AnyFunction } from "@tanstack/pacer/types";
+
+//#region src/lite-debouncer.d.ts
+
 /**
  * Options for configuring a lite debounced function
  */
-export interface LiteDebouncerOptions<TFn extends AnyFunction = AnyFunction> {
-    /**
-     * Whether to execute on the leading edge of the timeout.
-     * The first call will execute immediately and the rest will wait the delay.
-     * Defaults to false.
-     */
-    leading?: boolean;
-    /**
-     * Callback function that is called after the function is executed
-     */
-    onExecute?: (args: Parameters<TFn>, debouncer: LiteDebouncer<TFn>) => void;
-    /**
-     * Whether to execute on the trailing edge of the timeout.
-     * Defaults to true.
-     */
-    trailing?: boolean;
-    /**
-     * Delay in milliseconds before executing the function.
-     */
-    wait: number;
+interface LiteDebouncerOptions<TFn extends AnyFunction = AnyFunction> {
+  /**
+   * Whether to execute on the leading edge of the timeout.
+   * The first call will execute immediately and the rest will wait the delay.
+   * Defaults to false.
+   */
+  leading?: boolean;
+  /**
+   * Callback function that is called after the function is executed
+   */
+  onExecute?: (args: Parameters<TFn>, debouncer: LiteDebouncer<TFn>) => void;
+  /**
+   * Whether to execute on the trailing edge of the timeout.
+   * Defaults to true.
+   */
+  trailing?: boolean;
+  /**
+   * Delay in milliseconds before executing the function.
+   */
+  wait: number;
 }
 /**
  * A lightweight class that creates a debounced function.
@@ -63,31 +66,31 @@ export interface LiteDebouncerOptions<TFn extends AnyFunction = AnyFunction> {
  * });
  * ```
  */
-export declare class LiteDebouncer<TFn extends AnyFunction> {
-    fn: TFn;
-    options: LiteDebouncerOptions<TFn>;
-    private timeoutId;
-    private lastArgs;
-    private canLeadingExecute;
-    constructor(fn: TFn, options: LiteDebouncerOptions<TFn>);
-    /**
-     * Attempts to execute the debounced function.
-     * If leading is true and this is the first call, executes immediately.
-     * Otherwise, queues the execution for after the wait time.
-     * Each new call resets the timer.
-     */
-    maybeExecute: (...args: Parameters<TFn>) => void;
-    /**
-     * Processes the current pending execution immediately.
-     * If there's a pending execution, it will be executed right away
-     * and the timeout will be cleared.
-     */
-    flush: () => void;
-    /**
-     * Cancels any pending execution.
-     * Clears the timeout and resets the internal state.
-     */
-    cancel: () => void;
+declare class LiteDebouncer<TFn extends AnyFunction> {
+  fn: TFn;
+  options: LiteDebouncerOptions<TFn>;
+  private timeoutId;
+  private lastArgs;
+  private canLeadingExecute;
+  constructor(fn: TFn, options: LiteDebouncerOptions<TFn>);
+  /**
+   * Attempts to execute the debounced function.
+   * If leading is true and this is the first call, executes immediately.
+   * Otherwise, queues the execution for after the wait time.
+   * Each new call resets the timer.
+   */
+  maybeExecute: (...args: Parameters<TFn>) => void;
+  /**
+   * Processes the current pending execution immediately.
+   * If there's a pending execution, it will be executed right away
+   * and the timeout will be cleared.
+   */
+  flush: () => void;
+  /**
+   * Cancels any pending execution.
+   * Clears the timeout and resets the internal state.
+   */
+  cancel: () => void;
 }
 /**
  * Creates a lightweight debounced function that delays invoking the provided function until after a specified wait time.
@@ -118,4 +121,7 @@ export declare class LiteDebouncer<TFn extends AnyFunction> {
  * }, { wait: 300, leading: true });
  * ```
  */
-export declare function liteDebounce<TFn extends AnyFunction>(fn: TFn, options: LiteDebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;
+declare function liteDebounce<TFn extends AnyFunction>(fn: TFn, options: LiteDebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;
+//#endregion
+export { LiteDebouncer, LiteDebouncerOptions, liteDebounce };
+//# sourceMappingURL=lite-debouncer.d.ts.map