@tanstack/pacer-lite 0.2.2 → 0.3.0

package/dist/lite-rate-limiter.d.ts

@@ -1,10 +1,9 @@
 import { AnyFunction } from "./pacer/dist/types.js";
-
 //#region src/lite-rate-limiter.d.ts
 /**
  * Options for configuring a lite rate-limited function
  */
-interface LiteRateLimiterOptions<TFn extends AnyFunction = AnyFunction> {
+export interface LiteRateLimiterOptions<TFn extends AnyFunction = AnyFunction> {
   /**
    * Maximum number of executions allowed within the time window.
    */
@@ -67,7 +66,7 @@ interface LiteRateLimiterOptions<TFn extends AnyFunction = AnyFunction> {
  * }
  * ```
  */
-declare class LiteRateLimiter<TFn extends AnyFunction> {
+export declare class LiteRateLimiter<TFn extends AnyFunction> {
   fn: TFn;
   options: LiteRateLimiterOptions<TFn>;
   private executionTimes;
@@ -142,7 +141,5 @@ declare class LiteRateLimiter<TFn extends AnyFunction> {
  * });
  * ```
  */
-declare function liteRateLimit<TFn extends AnyFunction>(fn: TFn, options: LiteRateLimiterOptions<TFn>): (...args: Parameters<TFn>) => boolean;
-//#endregion
-export { LiteRateLimiter, LiteRateLimiterOptions, liteRateLimit };
-//# sourceMappingURL=lite-rate-limiter.d.ts.map
+export declare function liteRateLimit<TFn extends AnyFunction>(fn: TFn, options: LiteRateLimiterOptions<TFn>): (...args: Parameters<TFn>) => boolean;
+//#endregion

package/dist/lite-rate-limiter.js

@@ -38,72 +38,99 @@
 * ```
 */
 var LiteRateLimiter = class {
+	fn;
+	options;
+	executionTimes = [];
+	timeoutIds = /* @__PURE__ */ new Set();
 	constructor(fn, options) {
 		this.fn = fn;
 		this.options = options;
-		this.executionTimes = [];
-		this.timeoutIds = /* @__PURE__ */ new Set();
-		this.maybeExecute = (...args) => {
-			this.cleanupOldExecutions();
-			if (this.getExecutionTimesInWindow().length < this.options.limit) {
-				this.execute(...args);
-				return true;
-			}
-			this.options.onReject?.(this);
-			return false;
-		};
-		this.execute = (...args) => {
-			const now = Date.now();
-			this.fn(...args);
-			this.options.onExecute?.(args, this);
-			this.executionTimes.push(now);
-			this.setCleanupTimeout(now);
-		};
-		this.getExecutionTimesInWindow = () => {
-			if (this.options.windowType === "sliding") return this.executionTimes.filter((time) => time > Date.now() - this.options.window);
-			else {
-				if (this.executionTimes.length === 0) return [];
-				const windowStart = Math.min(...this.executionTimes);
-				const windowEnd = windowStart + this.options.window;
-				if (Date.now() > windowEnd) return [];
-				return this.executionTimes.filter((time) => time >= windowStart && time <= windowEnd);
-			}
-		};
-		this.setCleanupTimeout = (executionTime) => {
-			if (this.options.windowType === "sliding" || this.timeoutIds.size === 0) {
-				const timeUntilExpiration = executionTime - Date.now() + this.options.window + 1;
-				const timeoutId = setTimeout(() => {
-					this.cleanupOldExecutions();
-					this.clearTimeout(timeoutId);
-				}, timeUntilExpiration);
-				this.timeoutIds.add(timeoutId);
-			}
-		};
-		this.clearTimeout = (timeoutId) => {
-			clearTimeout(timeoutId);
-			this.timeoutIds.delete(timeoutId);
-		};
-		this.clearTimeouts = () => {
-			this.timeoutIds.forEach((timeoutId) => clearTimeout(timeoutId));
-			this.timeoutIds.clear();
-		};
-		this.cleanupOldExecutions = () => {
-			this.executionTimes = this.getExecutionTimesInWindow();
-		};
-		this.getRemainingInWindow = () => {
-			const relevantExecutionTimes = this.getExecutionTimesInWindow();
-			return Math.max(0, this.options.limit - relevantExecutionTimes.length);
-		};
-		this.getMsUntilNextWindow = () => {
-			if (this.getRemainingInWindow() > 0) return 0;
-			return (this.executionTimes[0] ?? Infinity) + this.options.window - Date.now();
-		};
-		this.reset = () => {
-			this.executionTimes = [];
-			this.clearTimeouts();
-		};
 		if (this.options.windowType === void 0) this.options.windowType = "fixed";
 	}
+	/**
+	* Attempts to execute the rate-limited function if within the configured limits.
+	* Returns true if executed, false if rejected due to rate limiting.
+	*
+	* @example
+	* ```ts
+	* const rateLimiter = new LiteRateLimiter(fn, { limit: 5, window: 1000 });
+	*
+	* // First 5 calls return true
+	* rateLimiter.maybeExecute('arg1', 'arg2'); // true
+	*
+	* // Additional calls within the window return false
+	* rateLimiter.maybeExecute('arg1', 'arg2'); // false
+	* ```
+	*/
+	maybeExecute = (...args) => {
+		this.cleanupOldExecutions();
+		if (this.getExecutionTimesInWindow().length < this.options.limit) {
+			this.execute(...args);
+			return true;
+		}
+		this.options.onReject?.(this);
+		return false;
+	};
+	execute = (...args) => {
+		const now = Date.now();
+		this.fn(...args);
+		this.options.onExecute?.(args, this);
+		this.executionTimes.push(now);
+		this.setCleanupTimeout(now);
+	};
+	getExecutionTimesInWindow = () => {
+		if (this.options.windowType === "sliding") return this.executionTimes.filter((time) => time > Date.now() - this.options.window);
+		else {
+			if (this.executionTimes.length === 0) return [];
+			const windowStart = Math.min(...this.executionTimes);
+			const windowEnd = windowStart + this.options.window;
+			if (Date.now() > windowEnd) return [];
+			return this.executionTimes.filter((time) => time >= windowStart && time <= windowEnd);
+		}
+	};
+	setCleanupTimeout = (executionTime) => {
+		if (this.options.windowType === "sliding" || this.timeoutIds.size === 0) {
+			const timeUntilExpiration = executionTime - Date.now() + this.options.window + 1;
+			const timeoutId = setTimeout(() => {
+				this.cleanupOldExecutions();
+				this.clearTimeout(timeoutId);
+			}, timeUntilExpiration);
+			this.timeoutIds.add(timeoutId);
+		}
+	};
+	clearTimeout = (timeoutId) => {
+		clearTimeout(timeoutId);
+		this.timeoutIds.delete(timeoutId);
+	};
+	clearTimeouts = () => {
+		this.timeoutIds.forEach((timeoutId) => clearTimeout(timeoutId));
+		this.timeoutIds.clear();
+	};
+	cleanupOldExecutions = () => {
+		this.executionTimes = this.getExecutionTimesInWindow();
+	};
+	/**
+	* Returns the number of remaining executions allowed in the current window.
+	*/
+	getRemainingInWindow = () => {
+		const relevantExecutionTimes = this.getExecutionTimesInWindow();
+		return Math.max(0, this.options.limit - relevantExecutionTimes.length);
+	};
+	/**
+	* Returns the number of milliseconds until the next execution will be possible.
+	* Returns 0 if executions are currently allowed.
+	*/
+	getMsUntilNextWindow = () => {
+		if (this.getRemainingInWindow() > 0) return 0;
+		return (this.executionTimes[0] ?? Infinity) + this.options.window - Date.now();
+	};
+	/**
+	* Resets the rate limiter state, clearing all execution history.
+	*/
+	reset = () => {
+		this.executionTimes = [];
+		this.clearTimeouts();
+	};
 };
 /**
 * Creates a lightweight rate-limited function that will execute the provided function up to a maximum number of times within a time window.
@@ -143,5 +170,4 @@ function liteRateLimit(fn, options) {
 }
 
 //#endregion
-export { LiteRateLimiter, liteRateLimit };
-//# sourceMappingURL=lite-rate-limiter.js.map
+export { LiteRateLimiter, liteRateLimit };

package/dist/lite-throttler.d.ts

@@ -1,10 +1,9 @@
 import { AnyFunction } from "./pacer/dist/types.js";
-
 //#region src/lite-throttler.d.ts
 /**
  * Options for configuring a lite throttled function
  */
-interface LiteThrottlerOptions<TFn extends AnyFunction = AnyFunction> {
+export interface LiteThrottlerOptions<TFn extends AnyFunction = AnyFunction> {
   /**
    * Whether to execute on the leading edge of the timeout.
    * Defaults to true.
@@ -64,7 +63,7 @@ interface LiteThrottlerOptions<TFn extends AnyFunction = AnyFunction> {
  * });
  * ```
  */
-declare class LiteThrottler<TFn extends AnyFunction> {
+export declare class LiteThrottler<TFn extends AnyFunction> {
   fn: TFn;
   options: LiteThrottlerOptions<TFn>;
   private timeoutId;
@@ -127,7 +126,5 @@ declare class LiteThrottler<TFn extends AnyFunction> {
  * }, { wait: 250, leading: true, trailing: false });
  * ```
  */
-declare function liteThrottle<TFn extends AnyFunction>(fn: TFn, options: LiteThrottlerOptions<TFn>): (...args: Parameters<TFn>) => void;
-//#endregion
-export { LiteThrottler, LiteThrottlerOptions, liteThrottle };
-//# sourceMappingURL=lite-throttler.d.ts.map
+export declare function liteThrottle<TFn extends AnyFunction>(fn: TFn, options: LiteThrottlerOptions<TFn>): (...args: Parameters<TFn>) => void;
+//#endregion

package/dist/lite-throttler.js

@@ -40,52 +40,76 @@
 * ```
 */
 var LiteThrottler = class {
+	fn;
+	options;
+	timeoutId;
+	lastArgs;
+	lastExecutionTime = 0;
+	isPending = false;
 	constructor(fn, options) {
 		this.fn = fn;
 		this.options = options;
-		this.lastExecutionTime = 0;
-		this.isPending = false;
-		this.maybeExecute = (...args) => {
-			const timeSinceLastExecution = Date.now() - this.lastExecutionTime;
-			if (this.options.leading && timeSinceLastExecution >= this.options.wait) this.execute(...args);
-			else {
-				this.lastArgs = args;
-				if (!this.timeoutId && this.options.trailing) {
-					const timeoutDuration = this.options.wait - timeSinceLastExecution;
-					this.isPending = true;
-					this.timeoutId = setTimeout(() => {
-						if (this.lastArgs !== void 0) this.execute(...this.lastArgs);
-					}, timeoutDuration);
-				}
-			}
-		};
-		this.execute = (...args) => {
-			this.fn(...args);
-			this.options.onExecute?.(args, this);
-			this.lastExecutionTime = Date.now();
-			this.clearTimeout();
-			this.lastArgs = void 0;
-			this.isPending = false;
-		};
-		this.flush = () => {
-			if (this.isPending && this.lastArgs) this.execute(...this.lastArgs);
-		};
-		this.cancel = () => {
-			this.clearTimeout();
-			this.lastArgs = void 0;
-			this.isPending = false;
-		};
-		this.clearTimeout = () => {
-			if (this.timeoutId) {
-				clearTimeout(this.timeoutId);
-				this.timeoutId = void 0;
-			}
-		};
 		if (this.options.leading === void 0 && this.options.trailing === void 0) {
 			this.options.leading = true;
 			this.options.trailing = true;
 		}
 	}
+	/**
+	* Attempts to execute the throttled function. The execution behavior depends on the throttler options:
+	*
+	* - If enough time has passed since the last execution (>= wait period):
+	*   - With leading=true: Executes immediately
+	*   - With leading=false: Waits for the next trailing execution
+	*
+	* - If within the wait period:
+	*   - With trailing=true: Schedules execution for end of wait period
+	*   - With trailing=false: Drops the execution
+	*/
+	maybeExecute = (...args) => {
+		const timeSinceLastExecution = Date.now() - this.lastExecutionTime;
+		if (this.options.leading && timeSinceLastExecution >= this.options.wait) this.execute(...args);
+		else {
+			this.lastArgs = args;
+			if (!this.timeoutId && this.options.trailing) {
+				const timeoutDuration = this.options.wait - timeSinceLastExecution;
+				this.isPending = true;
+				this.timeoutId = setTimeout(() => {
+					if (this.lastArgs !== void 0) this.execute(...this.lastArgs);
+				}, timeoutDuration);
+			}
+		}
+	};
+	execute = (...args) => {
+		this.fn(...args);
+		this.options.onExecute?.(args, this);
+		this.lastExecutionTime = Date.now();
+		this.clearTimeout();
+		this.lastArgs = void 0;
+		this.isPending = false;
+	};
+	/**
+	* 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 = () => {
+		if (this.isPending && this.lastArgs) this.execute(...this.lastArgs);
+	};
+	/**
+	* Cancels any pending trailing execution and clears internal state.
+	* If a trailing execution is scheduled, this will prevent that execution from occurring.
+	*/
+	cancel = () => {
+		this.clearTimeout();
+		this.lastArgs = void 0;
+		this.isPending = false;
+	};
+	clearTimeout = () => {
+		if (this.timeoutId) {
+			clearTimeout(this.timeoutId);
+			this.timeoutId = void 0;
+		}
+	};
 };
 /**
 * Creates a lightweight throttled function that limits how often the provided function can execute.
@@ -121,5 +145,4 @@ function liteThrottle(fn, options) {
 }
 
 //#endregion
-export { LiteThrottler, liteThrottle };
-//# sourceMappingURL=lite-throttler.js.map
+export { LiteThrottler, liteThrottle };

package/dist/pacer/dist/types.d.ts

@@ -3,10 +3,5 @@
 /**
  * Represents a function that can be called with any arguments and returns any value.
  */
-type AnyFunction = (...args: Array<any>) => any;
-/**
- * Represents an asynchronous function that can be called with any arguments and returns a promise.
- */
-//#endregion
-export { AnyFunction };
-//# sourceMappingURL=types.d.ts.map
+export type AnyFunction = (...args: Array<any>) => any;
+//#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/pacer-lite",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Lightweight utilities for debouncing, throttling, and more - designed for npm packages.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -23,46 +23,25 @@
     "minimal"
   ],
   "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.cts",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
-    "./lite-batcher": {
-      "import": "./dist/lite-batcher.js",
-      "require": "./dist/lite-batcher.cjs"
-    },
-    "./lite-debouncer": {
-      "import": "./dist/lite-debouncer.js",
-      "require": "./dist/lite-debouncer.cjs"
-    },
-    "./lite-queuer": {
-      "import": "./dist/lite-queuer.js",
-      "require": "./dist/lite-queuer.cjs"
-    },
-    "./lite-rate-limiter": {
-      "import": "./dist/lite-rate-limiter.js",
-      "require": "./dist/lite-rate-limiter.cjs"
-    },
-    "./lite-throttler": {
-      "import": "./dist/lite-throttler.js",
-      "require": "./dist/lite-throttler.cjs"
-    },
+    ".": "./dist/index.js",
+    "./lite-batcher": "./dist/lite-batcher.js",
+    "./lite-debouncer": "./dist/lite-debouncer.js",
+    "./lite-queuer": "./dist/lite-queuer.js",
+    "./lite-rate-limiter": "./dist/lite-rate-limiter.js",
+    "./lite-throttler": "./dist/lite-throttler.js",
     "./package.json": "./package.json"
   },
   "sideEffects": false,
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "files": [
-    "dist/",
-    "src"
+    "dist"
   ],
   "devDependencies": {
-    "@tanstack/pacer": "0.21.1"
+    "@tanstack/pacer": "0.23.0"
   },
   "scripts": {
     "clean": "premove ./build ./dist",
@@ -71,6 +50,7 @@
     "test:lib": "vitest",
     "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "tsc",
-    "build": "tsdown"
+    "build": "tsdown",
+    "test:build": "publint --strict && node ../../scripts/verify-package.ts"
   }
 }

package/dist/index.cjs

@@ -1,17 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_lite_debouncer = require('./lite-debouncer.cjs');
-const require_lite_throttler = require('./lite-throttler.cjs');
-const require_lite_rate_limiter = require('./lite-rate-limiter.cjs');
-const require_lite_queuer = require('./lite-queuer.cjs');
-const require_lite_batcher = require('./lite-batcher.cjs');
-
-exports.LiteBatcher = require_lite_batcher.LiteBatcher;
-exports.LiteDebouncer = require_lite_debouncer.LiteDebouncer;
-exports.LiteQueuer = require_lite_queuer.LiteQueuer;
-exports.LiteRateLimiter = require_lite_rate_limiter.LiteRateLimiter;
-exports.LiteThrottler = require_lite_throttler.LiteThrottler;
-exports.liteBatch = require_lite_batcher.liteBatch;
-exports.liteDebounce = require_lite_debouncer.liteDebounce;
-exports.liteQueue = require_lite_queuer.liteQueue;
-exports.liteRateLimit = require_lite_rate_limiter.liteRateLimit;
-exports.liteThrottle = require_lite_throttler.liteThrottle;

package/dist/index.d.cts

@@ -1,6 +0,0 @@
-import { LiteDebouncer, LiteDebouncerOptions, liteDebounce } from "./lite-debouncer.cjs";
-import { LiteThrottler, LiteThrottlerOptions, liteThrottle } from "./lite-throttler.cjs";
-import { LiteRateLimiter, LiteRateLimiterOptions, liteRateLimit } from "./lite-rate-limiter.cjs";
-import { LiteQueuer, LiteQueuerOptions, QueuePosition, liteQueue } from "./lite-queuer.cjs";
-import { LiteBatcher, LiteBatcherOptions, liteBatch } from "./lite-batcher.cjs";
-export { LiteBatcher, LiteBatcherOptions, LiteDebouncer, LiteDebouncerOptions, LiteQueuer, LiteQueuerOptions, LiteRateLimiter, LiteRateLimiterOptions, LiteThrottler, LiteThrottlerOptions, QueuePosition, liteBatch, liteDebounce, liteQueue, liteRateLimit, liteThrottle };

package/dist/lite-batcher.cjs

@@ -1,176 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-//#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
-exports.LiteBatcher = LiteBatcher;
-exports.liteBatch = liteBatch;
-//# sourceMappingURL=lite-batcher.cjs.map

package/dist/lite-batcher.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"lite-batcher.cjs","names":[],"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,AAAO,IACP,AAAO,UAAsC,EAAE,EAC/C;EAFO;EACA;eANsB,EAAE;mBACU;oBACtB;kBA8CV,SAAuB;GAChC,KAAK,MAAM,KAAK,KAAK;GACrB,KAAK,aAAa,KAAK,QAAQ,SAAS;GACxC,KAAK,QAAQ,gBAAgB,KAAK;GAMlC,IAHE,KAAK,MAAM,UAAU,KAAK,QAAQ,WAClC,KAAK,QAAQ,iBAAkB,KAAK,OAAO,KAAK,EAGhD,KAAK,SAAS;QACT,IAAI,KAAK,QAAQ,SAAS,UAAU;IACzC,KAAK,cAAc;IACnB,KAAK,YAAY,iBAAiB,KAAK,SAAS,EAAE,KAAK,SAAS,CAAC;;;uBAavC;GAC5B,IAAI,KAAK,MAAM,WAAW,GACxB;GAGF,MAAM,QAAQ,KAAK,cAAc;GACjC,KAAK,OAAO;GAEZ,KAAK,GAAG,MAAM;GACd,KAAK,QAAQ,YAAY,OAAO,KAAK;;qBAMnB;GAClB,KAAK,cAAc;GACnB,KAAK,SAAS;;4BAMoB;GAClC,OAAO,CAAC,GAAG,KAAK,MAAM;;4BAGW;GACjC,IAAI,KAAK,WAAW;IAClB,aAAa,KAAK,UAAU;IAC5B,KAAK,YAAY;;;qBAOD;GAClB,MAAM,WAAW,KAAK,MAAM,SAAS;GACrC,KAAK,QAAQ,EAAE;GACf,KAAK,aAAa;GAClB,IAAI,UACF,KAAK,QAAQ,gBAAgB,KAAK;;sBAQjB;GACnB,KAAK,cAAc;GACnB,KAAK,aAAa;;EArHlB,KAAK,QAAQ,UAAU,KAAK,QAAQ,WAAW;EAC/C,KAAK,QAAQ,UAAU,KAAK,QAAQ,WAAW;EAC/C,KAAK,QAAQ,OAAO,KAAK,QAAQ,QAAQ;EACzC,KAAK,QAAQ,mBACX,KAAK,QAAQ,2BAA2B;;;;;CAM5C,IAAI,OAAe;EACjB,OAAO,KAAK,MAAM;;;;;CAMpB,IAAI,UAAmB;EACrB,OAAO,KAAK,MAAM,WAAW;;;;;CAM/B,IAAI,YAAqB;EACvB,OAAO,KAAK;;CAGd,AAAQ,UAAkB;EACxB,IAAI,OAAO,KAAK,QAAQ,SAAS,YAC/B,OAAO,KAAK,QAAQ,KAAK,KAAK;EAEhC,OAAO,KAAK,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;AA8GxB,SAAgB,UACd,IACA,UAAsC,EAAE,EAChB;CAExB,OAAO,IADa,YAAoB,IAAI,QAC9B,CAAC"}