@tanstack/pacer-lite 0.1.0 → 0.1.1

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

@@ -1,26 +1,29 @@
-import { AnyFunction } from '@tanstack/pacer/types';
+import { AnyFunction } from "@tanstack/pacer/types";
+
+//#region src/lite-throttler.d.ts
+
 /**
  * Options for configuring a lite throttled function
  */
-export interface LiteThrottlerOptions<TFn extends AnyFunction = AnyFunction> {
-    /**
-     * Whether to execute on the leading edge of the timeout.
-     * Defaults to true.
-     */
-    leading?: boolean;
-    /**
-     * Callback function that is called after the function is executed
-     */
-    onExecute?: (args: Parameters<TFn>, throttler: LiteThrottler<TFn>) => void;
-    /**
-     * Whether to execute on the trailing edge of the timeout.
-     * Defaults to true.
-     */
-    trailing?: boolean;
-    /**
-     * Time window in milliseconds during which the function can only be executed once.
-     */
-    wait: number;
+interface LiteThrottlerOptions<TFn extends AnyFunction = AnyFunction> {
+  /**
+   * Whether to execute on the leading edge of the timeout.
+   * Defaults to true.
+   */
+  leading?: boolean;
+  /**
+   * Callback function that is called after the function is executed
+   */
+  onExecute?: (args: Parameters<TFn>, throttler: LiteThrottler<TFn>) => void;
+  /**
+   * Whether to execute on the trailing edge of the timeout.
+   * Defaults to true.
+   */
+  trailing?: boolean;
+  /**
+   * Time window in milliseconds during which the function can only be executed once.
+   */
+  wait: number;
 }
 /**
  * A lightweight class that creates a throttled function.
@@ -62,39 +65,39 @@ export interface LiteThrottlerOptions<TFn extends AnyFunction = AnyFunction> {
  * });
  * ```
  */
-export declare class LiteThrottler<TFn extends AnyFunction> {
-    fn: TFn;
-    options: LiteThrottlerOptions<TFn>;
-    private timeoutId;
-    private lastArgs;
-    private lastExecutionTime;
-    private isPending;
-    constructor(fn: TFn, options: LiteThrottlerOptions<TFn>);
-    /**
-     * 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: Parameters<TFn>) => void;
-    private execute;
-    /**
-     * 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 trailing execution and clears internal state.
-     * If a trailing execution is scheduled, this will prevent that execution from occurring.
-     */
-    cancel: () => void;
-    private clearTimeout;
+declare class LiteThrottler<TFn extends AnyFunction> {
+  fn: TFn;
+  options: LiteThrottlerOptions<TFn>;
+  private timeoutId;
+  private lastArgs;
+  private lastExecutionTime;
+  private isPending;
+  constructor(fn: TFn, options: LiteThrottlerOptions<TFn>);
+  /**
+   * 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: Parameters<TFn>) => void;
+  private execute;
+  /**
+   * 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 trailing execution and clears internal state.
+   * If a trailing execution is scheduled, this will prevent that execution from occurring.
+   */
+  cancel: () => void;
+  private clearTimeout;
 }
 /**
  * Creates a lightweight throttled function that limits how often the provided function can execute.
@@ -125,4 +128,7 @@ export declare class LiteThrottler<TFn extends AnyFunction> {
  * }, { wait: 250, leading: true, trailing: false });
  * ```
  */
-export declare function liteThrottle<TFn extends AnyFunction>(fn: TFn, options: LiteThrottlerOptions<TFn>): (...args: Parameters<TFn>) => void;
+declare function liteThrottle<TFn extends AnyFunction>(fn: TFn, options: LiteThrottlerOptions<TFn>): (...args: Parameters<TFn>) => void;
+//#endregion
+export { LiteThrottler, LiteThrottlerOptions, liteThrottle };
+//# sourceMappingURL=lite-throttler.d.cts.map

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

@@ -1,26 +1,29 @@
-import { AnyFunction } from '@tanstack/pacer/types';
+import { AnyFunction } from "@tanstack/pacer/types";
+
+//#region src/lite-throttler.d.ts
+
 /**
  * Options for configuring a lite throttled function
  */
-export interface LiteThrottlerOptions<TFn extends AnyFunction = AnyFunction> {
-    /**
-     * Whether to execute on the leading edge of the timeout.
-     * Defaults to true.
-     */
-    leading?: boolean;
-    /**
-     * Callback function that is called after the function is executed
-     */
-    onExecute?: (args: Parameters<TFn>, throttler: LiteThrottler<TFn>) => void;
-    /**
-     * Whether to execute on the trailing edge of the timeout.
-     * Defaults to true.
-     */
-    trailing?: boolean;
-    /**
-     * Time window in milliseconds during which the function can only be executed once.
-     */
-    wait: number;
+interface LiteThrottlerOptions<TFn extends AnyFunction = AnyFunction> {
+  /**
+   * Whether to execute on the leading edge of the timeout.
+   * Defaults to true.
+   */
+  leading?: boolean;
+  /**
+   * Callback function that is called after the function is executed
+   */
+  onExecute?: (args: Parameters<TFn>, throttler: LiteThrottler<TFn>) => void;
+  /**
+   * Whether to execute on the trailing edge of the timeout.
+   * Defaults to true.
+   */
+  trailing?: boolean;
+  /**
+   * Time window in milliseconds during which the function can only be executed once.
+   */
+  wait: number;
 }
 /**
  * A lightweight class that creates a throttled function.
@@ -62,39 +65,39 @@ export interface LiteThrottlerOptions<TFn extends AnyFunction = AnyFunction> {
  * });
  * ```
  */
-export declare class LiteThrottler<TFn extends AnyFunction> {
-    fn: TFn;
-    options: LiteThrottlerOptions<TFn>;
-    private timeoutId;
-    private lastArgs;
-    private lastExecutionTime;
-    private isPending;
-    constructor(fn: TFn, options: LiteThrottlerOptions<TFn>);
-    /**
-     * 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: Parameters<TFn>) => void;
-    private execute;
-    /**
-     * 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 trailing execution and clears internal state.
-     * If a trailing execution is scheduled, this will prevent that execution from occurring.
-     */
-    cancel: () => void;
-    private clearTimeout;
+declare class LiteThrottler<TFn extends AnyFunction> {
+  fn: TFn;
+  options: LiteThrottlerOptions<TFn>;
+  private timeoutId;
+  private lastArgs;
+  private lastExecutionTime;
+  private isPending;
+  constructor(fn: TFn, options: LiteThrottlerOptions<TFn>);
+  /**
+   * 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: Parameters<TFn>) => void;
+  private execute;
+  /**
+   * 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 trailing execution and clears internal state.
+   * If a trailing execution is scheduled, this will prevent that execution from occurring.
+   */
+  cancel: () => void;
+  private clearTimeout;
 }
 /**
  * Creates a lightweight throttled function that limits how often the provided function can execute.
@@ -125,4 +128,7 @@ export declare class LiteThrottler<TFn extends AnyFunction> {
  * }, { wait: 250, leading: true, trailing: false });
  * ```
  */
-export declare function liteThrottle<TFn extends AnyFunction>(fn: TFn, options: LiteThrottlerOptions<TFn>): (...args: Parameters<TFn>) => void;
+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

package/dist/lite-throttler.js

@@ -0,0 +1,125 @@
+//#region src/lite-throttler.ts
+/**
+* A lightweight class that creates a throttled function.
+*
+* This is an alternative to the Throttler in the core @tanstack/pacer package, but is more
+* suitable for libraries and npm packages that need minimal overhead. Unlike the core Throttler,
+* this version does not use TanStack Store for state management, has no devtools integration,
+* and provides only essential throttling functionality.
+*
+* Throttling ensures a function is called at most once within a specified time window.
+* Unlike debouncing which waits for a pause in calls, throttling guarantees consistent
+* execution timing regardless of call frequency.
+*
+* Supports both leading and trailing edge execution:
+* - Leading: Execute immediately on first call (default: true)
+* - Trailing: Execute after wait period if called during throttle (default: true)
+*
+* 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 throttler = new LiteThrottler((scrollY: number) => {
+*   updateScrollPosition(scrollY);
+* }, {
+*   wait: 100,
+*   onExecute: (args, throttler) => {
+*     console.log('Updated scroll position:', args[0]);
+*   }
+* });
+*
+* // Will execute at most once per 100ms
+* window.addEventListener('scroll', () => {
+*   throttler.maybeExecute(window.scrollY);
+* });
+* ```
+*/
+var LiteThrottler = class {
+	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;
+		}
+	}
+};
+/**
+* Creates a lightweight throttled function that limits how often the provided function can execute.
+*
+* This is an alternative to the throttle 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 throttler with no external dependencies, devtools integration, or reactive state.
+*
+* Throttling ensures a function executes at most once within a specified time window,
+* regardless of how many times it is called. This is useful for rate-limiting
+* expensive operations or UI updates.
+*
+* @example
+* ```ts
+* const throttledScroll = liteThrottle(() => {
+*   updateScrollIndicator();
+* }, { wait: 100 });
+*
+* // Will execute at most once per 100ms
+* window.addEventListener('scroll', throttledScroll);
+* ```
+*
+* @example
+* ```ts
+* // Leading edge execution - fires immediately then throttles
+* const throttledResize = liteThrottle(() => {
+*   recalculateLayout();
+* }, { wait: 250, leading: true, trailing: false });
+* ```
+*/
+function liteThrottle(fn, options) {
+	return new LiteThrottler(fn, options).maybeExecute;
+}
+
+//#endregion
+export { LiteThrottler, liteThrottle };
+//# sourceMappingURL=lite-throttler.js.map

package/dist/lite-throttler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lite-throttler.js","names":["fn: TFn","options: LiteThrottlerOptions<TFn>"],"sources":["../src/lite-throttler.ts"],"sourcesContent":["import type { AnyFunction } from '@tanstack/pacer/types'\n\n/**\n * Options for configuring a lite throttled function\n */\nexport interface LiteThrottlerOptions<TFn extends AnyFunction = AnyFunction> {\n  /**\n   * Whether to execute on the leading edge of the timeout.\n   * Defaults to true.\n   */\n  leading?: boolean\n  /**\n   * Callback function that is called after the function is executed\n   */\n  onExecute?: (args: Parameters<TFn>, throttler: LiteThrottler<TFn>) => void\n  /**\n   * Whether to execute on the trailing edge of the timeout.\n   * Defaults to true.\n   */\n  trailing?: boolean\n  /**\n   * Time window in milliseconds during which the function can only be executed once.\n   */\n  wait: number\n}\n\n/**\n * A lightweight class that creates a throttled function.\n *\n * This is an alternative to the Throttler in the core @tanstack/pacer package, but is more\n * suitable for libraries and npm packages that need minimal overhead. Unlike the core Throttler,\n * this version does not use TanStack Store for state management, has no devtools integration,\n * and provides only essential throttling functionality.\n *\n * Throttling ensures a function is called at most once within a specified time window.\n * Unlike debouncing which waits for a pause in calls, throttling guarantees consistent\n * execution timing regardless of call frequency.\n *\n * Supports both leading and trailing edge execution:\n * - Leading: Execute immediately on first call (default: true)\n * - Trailing: Execute after wait period if called during throttle (default: true)\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 throttler = new LiteThrottler((scrollY: number) => {\n *   updateScrollPosition(scrollY);\n * }, {\n *   wait: 100,\n *   onExecute: (args, throttler) => {\n *     console.log('Updated scroll position:', args[0]);\n *   }\n * });\n *\n * // Will execute at most once per 100ms\n * window.addEventListener('scroll', () => {\n *   throttler.maybeExecute(window.scrollY);\n * });\n * ```\n */\nexport class LiteThrottler<TFn extends AnyFunction> {\n  private timeoutId: NodeJS.Timeout | undefined\n  private lastArgs: Parameters<TFn> | undefined\n  private lastExecutionTime = 0\n  private isPending = false\n\n  constructor(\n    public fn: TFn,\n    public options: LiteThrottlerOptions<TFn>,\n  ) {\n    // Default both leading and trailing to true if neither is specified\n    if (\n      this.options.leading === undefined &&\n      this.options.trailing === undefined\n    ) {\n      this.options.leading = true\n      this.options.trailing = true\n    }\n  }\n\n  /**\n   * Attempts to execute the throttled function. The execution behavior depends on the throttler options:\n   *\n   * - If enough time has passed since the last execution (>= wait period):\n   *   - With leading=true: Executes immediately\n   *   - With leading=false: Waits for the next trailing execution\n   *\n   * - If within the wait period:\n   *   - With trailing=true: Schedules execution for end of wait period\n   *   - With trailing=false: Drops the execution\n   */\n  maybeExecute = (...args: Parameters<TFn>): void => {\n    const now = Date.now()\n    const timeSinceLastExecution = now - this.lastExecutionTime\n\n    // Handle leading execution\n    if (this.options.leading && timeSinceLastExecution >= this.options.wait) {\n      this.execute(...args)\n    } else {\n      // Store the most recent arguments for potential trailing execution\n      this.lastArgs = args\n\n      // Set up trailing execution if not already scheduled\n      if (!this.timeoutId && this.options.trailing) {\n        const timeoutDuration = this.options.wait - timeSinceLastExecution\n        this.isPending = true\n        this.timeoutId = setTimeout(() => {\n          if (this.lastArgs !== undefined) {\n            this.execute(...this.lastArgs)\n          }\n        }, timeoutDuration)\n      }\n    }\n  }\n\n  private execute = (...args: Parameters<TFn>): void => {\n    this.fn(...args)\n    this.options.onExecute?.(args, this)\n    this.lastExecutionTime = Date.now()\n    this.clearTimeout()\n    this.lastArgs = undefined\n    this.isPending = false\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.isPending && this.lastArgs) {\n      this.execute(...this.lastArgs)\n    }\n  }\n\n  /**\n   * Cancels any pending trailing execution and clears internal state.\n   * If a trailing execution is scheduled, this will prevent that execution from occurring.\n   */\n  cancel = (): void => {\n    this.clearTimeout()\n    this.lastArgs = undefined\n    this.isPending = false\n  }\n\n  private clearTimeout = (): void => {\n    if (this.timeoutId) {\n      clearTimeout(this.timeoutId)\n      this.timeoutId = undefined\n    }\n  }\n}\n\n/**\n * Creates a lightweight throttled function that limits how often the provided function can execute.\n *\n * This is an alternative to the throttle 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 throttler with no external dependencies, devtools integration, or reactive state.\n *\n * Throttling ensures a function executes at most once within a specified time window,\n * regardless of how many times it is called. This is useful for rate-limiting\n * expensive operations or UI updates.\n *\n * @example\n * ```ts\n * const throttledScroll = liteThrottle(() => {\n *   updateScrollIndicator();\n * }, { wait: 100 });\n *\n * // Will execute at most once per 100ms\n * window.addEventListener('scroll', throttledScroll);\n * ```\n *\n * @example\n * ```ts\n * // Leading edge execution - fires immediately then throttles\n * const throttledResize = liteThrottle(() => {\n *   recalculateLayout();\n * }, { wait: 250, leading: true, trailing: false });\n * ```\n */\nexport function liteThrottle<TFn extends AnyFunction>(\n  fn: TFn,\n  options: LiteThrottlerOptions<TFn>,\n): (...args: Parameters<TFn>) => void {\n  const throttler = new LiteThrottler(fn, options)\n  return throttler.maybeExecute\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,gBAAb,MAAoD;CAMlD,YACE,AAAOA,IACP,AAAOC,SACP;EAFO;EACA;2BALmB;mBACR;uBA2BJ,GAAG,SAAgC;GAEjD,MAAM,yBADM,KAAK,KAAK,GACe,KAAK;AAG1C,OAAI,KAAK,QAAQ,WAAW,0BAA0B,KAAK,QAAQ,KACjE,MAAK,QAAQ,GAAG,KAAK;QAChB;AAEL,SAAK,WAAW;AAGhB,QAAI,CAAC,KAAK,aAAa,KAAK,QAAQ,UAAU;KAC5C,MAAM,kBAAkB,KAAK,QAAQ,OAAO;AAC5C,UAAK,YAAY;AACjB,UAAK,YAAY,iBAAiB;AAChC,UAAI,KAAK,aAAa,OACpB,MAAK,QAAQ,GAAG,KAAK,SAAS;QAE/B,gBAAgB;;;;kBAKN,GAAG,SAAgC;AACpD,QAAK,GAAG,GAAG,KAAK;AAChB,QAAK,QAAQ,YAAY,MAAM,KAAK;AACpC,QAAK,oBAAoB,KAAK,KAAK;AACnC,QAAK,cAAc;AACnB,QAAK,WAAW;AAChB,QAAK,YAAY;;qBAQC;AAClB,OAAI,KAAK,aAAa,KAAK,SACzB,MAAK,QAAQ,GAAG,KAAK,SAAS;;sBAQb;AACnB,QAAK,cAAc;AACnB,QAAK,WAAW;AAChB,QAAK,YAAY;;4BAGgB;AACjC,OAAI,KAAK,WAAW;AAClB,iBAAa,KAAK,UAAU;AAC5B,SAAK,YAAY;;;AA7EnB,MACE,KAAK,QAAQ,YAAY,UACzB,KAAK,QAAQ,aAAa,QAC1B;AACA,QAAK,QAAQ,UAAU;AACvB,QAAK,QAAQ,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0G9B,SAAgB,aACd,IACA,SACoC;AAEpC,QADkB,IAAI,cAAc,IAAI,QAAQ,CAC/B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/pacer-lite",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Lightweight utilities for debouncing, throttling, and more - designed for npm packages.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -23,69 +23,33 @@
     "minimal"
   ],
   "type": "module",
-  "types": "dist/esm/index.d.ts",
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
-      }
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    },
+    "./lite-batcher": {
+      "require": "./dist/lite-batcher.cjs",
+      "import": "./dist/lite-batcher.js"
     },
     "./lite-debouncer": {
-      "import": {
-        "types": "./dist/esm/lite-debouncer.d.ts",
-        "default": "./dist/esm/lite-debouncer.js"
-      },
-      "require": {
-        "types": "./dist/cjs/lite-debouncer.d.cts",
-        "default": "./dist/cjs/lite-debouncer.cjs"
-      }
+      "require": "./dist/lite-debouncer.cjs",
+      "import": "./dist/lite-debouncer.js"
     },
-    "./lite-throttler": {
-      "import": {
-        "types": "./dist/esm/lite-throttler.d.ts",
-        "default": "./dist/esm/lite-throttler.js"
-      },
-      "require": {
-        "types": "./dist/cjs/lite-throttler.d.cts",
-        "default": "./dist/cjs/lite-throttler.cjs"
-      }
+    "./lite-queuer": {
+      "require": "./dist/lite-queuer.cjs",
+      "import": "./dist/lite-queuer.js"
     },
     "./lite-rate-limiter": {
-      "import": {
-        "types": "./dist/esm/lite-rate-limiter.d.ts",
-        "default": "./dist/esm/lite-rate-limiter.js"
-      },
-      "require": {
-        "types": "./dist/cjs/lite-rate-limiter.d.cts",
-        "default": "./dist/cjs/lite-rate-limiter.cjs"
-      }
+      "require": "./dist/lite-rate-limiter.cjs",
+      "import": "./dist/lite-rate-limiter.js"
     },
-    "./lite-queuer": {
-      "import": {
-        "types": "./dist/esm/lite-queuer.d.ts",
-        "default": "./dist/esm/lite-queuer.js"
-      },
-      "require": {
-        "types": "./dist/cjs/lite-queuer.d.cts",
-        "default": "./dist/cjs/lite-queuer.cjs"
-      }
-    },
-    "./lite-batcher": {
-      "import": {
-        "types": "./dist/esm/lite-batcher.d.ts",
-        "default": "./dist/esm/lite-batcher.js"
-      },
-      "require": {
-        "types": "./dist/cjs/lite-batcher.d.cts",
-        "default": "./dist/cjs/lite-batcher.cjs"
-      }
+    "./lite-throttler": {
+      "require": "./dist/lite-throttler.cjs",
+      "import": "./dist/lite-throttler.js"
     },
     "./package.json": "./package.json"
   },
@@ -98,7 +62,7 @@
     "src"
   ],
   "devDependencies": {
-    "@tanstack/pacer": "0.16.3"
+    "@tanstack/pacer": "0.16.4"
   },
   "scripts": {
     "clean": "premove ./build ./dist",
@@ -107,7 +71,6 @@
     "test:lib": "vitest",
     "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "tsc",
-    "test:build": "publint --strict",
-    "build": "vite build"
+    "build": "tsdown"
   }
 }

package/dist/cjs/index.cjs

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const liteDebouncer = require("./lite-debouncer.cjs");
-const liteThrottler = require("./lite-throttler.cjs");
-const liteRateLimiter = require("./lite-rate-limiter.cjs");
-const liteQueuer = require("./lite-queuer.cjs");
-const liteBatcher = require("./lite-batcher.cjs");
-exports.LiteDebouncer = liteDebouncer.LiteDebouncer;
-exports.liteDebounce = liteDebouncer.liteDebounce;
-exports.LiteThrottler = liteThrottler.LiteThrottler;
-exports.liteThrottle = liteThrottler.liteThrottle;
-exports.LiteRateLimiter = liteRateLimiter.LiteRateLimiter;
-exports.liteRateLimit = liteRateLimiter.liteRateLimit;
-exports.LiteQueuer = liteQueuer.LiteQueuer;
-exports.liteQueue = liteQueuer.liteQueue;
-exports.LiteBatcher = liteBatcher.LiteBatcher;
-exports.liteBatch = liteBatcher.liteBatch;
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -1,5 +0,0 @@
-export * from './lite-debouncer.cjs';
-export * from './lite-throttler.cjs';
-export * from './lite-rate-limiter.cjs';
-export * from './lite-queuer.cjs';
-export * from './lite-batcher.cjs';

package/dist/cjs/lite-batcher.cjs

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-class LiteBatcher {
-  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);
-      const shouldProcess = this.items.length >= this.options.maxSize || this.options.getShouldExecute(this.items, this);
-      if (shouldProcess) {
-        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;
-  }
-}
-function liteBatch(fn, options = {}) {
-  const batcher = new LiteBatcher(fn, options);
-  return batcher.addItem;
-}
-exports.LiteBatcher = LiteBatcher;
-exports.liteBatch = liteBatch;
-//# sourceMappingURL=lite-batcher.cjs.map