@tanstack/solid-pacer 0.9.1 → 0.11.0

package/dist/cjs/async-throttler/createAsyncThrottler.d.cts

@@ -1,13 +1,20 @@
 import { AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState } from '@tanstack/pacer/async-throttler';
+import { Store } from '@tanstack/solid-store';
 import { Accessor } from 'solid-js';
 import { AnyAsyncFunction } from '@tanstack/pacer/types';
-export interface SolidAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = AsyncThrottlerState<TFn>> extends Omit<AsyncThrottler<TFn>, 'store'> {
+export interface SolidAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncThrottler<TFn>, 'store'> {
     /**
-     * Reactive state that will be updated and re-rendered when the throttler state changes
+     * Reactive state that will be updated when the throttler state changes
      *
      * Use this instead of `throttler.store.state`
      */
     readonly state: Accessor<Readonly<TSelected>>;
+    /**
+     * @deprecated Use `throttler.state` instead of `throttler.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<AsyncThrottlerState<TFn>>>;
 }
 /**
  * A low-level Solid hook that creates an `AsyncThrottler` instance to limit how often an async function can execute.
@@ -30,9 +37,34 @@ export interface SolidAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = A
  * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown
  * - The error state can be checked using the underlying AsyncThrottler instance
  *
+ * ## 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:
+ * - `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
+ * - `hasError`: Whether the last execution resulted in an error
+ * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
+ * - `isExecuting`: Whether an async function execution is currently in progress
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `lastError`: The error from the most recent failed execution (if any)
+ * - `lastExecutionTime`: Timestamp of the last execution
+ * - `lastResult`: The result from the most recent successful execution
+ * - `nextExecutionTime`: Timestamp of the next allowed execution
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing')
+ *
  * @example
  * ```tsx
- * // Basic API call throttling
+ * // Default behavior - no reactive state subscriptions
  * const { maybeExecute } = createAsyncThrottler(
  *   async (id: string) => {
  *     const data = await api.fetchData(id);
@@ -41,12 +73,21 @@ export interface SolidAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = A
  *   { wait: 1000 }
  * );
  *
- * // With state management
- * const [data, setData] = createSignal(null);
- * const { maybeExecute } = createAsyncThrottler(
+ * // Opt-in to re-render when isPending or isExecuting changes (optimized for loading states)
+ * const throttler = createAsyncThrottler(
  *   async (query) => {
  *     const result = await searchAPI(query);
- *     setData(result);
+ *     return result;
+ *   },
+ *   { wait: 2000 },
+ *   (state) => ({ isPending: state.isPending, isExecuting: state.isExecuting })
+ * );
+ *
+ * // Opt-in to re-render when error state changes (optimized for error handling)
+ * const throttler = createAsyncThrottler(
+ *   async (query) => {
+ *     const result = await searchAPI(query);
+ *     return result;
  *   },
  *   {
  *     wait: 2000,
@@ -55,8 +96,12 @@ export interface SolidAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = A
  *     onError: (error) => {
  *       console.error('API call failed:', error);
  *     }
- *   }
+ *   },
+ *   (state) => ({ hasError: state.hasError, lastError: state.lastError })
  * );
+ *
+ * // Access the selected state (will be empty object {} unless selector provided)
+ * const { isPending, isExecuting } = throttler.state();
  * ```
  */
-export declare function createAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = AsyncThrottlerState<TFn>>(fn: TFn, initialOptions: AsyncThrottlerOptions<TFn>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): SolidAsyncThrottler<TFn, TSelected>;
+export declare function createAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, initialOptions: AsyncThrottlerOptions<TFn>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): SolidAsyncThrottler<TFn, TSelected>;

package/dist/cjs/batcher/createBatcher.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const batcher = require("@tanstack/pacer/batcher");
 const solidStore = require("@tanstack/solid-store");
-function createBatcher(fn, initialOptions = {}, selector) {
+function createBatcher(fn, initialOptions = {}, selector = () => ({})) {
   const batcher$1 = new batcher.Batcher(fn, initialOptions);
   const state = solidStore.useStore(batcher$1.store, selector);
   return {

package/dist/cjs/batcher/createBatcher.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createBatcher.cjs","sources":["../../../src/batcher/createBatcher.ts"],"sourcesContent":["import { Batcher } from '@tanstack/pacer/batcher'\nimport { useStore } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { BatcherOptions, BatcherState } from '@tanstack/pacer/batcher'\n\nexport interface SolidBatcher<TValue, TSelected = BatcherState<TValue>>\n  extends Omit<Batcher<TValue>, 'store'> {\n  /**\n   * Reactive state that will be updated when the batcher state changes\n   *\n   * Use this instead of `batcher.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n}\n\n/**\n * Creates a Solid-compatible Batcher instance for managing batches of items, exposing Solid signals for all stateful properties.\n *\n * Features:\n * - Batch processing of items using the provided `fn` function\n * - Configurable batch size and wait time\n * - Custom batch processing logic via getShouldExecute\n * - Event callbacks for monitoring batch operations\n * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * The batcher collects items and processes them in batches based on:\n * - Maximum batch size\n * - Time-based batching (process after X milliseconds)\n * - Custom batch processing logic via getShouldExecute\n *\n * Example usage:\n * ```tsx\n * const batcher = createBatcher(\n *   (items) => {\n *     // Process batch of items\n *     console.log('Processing batch:', items);\n *   },\n *   {\n *     maxSize: 5,\n *     wait: 2000,\n *     onExecute: (batcher) => console.log('Batch executed'),\n *     getShouldExecute: (items) => items.length >= 3\n *   }\n * );\n *\n * // Add items to batch\n * batcher.addItem('task1');\n * batcher.addItem('task2');\n *\n * // Control the batcher\n * batcher.stop();  // Pause processing\n * batcher.start(); // Resume processing\n *\n * // Access batcher state via signals\n * console.log('Items:', batcher.allItems());\n * console.log('Size:', batcher.size());\n * console.log('Is empty:', batcher.isEmpty());\n * console.log('Is running:', batcher.isRunning());\n * console.log('Batch count:', batcher.executionCount());\n * console.log('Item count:', batcher.totalItemsProcessed());\n * ```\n */\nexport function createBatcher<TValue, TSelected = BatcherState<TValue>>(\n  fn: (items: Array<TValue>) => void,\n  initialOptions: BatcherOptions<TValue> = {},\n  selector?: (state: BatcherState<TValue>) => TSelected,\n): SolidBatcher<TValue, TSelected> {\n  const batcher = new Batcher(fn, initialOptions)\n\n  const state = useStore(batcher.store, selector)\n  return {\n    ...batcher,\n    state,\n  } as SolidBatcher<TValue, TSelected>\n}\n"],"names":["batcher","Batcher","useStore"],"mappings":";;;;AA8DO,SAAS,cACd,IACA,iBAAyC,CAAA,GACzC,UACiC;AACjC,QAAMA,YAAU,IAAIC,gBAAQ,IAAI,cAAc;AAE9C,QAAM,QAAQC,WAAAA,SAASF,UAAQ,OAAO,QAAQ;AAC9C,SAAO;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,EAAA;AAEJ;;"}
+{"version":3,"file":"createBatcher.cjs","sources":["../../../src/batcher/createBatcher.ts"],"sourcesContent":["import { Batcher } from '@tanstack/pacer/batcher'\nimport { useStore } from '@tanstack/solid-store'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { BatcherOptions, BatcherState } from '@tanstack/pacer/batcher'\n\nexport interface SolidBatcher<TValue, TSelected = {}>\n  extends Omit<Batcher<TValue>, 'store'> {\n  /**\n   * Reactive state that will be updated when the batcher state changes\n   *\n   * Use this instead of `batcher.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `batcher.state` instead of `batcher.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<BatcherState<TValue>>>\n}\n\n/**\n * Creates a Solid-compatible Batcher instance for managing batches of items, exposing Solid signals for all stateful properties.\n *\n * Features:\n * - Batch processing of items using the provided `fn` function\n * - Configurable batch size and wait time\n * - Custom batch processing logic via getShouldExecute\n * - Event callbacks for monitoring batch operations\n * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * The batcher collects items and processes them in batches based on:\n * - Maximum batch size\n * - Time-based batching (process after X milliseconds)\n * - Custom batch processing logic via getShouldExecute\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 batch executions that have been completed\n * - `isRunning`: Whether the batcher is currently running (not stopped)\n * - `items`: Array of items currently queued for batching\n * - `totalItemsProcessed`: Total number of individual items that have been processed across all batches\n *\n * Example usage:\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const batcher = createBatcher(\n *   (items) => {\n *     // Process batch of items\n *     console.log('Processing batch:', items);\n *   },\n *   {\n *     maxSize: 5,\n *     wait: 2000,\n *     onExecute: (batcher) => console.log('Batch executed'),\n *     getShouldExecute: (items) => items.length >= 3\n *   }\n * );\n *\n * // Opt-in to re-render when items or isRunning changes (optimized for UI updates)\n * const batcher = createBatcher(\n *   (items) => console.log('Processing batch:', items),\n *   { maxSize: 5, wait: 2000 },\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 batcher = createBatcher(\n *   (items) => console.log('Processing batch:', items),\n *   { maxSize: 5, wait: 2000 },\n *   (state) => ({\n *     executionCount: state.executionCount,\n *     totalItemsProcessed: state.totalItemsProcessed\n *   })\n * );\n *\n * // Add items to batch\n * batcher.addItem('task1');\n * batcher.addItem('task2');\n *\n * // Control the batcher\n * batcher.stop();  // Pause processing\n * batcher.start(); // Resume processing\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { items, isRunning } = batcher.state();\n * ```\n */\nexport function createBatcher<TValue, TSelected = {}>(\n  fn: (items: Array<TValue>) => void,\n  initialOptions: BatcherOptions<TValue> = {},\n  selector: (state: BatcherState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): SolidBatcher<TValue, TSelected> {\n  const batcher = new Batcher(fn, initialOptions)\n\n  const state = useStore(batcher.store, selector)\n  return {\n    ...batcher,\n    state,\n  } as SolidBatcher<TValue, TSelected>\n}\n"],"names":["batcher","Batcher","useStore"],"mappings":";;;;AAmGO,SAAS,cACd,IACA,iBAAyC,CAAA,GACzC,WAAuD,OACpD,CAAA,IAC8B;AACjC,QAAMA,YAAU,IAAIC,gBAAQ,IAAI,cAAc;AAE9C,QAAM,QAAQC,WAAAA,SAASF,UAAQ,OAAO,QAAQ;AAC9C,SAAO;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,EAAA;AAEJ;;"}

package/dist/cjs/batcher/createBatcher.d.cts

@@ -1,12 +1,19 @@
 import { Batcher, BatcherOptions, BatcherState } from '@tanstack/pacer/batcher';
+import { Store } from '@tanstack/solid-store';
 import { Accessor } from 'solid-js';
-export interface SolidBatcher<TValue, TSelected = BatcherState<TValue>> extends Omit<Batcher<TValue>, 'store'> {
+export interface SolidBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'store'> {
     /**
      * Reactive state that will be updated when the batcher state changes
      *
      * Use this instead of `batcher.store.state`
      */
     readonly state: Accessor<Readonly<TSelected>>;
+    /**
+     * @deprecated Use `batcher.state` instead of `batcher.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<BatcherState<TValue>>>;
 }
 /**
  * Creates a Solid-compatible Batcher instance for managing batches of items, exposing Solid signals for all stateful properties.
@@ -23,8 +30,26 @@ export interface SolidBatcher<TValue, TSelected = BatcherState<TValue>> extends
  * - Time-based batching (process after X milliseconds)
  * - Custom batch processing logic via getShouldExecute
  *
+ * ## 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 batch executions that have been completed
+ * - `isRunning`: Whether the batcher is currently running (not stopped)
+ * - `items`: Array of items currently queued for batching
+ * - `totalItemsProcessed`: Total number of individual items that have been processed across all batches
+ *
  * Example usage:
  * ```tsx
+ * // Default behavior - no reactive state subscriptions
  * const batcher = createBatcher(
  *   (items) => {
  *     // Process batch of items
@@ -38,6 +63,23 @@ export interface SolidBatcher<TValue, TSelected = BatcherState<TValue>> extends
  *   }
  * );
  *
+ * // Opt-in to re-render when items or isRunning changes (optimized for UI updates)
+ * const batcher = createBatcher(
+ *   (items) => console.log('Processing batch:', items),
+ *   { maxSize: 5, wait: 2000 },
+ *   (state) => ({ items: state.items, isRunning: state.isRunning })
+ * );
+ *
+ * // Opt-in to re-render when execution metrics change (optimized for tracking progress)
+ * const batcher = createBatcher(
+ *   (items) => console.log('Processing batch:', items),
+ *   { maxSize: 5, wait: 2000 },
+ *   (state) => ({
+ *     executionCount: state.executionCount,
+ *     totalItemsProcessed: state.totalItemsProcessed
+ *   })
+ * );
+ *
  * // Add items to batch
  * batcher.addItem('task1');
  * batcher.addItem('task2');
@@ -46,13 +88,8 @@ export interface SolidBatcher<TValue, TSelected = BatcherState<TValue>> extends
  * batcher.stop();  // Pause processing
  * batcher.start(); // Resume processing
  *
- * // Access batcher state via signals
- * console.log('Items:', batcher.allItems());
- * console.log('Size:', batcher.size());
- * console.log('Is empty:', batcher.isEmpty());
- * console.log('Is running:', batcher.isRunning());
- * console.log('Batch count:', batcher.executionCount());
- * console.log('Item count:', batcher.totalItemsProcessed());
+ * // Access the selected state (will be empty object {} unless selector provided)
+ * const { items, isRunning } = batcher.state();
  * ```
  */
-export declare function createBatcher<TValue, TSelected = BatcherState<TValue>>(fn: (items: Array<TValue>) => void, initialOptions?: BatcherOptions<TValue>, selector?: (state: BatcherState<TValue>) => TSelected): SolidBatcher<TValue, TSelected>;
+export declare function createBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => void, initialOptions?: BatcherOptions<TValue>, selector?: (state: BatcherState<TValue>) => TSelected): SolidBatcher<TValue, TSelected>;

package/dist/cjs/debouncer/createDebouncedSignal.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createDebouncedSignal.cjs","sources":["../../../src/debouncer/createDebouncedSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createDebouncer } from './createDebouncer'\nimport type { SolidDebouncer } from './createDebouncer'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\n/**\n * A Solid hook that creates a debounced state value, combining Solid's createSignal with debouncing functionality.\n * This hook provides both the current debounced value and methods to update it.\n *\n * The state value is only updated after the specified wait time has elapsed since the last update attempt.\n * If another update is attempted before the wait time expires, the timer resets and starts waiting again.\n * This is useful for handling frequent state updates that should be throttled, like search input values\n * or window resize dimensions.\n *\n * The hook returns a tuple containing:\n * - The current debounced value accessor\n * - A function to update the debounced value\n * - The debouncer instance with additional control methods and state signals\n *\n * @example\n * ```tsx\n * // Debounced search input\n * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal('', {\n *   wait: 500 // Wait 500ms after last keystroke\n * });\n *\n * // Update value - will be debounced\n * const handleChange = (e) => {\n *   setSearchTerm(e.target.value);\n * };\n *\n * // Access debouncer state via signals\n * console.log('Executions:', debouncer.executionCount());\n * console.log('Is pending:', debouncer.isPending());\n *\n * // In onExecute callback, use get* methods\n * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal('', {\n *   wait: 500,\n *   onExecute: (debouncer) => {\n *     console.log('Total executions:', debouncer.getExecutionCount());\n *   }\n * });\n * ```\n */\nexport function createDebouncedSignal<\n  TValue,\n  TSelected = DebouncerState<Setter<TValue>>,\n>(\n  value: TValue,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): [\n  Accessor<TValue>,\n  Setter<TValue>,\n  SolidDebouncer<Setter<TValue>, TSelected>,\n] {\n  const [debouncedValue, setDebouncedValue] = createSignal<TValue>(value)\n\n  const debouncer = createDebouncer(setDebouncedValue, initialOptions, selector)\n\n  return [debouncedValue, debouncer.maybeExecute as Setter<TValue>, debouncer]\n}\n"],"names":["createSignal","createDebouncer"],"mappings":";;;;AAgDO,SAAS,sBAId,OACA,gBACA,UAKA;AACA,QAAM,CAAC,gBAAgB,iBAAiB,IAAIA,QAAAA,aAAqB,KAAK;AAEtE,QAAM,YAAYC,gBAAAA,gBAAgB,mBAAmB,gBAAgB,QAAQ;AAE7E,SAAO,CAAC,gBAAgB,UAAU,cAAgC,SAAS;AAC7E;;"}
+{"version":3,"file":"createDebouncedSignal.cjs","sources":["../../../src/debouncer/createDebouncedSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createDebouncer } from './createDebouncer'\nimport type { SolidDebouncer } from './createDebouncer'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\n/**\n * A Solid hook that creates a debounced state value, combining Solid's createSignal with debouncing functionality.\n * This hook provides both the current debounced value and methods to update it.\n *\n * The state value is only updated after the specified wait time has elapsed since the last update attempt.\n * If another update is attempted before the wait time expires, the timer resets and starts waiting again.\n * This is useful for handling frequent state updates that should be throttled, like search input values\n * or window resize dimensions.\n *\n * The hook returns a tuple containing:\n * - The current debounced value accessor\n * - A function to update the debounced value\n * - The debouncer instance with additional control methods and state signals\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management via the underlying debouncer instance.\n * The `selector` parameter allows you to specify which debouncer 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 debouncer state properties:\n * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal('', {\n *   wait: 500 // Wait 500ms after last keystroke\n * });\n *\n * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)\n * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal(\n *   '',\n *   { wait: 500 },\n *   (state) => ({ isPending: state.isPending })\n * );\n *\n * // Opt-in to reactive updates when execution count changes (optimized for tracking executions)\n * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal(\n *   '',\n *   { wait: 500 },\n *   (state) => ({ executionCount: state.executionCount })\n * );\n *\n * // Update value - will be debounced\n * const handleChange = (e) => {\n *   setSearchTerm(e.target.value);\n * };\n *\n * // Access debouncer state via signals\n * console.log('Executions:', debouncer.state().executionCount);\n * console.log('Is pending:', debouncer.state().isPending);\n *\n * // In onExecute callback, use get* methods\n * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal('', {\n *   wait: 500,\n *   onExecute: (debouncer) => {\n *     console.log('Total executions:', debouncer.getExecutionCount());\n *   }\n * });\n * ```\n */\nexport function createDebouncedSignal<TValue, TSelected = {}>(\n  value: TValue,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): [\n  Accessor<TValue>,\n  Setter<TValue>,\n  SolidDebouncer<Setter<TValue>, TSelected>,\n] {\n  const [debouncedValue, setDebouncedValue] = createSignal<TValue>(value)\n\n  const debouncer = createDebouncer(setDebouncedValue, initialOptions, selector)\n\n  return [debouncedValue, debouncer.maybeExecute as Setter<TValue>, debouncer]\n}\n"],"names":["createSignal","createDebouncer"],"mappings":";;;;AAgFO,SAAS,sBACd,OACA,gBACA,UAKA;AACA,QAAM,CAAC,gBAAgB,iBAAiB,IAAIA,QAAAA,aAAqB,KAAK;AAEtE,QAAM,YAAYC,gBAAAA,gBAAgB,mBAAmB,gBAAgB,QAAQ;AAE7E,SAAO,CAAC,gBAAgB,UAAU,cAAgC,SAAS;AAC7E;;"}

package/dist/cjs/debouncer/createDebouncedSignal.d.cts

@@ -15,21 +15,53 @@ import { DebouncerOptions, DebouncerState } from '@tanstack/pacer/debouncer';
  * - A function to update the debounced value
  * - The debouncer instance with additional control methods and state signals
  *
+ * ## State Management and Selector
+ *
+ * The hook uses TanStack Store for reactive state management via the underlying debouncer instance.
+ * The `selector` parameter allows you to specify which debouncer 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 debouncer state properties:
+ * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+ * - `executionCount`: Number of function executions that have been completed
+ * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+ *
  * @example
  * ```tsx
- * // Debounced search input
+ * // Default behavior - no reactive state subscriptions
  * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal('', {
  *   wait: 500 // Wait 500ms after last keystroke
  * });
  *
+ * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)
+ * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal(
+ *   '',
+ *   { wait: 500 },
+ *   (state) => ({ isPending: state.isPending })
+ * );
+ *
+ * // Opt-in to reactive updates when execution count changes (optimized for tracking executions)
+ * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal(
+ *   '',
+ *   { wait: 500 },
+ *   (state) => ({ executionCount: state.executionCount })
+ * );
+ *
  * // Update value - will be debounced
  * const handleChange = (e) => {
  *   setSearchTerm(e.target.value);
  * };
  *
  * // Access debouncer state via signals
- * console.log('Executions:', debouncer.executionCount());
- * console.log('Is pending:', debouncer.isPending());
+ * console.log('Executions:', debouncer.state().executionCount);
+ * console.log('Is pending:', debouncer.state().isPending);
  *
  * // In onExecute callback, use get* methods
  * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal('', {
@@ -40,7 +72,7 @@ import { DebouncerOptions, DebouncerState } from '@tanstack/pacer/debouncer';
  * });
  * ```
  */
-export declare function createDebouncedSignal<TValue, TSelected = DebouncerState<Setter<TValue>>>(value: TValue, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): [
+export declare function createDebouncedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): [
     Accessor<TValue>,
     Setter<TValue>,
     SolidDebouncer<Setter<TValue>, TSelected>

package/dist/cjs/debouncer/createDebouncedValue.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createDebouncedValue.cjs","sources":["../../../src/debouncer/createDebouncedValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createDebouncedSignal } from './createDebouncedSignal'\nimport type { SolidDebouncer } from './createDebouncer'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\n/**\n * A Solid hook that creates a debounced value that updates only after a specified delay.\n * Unlike createDebouncedSignal, this hook automatically tracks changes to the input value\n * and updates the debounced value accordingly.\n *\n * The debounced value will only update after the specified wait time has elapsed since\n * the last change to the input value. If the input value changes again before the wait\n * time expires, the timer resets and starts waiting again.\n *\n * This is useful for deriving debounced values from props or state that change frequently,\n * like search queries or form inputs, where you want to limit how often downstream effects\n * or calculations occur.\n *\n * The hook returns a tuple containing:\n * - An Accessor that provides the current debounced value\n * - The debouncer instance with control methods\n *\n * @example\n * ```tsx\n * // Debounce a search query\n * const [searchQuery, setSearchQuery] = createSignal('');\n * const [debouncedQuery, debouncer] = createDebouncedValue(searchQuery, {\n *   wait: 500 // Wait 500ms after last change\n * });\n *\n * // debouncedQuery will update 500ms after searchQuery stops changing\n * createEffect(() => {\n *   fetchSearchResults(debouncedQuery());\n * });\n *\n * // Control the debouncer\n * debouncer.cancel(); // Cancel any pending updates\n * ```\n */\nexport function createDebouncedValue<\n  TValue,\n  TSelected = DebouncerState<Setter<TValue>>,\n>(\n  value: Accessor<TValue>,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, TSelected>] {\n  const [debouncedValue, setDebouncedValue, debouncer] = createDebouncedSignal(\n    value(),\n    initialOptions,\n    selector,\n  )\n\n  createEffect(() => {\n    setDebouncedValue(value() as any)\n  })\n\n  return [debouncedValue, debouncer]\n}\n"],"names":["createDebouncedSignal","createEffect"],"mappings":";;;;AA2CO,SAAS,qBAId,OACA,gBACA,UAC+D;AAC/D,QAAM,CAAC,gBAAgB,mBAAmB,SAAS,IAAIA,sBAAAA;AAAAA,IACrD,MAAA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAGFC,UAAAA,aAAa,MAAM;AACjB,sBAAkB,OAAc;AAAA,EAAA,CACjC;AAED,SAAO,CAAC,gBAAgB,SAAS;AACnC;;"}
+{"version":3,"file":"createDebouncedValue.cjs","sources":["../../../src/debouncer/createDebouncedValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createDebouncedSignal } from './createDebouncedSignal'\nimport type { SolidDebouncer } from './createDebouncer'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\n/**\n * A Solid hook that creates a debounced value that updates only after a specified delay.\n * Unlike createDebouncedSignal, this hook automatically tracks changes to the input value\n * and updates the debounced value accordingly.\n *\n * The debounced value will only update after the specified wait time has elapsed since\n * the last change to the input value. If the input value changes again before the wait\n * time expires, the timer resets and starts waiting again.\n *\n * This is useful for deriving debounced values from props or state that change frequently,\n * like search queries or form inputs, where you want to limit how often downstream effects\n * or calculations occur.\n *\n * The hook returns a tuple containing:\n * - An Accessor that provides the current debounced value\n * - The debouncer instance with control methods\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management via the underlying debouncer instance.\n * The `selector` parameter allows you to specify which debouncer 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 debouncer state properties:\n * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [searchQuery, setSearchQuery] = createSignal('');\n * const [debouncedQuery, debouncer] = createDebouncedValue(searchQuery, {\n *   wait: 500 // Wait 500ms after last change\n * });\n *\n * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)\n * const [debouncedQuery, debouncer] = createDebouncedValue(\n *   searchQuery,\n *   { wait: 500 },\n *   (state) => ({ isPending: state.isPending })\n * );\n *\n * // debouncedQuery will update 500ms after searchQuery stops changing\n * createEffect(() => {\n *   fetchSearchResults(debouncedQuery());\n * });\n *\n * // Access debouncer state via signals\n * console.log('Is pending:', debouncer.state().isPending);\n *\n * // Control the debouncer\n * debouncer.cancel(); // Cancel any pending updates\n * ```\n */\nexport function createDebouncedValue<TValue, TSelected = {}>(\n  value: Accessor<TValue>,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, TSelected>] {\n  const [debouncedValue, setDebouncedValue, debouncer] = createDebouncedSignal(\n    value(),\n    initialOptions,\n    selector,\n  )\n\n  createEffect(() => {\n    setDebouncedValue(value() as any)\n  })\n\n  return [debouncedValue, debouncer]\n}\n"],"names":["createDebouncedSignal","createEffect"],"mappings":";;;;AAuEO,SAAS,qBACd,OACA,gBACA,UAC+D;AAC/D,QAAM,CAAC,gBAAgB,mBAAmB,SAAS,IAAIA,sBAAAA;AAAAA,IACrD,MAAA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAGFC,UAAAA,aAAa,MAAM;AACjB,sBAAkB,OAAc;AAAA,EAAA,CACjC;AAED,SAAO,CAAC,gBAAgB,SAAS;AACnC;;"}

package/dist/cjs/debouncer/createDebouncedValue.d.cts

@@ -18,21 +18,49 @@ import { DebouncerOptions, DebouncerState } from '@tanstack/pacer/debouncer';
  * - An Accessor that provides the current debounced value
  * - The debouncer instance with control methods
  *
+ * ## State Management and Selector
+ *
+ * The hook uses TanStack Store for reactive state management via the underlying debouncer instance.
+ * The `selector` parameter allows you to specify which debouncer 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 debouncer state properties:
+ * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+ * - `executionCount`: Number of function executions that have been completed
+ * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+ *
  * @example
  * ```tsx
- * // Debounce a search query
+ * // Default behavior - no reactive state subscriptions
  * const [searchQuery, setSearchQuery] = createSignal('');
  * const [debouncedQuery, debouncer] = createDebouncedValue(searchQuery, {
  *   wait: 500 // Wait 500ms after last change
  * });
  *
+ * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)
+ * const [debouncedQuery, debouncer] = createDebouncedValue(
+ *   searchQuery,
+ *   { wait: 500 },
+ *   (state) => ({ isPending: state.isPending })
+ * );
+ *
  * // debouncedQuery will update 500ms after searchQuery stops changing
  * createEffect(() => {
  *   fetchSearchResults(debouncedQuery());
  * });
  *
+ * // Access debouncer state via signals
+ * console.log('Is pending:', debouncer.state().isPending);
+ *
  * // Control the debouncer
  * debouncer.cancel(); // Cancel any pending updates
  * ```
  */
-export declare function createDebouncedValue<TValue, TSelected = DebouncerState<Setter<TValue>>>(value: Accessor<TValue>, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, TSelected>];
+export declare function createDebouncedValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, TSelected>];

package/dist/cjs/debouncer/createDebouncer.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const debouncer = require("@tanstack/pacer/debouncer");
 const solidJs = require("solid-js");
 const solidStore = require("@tanstack/solid-store");
-function createDebouncer(fn, initialOptions, selector) {
+function createDebouncer(fn, initialOptions, selector = () => ({})) {
   const asyncDebouncer = new debouncer.Debouncer(fn, initialOptions);
   const state = solidStore.useStore(asyncDebouncer.store, selector);
   solidJs.createEffect(() => {

package/dist/cjs/debouncer/createDebouncer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createDebouncer.cjs","sources":["../../../src/debouncer/createDebouncer.ts"],"sourcesContent":["import { Debouncer } from '@tanstack/pacer/debouncer'\nimport { createEffect, onCleanup } from 'solid-js'\nimport { useStore } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\nexport interface SolidDebouncer<\n  TFn extends AnyFunction,\n  TSelected = DebouncerState<TFn>,\n> extends Omit<Debouncer<TFn>, 'store'> {\n  /**\n   * Reactive state that will be updated when the debouncer state changes\n   *\n   * Use this instead of `debouncer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n}\n\n/**\n * A Solid hook that creates and manages a Debouncer instance.\n *\n * This is a lower-level hook that provides direct access to the Debouncer's functionality without\n * any built-in state management. This allows you to integrate it with any state management solution\n * you prefer (createSignal, Redux, Zustand, etc.).\n *\n * This hook provides debouncing functionality to limit how often a function can be called,\n * waiting for a specified delay before executing the latest call. This is useful for handling\n * frequent events like window resizing, scroll events, or real-time search inputs.\n *\n * The debouncer will only execute the function after the specified wait time has elapsed\n * since the last call. If the function is called again before the wait time expires, the\n * timer resets and starts waiting again.\n *\n * @example\n * ```tsx\n * // Debounce a search function to limit API calls\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 } // Wait 500ms after last keystroke\n * );\n *\n * // In an event handler\n * const handleChange = (e) => {\n *   debouncer.maybeExecute(e.target.value);\n * };\n *\n * // Access debouncer state via signals\n * console.log('Executions:', debouncer.executionCount());\n * console.log('Is pending:', debouncer.isPending());\n *\n * // Update options\n * debouncer.setOptions({ wait: 1000 });\n * ```\n */\nexport function createDebouncer<\n  TFn extends AnyFunction,\n  TSelected = DebouncerState<TFn>,\n>(\n  fn: TFn,\n  initialOptions: DebouncerOptions<TFn>,\n  selector?: (state: DebouncerState<TFn>) => TSelected,\n): SolidDebouncer<TFn, TSelected> {\n  const asyncDebouncer = new Debouncer<TFn>(fn, initialOptions)\n\n  const state = useStore(asyncDebouncer.store, selector)\n\n  createEffect(() => {\n    onCleanup(() => {\n      asyncDebouncer.cancel()\n    })\n  })\n\n  return {\n    ...asyncDebouncer,\n    state,\n  } as SolidDebouncer<TFn, TSelected> // omit `store` in favor of `state`\n}\n"],"names":["Debouncer","useStore","createEffect","onCleanup"],"mappings":";;;;;AA0DO,SAAS,gBAId,IACA,gBACA,UACgC;AAChC,QAAM,iBAAiB,IAAIA,oBAAe,IAAI,cAAc;AAE5D,QAAM,QAAQC,WAAAA,SAAS,eAAe,OAAO,QAAQ;AAErDC,UAAAA,aAAa,MAAM;AACjBC,YAAAA,UAAU,MAAM;AACd,qBAAe,OAAA;AAAA,IAAO,CACvB;AAAA,EAAA,CACF;AAED,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EAAA;AAEJ;;"}
+{"version":3,"file":"createDebouncer.cjs","sources":["../../../src/debouncer/createDebouncer.ts"],"sourcesContent":["import { Debouncer } from '@tanstack/pacer/debouncer'\nimport { createEffect, onCleanup } from 'solid-js'\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  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\nexport interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}>\n  extends Omit<Debouncer<TFn>, 'store'> {\n  /**\n   * Reactive state that will be updated when the debouncer state changes\n   *\n   * Use this instead of `debouncer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `debouncer.state` instead of `debouncer.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<DebouncerState<TFn>>>\n}\n\n/**\n * A Solid hook that creates and manages a Debouncer instance.\n *\n * This is a lower-level hook that provides direct access to the Debouncer's functionality without\n * any built-in state management. This allows you to integrate it with any state management solution\n * you prefer (createSignal, Redux, Zustand, etc.).\n *\n * This hook provides debouncing functionality to limit how often a function can be called,\n * waiting for a specified delay before executing the latest call. This is useful for handling\n * frequent events like window resizing, scroll events, or real-time search inputs.\n *\n * The debouncer will only execute the function after the specified wait time has elapsed\n * since the last call. If the function is called again before the wait time expires, the\n * timer resets and starts waiting again.\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 * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 }\n * );\n *\n * // Opt-in to re-render when isPending changes (optimized for loading states)\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({ isPending: state.isPending })\n * );\n *\n * // Opt-in to re-render when executionCount changes (optimized for tracking execution)\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({ executionCount: state.executionCount })\n * );\n *\n * // Multiple state properties - re-render when any of these change\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({\n *     isPending: state.isPending,\n *     executionCount: state.executionCount,\n *     status: state.status\n *   })\n * );\n *\n * // In an event handler\n * const handleChange = (e) => {\n *   debouncer.maybeExecute(e.target.value);\n * };\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { isPending } = debouncer.state();\n * ```\n */\nexport function createDebouncer<TFn extends AnyFunction, TSelected = {}>(\n  fn: TFn,\n  initialOptions: DebouncerOptions<TFn>,\n  selector: (state: DebouncerState<TFn>) => TSelected = () => ({}) as TSelected,\n): SolidDebouncer<TFn, TSelected> {\n  const asyncDebouncer = new Debouncer<TFn>(fn, initialOptions)\n\n  const state = useStore(asyncDebouncer.store, selector)\n\n  createEffect(() => {\n    onCleanup(() => {\n      asyncDebouncer.cancel()\n    })\n  })\n\n  return {\n    ...asyncDebouncer,\n    state,\n  } as SolidDebouncer<TFn, TSelected> // omit `store` in favor of `state`\n}\n"],"names":["Debouncer","useStore","createEffect","onCleanup"],"mappings":";;;;;AAsGO,SAAS,gBACd,IACA,gBACA,WAAsD,OAAO,CAAA,IAC7B;AAChC,QAAM,iBAAiB,IAAIA,oBAAe,IAAI,cAAc;AAE5D,QAAM,QAAQC,WAAAA,SAAS,eAAe,OAAO,QAAQ;AAErDC,UAAAA,aAAa,MAAM;AACjBC,YAAAA,UAAU,MAAM;AACd,qBAAe,OAAA;AAAA,IAAO,CACvB;AAAA,EAAA,CACF;AAED,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EAAA;AAEJ;;"}

package/dist/cjs/debouncer/createDebouncer.d.cts

@@ -1,13 +1,20 @@
 import { Debouncer, DebouncerOptions, DebouncerState } from '@tanstack/pacer/debouncer';
+import { Store } from '@tanstack/solid-store';
 import { Accessor } from 'solid-js';
 import { AnyFunction } from '@tanstack/pacer/types';
-export interface SolidDebouncer<TFn extends AnyFunction, TSelected = DebouncerState<TFn>> extends Omit<Debouncer<TFn>, 'store'> {
+export interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
     /**
      * Reactive state that will be updated when the debouncer state changes
      *
      * Use this instead of `debouncer.store.state`
      */
     readonly state: Accessor<Readonly<TSelected>>;
+    /**
+     * @deprecated Use `debouncer.state` instead of `debouncer.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<DebouncerState<TFn>>>;
 }
 /**
  * A Solid hook that creates and manages a Debouncer instance.
@@ -24,12 +31,55 @@ export interface SolidDebouncer<TFn extends AnyFunction, TSelected = DebouncerSt
  * since the last call. If the function is called again before the wait time expires, the
  * timer resets and starts waiting again.
  *
+ * ## 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:
+ * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+ * - `executionCount`: Number of function executions that have been completed
+ * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+ *
  * @example
  * ```tsx
- * // Debounce a search function to limit API calls
+ * // Default behavior - no reactive state subscriptions
+ * const debouncer = createDebouncer(
+ *   (query: string) => fetchSearchResults(query),
+ *   { wait: 500 }
+ * );
+ *
+ * // Opt-in to re-render when isPending changes (optimized for loading states)
  * const debouncer = createDebouncer(
  *   (query: string) => fetchSearchResults(query),
- *   { wait: 500 } // Wait 500ms after last keystroke
+ *   { wait: 500 },
+ *   (state) => ({ isPending: state.isPending })
+ * );
+ *
+ * // Opt-in to re-render when executionCount changes (optimized for tracking execution)
+ * const debouncer = createDebouncer(
+ *   (query: string) => fetchSearchResults(query),
+ *   { wait: 500 },
+ *   (state) => ({ executionCount: state.executionCount })
+ * );
+ *
+ * // Multiple state properties - re-render when any of these change
+ * const debouncer = createDebouncer(
+ *   (query: string) => fetchSearchResults(query),
+ *   { wait: 500 },
+ *   (state) => ({
+ *     isPending: state.isPending,
+ *     executionCount: state.executionCount,
+ *     status: state.status
+ *   })
  * );
  *
  * // In an event handler
@@ -37,12 +87,8 @@ export interface SolidDebouncer<TFn extends AnyFunction, TSelected = DebouncerSt
  *   debouncer.maybeExecute(e.target.value);
  * };
  *
- * // Access debouncer state via signals
- * console.log('Executions:', debouncer.executionCount());
- * console.log('Is pending:', debouncer.isPending());
- *
- * // Update options
- * debouncer.setOptions({ wait: 1000 });
+ * // Access the selected state (will be empty object {} unless selector provided)
+ * const { isPending } = debouncer.state();
  * ```
  */
-export declare function createDebouncer<TFn extends AnyFunction, TSelected = DebouncerState<TFn>>(fn: TFn, initialOptions: DebouncerOptions<TFn>, selector?: (state: DebouncerState<TFn>) => TSelected): SolidDebouncer<TFn, TSelected>;
+export declare function createDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, initialOptions: DebouncerOptions<TFn>, selector?: (state: DebouncerState<TFn>) => TSelected): SolidDebouncer<TFn, TSelected>;

package/dist/cjs/queuer/createQueuer.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const queuer = require("@tanstack/pacer/queuer");
 const solidStore = require("@tanstack/solid-store");
-function createQueuer(fn, initialOptions = {}, selector) {
+function createQueuer(fn, initialOptions = {}, selector = () => ({})) {
   const queuer$1 = new queuer.Queuer(fn, initialOptions);
   const state = solidStore.useStore(queuer$1.store, selector);
   return {

package/dist/cjs/queuer/createQueuer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createQueuer.cjs","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":["queuer","Queuer","useStore"],"mappings":";;;;AAkEO,SAAS,aACd,IACA,iBAAwC,CAAA,GACxC,UACgC;AAChC,QAAMA,WAAS,IAAIC,cAAO,IAAI,cAAc;AAE5C,QAAM,QAAQC,WAAAA,SAASF,SAAO,OAAO,QAAQ;AAE7C,SAAO;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,EAAA;AAEJ;;"}
+{"version":3,"file":"createQueuer.cjs","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":["queuer","Queuer","useStore"],"mappings":";;;;AAoGO,SAAS,aACd,IACA,iBAAwC,CAAA,GACxC,WAAsD,OAAO,CAAA,IAC7B;AAChC,QAAMA,WAAS,IAAIC,cAAO,IAAI,cAAc;AAE5C,QAAM,QAAQC,WAAAA,SAASF,SAAO,OAAO,QAAQ;AAE7C,SAAO;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,EAAA;AAEJ;;"}