@tanstack/solid-pacer 0.10.0 → 0.11.0

package/dist/esm/queuer/createQueuer.d.ts

@@ -1,12 +1,19 @@
 import { Queuer, QueuerOptions, QueuerState } from '@tanstack/pacer/queuer';
+import { Store } from '@tanstack/solid-store';
 import { Accessor } from 'solid-js';
-export interface SolidQueuer<TValue, TSelected = QueuerState<TValue>> extends Omit<Queuer<TValue>, 'store'> {
+export interface SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'store'> {
     /**
      * Reactive state that will be updated when the queuer state changes
      *
      * Use this instead of `queuer.store.state`
      */
     readonly state: Accessor<Readonly<TSelected>>;
+    /**
+     * @deprecated Use `queuer.state` instead of `queuer.store.state` if you want to read reactive state.
+     * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
+     * Although, you can make the state reactive by using the `useStore` in your own usage.
+     */
+    readonly store: Store<Readonly<QueuerState<TValue>>>;
 }
 /**
  * Creates a Solid-compatible Queuer instance for managing a synchronous queue of items, exposing Solid signals for all stateful properties.
@@ -25,11 +32,26 @@ export interface SolidQueuer<TValue, TSelected = QueuerState<TValue>> extends Om
  *
  * By default, the queue uses FIFO behavior, but you can configure LIFO or double-ended queueing by specifying the position when adding or removing items.
  *
+ * ## State Management and Selector
+ *
+ * The hook uses TanStack Store for reactive state management. The `selector` parameter allows you
+ * to specify which state changes will trigger a re-render, optimizing performance by preventing
+ * unnecessary re-renders when irrelevant state changes occur.
+ *
+ * **By default, there will be no reactive state subscriptions** and you must opt-in to state
+ * tracking by providing a selector function. This prevents unnecessary re-renders and gives you
+ * full control over when your component updates. Only when you provide a selector will the
+ * component re-render when the selected state values change.
+ *
+ * Available state properties:
+ * - `executionCount`: Number of items that have been processed
+ * - `isRunning`: Whether the queuer is currently running (not stopped)
+ * - `items`: Array of items currently queued for processing
+ * - `rejectionCount`: Number of items that were rejected (expired or failed validation)
+ *
  * Example usage:
  * ```tsx
- * // Example with Solid signals and scheduling
- * const [items, setItems] = createSignal([]);
- *
+ * // Default behavior - no reactive state subscriptions
  * const queue = createQueuer(
  *   (item) => {
  *     // process item synchronously
@@ -38,11 +60,27 @@ export interface SolidQueuer<TValue, TSelected = QueuerState<TValue>> extends Om
  *   {
  *     started: true, // Start processing immediately
  *     wait: 1000,    // Process one item every second
- *     onItemsChange: (queue) => setItems(queue.peekAllItems()),
  *     getPriority: (item) => item.priority // Process higher priority items first
  *   }
  * );
  *
+ * // Opt-in to re-render when items or isRunning changes (optimized for UI updates)
+ * const queue = createQueuer(
+ *   (item) => console.log('Processing', item),
+ *   { started: true, wait: 1000 },
+ *   (state) => ({ items: state.items, isRunning: state.isRunning })
+ * );
+ *
+ * // Opt-in to re-render when execution metrics change (optimized for tracking progress)
+ * const queue = createQueuer(
+ *   (item) => console.log('Processing', item),
+ *   { started: true, wait: 1000 },
+ *   (state) => ({
+ *     executionCount: state.executionCount,
+ *     rejectionCount: state.rejectionCount
+ *   })
+ * );
+ *
  * // Add items to process - they'll be handled automatically
  * queue.addItem('task1');
  * queue.addItem('task2');
@@ -51,12 +89,8 @@ export interface SolidQueuer<TValue, TSelected = QueuerState<TValue>> extends Om
  * queue.stop();  // Pause processing
  * queue.start(); // Resume processing
  *
- * // Access queue state via signals
- * console.log('Items:', queue.allItems());
- * console.log('Size:', queue.size());
- * console.log('Is empty:', queue.isEmpty());
- * console.log('Is running:', queue.isRunning());
- * console.log('Next item:', queue.nextItem());
+ * // Access the selected state (will be empty object {} unless selector provided)
+ * const { items, isRunning } = queue.state();
  * ```
  */
-export declare function createQueuer<TValue, TSelected = QueuerState<TValue>>(fn: (item: TValue) => void, initialOptions?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): SolidQueuer<TValue, TSelected>;
+export declare function createQueuer<TValue, TSelected = {}>(fn: (item: TValue) => void, initialOptions?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): SolidQueuer<TValue, TSelected>;

package/dist/esm/queuer/createQueuer.js

@@ -1,6 +1,6 @@
 import { Queuer } from "@tanstack/pacer/queuer";
 import { useStore } from "@tanstack/solid-store";
-function createQueuer(fn, initialOptions = {}, selector) {
+function createQueuer(fn, initialOptions = {}, selector = () => ({})) {
   const queuer = new Queuer(fn, initialOptions);
   const state = useStore(queuer.store, selector);
   return {

package/dist/esm/queuer/createQueuer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createQueuer.js","sources":["../../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { useStore } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer'\n\nexport interface SolidQueuer<TValue, TSelected = QueuerState<TValue>>\n  extends Omit<Queuer<TValue>, 'store'> {\n  /**\n   * Reactive state that will be updated when the queuer state changes\n   *\n   * Use this instead of `queuer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n}\n\n/**\n * Creates a Solid-compatible Queuer instance for managing a synchronous queue of items, exposing Solid signals for all stateful properties.\n *\n * Features:\n * - Synchronous processing of items using the provided `fn` function\n * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior\n * - Priority queueing via `getPriority` or item `priority` property\n * - Item expiration and removal of stale items\n * - Configurable wait time between processing items\n * - Pause/resume processing\n * - Callbacks for queue state changes, execution, rejection, and expiration\n * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * The queue processes items synchronously in order, with optional delays between each item. When started, it will process one item per tick, with an optional wait time between ticks. You can pause and resume processing with `stop()` and `start()`.\n *\n * By default, the queue uses FIFO behavior, but you can configure LIFO or double-ended queueing by specifying the position when adding or removing items.\n *\n * Example usage:\n * ```tsx\n * // Example with Solid signals and scheduling\n * const [items, setItems] = createSignal([]);\n *\n * const queue = createQueuer(\n *   (item) => {\n *     // process item synchronously\n *     console.log('Processing', item);\n *   },\n *   {\n *     started: true, // Start processing immediately\n *     wait: 1000,    // Process one item every second\n *     onItemsChange: (queue) => setItems(queue.peekAllItems()),\n *     getPriority: (item) => item.priority // Process higher priority items first\n *   }\n * );\n *\n * // Add items to process - they'll be handled automatically\n * queue.addItem('task1');\n * queue.addItem('task2');\n *\n * // Control the scheduler\n * queue.stop();  // Pause processing\n * queue.start(); // Resume processing\n *\n * // Access queue state via signals\n * console.log('Items:', queue.allItems());\n * console.log('Size:', queue.size());\n * console.log('Is empty:', queue.isEmpty());\n * console.log('Is running:', queue.isRunning());\n * console.log('Next item:', queue.nextItem());\n * ```\n */\nexport function createQueuer<TValue, TSelected = QueuerState<TValue>>(\n  fn: (item: TValue) => void,\n  initialOptions: QueuerOptions<TValue> = {},\n  selector?: (state: QueuerState<TValue>) => TSelected,\n): SolidQueuer<TValue, TSelected> {\n  const queuer = new Queuer(fn, initialOptions)\n\n  const state = useStore(queuer.store, selector)\n\n  return {\n    ...queuer,\n    state,\n  } as unknown as SolidQueuer<TValue, TSelected> // omit `store` in favor of `state`\n}\n"],"names":[],"mappings":";;AAkEO,SAAS,aACd,IACA,iBAAwC,CAAA,GACxC,UACgC;AAChC,QAAM,SAAS,IAAI,OAAO,IAAI,cAAc;AAE5C,QAAM,QAAQ,SAAS,OAAO,OAAO,QAAQ;AAE7C,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"createQueuer.js","sources":["../../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { useStore } from '@tanstack/solid-store'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer'\n\nexport interface SolidQueuer<TValue, TSelected = {}>\n  extends Omit<Queuer<TValue>, 'store'> {\n  /**\n   * Reactive state that will be updated when the queuer state changes\n   *\n   * Use this instead of `queuer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `queuer.state` instead of `queuer.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.\n   * Although, you can make the state reactive by using the `useStore` in your own usage.\n   */\n  readonly store: Store<Readonly<QueuerState<TValue>>>\n}\n\n/**\n * Creates a Solid-compatible Queuer instance for managing a synchronous queue of items, exposing Solid signals for all stateful properties.\n *\n * Features:\n * - Synchronous processing of items using the provided `fn` function\n * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior\n * - Priority queueing via `getPriority` or item `priority` property\n * - Item expiration and removal of stale items\n * - Configurable wait time between processing items\n * - Pause/resume processing\n * - Callbacks for queue state changes, execution, rejection, and expiration\n * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * The queue processes items synchronously in order, with optional delays between each item. When started, it will process one item per tick, with an optional wait time between ticks. You can pause and resume processing with `stop()` and `start()`.\n *\n * By default, the queue uses FIFO behavior, but you can configure LIFO or double-ended queueing by specifying the position when adding or removing items.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management. The `selector` parameter allows you\n * to specify which state changes will trigger a re-render, optimizing performance by preventing\n * unnecessary re-renders when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n *\n * Available state properties:\n * - `executionCount`: Number of items that have been processed\n * - `isRunning`: Whether the queuer is currently running (not stopped)\n * - `items`: Array of items currently queued for processing\n * - `rejectionCount`: Number of items that were rejected (expired or failed validation)\n *\n * Example usage:\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const queue = createQueuer(\n *   (item) => {\n *     // process item synchronously\n *     console.log('Processing', item);\n *   },\n *   {\n *     started: true, // Start processing immediately\n *     wait: 1000,    // Process one item every second\n *     getPriority: (item) => item.priority // Process higher priority items first\n *   }\n * );\n *\n * // Opt-in to re-render when items or isRunning changes (optimized for UI updates)\n * const queue = createQueuer(\n *   (item) => console.log('Processing', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({ items: state.items, isRunning: state.isRunning })\n * );\n *\n * // Opt-in to re-render when execution metrics change (optimized for tracking progress)\n * const queue = createQueuer(\n *   (item) => console.log('Processing', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({\n *     executionCount: state.executionCount,\n *     rejectionCount: state.rejectionCount\n *   })\n * );\n *\n * // Add items to process - they'll be handled automatically\n * queue.addItem('task1');\n * queue.addItem('task2');\n *\n * // Control the scheduler\n * queue.stop();  // Pause processing\n * queue.start(); // Resume processing\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { items, isRunning } = queue.state();\n * ```\n */\nexport function createQueuer<TValue, TSelected = {}>(\n  fn: (item: TValue) => void,\n  initialOptions: QueuerOptions<TValue> = {},\n  selector: (state: QueuerState<TValue>) => TSelected = () => ({}) as TSelected,\n): SolidQueuer<TValue, TSelected> {\n  const queuer = new Queuer(fn, initialOptions)\n\n  const state = useStore(queuer.store, selector)\n\n  return {\n    ...queuer,\n    state,\n  } as SolidQueuer<TValue, TSelected> // omit `store` in favor of `state`\n}\n"],"names":[],"mappings":";;AAoGO,SAAS,aACd,IACA,iBAAwC,CAAA,GACxC,WAAsD,OAAO,CAAA,IAC7B;AAChC,QAAM,SAAS,IAAI,OAAO,IAAI,cAAc;AAE5C,QAAM,QAAQ,SAAS,OAAO,OAAO,QAAQ;AAE7C,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EAAA;AAEJ;"}

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

@@ -29,15 +29,42 @@ import { RateLimiterOptions, RateLimiterState } from '@tanstack/pacer/rate-limit
  * For more direct control over rate limiting without state management,
  * consider using the lower-level createRateLimiter hook instead.
  *
+ * ## State Management and Selector
+ *
+ * The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.
+ * The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,
+ * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.
+ *
+ * **By default, there will be no reactive state subscriptions** and you must opt-in to state
+ * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you
+ * full control over when your component subscribes to state changes. Only when you provide a selector will
+ * 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')
+ *
  * @example
  * ```tsx
- * // Basic rate limiting - update state at most 5 times per minute with a sliding window
+ * // Default behavior - no reactive state subscriptions
  * const [value, setValue, rateLimiter] = createRateLimitedSignal(0, {
  *   limit: 5,
  *   window: 60000,
  *   windowType: 'sliding'
  * });
  *
+ * // Opt-in to reactive updates when limit state changes (optimized for UI feedback)
+ * const [value, setValue, rateLimiter] = createRateLimitedSignal(
+ *   0,
+ *   { limit: 5, window: 60000 },
+ *   (state) => ({ isAtLimit: state.isAtLimit, remainingInWindow: state.remainingInWindow })
+ * );
+ *
  * // With rejection callback and fixed window
  * const [value, setValue] = createRateLimitedSignal(0, {
  *   limit: 3,
@@ -50,7 +77,7 @@ import { RateLimiterOptions, RateLimiterState } from '@tanstack/pacer/rate-limit
  *
  * // Access rateLimiter state via signals
  * const handleSubmit = () => {
- *   const remaining = rateLimiter.remainingInWindow();
+ *   const remaining = rateLimiter.state().remainingInWindow;
  *   if (remaining > 0) {
  *     setValue(newValue);
  *   } else {
@@ -59,7 +86,7 @@ import { RateLimiterOptions, RateLimiterState } from '@tanstack/pacer/rate-limit
  * };
  * ```
  */
-export declare function createRateLimitedSignal<TValue, TSelected = RateLimiterState>(value: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): [
+export declare function createRateLimitedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): [
     Accessor<TValue>,
     Setter<TValue>,
     SolidRateLimiter<Setter<TValue>, TSelected>

package/dist/esm/rate-limiter/createRateLimitedSignal.js.map

@@ -1 +1 @@
-{"version":3,"file":"createRateLimitedSignal.js","sources":["../../../src/rate-limiter/createRateLimitedSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createRateLimiter } from './createRateLimiter'\nimport type { SolidRateLimiter } from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\n/**\n * A Solid hook that creates a rate-limited state value that enforces a hard limit on state updates within a time window.\n * This hook combines Solid's createSignal with rate limiting functionality to provide controlled state updates.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledSignal: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedSignal: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - The rate-limited state value accessor\n * - A rate-limited setter function that respects the configured limits\n * - The rateLimiter instance for additional control\n *\n * For more direct control over rate limiting without state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * @example\n * ```tsx\n * // Basic rate limiting - update state at most 5 times per minute with a sliding window\n * const [value, setValue, rateLimiter] = createRateLimitedSignal(0, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // With rejection callback and fixed window\n * const [value, setValue] = createRateLimitedSignal(0, {\n *   limit: 3,\n *   window: 5000,\n *   windowType: 'fixed',\n *   onReject: (rateLimiter) => {\n *     alert(`Rate limit reached. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access rateLimiter state via signals\n * const handleSubmit = () => {\n *   const remaining = rateLimiter.remainingInWindow();\n *   if (remaining > 0) {\n *     setValue(newValue);\n *   } else {\n *     showRateLimitWarning();\n *   }\n * };\n * ```\n */\nexport function createRateLimitedSignal<TValue, TSelected = RateLimiterState>(\n  value: TValue,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n  selector?: (state: RateLimiterState) => TSelected,\n): [\n  Accessor<TValue>,\n  Setter<TValue>,\n  SolidRateLimiter<Setter<TValue>, TSelected>,\n] {\n  const [rateLimitedValue, setRateLimitedValue] = createSignal<TValue>(value)\n\n  const rateLimiter = createRateLimiter(\n    setRateLimitedValue,\n    initialOptions,\n    selector,\n  )\n\n  return [\n    rateLimitedValue,\n    rateLimiter.maybeExecute as Setter<TValue>,\n    rateLimiter,\n  ]\n}\n"],"names":[],"mappings":";;AAmEO,SAAS,wBACd,OACA,gBACA,UAKA;AACA,QAAM,CAAC,kBAAkB,mBAAmB,IAAI,aAAqB,KAAK;AAE1E,QAAM,cAAc;AAAA,IAClB;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAGF,SAAO;AAAA,IACL;AAAA,IACA,YAAY;AAAA,IACZ;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"createRateLimitedSignal.js","sources":["../../../src/rate-limiter/createRateLimitedSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createRateLimiter } from './createRateLimiter'\nimport type { SolidRateLimiter } from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\n/**\n * A Solid hook that creates a rate-limited state value that enforces a hard limit on state updates within a time window.\n * This hook combines Solid's createSignal with rate limiting functionality to provide controlled state updates.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledSignal: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedSignal: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - The rate-limited state value accessor\n * - A rate-limited setter function that respects the configured limits\n * - The rateLimiter instance for additional control\n *\n * For more direct control over rate limiting without state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.\n * The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,\n * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you\n * full control over when your component subscribes to state changes. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available rate limiter state properties:\n * - `callsInWindow`: Number of calls made in the current window\n * - `remainingInWindow`: Number of calls remaining in the current window\n * - `windowStart`: Unix timestamp when the current window started\n * - `nextWindowStart`: Unix timestamp when the next window will start\n * - `msUntilNextWindow`: Milliseconds until the next window starts\n * - `isAtLimit`: Whether the call limit for the current window has been reached\n * - `status`: Current status ('disabled' | 'idle' | 'at-limit')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue, rateLimiter] = createRateLimitedSignal(0, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Opt-in to reactive updates when limit state changes (optimized for UI feedback)\n * const [value, setValue, rateLimiter] = createRateLimitedSignal(\n *   0,\n *   { limit: 5, window: 60000 },\n *   (state) => ({ isAtLimit: state.isAtLimit, remainingInWindow: state.remainingInWindow })\n * );\n *\n * // With rejection callback and fixed window\n * const [value, setValue] = createRateLimitedSignal(0, {\n *   limit: 3,\n *   window: 5000,\n *   windowType: 'fixed',\n *   onReject: (rateLimiter) => {\n *     alert(`Rate limit reached. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access rateLimiter state via signals\n * const handleSubmit = () => {\n *   const remaining = rateLimiter.state().remainingInWindow;\n *   if (remaining > 0) {\n *     setValue(newValue);\n *   } else {\n *     showRateLimitWarning();\n *   }\n * };\n * ```\n */\nexport function createRateLimitedSignal<TValue, TSelected = {}>(\n  value: TValue,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n  selector?: (state: RateLimiterState) => TSelected,\n): [\n  Accessor<TValue>,\n  Setter<TValue>,\n  SolidRateLimiter<Setter<TValue>, TSelected>,\n] {\n  const [rateLimitedValue, setRateLimitedValue] = createSignal<TValue>(value)\n\n  const rateLimiter = createRateLimiter(\n    setRateLimitedValue,\n    initialOptions,\n    selector,\n  )\n\n  return [\n    rateLimitedValue,\n    rateLimiter.maybeExecute as Setter<TValue>,\n    rateLimiter,\n  ]\n}\n"],"names":[],"mappings":";;AA8FO,SAAS,wBACd,OACA,gBACA,UAKA;AACA,QAAM,CAAC,kBAAkB,mBAAmB,IAAI,aAAqB,KAAK;AAE1E,QAAM,cAAc;AAAA,IAClB;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAGF,SAAO;AAAA,IACL;AAAA,IACA,YAAY;AAAA,IACZ;AAAA,EAAA;AAEJ;"}

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

@@ -28,20 +28,50 @@ import { RateLimiterOptions, RateLimiterState } from '@tanstack/pacer/rate-limit
  * For more direct control over rate limiting behavior without Solid state management,
  * consider using the lower-level createRateLimiter hook instead.
  *
+ * ## State Management and Selector
+ *
+ * The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.
+ * The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,
+ * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.
+ *
+ * **By default, there will be no reactive state subscriptions** and you must opt-in to state
+ * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you
+ * full control over when your component subscribes to state changes. Only when you provide a selector will
+ * 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')
+ *
  * @example
  * ```tsx
- * // Basic rate limiting - update at most 5 times per minute with a sliding window
+ * // Default behavior - no reactive state subscriptions
  * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {
  *   limit: 5,
  *   window: 60000,
  *   windowType: 'sliding'
  * });
  *
+ * // Opt-in to reactive updates when limit state changes (optimized for UI feedback)
+ * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(
+ *   rawValue,
+ *   { limit: 5, window: 60000 },
+ *   (state) => ({ isAtLimit: state.isAtLimit, remainingInWindow: state.remainingInWindow })
+ * );
+ *
  * // Use the rate-limited value
  * console.log(rateLimitedValue()); // Access the current rate-limited value
  *
+ * // Access rate limiter state via signals
+ * console.log('Is at limit:', rateLimiter.state().isAtLimit);
+ *
  * // Control the rate limiter
  * rateLimiter.reset(); // Reset the rate limit window
  * ```
  */
-export declare function createRateLimitedValue<TValue, TSelected = RateLimiterState>(value: Accessor<TValue>, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>];
+export declare function createRateLimitedValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>];

package/dist/esm/rate-limiter/createRateLimitedValue.js.map

@@ -1 +1 @@
-{"version":3,"file":"createRateLimitedValue.js","sources":["../../../src/rate-limiter/createRateLimitedValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createRateLimitedSignal } from './createRateLimitedSignal'\nimport type { SolidRateLimiter } from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\n/**\n * 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.\n * This hook uses Solid's createSignal internally to manage the rate-limited state.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledValue: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedValue: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - An accessor function that provides the rate-limited value\n * - The rate limiter instance with control methods\n *\n * For more direct control over rate limiting behavior without Solid state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * @example\n * ```tsx\n * // Basic rate limiting - update at most 5 times per minute with a sliding window\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Use the rate-limited value\n * console.log(rateLimitedValue()); // Access the current rate-limited value\n *\n * // Control the rate limiter\n * rateLimiter.reset(); // Reset the rate limit window\n * ```\n */\nexport function createRateLimitedValue<TValue, TSelected = RateLimiterState>(\n  value: Accessor<TValue>,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n  selector?: (state: RateLimiterState) => TSelected,\n): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>] {\n  const [rateLimitedValue, setRateLimitedValue, rateLimiter] =\n    createRateLimitedSignal(value(), initialOptions, selector)\n\n  createEffect(() => {\n    setRateLimitedValue(value() as any)\n  })\n\n  return [rateLimitedValue, rateLimiter]\n}\n"],"names":[],"mappings":";;AAoDO,SAAS,uBACd,OACA,gBACA,UACiE;AACjE,QAAM,CAAC,kBAAkB,qBAAqB,WAAW,IACvD,wBAAwB,MAAA,GAAS,gBAAgB,QAAQ;AAE3D,eAAa,MAAM;AACjB,wBAAoB,OAAc;AAAA,EAAA,CACnC;AAED,SAAO,CAAC,kBAAkB,WAAW;AACvC;"}
+{"version":3,"file":"createRateLimitedValue.js","sources":["../../../src/rate-limiter/createRateLimitedValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createRateLimitedSignal } from './createRateLimitedSignal'\nimport type { SolidRateLimiter } from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\n/**\n * 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.\n * This hook uses Solid's createSignal internally to manage the rate-limited state.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledValue: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedValue: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - An accessor function that provides the rate-limited value\n * - The rate limiter instance with control methods\n *\n * For more direct control over rate limiting behavior without Solid state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.\n * The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,\n * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you\n * full control over when your component subscribes to state changes. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available rate limiter state properties:\n * - `callsInWindow`: Number of calls made in the current window\n * - `remainingInWindow`: Number of calls remaining in the current window\n * - `windowStart`: Unix timestamp when the current window started\n * - `nextWindowStart`: Unix timestamp when the next window will start\n * - `msUntilNextWindow`: Milliseconds until the next window starts\n * - `isAtLimit`: Whether the call limit for the current window has been reached\n * - `status`: Current status ('disabled' | 'idle' | 'at-limit')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Opt-in to reactive updates when limit state changes (optimized for UI feedback)\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(\n *   rawValue,\n *   { limit: 5, window: 60000 },\n *   (state) => ({ isAtLimit: state.isAtLimit, remainingInWindow: state.remainingInWindow })\n * );\n *\n * // Use the rate-limited value\n * console.log(rateLimitedValue()); // Access the current rate-limited value\n *\n * // Access rate limiter state via signals\n * console.log('Is at limit:', rateLimiter.state().isAtLimit);\n *\n * // Control the rate limiter\n * rateLimiter.reset(); // Reset the rate limit window\n * ```\n */\nexport function createRateLimitedValue<TValue, TSelected = {}>(\n  value: Accessor<TValue>,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n  selector?: (state: RateLimiterState) => TSelected,\n): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>] {\n  const [rateLimitedValue, setRateLimitedValue, rateLimiter] =\n    createRateLimitedSignal(value(), initialOptions, selector)\n\n  createEffect(() => {\n    setRateLimitedValue(value() as any)\n  })\n\n  return [rateLimitedValue, rateLimiter]\n}\n"],"names":[],"mappings":";;AAkFO,SAAS,uBACd,OACA,gBACA,UACiE;AACjE,QAAM,CAAC,kBAAkB,qBAAqB,WAAW,IACvD,wBAAwB,MAAA,GAAS,gBAAgB,QAAQ;AAE3D,eAAa,MAAM;AACjB,wBAAoB,OAAc;AAAA,EAAA,CACnC;AAED,SAAO,CAAC,kBAAkB,WAAW;AACvC;"}

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

@@ -1,13 +1,20 @@
 import { RateLimiter, RateLimiterOptions, RateLimiterState } from '@tanstack/pacer/rate-limiter';
+import { Store } from '@tanstack/solid-store';
 import { Accessor } from 'solid-js';
 import { AnyFunction } from '@tanstack/pacer/types';
-export interface SolidRateLimiter<TFn extends AnyFunction, TSelected = RateLimiterState> extends Omit<RateLimiter<TFn>, 'store'> {
+export interface SolidRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit<RateLimiter<TFn>, 'store'> {
     /**
      * Reactive state that will be updated when the rate limiter state changes
      *
      * Use this instead of `rateLimiter.store.state`
      */
     readonly state: Accessor<Readonly<TSelected>>;
+    /**
+     * @deprecated Use `rateLimiter.state` instead of `rateLimiter.store.state` if you want to read reactive state.
+     * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
+     * Although, you can make the state reactive by using the `useStore` in your own usage.
+     */
+    readonly store: Store<Readonly<RateLimiterState>>;
 }
 /**
  * A low-level Solid hook that creates a `RateLimiter` instance to enforce rate limits on function execution.
@@ -30,9 +37,27 @@ export interface SolidRateLimiter<TFn extends AnyFunction, TSelected = RateLimit
  * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)
  * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)
  *
+ * ## State Management and Selector
+ *
+ * The hook uses TanStack Store for reactive state management. The `selector` parameter allows you
+ * to specify which state changes will trigger a re-render, optimizing performance by preventing
+ * unnecessary re-renders when irrelevant state changes occur.
+ *
+ * **By default, there will be no reactive state subscriptions** and you must opt-in to state
+ * tracking by providing a selector function. This prevents unnecessary re-renders and gives you
+ * full control over when your component updates. Only when you provide a selector will the
+ * component re-render when the selected state values change.
+ *
+ * Available state properties:
+ * - `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
- * // Basic rate limiting - max 5 calls per minute with a sliding window
+ * // Default behavior - no reactive state subscriptions
  * const rateLimiter = createRateLimiter(apiCall, {
  *   limit: 5,
  *   window: 60000,
@@ -42,11 +67,28 @@ export interface SolidRateLimiter<TFn extends AnyFunction, TSelected = RateLimit
  *   }
  * });
  *
- * // Access rate limiter state via signals
- * console.log('Executions:', rateLimiter.executionCount());
- * console.log('Rejections:', rateLimiter.rejectionCount());
- * console.log('Remaining:', rateLimiter.remainingInWindow());
- * console.log('Next window in:', rateLimiter.msUntilNextWindow());
+ * // Opt-in to re-render when rate limit state changes (optimized for UI feedback)
+ * const rateLimiter = createRateLimiter(
+ *   apiCall,
+ *   { limit: 5, window: 60000 },
+ *   (state) => ({
+ *     remainingInWindow: state.remainingInWindow,
+ *     rejectionCount: state.rejectionCount
+ *   })
+ * );
+ *
+ * // Opt-in to re-render when execution metrics change (optimized for tracking progress)
+ * const rateLimiter = createRateLimiter(
+ *   apiCall,
+ *   { limit: 5, window: 60000 },
+ *   (state) => ({
+ *     executionCount: state.executionCount,
+ *     nextWindowTime: state.nextWindowTime
+ *   })
+ * );
+ *
+ * // Access the selected state (will be empty object {} unless selector provided)
+ * const { remainingInWindow, rejectionCount } = rateLimiter.state();
  * ```
  */
-export declare function createRateLimiter<TFn extends AnyFunction, TSelected = RateLimiterState>(fn: TFn, initialOptions: RateLimiterOptions<TFn>, selector?: (state: RateLimiterState) => TSelected): SolidRateLimiter<TFn, TSelected>;
+export declare function createRateLimiter<TFn extends AnyFunction, TSelected = {}>(fn: TFn, initialOptions: RateLimiterOptions<TFn>, selector?: (state: RateLimiterState) => TSelected): SolidRateLimiter<TFn, TSelected>;

package/dist/esm/rate-limiter/createRateLimiter.js

@@ -1,6 +1,6 @@
 import { RateLimiter } from "@tanstack/pacer/rate-limiter";
 import { useStore } from "@tanstack/solid-store";
-function createRateLimiter(fn, initialOptions, selector) {
+function createRateLimiter(fn, initialOptions, selector = () => ({})) {
   const rateLimiter = new RateLimiter(fn, initialOptions);
   const state = useStore(rateLimiter.store, selector);
   return {

package/dist/esm/rate-limiter/createRateLimiter.js.map

@@ -1 +1 @@
-{"version":3,"file":"createRateLimiter.js","sources":["../../../src/rate-limiter/createRateLimiter.ts"],"sourcesContent":["import { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { useStore } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\nexport interface SolidRateLimiter<\n  TFn extends AnyFunction,\n  TSelected = RateLimiterState,\n> extends Omit<RateLimiter<TFn>, 'store'> {\n  /**\n   * Reactive state that will be updated when the rate limiter state changes\n   *\n   * Use this instead of `rateLimiter.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n}\n\n/**\n * A low-level Solid hook that creates a `RateLimiter` instance to enforce rate limits on function execution.\n *\n * This hook is designed to be flexible and state-management agnostic - it simply returns a rate limiter instance that\n * you can integrate with any state management solution (createSignal, etc).\n *\n * Rate limiting is a simple \"hard limit\" approach that allows executions until a maximum count is reached within\n * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,\n * it does not attempt to space out or collapse executions intelligently.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n *   consistent rate of execution over time.\n *\n * For smoother execution patterns:\n * - Use throttling when you want consistent spacing between executions (e.g. UI updates)\n * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)\n * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)\n *\n * @example\n * ```tsx\n * // Basic rate limiting - max 5 calls per minute with a sliding window\n * const rateLimiter = createRateLimiter(apiCall, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding',\n *   onReject: (rateLimiter) => {\n *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access rate limiter state via signals\n * console.log('Executions:', rateLimiter.executionCount());\n * console.log('Rejections:', rateLimiter.rejectionCount());\n * console.log('Remaining:', rateLimiter.remainingInWindow());\n * console.log('Next window in:', rateLimiter.msUntilNextWindow());\n * ```\n */\nexport function createRateLimiter<\n  TFn extends AnyFunction,\n  TSelected = RateLimiterState,\n>(\n  fn: TFn,\n  initialOptions: RateLimiterOptions<TFn>,\n  selector?: (state: RateLimiterState) => TSelected,\n): SolidRateLimiter<TFn, TSelected> {\n  const rateLimiter = new RateLimiter<TFn>(fn, initialOptions)\n\n  const state = useStore(rateLimiter.store, selector)\n\n  return {\n    ...rateLimiter,\n    state,\n  } as unknown as SolidRateLimiter<TFn, TSelected> // omit `store` in favor of `state`\n}\n"],"names":[],"mappings":";;AA6DO,SAAS,kBAId,IACA,gBACA,UACkC;AAClC,QAAM,cAAc,IAAI,YAAiB,IAAI,cAAc;AAE3D,QAAM,QAAQ,SAAS,YAAY,OAAO,QAAQ;AAElD,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"createRateLimiter.js","sources":["../../../src/rate-limiter/createRateLimiter.ts"],"sourcesContent":["import { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { useStore } from '@tanstack/solid-store'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\nexport interface SolidRateLimiter<TFn extends AnyFunction, TSelected = {}>\n  extends Omit<RateLimiter<TFn>, 'store'> {\n  /**\n   * Reactive state that will be updated when the rate limiter state changes\n   *\n   * Use this instead of `rateLimiter.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `rateLimiter.state` instead of `rateLimiter.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.\n   * Although, you can make the state reactive by using the `useStore` in your own usage.\n   */\n  readonly store: Store<Readonly<RateLimiterState>>\n}\n\n/**\n * A low-level Solid hook that creates a `RateLimiter` instance to enforce rate limits on function execution.\n *\n * This hook is designed to be flexible and state-management agnostic - it simply returns a rate limiter instance that\n * you can integrate with any state management solution (createSignal, etc).\n *\n * Rate limiting is a simple \"hard limit\" approach that allows executions until a maximum count is reached within\n * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,\n * it does not attempt to space out or collapse executions intelligently.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n *   consistent rate of execution over time.\n *\n * For smoother execution patterns:\n * - Use throttling when you want consistent spacing between executions (e.g. UI updates)\n * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)\n * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management. The `selector` parameter allows you\n * to specify which state changes will trigger a re-render, optimizing performance by preventing\n * unnecessary re-renders when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n *\n * Available state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `rejectionCount`: Number of function calls that were rejected due to rate limiting\n * - `remainingInWindow`: Number of executions remaining in the current window\n * - `nextWindowTime`: Timestamp when the next window begins\n * - `currentWindowStart`: Timestamp when the current window started\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const rateLimiter = createRateLimiter(apiCall, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding',\n *   onReject: (rateLimiter) => {\n *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Opt-in to re-render when rate limit state changes (optimized for UI feedback)\n * const rateLimiter = createRateLimiter(\n *   apiCall,\n *   { limit: 5, window: 60000 },\n *   (state) => ({\n *     remainingInWindow: state.remainingInWindow,\n *     rejectionCount: state.rejectionCount\n *   })\n * );\n *\n * // Opt-in to re-render when execution metrics change (optimized for tracking progress)\n * const rateLimiter = createRateLimiter(\n *   apiCall,\n *   { limit: 5, window: 60000 },\n *   (state) => ({\n *     executionCount: state.executionCount,\n *     nextWindowTime: state.nextWindowTime\n *   })\n * );\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { remainingInWindow, rejectionCount } = rateLimiter.state();\n * ```\n */\nexport function createRateLimiter<TFn extends AnyFunction, TSelected = {}>(\n  fn: TFn,\n  initialOptions: RateLimiterOptions<TFn>,\n  selector: (state: RateLimiterState) => TSelected = () => ({}) as TSelected,\n): SolidRateLimiter<TFn, TSelected> {\n  const rateLimiter = new RateLimiter<TFn>(fn, initialOptions)\n\n  const state = useStore(rateLimiter.store, selector)\n\n  return {\n    ...rateLimiter,\n    state,\n  } as SolidRateLimiter<TFn, TSelected> // omit `store` in favor of `state`\n}\n"],"names":[],"mappings":";;AAqGO,SAAS,kBACd,IACA,gBACA,WAAmD,OAAO,CAAA,IACxB;AAClC,QAAM,cAAc,IAAI,YAAiB,IAAI,cAAc;AAE3D,QAAM,QAAQ,SAAS,YAAY,OAAO,QAAQ;AAElD,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EAAA;AAEJ;"}

package/dist/esm/throttler/createThrottledSignal.d.ts

@@ -16,11 +16,39 @@ import { ThrottlerOptions, ThrottlerState } from '@tanstack/pacer/throttler';
  * For more direct control over throttling without state management,
  * consider using the lower-level createThrottler hook instead.
  *
+ * ## State Management and Selector
+ *
+ * The hook uses TanStack Store for reactive state management via the underlying throttler instance.
+ * The `selector` parameter allows you to specify which throttler state changes will trigger reactive updates,
+ * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.
+ *
+ * **By default, there will be no reactive state subscriptions** and you must opt-in to state
+ * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you
+ * full control over when your component subscribes to state changes. Only when you provide a selector will
+ * 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
+ * - `lastExecutionTime`: Unix timestamp of the last execution
+ * - `nextExecutionTime`: Unix timestamp of the next allowed execution
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+ *
  * @example
  * ```tsx
- * // Basic throttling - update state at most once per second
+ * // Default behavior - no reactive state subscriptions
  * const [value, setValue, throttler] = createThrottledSignal(0, { wait: 1000 });
  *
+ * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)
+ * const [value, setValue, throttler] = createThrottledSignal(
+ *   0,
+ *   { wait: 1000 },
+ *   (state) => ({ isPending: state.isPending })
+ * );
+ *
  * // With custom leading/trailing behavior
  * const [value, setValue] = createThrottledSignal(0, {
  *   wait: 1000,
@@ -29,13 +57,13 @@ import { ThrottlerOptions, ThrottlerState } from '@tanstack/pacer/throttler';
  * });
  *
  * // Access throttler state via signals
- * console.log('Executions:', throttler.executionCount());
- * console.log('Is pending:', throttler.isPending());
- * console.log('Last execution:', throttler.lastExecutionTime());
- * console.log('Next execution:', throttler.nextExecutionTime());
+ * console.log('Executions:', throttler.state().executionCount);
+ * console.log('Is pending:', throttler.state().isPending);
+ * console.log('Last execution:', throttler.state().lastExecutionTime);
+ * console.log('Next execution:', throttler.state().nextExecutionTime);
  * ```
  */
-export declare function createThrottledSignal<TValue, TSelected = ThrottlerState<Setter<TValue>>>(value: TValue, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): [
+export declare function createThrottledSignal<TValue, TSelected = {}>(value: TValue, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): [
     Accessor<TValue>,
     Setter<TValue>,
     SolidThrottler<Setter<TValue>, TSelected>

package/dist/esm/throttler/createThrottledSignal.js.map

@@ -1 +1 @@
-{"version":3,"file":"createThrottledSignal.js","sources":["../../../src/throttler/createThrottledSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createThrottler } from './createThrottler'\nimport type { SolidThrottler } from './createThrottler'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  ThrottlerOptions,\n  ThrottlerState,\n} from '@tanstack/pacer/throttler'\n\n/**\n * A Solid hook that creates a throttled state value that updates at most once within a specified time window.\n * This hook combines Solid's createSignal with throttling functionality to provide controlled state updates.\n *\n * Throttling ensures state updates occur at a controlled rate regardless of how frequently the setter is called.\n * This is useful for rate-limiting expensive re-renders or operations that depend on rapidly changing state.\n *\n * The hook returns a tuple containing:\n * - The throttled state value accessor\n * - A throttled setter function that respects the configured wait time\n * - The throttler instance for additional control\n *\n * For more direct control over throttling without state management,\n * consider using the lower-level createThrottler hook instead.\n *\n * @example\n * ```tsx\n * // Basic throttling - update state at most once per second\n * const [value, setValue, throttler] = createThrottledSignal(0, { wait: 1000 });\n *\n * // With custom leading/trailing behavior\n * const [value, setValue] = createThrottledSignal(0, {\n *   wait: 1000,\n *   leading: true,   // Update immediately on first change\n *   trailing: false  // Skip trailing edge updates\n * });\n *\n * // Access throttler state via signals\n * console.log('Executions:', throttler.executionCount());\n * console.log('Is pending:', throttler.isPending());\n * console.log('Last execution:', throttler.lastExecutionTime());\n * console.log('Next execution:', throttler.nextExecutionTime());\n * ```\n */\nexport function createThrottledSignal<\n  TValue,\n  TSelected = ThrottlerState<Setter<TValue>>,\n>(\n  value: TValue,\n  initialOptions: ThrottlerOptions<Setter<TValue>>,\n  selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected,\n): [\n  Accessor<TValue>,\n  Setter<TValue>,\n  SolidThrottler<Setter<TValue>, TSelected>,\n] {\n  const [throttledValue, setThrottledValue] = createSignal<TValue>(value)\n  const throttler = createThrottler(setThrottledValue, initialOptions, selector)\n  return [throttledValue, throttler.maybeExecute as Setter<TValue>, throttler]\n}\n"],"names":[],"mappings":";;AA2CO,SAAS,sBAId,OACA,gBACA,UAKA;AACA,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,aAAqB,KAAK;AACtE,QAAM,YAAY,gBAAgB,mBAAmB,gBAAgB,QAAQ;AAC7E,SAAO,CAAC,gBAAgB,UAAU,cAAgC,SAAS;AAC7E;"}
+{"version":3,"file":"createThrottledSignal.js","sources":["../../../src/throttler/createThrottledSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createThrottler } from './createThrottler'\nimport type { SolidThrottler } from './createThrottler'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  ThrottlerOptions,\n  ThrottlerState,\n} from '@tanstack/pacer/throttler'\n\n/**\n * A Solid hook that creates a throttled state value that updates at most once within a specified time window.\n * This hook combines Solid's createSignal with throttling functionality to provide controlled state updates.\n *\n * Throttling ensures state updates occur at a controlled rate regardless of how frequently the setter is called.\n * This is useful for rate-limiting expensive re-renders or operations that depend on rapidly changing state.\n *\n * The hook returns a tuple containing:\n * - The throttled state value accessor\n * - A throttled setter function that respects the configured wait time\n * - The throttler instance for additional control\n *\n * For more direct control over throttling without state management,\n * consider using the lower-level createThrottler hook instead.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management via the underlying throttler instance.\n * The `selector` parameter allows you to specify which throttler state changes will trigger reactive updates,\n * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you\n * full control over when your component subscribes to state changes. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available throttler state properties:\n * - `canLeadingExecute`: Whether the throttler can execute on the leading edge\n * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger trailing execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Unix timestamp of the last execution\n * - `nextExecutionTime`: Unix timestamp of the next allowed execution\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue, throttler] = createThrottledSignal(0, { wait: 1000 });\n *\n * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)\n * const [value, setValue, throttler] = createThrottledSignal(\n *   0,\n *   { wait: 1000 },\n *   (state) => ({ isPending: state.isPending })\n * );\n *\n * // With custom leading/trailing behavior\n * const [value, setValue] = createThrottledSignal(0, {\n *   wait: 1000,\n *   leading: true,   // Update immediately on first change\n *   trailing: false  // Skip trailing edge updates\n * });\n *\n * // Access throttler state via signals\n * console.log('Executions:', throttler.state().executionCount);\n * console.log('Is pending:', throttler.state().isPending);\n * console.log('Last execution:', throttler.state().lastExecutionTime);\n * console.log('Next execution:', throttler.state().nextExecutionTime);\n * ```\n */\nexport function createThrottledSignal<TValue, TSelected = {}>(\n  value: TValue,\n  initialOptions: ThrottlerOptions<Setter<TValue>>,\n  selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected,\n): [\n  Accessor<TValue>,\n  Setter<TValue>,\n  SolidThrottler<Setter<TValue>, TSelected>,\n] {\n  const [throttledValue, setThrottledValue] = createSignal<TValue>(value)\n  const throttler = createThrottler(setThrottledValue, initialOptions, selector)\n  return [throttledValue, throttler.maybeExecute as Setter<TValue>, throttler]\n}\n"],"names":[],"mappings":";;AAuEO,SAAS,sBACd,OACA,gBACA,UAKA;AACA,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,aAAqB,KAAK;AACtE,QAAM,YAAY,gBAAgB,mBAAmB,gBAAgB,QAAQ;AAC7E,SAAO,CAAC,gBAAgB,UAAU,cAAgC,SAAS;AAC7E;"}

package/dist/esm/throttler/createThrottledValue.d.ts

@@ -17,16 +17,47 @@ import { ThrottlerOptions, ThrottlerState } from '@tanstack/pacer/throttler';
  * For more direct control over throttling behavior without Solid state management,
  * consider using the lower-level createThrottler hook instead.
  *
+ * ## State Management and Selector
+ *
+ * The hook uses TanStack Store for reactive state management via the underlying throttler instance.
+ * The `selector` parameter allows you to specify which throttler state changes will trigger reactive updates,
+ * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.
+ *
+ * **By default, there will be no reactive state subscriptions** and you must opt-in to state
+ * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you
+ * full control over when your component subscribes to state changes. Only when you provide a selector will
+ * 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
+ * - `lastExecutionTime`: Unix timestamp of the last execution
+ * - `nextExecutionTime`: Unix timestamp of the next allowed execution
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+ *
  * @example
  * ```tsx
- * // Basic throttling - update at most once per second
+ * // Default behavior - no reactive state subscriptions
  * const [throttledValue, throttler] = createThrottledValue(rawValue, { wait: 1000 });
  *
+ * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)
+ * const [throttledValue, throttler] = createThrottledValue(
+ *   rawValue,
+ *   { wait: 1000 },
+ *   (state) => ({ isPending: state.isPending })
+ * );
+ *
  * // Use the throttled value
  * console.log(throttledValue()); // Access the current throttled value
  *
+ * // Access throttler state via signals
+ * console.log('Is pending:', throttler.state().isPending);
+ *
  * // Control the throttler
  * throttler.cancel(); // Cancel any pending updates
  * ```
  */
-export declare function createThrottledValue<TValue, TSelected = ThrottlerState<Setter<TValue>>>(value: Accessor<TValue>, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, SolidThrottler<Setter<TValue>, TSelected>];
+export declare function createThrottledValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, SolidThrottler<Setter<TValue>, TSelected>];

package/dist/esm/throttler/createThrottledValue.js.map

@@ -1 +1 @@
-{"version":3,"file":"createThrottledValue.js","sources":["../../../src/throttler/createThrottledValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createThrottledSignal } from './createThrottledSignal'\nimport type { SolidThrottler } from './createThrottler'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  ThrottlerOptions,\n  ThrottlerState,\n} from '@tanstack/pacer/throttler'\n\n/**\n * A high-level Solid hook that creates a throttled version of a value that updates at most once within a specified time window.\n * This hook uses Solid's createSignal internally to manage the throttled state.\n *\n * Throttling ensures the value updates occur at a controlled rate regardless of how frequently the input value changes.\n * This is useful for rate-limiting expensive re-renders or API calls that depend on rapidly changing values.\n *\n * The hook returns a tuple containing:\n * - An accessor function that provides the throttled value\n * - The throttler instance with control methods\n *\n * The throttled value will update according to the leading/trailing edge behavior specified in the options.\n *\n * For more direct control over throttling behavior without Solid state management,\n * consider using the lower-level createThrottler hook instead.\n *\n * @example\n * ```tsx\n * // Basic throttling - update at most once per second\n * const [throttledValue, throttler] = createThrottledValue(rawValue, { wait: 1000 });\n *\n * // Use the throttled value\n * console.log(throttledValue()); // Access the current throttled value\n *\n * // Control the throttler\n * throttler.cancel(); // Cancel any pending updates\n * ```\n */\nexport function createThrottledValue<\n  TValue,\n  TSelected = ThrottlerState<Setter<TValue>>,\n>(\n  value: Accessor<TValue>,\n  initialOptions: ThrottlerOptions<Setter<TValue>>,\n  selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected,\n): [Accessor<TValue>, SolidThrottler<Setter<TValue>, TSelected>] {\n  const [throttledValue, setThrottledValue, throttler] = createThrottledSignal(\n    value(),\n    initialOptions,\n    selector,\n  )\n\n  createEffect(() => {\n    setThrottledValue(value() as any)\n  })\n\n  return [throttledValue, throttler]\n}\n"],"names":[],"mappings":";;AAqCO,SAAS,qBAId,OACA,gBACA,UAC+D;AAC/D,QAAM,CAAC,gBAAgB,mBAAmB,SAAS,IAAI;AAAA,IACrD,MAAA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAGF,eAAa,MAAM;AACjB,sBAAkB,OAAc;AAAA,EAAA,CACjC;AAED,SAAO,CAAC,gBAAgB,SAAS;AACnC;"}
+{"version":3,"file":"createThrottledValue.js","sources":["../../../src/throttler/createThrottledValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createThrottledSignal } from './createThrottledSignal'\nimport type { SolidThrottler } from './createThrottler'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  ThrottlerOptions,\n  ThrottlerState,\n} from '@tanstack/pacer/throttler'\n\n/**\n * A high-level Solid hook that creates a throttled version of a value that updates at most once within a specified time window.\n * This hook uses Solid's createSignal internally to manage the throttled state.\n *\n * Throttling ensures the value updates occur at a controlled rate regardless of how frequently the input value changes.\n * This is useful for rate-limiting expensive re-renders or API calls that depend on rapidly changing values.\n *\n * The hook returns a tuple containing:\n * - An accessor function that provides the throttled value\n * - The throttler instance with control methods\n *\n * The throttled value will update according to the leading/trailing edge behavior specified in the options.\n *\n * For more direct control over throttling behavior without Solid state management,\n * consider using the lower-level createThrottler hook instead.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management via the underlying throttler instance.\n * The `selector` parameter allows you to specify which throttler state changes will trigger reactive updates,\n * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you\n * full control over when your component subscribes to state changes. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available throttler state properties:\n * - `canLeadingExecute`: Whether the throttler can execute on the leading edge\n * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger trailing execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Unix timestamp of the last execution\n * - `nextExecutionTime`: Unix timestamp of the next allowed execution\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [throttledValue, throttler] = createThrottledValue(rawValue, { wait: 1000 });\n *\n * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)\n * const [throttledValue, throttler] = createThrottledValue(\n *   rawValue,\n *   { wait: 1000 },\n *   (state) => ({ isPending: state.isPending })\n * );\n *\n * // Use the throttled value\n * console.log(throttledValue()); // Access the current throttled value\n *\n * // Access throttler state via signals\n * console.log('Is pending:', throttler.state().isPending);\n *\n * // Control the throttler\n * throttler.cancel(); // Cancel any pending updates\n * ```\n */\nexport function createThrottledValue<TValue, TSelected = {}>(\n  value: Accessor<TValue>,\n  initialOptions: ThrottlerOptions<Setter<TValue>>,\n  selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected,\n): [Accessor<TValue>, SolidThrottler<Setter<TValue>, TSelected>] {\n  const [throttledValue, setThrottledValue, throttler] = createThrottledSignal(\n    value(),\n    initialOptions,\n    selector,\n  )\n\n  createEffect(() => {\n    setThrottledValue(value() as any)\n  })\n\n  return [throttledValue, throttler]\n}\n"],"names":[],"mappings":";;AAoEO,SAAS,qBACd,OACA,gBACA,UAC+D;AAC/D,QAAM,CAAC,gBAAgB,mBAAmB,SAAS,IAAI;AAAA,IACrD,MAAA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAGF,eAAa,MAAM;AACjB,sBAAkB,OAAc;AAAA,EAAA,CACjC;AAED,SAAO,CAAC,gBAAgB,SAAS;AACnC;"}