@tanstack/solid-pacer 0.22.0 → 0.23.0

package/dist/debouncer/createDebouncer.d.ts

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/solid-store";
 import { Debouncer, DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
 import { AnyFunction } from "@tanstack/pacer/types";
 //#region src/debouncer/createDebouncer.d.ts
-interface SolidDebouncerOptions<TFn extends AnyFunction, TSelected = {}> extends DebouncerOptions<TFn> {
+export interface SolidDebouncerOptions<TFn extends AnyFunction, TSelected = {}> extends DebouncerOptions<TFn> {
   /**
    * Optional callback invoked when the owning component unmounts. Receives the debouncer instance.
    * When provided, replaces the default cleanup (cancel); use it to call flush(), reset(), cancel(), add logging, etc.
    */
   onUnmount?: (debouncer: SolidDebouncer<TFn, TSelected>) => void;
 }
-interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
+export interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
   /**
    * A Solid component that allows you to subscribe to the debouncer state.
    *
@@ -138,7 +138,5 @@ interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<D
  * const { isPending } = debouncer.state();
  * ```
  */
-declare function createDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: SolidDebouncerOptions<TFn, TSelected>, selector?: (state: DebouncerState<TFn>) => TSelected): SolidDebouncer<TFn, TSelected>;
-//#endregion
-export { SolidDebouncer, SolidDebouncerOptions, createDebouncer };
-//# sourceMappingURL=createDebouncer.d.ts.map
+export declare function createDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: SolidDebouncerOptions<TFn, TSelected>, selector?: (state: DebouncerState<TFn>) => TSelected): SolidDebouncer<TFn, TSelected>;
+//#endregion

package/dist/debouncer/createDebouncer.js

@@ -125,5 +125,4 @@ function createDebouncer(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { createDebouncer };
-//# sourceMappingURL=createDebouncer.js.map
+export { createDebouncer };

package/dist/provider/PacerProvider.d.ts

@@ -1,7 +1,7 @@
 import { AnyAsyncFunction, AnyFunction, AsyncBatcherOptions, AsyncDebouncerOptions, AsyncQueuerOptions, AsyncRateLimiterOptions, AsyncThrottlerOptions, BatcherOptions, DebouncerOptions, QueuerOptions, RateLimiterOptions, ThrottlerOptions } from "@tanstack/pacer";
 import { JSX } from "solid-js";
 //#region src/provider/PacerProvider.d.ts
-interface PacerProviderOptions {
+export interface PacerProviderOptions {
   asyncBatcher?: Partial<AsyncBatcherOptions<any>>;
   asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>;
   asyncQueuer?: Partial<AsyncQueuerOptions<any>>;
@@ -16,13 +16,11 @@ interface PacerProviderOptions {
 interface PacerContextValue {
   defaultOptions: PacerProviderOptions;
 }
-interface PacerProviderProps {
+export interface PacerProviderProps {
   children: JSX.Element;
   defaultOptions?: PacerProviderOptions;
 }
-declare function PacerProvider(props: PacerProviderProps): JSX.Element;
-declare function usePacerContext(): PacerContextValue | null;
-declare function useDefaultPacerOptions(): PacerProviderOptions;
-//#endregion
-export { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext };
-//# sourceMappingURL=PacerProvider.d.ts.map
+export declare function PacerProvider(props: PacerProviderProps): JSX.Element;
+export declare function usePacerContext(): PacerContextValue | null;
+export declare function useDefaultPacerOptions(): PacerProviderOptions;
+//#endregion

package/dist/provider/PacerProvider.js

@@ -21,5 +21,4 @@ function useDefaultPacerOptions() {
 }
 
 //#endregion
-export { PacerProvider, useDefaultPacerOptions, usePacerContext };
-//# sourceMappingURL=PacerProvider.js.map
+export { PacerProvider, useDefaultPacerOptions, usePacerContext };

package/dist/queuer/createQueuedSignal.d.ts

@@ -115,7 +115,5 @@ import { QueuerState } from "@tanstack/pacer/queuer";
  * const { size, isRunning, executionCount } = queue.state;
  * ```
  */
-declare function createQueuedSignal<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(fn: (item: TValue) => void, options?: SolidQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): [() => Array<TValue>, SolidQueuer<TValue, TSelected>['addItem'], SolidQueuer<TValue, TSelected>];
-//#endregion
-export { createQueuedSignal };
-//# sourceMappingURL=createQueuedSignal.d.ts.map
+export declare function createQueuedSignal<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(fn: (item: TValue) => void, options?: SolidQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): [() => Array<TValue>, SolidQueuer<TValue, TSelected>['addItem'], SolidQueuer<TValue, TSelected>];
+//#endregion

package/dist/queuer/createQueuedSignal.js

@@ -125,5 +125,4 @@ function createQueuedSignal(fn, options = {}, selector = (state) => ({ items: st
 }
 
 //#endregion
-export { createQueuedSignal };
-//# sourceMappingURL=createQueuedSignal.js.map
+export { createQueuedSignal };

package/dist/queuer/createQueuer.d.ts

@@ -2,14 +2,14 @@ import { Accessor, JSX } from "solid-js";
 import { Store } from "@tanstack/solid-store";
 import { Queuer, QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
 //#region src/queuer/createQueuer.d.ts
-interface SolidQueuerOptions<TValue, TSelected = {}> extends QueuerOptions<TValue> {
+export interface SolidQueuerOptions<TValue, TSelected = {}> extends QueuerOptions<TValue> {
   /**
    * Optional callback invoked when the owning component unmounts. Receives the queuer instance.
    * When provided, replaces the default cleanup (stop); use it to call flush(), flushAsBatch(), stop(), add logging, etc.
    */
   onUnmount?: (queuer: SolidQueuer<TValue, TSelected>) => void;
 }
-interface SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'store'> {
+export interface SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'store'> {
   /**
    * A Solid component that allows you to subscribe to the queuer state.
    *
@@ -141,7 +141,5 @@ interface SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'stor
  * const { items, isRunning } = queue.state();
  * ```
  */
-declare function createQueuer<TValue, TSelected = {}>(fn: (item: TValue) => void, options?: SolidQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): SolidQueuer<TValue, TSelected>;
-//#endregion
-export { SolidQueuer, SolidQueuerOptions, createQueuer };
-//# sourceMappingURL=createQueuer.d.ts.map
+export declare function createQueuer<TValue, TSelected = {}>(fn: (item: TValue) => void, options?: SolidQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): SolidQueuer<TValue, TSelected>;
+//#endregion

package/dist/queuer/createQueuer.js

@@ -129,5 +129,4 @@ function createQueuer(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { createQueuer };
-//# sourceMappingURL=createQueuer.js.map
+export { createQueuer };

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

@@ -42,13 +42,14 @@ import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
  * the reactive system track the selected state values.
  *
  * Available rate limiter state properties:
- * - `callsInWindow`: Number of calls made in the current window
- * - `remainingInWindow`: Number of calls remaining in the current window
- * - `windowStart`: Unix timestamp when the current window started
- * - `nextWindowStart`: Unix timestamp when the next window will start
- * - `msUntilNextWindow`: Milliseconds until the next window starts
- * - `isAtLimit`: Whether the call limit for the current window has been reached
- * - `status`: Current status ('disabled' | 'idle' | 'at-limit')
+ * - `executionCount`: Number of function executions
+ * - `executionTimes`: Timestamps of executions tracked for the current window
+ * - `maybeExecuteCount`: Number of calls to maybeExecute
+ * - `rejectionCount`: Number of calls rejected by the rate limit
+ * - `isExceeded`: Whether the rate limit has been reached
+ * - `status`: Current status ('disabled' | 'exceeded' | 'idle')
+ *
+ * Use `getRemainingInWindow()` and `getMsUntilNextWindow()` for current window capacity and timing.
  *
  * @example
  * ```tsx
@@ -63,7 +64,7 @@ import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
  * const [value, setValue, rateLimiter] = createRateLimitedSignal(
  *   0,
  *   { limit: 5, window: 60000 },
- *   (state) => ({ isAtLimit: state.isAtLimit, remainingInWindow: state.remainingInWindow })
+ *   (state) => ({ isExceeded: state.isExceeded })
  * );
  *
  * // With rejection callback and fixed window
@@ -78,7 +79,7 @@ import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
  *
  * // Access rateLimiter state via signals
  * const handleSubmit = () => {
- *   const remaining = rateLimiter.state().remainingInWindow;
+ *   const remaining = rateLimiter.getRemainingInWindow();
  *   if (remaining > 0) {
  *     setValue(newValue);
  *   } else {
@@ -87,7 +88,5 @@ import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
  * };
  * ```
  */
-declare function createRateLimitedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: SolidRateLimiterOptions<Setter<TValue>, TSelected>, selector?: (state: RateLimiterState) => TSelected): [Accessor<TValue>, Setter<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>];
-//#endregion
-export { createRateLimitedSignal };
-//# sourceMappingURL=createRateLimitedSignal.d.ts.map
+export declare function createRateLimitedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: SolidRateLimiterOptions<Setter<TValue>, TSelected>, selector?: (state: RateLimiterState) => TSelected): [Accessor<TValue>, Setter<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>];
+//#endregion

package/dist/rate-limiter/createRateLimitedSignal.js

@@ -42,13 +42,14 @@ import { createSignal } from "solid-js";
 * the reactive system track the selected state values.
 *
 * Available rate limiter state properties:
-* - `callsInWindow`: Number of calls made in the current window
-* - `remainingInWindow`: Number of calls remaining in the current window
-* - `windowStart`: Unix timestamp when the current window started
-* - `nextWindowStart`: Unix timestamp when the next window will start
-* - `msUntilNextWindow`: Milliseconds until the next window starts
-* - `isAtLimit`: Whether the call limit for the current window has been reached
-* - `status`: Current status ('disabled' | 'idle' | 'at-limit')
+* - `executionCount`: Number of function executions
+* - `executionTimes`: Timestamps of executions tracked for the current window
+* - `maybeExecuteCount`: Number of calls to maybeExecute
+* - `rejectionCount`: Number of calls rejected by the rate limit
+* - `isExceeded`: Whether the rate limit has been reached
+* - `status`: Current status ('disabled' | 'exceeded' | 'idle')
+*
+* Use `getRemainingInWindow()` and `getMsUntilNextWindow()` for current window capacity and timing.
 *
 * @example
 * ```tsx
@@ -63,7 +64,7 @@ import { createSignal } from "solid-js";
 * const [value, setValue, rateLimiter] = createRateLimitedSignal(
 *   0,
 *   { limit: 5, window: 60000 },
-*   (state) => ({ isAtLimit: state.isAtLimit, remainingInWindow: state.remainingInWindow })
+*   (state) => ({ isExceeded: state.isExceeded })
 * );
 *
 * // With rejection callback and fixed window
@@ -78,7 +79,7 @@ import { createSignal } from "solid-js";
 *
 * // Access rateLimiter state via signals
 * const handleSubmit = () => {
-*   const remaining = rateLimiter.state().remainingInWindow;
+*   const remaining = rateLimiter.getRemainingInWindow();
 *   if (remaining > 0) {
 *     setValue(newValue);
 *   } else {
@@ -98,5 +99,4 @@ function createRateLimitedSignal(value, initialOptions, selector) {
 }
 
 //#endregion
-export { createRateLimitedSignal };
-//# sourceMappingURL=createRateLimitedSignal.js.map
+export { createRateLimitedSignal };

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

@@ -89,7 +89,5 @@ import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
  * const { executionCount, rejectionCount } = rateLimiter.state;
  * ```
  */
-declare function createRateLimitedValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: SolidRateLimiterOptions<Setter<TValue>, TSelected>, selector?: (state: RateLimiterState) => TSelected): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>];
-//#endregion
-export { createRateLimitedValue };
-//# sourceMappingURL=createRateLimitedValue.d.ts.map
+export declare function createRateLimitedValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: SolidRateLimiterOptions<Setter<TValue>, TSelected>, selector?: (state: RateLimiterState) => TSelected): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>];
+//#endregion

package/dist/rate-limiter/createRateLimitedValue.js

@@ -98,5 +98,4 @@ function createRateLimitedValue(value, initialOptions, selector) {
 }
 
 //#endregion
-export { createRateLimitedValue };
-//# sourceMappingURL=createRateLimitedValue.js.map
+export { createRateLimitedValue };

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

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/solid-store";
 import { RateLimiter, RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
 import { AnyFunction } from "@tanstack/pacer/types";
 //#region src/rate-limiter/createRateLimiter.d.ts
-interface SolidRateLimiterOptions<TFn extends AnyFunction, TSelected = {}> extends RateLimiterOptions<TFn> {
+export interface SolidRateLimiterOptions<TFn extends AnyFunction, TSelected = {}> extends RateLimiterOptions<TFn> {
   /**
    * Optional callback invoked when the owning component unmounts. Receives the rate limiter instance.
    * When provided, replaces the default cleanup; use it to call reset(), add logging, etc.
    */
   onUnmount?: (rateLimiter: SolidRateLimiter<TFn, TSelected>) => void;
 }
-interface SolidRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit<RateLimiter<TFn>, 'store'> {
+export interface SolidRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit<RateLimiter<TFn>, 'store'> {
   /**
    * A Solid component that allows you to subscribe to the rate limiter state.
    *
@@ -83,12 +83,13 @@ interface SolidRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit
  * tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary
  * updates and gives you full control over when your component tracks state changes.
  *
+ * Use `getRemainingInWindow()` and `getMsUntilNextWindow()` for current window capacity and timing.
+ *
  * Available state properties:
+ * - `executionTimes`: Timestamps of executions tracked for the current window
+ * - `isExceeded`: Whether the rate limit has been reached
  * - `executionCount`: Number of function executions that have been completed
  * - `rejectionCount`: Number of function calls that were rejected due to rate limiting
- * - `remainingInWindow`: Number of executions remaining in the current window
- * - `nextWindowTime`: Timestamp when the next window begins
- * - `currentWindowStart`: Timestamp when the current window started
  *
  * @example
  * ```tsx
@@ -167,7 +168,5 @@ interface SolidRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit
  * const { executionCount, rejectionCount } = rateLimiter.state();
  * ```
  */
-declare function createRateLimiter<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: SolidRateLimiterOptions<TFn, TSelected>, selector?: (state: RateLimiterState) => TSelected): SolidRateLimiter<TFn, TSelected>;
-//#endregion
-export { SolidRateLimiter, SolidRateLimiterOptions, createRateLimiter };
-//# sourceMappingURL=createRateLimiter.d.ts.map
+export declare function createRateLimiter<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: SolidRateLimiterOptions<TFn, TSelected>, selector?: (state: RateLimiterState) => TSelected): SolidRateLimiter<TFn, TSelected>;
+//#endregion

package/dist/rate-limiter/createRateLimiter.js

@@ -46,12 +46,13 @@ import { RateLimiter } from "@tanstack/pacer/rate-limiter";
 * tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary
 * updates and gives you full control over when your component tracks state changes.
 *
+* Use `getRemainingInWindow()` and `getMsUntilNextWindow()` for current window capacity and timing.
+*
 * Available state properties:
+* - `executionTimes`: Timestamps of executions tracked for the current window
+* - `isExceeded`: Whether the rate limit has been reached
 * - `executionCount`: Number of function executions that have been completed
 * - `rejectionCount`: Number of function calls that were rejected due to rate limiting
-* - `remainingInWindow`: Number of executions remaining in the current window
-* - `nextWindowTime`: Timestamp when the next window begins
-* - `currentWindowStart`: Timestamp when the current window started
 *
 * @example
 * ```tsx
@@ -153,5 +154,4 @@ function createRateLimiter(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { createRateLimiter };
-//# sourceMappingURL=createRateLimiter.js.map
+export { createRateLimiter };

package/dist/throttler/createThrottledSignal.d.ts

@@ -29,8 +29,6 @@ import { ThrottlerState } from "@tanstack/pacer/throttler";
  * the reactive system track the selected state values.
  *
  * Available throttler state properties:
- * - `canLeadingExecute`: Whether the throttler can execute on the leading edge
- * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
  * - `executionCount`: Number of function executions that have been completed
  * - `isPending`: Whether the throttler is waiting for the timeout to trigger trailing execution
  * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -64,7 +62,5 @@ import { ThrottlerState } from "@tanstack/pacer/throttler";
  * console.log('Next execution:', throttler.state().nextExecutionTime);
  * ```
  */
-declare function createThrottledSignal<TValue, TSelected = {}>(value: TValue, initialOptions: SolidThrottlerOptions<Setter<TValue>, TSelected>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, Setter<TValue>, SolidThrottler<Setter<TValue>, TSelected>];
-//#endregion
-export { createThrottledSignal };
-//# sourceMappingURL=createThrottledSignal.d.ts.map
+export declare function createThrottledSignal<TValue, TSelected = {}>(value: TValue, initialOptions: SolidThrottlerOptions<Setter<TValue>, TSelected>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, Setter<TValue>, SolidThrottler<Setter<TValue>, TSelected>];
+//#endregion

package/dist/throttler/createThrottledSignal.js

@@ -29,8 +29,6 @@ import { createSignal } from "solid-js";
 * the reactive system track the selected state values.
 *
 * Available throttler state properties:
-* - `canLeadingExecute`: Whether the throttler can execute on the leading edge
-* - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
 * - `executionCount`: Number of function executions that have been completed
 * - `isPending`: Whether the throttler is waiting for the timeout to trigger trailing execution
 * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -75,5 +73,4 @@ function createThrottledSignal(value, initialOptions, selector) {
 }
 
 //#endregion
-export { createThrottledSignal };
-//# sourceMappingURL=createThrottledSignal.js.map
+export { createThrottledSignal };

package/dist/throttler/createThrottledValue.d.ts

@@ -30,8 +30,6 @@ import { ThrottlerState } from "@tanstack/pacer/throttler";
  * the reactive system track the selected state values.
  *
  * Available throttler state properties:
- * - `canLeadingExecute`: Whether the throttler can execute on the leading edge
- * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
  * - `executionCount`: Number of function executions that have been completed
  * - `isPending`: Whether the throttler is waiting for the timeout to trigger trailing execution
  * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -61,7 +59,5 @@ import { ThrottlerState } from "@tanstack/pacer/throttler";
  * throttler.cancel(); // Cancel any pending updates
  * ```
  */
-declare function createThrottledValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: SolidThrottlerOptions<Setter<TValue>, TSelected>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, SolidThrottler<Setter<TValue>, TSelected>];
-//#endregion
-export { createThrottledValue };
-//# sourceMappingURL=createThrottledValue.d.ts.map
+export declare function createThrottledValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: SolidThrottlerOptions<Setter<TValue>, TSelected>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, SolidThrottler<Setter<TValue>, TSelected>];
+//#endregion

package/dist/throttler/createThrottledValue.js

@@ -30,8 +30,6 @@ import { createEffect } from "solid-js";
 * the reactive system track the selected state values.
 *
 * Available throttler state properties:
-* - `canLeadingExecute`: Whether the throttler can execute on the leading edge
-* - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
 * - `executionCount`: Number of function executions that have been completed
 * - `isPending`: Whether the throttler is waiting for the timeout to trigger trailing execution
 * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -70,5 +68,4 @@ function createThrottledValue(value, initialOptions, selector) {
 }
 
 //#endregion
-export { createThrottledValue };
-//# sourceMappingURL=createThrottledValue.js.map
+export { createThrottledValue };

package/dist/throttler/createThrottler.d.ts

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/solid-store";
 import { Throttler, ThrottlerOptions, ThrottlerState } from "@tanstack/pacer/throttler";
 import { AnyFunction } from "@tanstack/pacer/types";
 //#region src/throttler/createThrottler.d.ts
-interface SolidThrottlerOptions<TFn extends AnyFunction, TSelected = {}> extends ThrottlerOptions<TFn> {
+export interface SolidThrottlerOptions<TFn extends AnyFunction, TSelected = {}> extends ThrottlerOptions<TFn> {
   /**
    * Optional callback invoked when the owning component unmounts. Receives the throttler instance.
    * When provided, replaces the default cleanup (cancel); use it to call flush(), reset(), cancel(), add logging, etc.
    */
   onUnmount?: (throttler: SolidThrottler<TFn, TSelected>) => void;
 }
-interface SolidThrottler<TFn extends AnyFunction, TSelected = {}> extends Omit<Throttler<TFn>, 'store'> {
+export interface SolidThrottler<TFn extends AnyFunction, TSelected = {}> extends Omit<Throttler<TFn>, 'store'> {
   /**
    * A Solid component that allows you to subscribe to the throttler state.
    *
@@ -74,8 +74,6 @@ interface SolidThrottler<TFn extends AnyFunction, TSelected = {}> extends Omit<T
  * updates and gives you full control over when your component tracks state changes.
  *
  * Available state properties:
- * - `canLeadingExecute`: Whether the throttler can execute on the leading edge
- * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
  * - `executionCount`: Number of function executions that have been completed
  * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
  * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -141,7 +139,5 @@ interface SolidThrottler<TFn extends AnyFunction, TSelected = {}> extends Omit<T
  * const { isPending, executionCount } = throttler.state();
  * ```
  */
-declare function createThrottler<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: SolidThrottlerOptions<TFn, TSelected>, selector?: (state: ThrottlerState<TFn>) => TSelected): SolidThrottler<TFn, TSelected>;
-//#endregion
-export { SolidThrottler, SolidThrottlerOptions, createThrottler };
-//# sourceMappingURL=createThrottler.d.ts.map
+export declare function createThrottler<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: SolidThrottlerOptions<TFn, TSelected>, selector?: (state: ThrottlerState<TFn>) => TSelected): SolidThrottler<TFn, TSelected>;
+//#endregion

package/dist/throttler/createThrottler.js

@@ -37,8 +37,6 @@ import { Throttler } from "@tanstack/pacer/throttler";
 * updates and gives you full control over when your component tracks state changes.
 *
 * Available state properties:
-* - `canLeadingExecute`: Whether the throttler can execute on the leading edge
-* - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
 * - `executionCount`: Number of function executions that have been completed
 * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
 * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -128,5 +126,4 @@ function createThrottler(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { createThrottler };
-//# sourceMappingURL=createThrottler.js.map
+export { createThrottler };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-pacer",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Utilities for debouncing and throttling functions in Solid.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -23,82 +23,37 @@
     "async"
   ],
   "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"
-    },
-    "./async-batcher": {
-      "import": "./dist/async-batcher/index.js",
-      "require": "./dist/async-batcher/index.cjs"
-    },
-    "./async-debouncer": {
-      "import": "./dist/async-debouncer/index.js",
-      "require": "./dist/async-debouncer/index.cjs"
-    },
-    "./async-queuer": {
-      "import": "./dist/async-queuer/index.js",
-      "require": "./dist/async-queuer/index.cjs"
-    },
-    "./async-rate-limiter": {
-      "import": "./dist/async-rate-limiter/index.js",
-      "require": "./dist/async-rate-limiter/index.cjs"
-    },
-    "./async-throttler": {
-      "import": "./dist/async-throttler/index.js",
-      "require": "./dist/async-throttler/index.cjs"
-    },
-    "./batcher": {
-      "import": "./dist/batcher/index.js",
-      "require": "./dist/batcher/index.cjs"
-    },
-    "./debouncer": {
-      "import": "./dist/debouncer/index.js",
-      "require": "./dist/debouncer/index.cjs"
-    },
-    "./provider": {
-      "import": "./dist/provider/index.js",
-      "require": "./dist/provider/index.cjs"
-    },
-    "./queuer": {
-      "import": "./dist/queuer/index.js",
-      "require": "./dist/queuer/index.cjs"
-    },
-    "./rate-limiter": {
-      "import": "./dist/rate-limiter/index.js",
-      "require": "./dist/rate-limiter/index.cjs"
-    },
-    "./throttler": {
-      "import": "./dist/throttler/index.js",
-      "require": "./dist/throttler/index.cjs"
-    },
-    "./types": {
-      "import": "./dist/types/index.js",
-      "require": "./dist/types/index.cjs"
-    },
-    "./utils": {
-      "import": "./dist/utils/index.js",
-      "require": "./dist/utils/index.cjs"
-    },
+    ".": "./dist/index.js",
+    "./async-batcher": "./dist/async-batcher/index.js",
+    "./async-debouncer": "./dist/async-debouncer/index.js",
+    "./async-queuer": "./dist/async-queuer/index.js",
+    "./async-rate-limiter": "./dist/async-rate-limiter/index.js",
+    "./async-throttler": "./dist/async-throttler/index.js",
+    "./batcher": "./dist/batcher/index.js",
+    "./debouncer": "./dist/debouncer/index.js",
+    "./provider": "./dist/provider/index.js",
+    "./queuer": "./dist/queuer/index.js",
+    "./rate-limiter": "./dist/rate-limiter/index.js",
+    "./throttler": "./dist/throttler/index.js",
+    "./types": "./dist/types/index.js",
+    "./utils": "./dist/utils/index.js",
     "./package.json": "./package.json"
   },
   "sideEffects": false,
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "dependencies": {
-    "@tanstack/solid-store": "^0.11.1",
-    "@tanstack/pacer": "0.22.0"
+    "@tanstack/pacer": "0.23.0",
+    "@tanstack/solid-store": "^0.11.1"
   },
   "devDependencies": {
-    "solid-js": "^1.9.14",
+    "solid-js": "^1.9.15",
     "vite-plugin-solid": "^2.11.14"
   },
   "peerDependencies": {
@@ -111,6 +66,7 @@
     "test:lib": "vitest --passWithNoTests",
     "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "tsc",
-    "build": "tsdown"
+    "build": "tsdown",
+    "test:build": "publint --strict && node ../../scripts/verify-package.ts"
   }
 }