@tanstack/solid-pacer 0.17.0 → 0.18.1

package/dist/queuer/createQueuer.d.cts

@@ -1,9 +1,26 @@
 import { Store } from "@tanstack/solid-store";
-import { Accessor } from "solid-js";
+import { Accessor, JSX } from "solid-js";
 import { Queuer, QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
 
 //#region src/queuer/createQueuer.d.ts
 interface SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'store'> {
+  /**
+   * A Solid component that allows you to subscribe to the queuer state.
+   *
+   * This is useful for tracking specific parts of the queuer state
+   * deep in your component tree without needing to pass a selector to the hook.
+   *
+   * @example
+   * <queuer.Subscribe selector={(state) => ({ size: state.size, isRunning: state.isRunning })}>
+   *   {(state) => (
+   *     <div>Queue: {state().size} items, {state().isRunning ? 'Processing' : 'Idle'}</div>
+   *   )}
+   * </queuer.Subscribe>
+   */
+  Subscribe: <TSelected>(props: {
+    selector: (state: QueuerState<TValue>) => TSelected;
+    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element;
+  }) => JSX.Element;
   /**
    * Reactive state that will be updated when the queuer state changes
    *
@@ -36,14 +53,24 @@ interface SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'stor
  *
  * ## 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.
+ * The hook uses TanStack Store for reactive state management. You can subscribe to state changes
+ * in two ways:
+ *
+ * **1. Using `queuer.Subscribe` component (Recommended for component tree subscriptions)**
+ *
+ * Use the `Subscribe` component to subscribe to state changes deep in your component tree without
+ * needing to pass a selector to the hook. This is ideal when you want to subscribe to state
+ * in child components.
+ *
+ * **2. Using the `selector` parameter (For hook-level subscriptions)**
+ *
+ * The `selector` parameter allows you to specify which state changes will trigger reactive updates
+ * at the hook level, optimizing performance by preventing unnecessary updates 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.
+ * 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.
  *
  * Available state properties:
  * - `executionCount`: Number of items that have been processed
@@ -66,14 +93,14 @@ interface SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'stor
  *   }
  * );
  *
- * // Opt-in to re-render when items or isRunning changes (optimized for UI updates)
+ * // Opt-in to track 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)
+ * // Opt-in to track execution metrics changes (optimized for tracking progress)
  * const queue = createQueuer(
  *   (item) => console.log('Processing', item),
  *   { started: true, wait: 1000 },

package/dist/queuer/createQueuer.d.ts

@@ -1,9 +1,26 @@
-import { Accessor } from "solid-js";
+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 SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'store'> {
+  /**
+   * A Solid component that allows you to subscribe to the queuer state.
+   *
+   * This is useful for tracking specific parts of the queuer state
+   * deep in your component tree without needing to pass a selector to the hook.
+   *
+   * @example
+   * <queuer.Subscribe selector={(state) => ({ size: state.size, isRunning: state.isRunning })}>
+   *   {(state) => (
+   *     <div>Queue: {state().size} items, {state().isRunning ? 'Processing' : 'Idle'}</div>
+   *   )}
+   * </queuer.Subscribe>
+   */
+  Subscribe: <TSelected>(props: {
+    selector: (state: QueuerState<TValue>) => TSelected;
+    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element;
+  }) => JSX.Element;
   /**
    * Reactive state that will be updated when the queuer state changes
    *
@@ -36,14 +53,24 @@ interface SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'stor
  *
  * ## 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.
+ * The hook uses TanStack Store for reactive state management. You can subscribe to state changes
+ * in two ways:
+ *
+ * **1. Using `queuer.Subscribe` component (Recommended for component tree subscriptions)**
+ *
+ * Use the `Subscribe` component to subscribe to state changes deep in your component tree without
+ * needing to pass a selector to the hook. This is ideal when you want to subscribe to state
+ * in child components.
+ *
+ * **2. Using the `selector` parameter (For hook-level subscriptions)**
+ *
+ * The `selector` parameter allows you to specify which state changes will trigger reactive updates
+ * at the hook level, optimizing performance by preventing unnecessary updates 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.
+ * 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.
  *
  * Available state properties:
  * - `executionCount`: Number of items that have been processed
@@ -66,14 +93,14 @@ interface SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'stor
  *   }
  * );
  *
- * // Opt-in to re-render when items or isRunning changes (optimized for UI updates)
+ * // Opt-in to track 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)
+ * // Opt-in to track execution metrics changes (optimized for tracking progress)
  * const queue = createQueuer(
  *   (item) => console.log('Processing', item),
  *   { started: true, wait: 1000 },

package/dist/queuer/createQueuer.js

@@ -22,14 +22,24 @@ import { Queuer } from "@tanstack/pacer/queuer";
 *
 * ## 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.
+* The hook uses TanStack Store for reactive state management. You can subscribe to state changes
+* in two ways:
+*
+* **1. Using `queuer.Subscribe` component (Recommended for component tree subscriptions)**
+*
+* Use the `Subscribe` component to subscribe to state changes deep in your component tree without
+* needing to pass a selector to the hook. This is ideal when you want to subscribe to state
+* in child components.
+*
+* **2. Using the `selector` parameter (For hook-level subscriptions)**
+*
+* The `selector` parameter allows you to specify which state changes will trigger reactive updates
+* at the hook level, optimizing performance by preventing unnecessary updates 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.
+* 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.
 *
 * Available state properties:
 * - `executionCount`: Number of items that have been processed
@@ -52,14 +62,14 @@ import { Queuer } from "@tanstack/pacer/queuer";
 *   }
 * );
 *
-* // Opt-in to re-render when items or isRunning changes (optimized for UI updates)
+* // Opt-in to track 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)
+* // Opt-in to track execution metrics changes (optimized for tracking progress)
 * const queue = createQueuer(
 *   (item) => console.log('Processing', item),
 *   { started: true, wait: 1000 },
@@ -86,6 +96,10 @@ function createQueuer(fn, options = {}, selector = () => ({})) {
 		...useDefaultPacerOptions().queuer,
 		...options
 	});
+	queuer.Subscribe = function Subscribe(props) {
+		const selected = useStore(queuer.store, props.selector);
+		return typeof props.children === "function" ? props.children(selected) : props.children;
+	};
 	const state = useStore(queuer.store, selector);
 	return {
 		...queuer,

package/dist/queuer/createQueuer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createQueuer.js","names":[],"sources":["../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\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 = {}> extends Omit<\n  Queuer<TValue>,\n  'store'\n> {\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  options: QueuerOptions<TValue> = {},\n  selector: (state: QueuerState<TValue>) => TSelected = () => ({}) as TSelected,\n): SolidQueuer<TValue, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().queuer,\n    ...options,\n  } as QueuerOptions<TValue>\n\n  const queuer = new Queuer(fn, mergedOptions)\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuGA,SAAgB,aACd,IACA,UAAiC,EAAE,EACnC,kBAA6D,EAAE,GAC/B;CAMhC,MAAM,SAAS,IAAI,OAAO,IALJ;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ,CAE2C;CAE5C,MAAM,QAAQ,SAAS,OAAO,OAAO,SAAS;AAE9C,QAAO;EACL,GAAG;EACH;EACD"}
+{"version":3,"file":"createQueuer.js","names":[],"sources":["../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor, JSX } from 'solid-js'\nimport type { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer'\n\nexport interface SolidQueuer<TValue, TSelected = {}> extends Omit<\n  Queuer<TValue>,\n  'store'\n> {\n  /**\n   * A Solid component that allows you to subscribe to the queuer state.\n   *\n   * This is useful for tracking specific parts of the queuer state\n   * deep in your component tree without needing to pass a selector to the hook.\n   *\n   * @example\n   * <queuer.Subscribe selector={(state) => ({ size: state.size, isRunning: state.isRunning })}>\n   *   {(state) => (\n   *     <div>Queue: {state().size} items, {state().isRunning ? 'Processing' : 'Idle'}</div>\n   *   )}\n   * </queuer.Subscribe>\n   */\n  Subscribe: <TSelected>(props: {\n    selector: (state: QueuerState<TValue>) => TSelected\n    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element\n  }) => JSX.Element\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. You can subscribe to state changes\n * in two ways:\n *\n * **1. Using `queuer.Subscribe` component (Recommended for component tree subscriptions)**\n *\n * Use the `Subscribe` component to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n *\n * **2. Using the `selector` parameter (For hook-level subscriptions)**\n *\n * The `selector` parameter allows you to specify which state changes will trigger reactive updates\n * at the hook level, optimizing performance by preventing unnecessary updates when irrelevant\n * 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 or using the `Subscribe` component. This prevents unnecessary\n * updates and gives you full control over when your component tracks state changes.\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 track 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 track execution metrics changes (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  options: QueuerOptions<TValue> = {},\n  selector: (state: QueuerState<TValue>) => TSelected = () => ({}) as TSelected,\n): SolidQueuer<TValue, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().queuer,\n    ...options,\n  } as QueuerOptions<TValue>\n\n  const queuer = new Queuer(fn, mergedOptions) as unknown as SolidQueuer<\n    TValue,\n    TSelected\n  >\n\n  queuer.Subscribe = function Subscribe<TSelected>(props: {\n    selector: (state: QueuerState<TValue>) => TSelected\n    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element\n  }) {\n    const selected = useStore(queuer.store, props.selector)\n\n    return typeof props.children === 'function'\n      ? props.children(selected)\n      : props.children\n  }\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkIA,SAAgB,aACd,IACA,UAAiC,EAAE,EACnC,kBAA6D,EAAE,GAC/B;CAMhC,MAAM,SAAS,IAAI,OAAO,IALJ;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ,CAE2C;AAK5C,QAAO,YAAY,SAAS,UAAqB,OAG9C;EACD,MAAM,WAAW,SAAS,OAAO,OAAO,MAAM,SAAS;AAEvD,SAAO,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;CAGZ,MAAM,QAAQ,SAAS,OAAO,OAAO,SAAS;AAE9C,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/queuer/index.cjs

@@ -3,10 +3,10 @@ const require_createQueuedSignal = require('./createQueuedSignal.cjs');
 
 exports.createQueuedSignal = require_createQueuedSignal.createQueuedSignal;
 exports.createQueuer = require_createQueuer.createQueuer;
-var __tanstack_pacer_queuer = require("@tanstack/pacer/queuer");
-Object.keys(__tanstack_pacer_queuer).forEach(function (k) {
+var _tanstack_pacer_queuer = require("@tanstack/pacer/queuer");
+Object.keys(_tanstack_pacer_queuer).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
-    get: function () { return __tanstack_pacer_queuer[k]; }
+    get: function () { return _tanstack_pacer_queuer[k]; }
   });
 });

package/dist/rate-limiter/createRateLimiter.cjs

@@ -1,6 +1,6 @@
 const require_PacerProvider = require('../provider/PacerProvider.cjs');
-let __tanstack_solid_store = require("@tanstack/solid-store");
-let __tanstack_pacer_rate_limiter = require("@tanstack/pacer/rate-limiter");
+let _tanstack_solid_store = require("@tanstack/solid-store");
+let _tanstack_pacer_rate_limiter = require("@tanstack/pacer/rate-limiter");
 
 //#region src/rate-limiter/createRateLimiter.ts
 /**
@@ -26,14 +26,24 @@ let __tanstack_pacer_rate_limiter = require("@tanstack/pacer/rate-limiter");
 *
 * ## 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.
+* The hook uses TanStack Store for reactive state management. You can subscribe to state changes
+* in two ways:
+*
+* **1. Using `rateLimiter.Subscribe` component (Recommended for component tree subscriptions)**
+*
+* Use the `Subscribe` component to subscribe to state changes deep in your component tree without
+* needing to pass a selector to the hook. This is ideal when you want to subscribe to state
+* in child components.
+*
+* **2. Using the `selector` parameter (For hook-level subscriptions)**
+*
+* The `selector` parameter allows you to specify which state changes will trigger reactive updates
+* at the hook level, optimizing performance by preventing unnecessary updates 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.
+* 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.
 *
 * Available state properties:
 * - `executionCount`: Number of function executions that have been completed
@@ -49,41 +59,86 @@ let __tanstack_pacer_rate_limiter = require("@tanstack/pacer/rate-limiter");
 *   limit: 5,
 *   window: 60000,
 *   windowType: 'sliding',
-*   onReject: (rateLimiter) => {
-*     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);
-*   }
 * });
 *
-* // Opt-in to re-render when rate limit state changes (optimized for UI feedback)
+* // Subscribe to state changes deep in component tree using Subscribe component
+* <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>
+*   {(state) => (
+*     <div>Rejections: {state().rejectionCount}</div>
+*   )}
+* </rateLimiter.Subscribe>
+*
+* // Opt-in to track execution count changes at hook level (optimized for tracking successful executions)
 * const rateLimiter = createRateLimiter(
 *   apiCall,
-*   { limit: 5, window: 60000 },
-*   (state) => ({
-*     remainingInWindow: state.remainingInWindow,
-*     rejectionCount: state.rejectionCount
-*   })
+*   {
+*     limit: 5,
+*     window: 60000,
+*     windowType: 'sliding',
+*   },
+*   (state) => ({ executionCount: state.executionCount })
 * );
 *
-* // Opt-in to re-render when execution metrics change (optimized for tracking progress)
+* // Opt-in to track rejection count changes (optimized for tracking rate limit violations)
 * const rateLimiter = createRateLimiter(
 *   apiCall,
-*   { limit: 5, window: 60000 },
+*   {
+*     limit: 5,
+*     window: 60000,
+*     windowType: 'sliding',
+*   },
+*   (state) => ({ rejectionCount: state.rejectionCount })
+* );
+*
+* // Opt-in to track execution times changes (optimized for window calculations)
+* const rateLimiter = createRateLimiter(
+*   apiCall,
+*   {
+*     limit: 5,
+*     window: 60000,
+*     windowType: 'sliding',
+*   },
+*   (state) => ({ executionTimes: state.executionTimes })
+* );
+*
+* // Multiple state properties - track when any of these change
+* const rateLimiter = createRateLimiter(
+*   apiCall,
+*   {
+*     limit: 5,
+*     window: 60000,
+*     windowType: 'sliding',
+*   },
 *   (state) => ({
 *     executionCount: state.executionCount,
-*     nextWindowTime: state.nextWindowTime
+*     rejectionCount: state.rejectionCount
 *   })
 * );
 *
+* // Monitor rate limit status
+* const handleClick = () => {
+*   const remaining = rateLimiter.getRemainingInWindow();
+*   if (remaining > 0) {
+*     rateLimiter.maybeExecute(data);
+*   } else {
+*     showRateLimitWarning();
+*   }
+* };
+*
 * // Access the selected state (will be empty object {} unless selector provided)
-* const { remainingInWindow, rejectionCount } = rateLimiter.state();
+* const { executionCount, rejectionCount } = rateLimiter.state();
 * ```
 */
 function createRateLimiter(fn, options, selector = () => ({})) {
-	const rateLimiter = new __tanstack_pacer_rate_limiter.RateLimiter(fn, {
+	const rateLimiter = new _tanstack_pacer_rate_limiter.RateLimiter(fn, {
 		...require_PacerProvider.useDefaultPacerOptions().rateLimiter,
 		...options
 	});
-	const state = (0, __tanstack_solid_store.useStore)(rateLimiter.store, selector);
+	rateLimiter.Subscribe = function Subscribe(props) {
+		const selected = (0, _tanstack_solid_store.useStore)(rateLimiter.store, props.selector);
+		return typeof props.children === "function" ? props.children(selected) : props.children;
+	};
+	const state = (0, _tanstack_solid_store.useStore)(rateLimiter.store, selector);
 	return {
 		...rateLimiter,
 		state

package/dist/rate-limiter/createRateLimiter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createRateLimiter.cjs","names":["RateLimiter","useDefaultPacerOptions"],"sources":["../../src/rate-limiter/createRateLimiter.ts"],"sourcesContent":["import { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\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<\n  TFn extends AnyFunction,\n  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  options: RateLimiterOptions<TFn>,\n  selector: (state: RateLimiterState) => TSelected = () => ({}) as TSelected,\n): SolidRateLimiter<TFn, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().rateLimiter,\n    ...options,\n  } as RateLimiterOptions<TFn>\n\n  const rateLimiter = new RateLimiter<TFn>(fn, mergedOptions)\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,SAAgB,kBACd,IACA,SACA,kBAA0D,EAAE,GAC1B;CAMlC,MAAM,cAAc,IAAIA,0CAAiB,IALnB;EACpB,GAAGC,8CAAwB,CAAC;EAC5B,GAAG;EACJ,CAE0D;CAE3D,MAAM,6CAAiB,YAAY,OAAO,SAAS;AAEnD,QAAO;EACL,GAAG;EACH;EACD"}
+{"version":3,"file":"createRateLimiter.cjs","names":["RateLimiter","useDefaultPacerOptions"],"sources":["../../src/rate-limiter/createRateLimiter.ts"],"sourcesContent":["import { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor, JSX } 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 = {},\n> extends Omit<RateLimiter<TFn>, 'store'> {\n  /**\n   * A Solid component that allows you to subscribe to the rate limiter state.\n   *\n   * This is useful for tracking specific parts of the rate limiter state\n   * deep in your component tree without needing to pass a selector to the hook.\n   *\n   * @example\n   * <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>\n   *   {(state) => (\n   *     <div>Rejections: {state().rejectionCount}</div>\n   *   )}\n   * </rateLimiter.Subscribe>\n   */\n  Subscribe: <TSelected>(props: {\n    selector: (state: RateLimiterState) => TSelected\n    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element\n  }) => JSX.Element\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. You can subscribe to state changes\n * in two ways:\n *\n * **1. Using `rateLimiter.Subscribe` component (Recommended for component tree subscriptions)**\n *\n * Use the `Subscribe` component to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n *\n * **2. Using the `selector` parameter (For hook-level subscriptions)**\n *\n * The `selector` parameter allows you to specify which state changes will trigger reactive updates\n * at the hook level, optimizing performance by preventing unnecessary updates when irrelevant\n * 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 or using the `Subscribe` component. This prevents unnecessary\n * updates and gives you full control over when your component tracks state changes.\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 * });\n *\n * // Subscribe to state changes deep in component tree using Subscribe component\n * <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>\n *   {(state) => (\n *     <div>Rejections: {state().rejectionCount}</div>\n *   )}\n * </rateLimiter.Subscribe>\n *\n * // Opt-in to track execution count changes at hook level (optimized for tracking successful executions)\n * const rateLimiter = createRateLimiter(\n *   apiCall,\n *   {\n *     limit: 5,\n *     window: 60000,\n *     windowType: 'sliding',\n *   },\n *   (state) => ({ executionCount: state.executionCount })\n * );\n *\n * // Opt-in to track rejection count changes (optimized for tracking rate limit violations)\n * const rateLimiter = createRateLimiter(\n *   apiCall,\n *   {\n *     limit: 5,\n *     window: 60000,\n *     windowType: 'sliding',\n *   },\n *   (state) => ({ rejectionCount: state.rejectionCount })\n * );\n *\n * // Opt-in to track execution times changes (optimized for window calculations)\n * const rateLimiter = createRateLimiter(\n *   apiCall,\n *   {\n *     limit: 5,\n *     window: 60000,\n *     windowType: 'sliding',\n *   },\n *   (state) => ({ executionTimes: state.executionTimes })\n * );\n *\n * // Multiple state properties - track when any of these change\n * const rateLimiter = createRateLimiter(\n *   apiCall,\n *   {\n *     limit: 5,\n *     window: 60000,\n *     windowType: 'sliding',\n *   },\n *   (state) => ({\n *     executionCount: state.executionCount,\n *     rejectionCount: state.rejectionCount\n *   })\n * );\n *\n * // Monitor rate limit status\n * const handleClick = () => {\n *   const remaining = rateLimiter.getRemainingInWindow();\n *   if (remaining > 0) {\n *     rateLimiter.maybeExecute(data);\n *   } else {\n *     showRateLimitWarning();\n *   }\n * };\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { executionCount, rejectionCount } = rateLimiter.state();\n * ```\n */\nexport function createRateLimiter<TFn extends AnyFunction, TSelected = {}>(\n  fn: TFn,\n  options: RateLimiterOptions<TFn>,\n  selector: (state: RateLimiterState) => TSelected = () => ({}) as TSelected,\n): SolidRateLimiter<TFn, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().rateLimiter,\n    ...options,\n  } as RateLimiterOptions<TFn>\n\n  const rateLimiter = new RateLimiter<TFn>(\n    fn,\n    mergedOptions,\n  ) as unknown as SolidRateLimiter<TFn, TSelected>\n\n  rateLimiter.Subscribe = function Subscribe<TSelected>(props: {\n    selector: (state: RateLimiterState) => TSelected\n    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element\n  }) {\n    const selected = useStore(rateLimiter.store, props.selector)\n\n    return typeof props.children === 'function'\n      ? props.children(selected)\n      : props.children\n  }\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4KA,SAAgB,kBACd,IACA,SACA,kBAA0D,EAAE,GAC1B;CAMlC,MAAM,cAAc,IAAIA,yCACtB,IANoB;EACpB,GAAGC,8CAAwB,CAAC;EAC5B,GAAG;EACJ,CAKA;AAED,aAAY,YAAY,SAAS,UAAqB,OAGnD;EACD,MAAM,+CAAoB,YAAY,OAAO,MAAM,SAAS;AAE5D,SAAO,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;CAGZ,MAAM,4CAAiB,YAAY,OAAO,SAAS;AAEnD,QAAO;EACL,GAAG;EACH;EACD"}

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

@@ -1,10 +1,27 @@
 import { Store } from "@tanstack/solid-store";
-import { Accessor } from "solid-js";
+import { Accessor, JSX } from "solid-js";
 import { AnyFunction } from "@tanstack/pacer/types";
 import { RateLimiter, RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
 
 //#region src/rate-limiter/createRateLimiter.d.ts
 interface SolidRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit<RateLimiter<TFn>, 'store'> {
+  /**
+   * A Solid component that allows you to subscribe to the rate limiter state.
+   *
+   * This is useful for tracking specific parts of the rate limiter state
+   * deep in your component tree without needing to pass a selector to the hook.
+   *
+   * @example
+   * <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>
+   *   {(state) => (
+   *     <div>Rejections: {state().rejectionCount}</div>
+   *   )}
+   * </rateLimiter.Subscribe>
+   */
+  Subscribe: <TSelected>(props: {
+    selector: (state: RateLimiterState) => TSelected;
+    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element;
+  }) => JSX.Element;
   /**
    * Reactive state that will be updated when the rate limiter state changes
    *
@@ -41,14 +58,24 @@ interface SolidRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit
  *
  * ## 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.
+ * The hook uses TanStack Store for reactive state management. You can subscribe to state changes
+ * in two ways:
+ *
+ * **1. Using `rateLimiter.Subscribe` component (Recommended for component tree subscriptions)**
+ *
+ * Use the `Subscribe` component to subscribe to state changes deep in your component tree without
+ * needing to pass a selector to the hook. This is ideal when you want to subscribe to state
+ * in child components.
+ *
+ * **2. Using the `selector` parameter (For hook-level subscriptions)**
+ *
+ * The `selector` parameter allows you to specify which state changes will trigger reactive updates
+ * at the hook level, optimizing performance by preventing unnecessary updates 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.
+ * 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.
  *
  * Available state properties:
  * - `executionCount`: Number of function executions that have been completed
@@ -64,33 +91,74 @@ interface SolidRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit
  *   limit: 5,
  *   window: 60000,
  *   windowType: 'sliding',
- *   onReject: (rateLimiter) => {
- *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);
- *   }
  * });
  *
- * // Opt-in to re-render when rate limit state changes (optimized for UI feedback)
+ * // Subscribe to state changes deep in component tree using Subscribe component
+ * <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>
+ *   {(state) => (
+ *     <div>Rejections: {state().rejectionCount}</div>
+ *   )}
+ * </rateLimiter.Subscribe>
+ *
+ * // Opt-in to track execution count changes at hook level (optimized for tracking successful executions)
  * const rateLimiter = createRateLimiter(
  *   apiCall,
- *   { limit: 5, window: 60000 },
- *   (state) => ({
- *     remainingInWindow: state.remainingInWindow,
- *     rejectionCount: state.rejectionCount
- *   })
+ *   {
+ *     limit: 5,
+ *     window: 60000,
+ *     windowType: 'sliding',
+ *   },
+ *   (state) => ({ executionCount: state.executionCount })
+ * );
+ *
+ * // Opt-in to track rejection count changes (optimized for tracking rate limit violations)
+ * const rateLimiter = createRateLimiter(
+ *   apiCall,
+ *   {
+ *     limit: 5,
+ *     window: 60000,
+ *     windowType: 'sliding',
+ *   },
+ *   (state) => ({ rejectionCount: state.rejectionCount })
+ * );
+ *
+ * // Opt-in to track execution times changes (optimized for window calculations)
+ * const rateLimiter = createRateLimiter(
+ *   apiCall,
+ *   {
+ *     limit: 5,
+ *     window: 60000,
+ *     windowType: 'sliding',
+ *   },
+ *   (state) => ({ executionTimes: state.executionTimes })
  * );
  *
- * // Opt-in to re-render when execution metrics change (optimized for tracking progress)
+ * // Multiple state properties - track when any of these change
  * const rateLimiter = createRateLimiter(
  *   apiCall,
- *   { limit: 5, window: 60000 },
+ *   {
+ *     limit: 5,
+ *     window: 60000,
+ *     windowType: 'sliding',
+ *   },
  *   (state) => ({
  *     executionCount: state.executionCount,
- *     nextWindowTime: state.nextWindowTime
+ *     rejectionCount: state.rejectionCount
  *   })
  * );
  *
+ * // Monitor rate limit status
+ * const handleClick = () => {
+ *   const remaining = rateLimiter.getRemainingInWindow();
+ *   if (remaining > 0) {
+ *     rateLimiter.maybeExecute(data);
+ *   } else {
+ *     showRateLimitWarning();
+ *   }
+ * };
+ *
  * // Access the selected state (will be empty object {} unless selector provided)
- * const { remainingInWindow, rejectionCount } = rateLimiter.state();
+ * const { executionCount, rejectionCount } = rateLimiter.state();
  * ```
  */
 declare function createRateLimiter<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: RateLimiterOptions<TFn>, selector?: (state: RateLimiterState) => TSelected): SolidRateLimiter<TFn, TSelected>;