@tanstack/solid-pacer 0.21.1 → 0.23.0

package/dist/debouncer/createDebouncedValue.d.ts

@@ -1,7 +1,6 @@
 import { SolidDebouncer, SolidDebouncerOptions } from "./createDebouncer.js";
 import { Accessor, Setter } from "solid-js";
 import { DebouncerState } from "@tanstack/pacer/debouncer";
-
 //#region src/debouncer/createDebouncedValue.d.ts
 /**
  * A Solid hook that creates a debounced value that updates only after a specified delay.
@@ -65,7 +64,5 @@ import { DebouncerState } from "@tanstack/pacer/debouncer";
  * debouncer.cancel(); // Cancel any pending updates
  * ```
  */
-declare function createDebouncedValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: SolidDebouncerOptions<Setter<TValue>, TSelected>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, TSelected>];
-//#endregion
-export { createDebouncedValue };
-//# sourceMappingURL=createDebouncedValue.d.ts.map
+export declare function createDebouncedValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: SolidDebouncerOptions<Setter<TValue>, TSelected>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, TSelected>];
+//#endregion

package/dist/debouncer/createDebouncedValue.js

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

package/dist/debouncer/createDebouncer.d.ts

@@ -2,16 +2,15 @@ import { Accessor, JSX } from "solid-js";
 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.
    *
@@ -139,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,8 +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>>;
@@ -17,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

@@ -1,6 +1,5 @@
 import { SolidQueuer, SolidQueuerOptions } from "./createQueuer.js";
 import { QueuerState } from "@tanstack/pacer/queuer";
-
 //#region src/queuer/createQueuedSignal.d.ts
 /**
  * A Solid primitive that creates a queuer with managed state, combining Solid's signals with queuing functionality.
@@ -116,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

@@ -1,16 +1,15 @@
 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.
    *
@@ -142,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

@@ -1,7 +1,6 @@
 import { SolidRateLimiter, SolidRateLimiterOptions } from "./createRateLimiter.js";
 import { Accessor, Setter } from "solid-js";
 import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
-
 //#region src/rate-limiter/createRateLimitedSignal.d.ts
 /**
  * A Solid hook that creates a rate-limited state value that enforces a hard limit on state updates within a time window.
@@ -43,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
@@ -64,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
@@ -79,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 {
@@ -88,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

@@ -1,7 +1,6 @@
 import { SolidRateLimiter, SolidRateLimiterOptions } from "./createRateLimiter.js";
 import { Accessor, Setter } from "solid-js";
 import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
-
 //#region src/rate-limiter/createRateLimitedValue.d.ts
 /**
  * A high-level Solid hook that creates a rate-limited version of a value that updates at most a certain number of times within a time window.
@@ -90,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

@@ -2,16 +2,15 @@ import { Accessor, JSX } from "solid-js";
 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.
    *
@@ -84,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
@@ -168,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

@@ -1,7 +1,6 @@
 import { SolidThrottler, SolidThrottlerOptions } from "./createThrottler.js";
 import { Accessor, Setter } from "solid-js";
 import { ThrottlerState } from "@tanstack/pacer/throttler";
-
 //#region src/throttler/createThrottledSignal.d.ts
 /**
  * A Solid hook that creates a throttled state value that updates at most once within a specified time window.
@@ -30,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
@@ -65,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

@@ -1,7 +1,6 @@
 import { SolidThrottler, SolidThrottlerOptions } from "./createThrottler.js";
 import { Accessor, Setter } from "solid-js";
 import { ThrottlerState } from "@tanstack/pacer/throttler";
-
 //#region src/throttler/createThrottledValue.d.ts
 /**
  * A high-level Solid hook that creates a throttled version of a value that updates at most once within a specified time window.
@@ -31,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
@@ -62,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

@@ -2,16 +2,15 @@ import { Accessor, JSX } from "solid-js";
 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.
    *
@@ -75,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
@@ -142,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 };