@tanstack/solid-pacer 0.8.0 → 0.9.0

package/dist/esm/debouncer/createDebouncedSignal.js

@@ -1,8 +1,8 @@
 import { createSignal } from "solid-js";
 import { createDebouncer } from "./createDebouncer.js";
-function createDebouncedSignal(value, initialOptions) {
+function createDebouncedSignal(value, initialOptions, selector) {
   const [debouncedValue, setDebouncedValue] = createSignal(value);
-  const debouncer = createDebouncer(setDebouncedValue, initialOptions);
+  const debouncer = createDebouncer(setDebouncedValue, initialOptions, selector);
   return [debouncedValue, debouncer.maybeExecute, debouncer];
 }
 export {

package/dist/esm/debouncer/createDebouncedSignal.js.map

@@ -1 +1 @@
-{"version":3,"file":"createDebouncedSignal.js","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 { DebouncerOptions } 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<TValue>(\n  value: TValue,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n): [Accessor<TValue>, Setter<TValue>, SolidDebouncer<Setter<TValue>>] {\n  const [debouncedValue, setDebouncedValue] = createSignal<TValue>(value)\n\n  const debouncer = createDebouncer(setDebouncedValue, initialOptions)\n\n  return [debouncedValue, debouncer.maybeExecute as Setter<TValue>, debouncer]\n}\n"],"names":[],"mappings":";;AA6CgB,SAAA,sBACd,OACA,gBACoE;AACpE,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,aAAqB,KAAK;AAEhE,QAAA,YAAY,gBAAgB,mBAAmB,cAAc;AAEnE,SAAO,CAAC,gBAAgB,UAAU,cAAgC,SAAS;AAC7E;"}
+{"version":3,"file":"createDebouncedSignal.js","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":[],"mappings":";;AAgDO,SAAS,sBAId,OACA,gBACA,UAKA;AACA,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,aAAqB,KAAK;AAEtE,QAAM,YAAY,gBAAgB,mBAAmB,gBAAgB,QAAQ;AAE7E,SAAO,CAAC,gBAAgB,UAAU,cAAgC,SAAS;AAC7E;"}

package/dist/esm/debouncer/createDebouncedValue.d.ts

@@ -1,6 +1,6 @@
 import { SolidDebouncer } from './createDebouncer.js';
 import { Accessor, Setter } from 'solid-js';
-import { DebouncerOptions } from '@tanstack/pacer/debouncer';
+import { DebouncerOptions, DebouncerState } from '@tanstack/pacer/debouncer';
 /**
  * A Solid hook that creates a debounced value that updates only after a specified delay.
  * Unlike createDebouncedSignal, this hook automatically tracks changes to the input value
@@ -35,4 +35,4 @@ import { DebouncerOptions } from '@tanstack/pacer/debouncer';
  * debouncer.cancel(); // Cancel any pending updates
  * ```
  */
-export declare function createDebouncedValue<TValue>(value: Accessor<TValue>, initialOptions: DebouncerOptions<Setter<TValue>>): [Accessor<TValue>, SolidDebouncer<Setter<TValue>>];
+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>];

package/dist/esm/debouncer/createDebouncedValue.js

@@ -1,9 +1,10 @@
 import { createEffect } from "solid-js";
 import { createDebouncedSignal } from "./createDebouncedSignal.js";
-function createDebouncedValue(value, initialOptions) {
+function createDebouncedValue(value, initialOptions, selector) {
   const [debouncedValue, setDebouncedValue, debouncer] = createDebouncedSignal(
     value(),
-    initialOptions
+    initialOptions,
+    selector
   );
   createEffect(() => {
     setDebouncedValue(value());

package/dist/esm/debouncer/createDebouncedValue.js.map

@@ -1 +1 @@
-{"version":3,"file":"createDebouncedValue.js","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 { DebouncerOptions } 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<TValue>(\n  value: Accessor<TValue>,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n): [Accessor<TValue>, SolidDebouncer<Setter<TValue>>] {\n  const [debouncedValue, setDebouncedValue, debouncer] = createDebouncedSignal(\n    value(),\n    initialOptions,\n  )\n\n  createEffect(() => {\n    setDebouncedValue(value() as any)\n  })\n\n  return [debouncedValue, debouncer]\n}\n"],"names":[],"mappings":";;AAwCgB,SAAA,qBACd,OACA,gBACoD;AACpD,QAAM,CAAC,gBAAgB,mBAAmB,SAAS,IAAI;AAAA,IACrD,MAAM;AAAA,IACN;AAAA,EACF;AAEA,eAAa,MAAM;AACjB,sBAAkB,OAAc;AAAA,EAAA,CACjC;AAEM,SAAA,CAAC,gBAAgB,SAAS;AACnC;"}
+{"version":3,"file":"createDebouncedValue.js","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":[],"mappings":";;AA2CO,SAAS,qBAId,OACA,gBACA,UAC+D;AAC/D,QAAM,CAAC,gBAAgB,mBAAmB,SAAS,IAAI;AAAA,IACrD,MAAA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAGF,eAAa,MAAM;AACjB,sBAAkB,OAAc;AAAA,EAAA,CACjC;AAED,SAAO,CAAC,gBAAgB,SAAS;AACnC;"}

package/dist/esm/debouncer/createDebouncer.d.ts

@@ -1,12 +1,13 @@
-import { Debouncer, DebouncerOptions } from '@tanstack/pacer/debouncer';
+import { Debouncer, DebouncerOptions, DebouncerState } from '@tanstack/pacer/debouncer';
 import { Accessor } from 'solid-js';
 import { AnyFunction } from '@tanstack/pacer/types';
-/**
- * An extension of the Debouncer class that adds Solid signals to access the internal state of the debouncer
- */
-export interface SolidDebouncer<TFn extends AnyFunction> extends Omit<Debouncer<TFn>, 'getExecutionCount' | 'getIsPending'> {
-    executionCount: Accessor<number>;
-    isPending: Accessor<boolean>;
+export interface SolidDebouncer<TFn extends AnyFunction, TSelected = DebouncerState<TFn>> 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>>;
 }
 /**
  * A Solid hook that creates and manages a Debouncer instance.
@@ -44,4 +45,4 @@ export interface SolidDebouncer<TFn extends AnyFunction> extends Omit<Debouncer<
  * debouncer.setOptions({ wait: 1000 });
  * ```
  */
-export declare function createDebouncer<TFn extends AnyFunction>(fn: TFn, initialOptions: DebouncerOptions<TFn>): SolidDebouncer<TFn>;
+export declare function createDebouncer<TFn extends AnyFunction, TSelected = DebouncerState<TFn>>(fn: TFn, initialOptions: DebouncerOptions<TFn>, selector?: (state: DebouncerState<TFn>) => TSelected): SolidDebouncer<TFn, TSelected>;

package/dist/esm/debouncer/createDebouncer.js

@@ -1,34 +1,17 @@
 import { Debouncer } from "@tanstack/pacer/debouncer";
-import { createSignal, createEffect, onCleanup } from "solid-js";
-import { bindInstanceMethods } from "@tanstack/pacer/utils";
-function createDebouncer(fn, initialOptions) {
-  const debouncer = bindInstanceMethods(new Debouncer(fn, initialOptions));
-  const [executionCount, setExecutionCount] = createSignal(
-    debouncer.getExecutionCount()
-  );
-  const [isPending, setIsPending] = createSignal(debouncer.getIsPending());
-  function setOptions(newOptions) {
-    debouncer.setOptions({
-      ...newOptions,
-      onExecute: (debouncer2) => {
-        setExecutionCount(debouncer2.getExecutionCount());
-        setIsPending(debouncer2.getIsPending());
-        const onExecute = newOptions.onExecute ?? initialOptions.onExecute;
-        onExecute == null ? void 0 : onExecute(debouncer2);
-      }
-    });
-  }
-  setOptions(initialOptions);
+import { createEffect, onCleanup } from "solid-js";
+import { useStore } from "@tanstack/solid-store";
+function createDebouncer(fn, initialOptions, selector) {
+  const asyncDebouncer = new Debouncer(fn, initialOptions);
+  const state = useStore(asyncDebouncer.store, selector);
   createEffect(() => {
     onCleanup(() => {
-      debouncer.cancel();
+      asyncDebouncer.cancel();
     });
   });
   return {
-    ...debouncer,
-    executionCount,
-    isPending,
-    setOptions
+    ...asyncDebouncer,
+    state
   };
 }
 export {

package/dist/esm/debouncer/createDebouncer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createDebouncer.js","sources":["../../../src/debouncer/createDebouncer.ts"],"sourcesContent":["import { Debouncer } from '@tanstack/pacer/debouncer'\nimport { createEffect, createSignal, onCleanup } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type { DebouncerOptions } from '@tanstack/pacer/debouncer'\n\n/**\n * An extension of the Debouncer class that adds Solid signals to access the internal state of the debouncer\n */\nexport interface SolidDebouncer<TFn extends AnyFunction>\n  extends Omit<Debouncer<TFn>, 'getExecutionCount' | 'getIsPending'> {\n  executionCount: Accessor<number>\n  isPending: Accessor<boolean>\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<TFn extends AnyFunction>(\n  fn: TFn,\n  initialOptions: DebouncerOptions<TFn>,\n): SolidDebouncer<TFn> {\n  const debouncer = bindInstanceMethods(new Debouncer<TFn>(fn, initialOptions))\n\n  const [executionCount, setExecutionCount] = createSignal(\n    debouncer.getExecutionCount(),\n  )\n  const [isPending, setIsPending] = createSignal(debouncer.getIsPending())\n\n  function setOptions(newOptions: Partial<DebouncerOptions<TFn>>) {\n    debouncer.setOptions({\n      ...newOptions,\n      onExecute: (debouncer) => {\n        setExecutionCount(debouncer.getExecutionCount())\n        setIsPending(debouncer.getIsPending())\n\n        const onExecute = newOptions.onExecute ?? initialOptions.onExecute\n        onExecute?.(debouncer)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  createEffect(() => {\n    onCleanup(() => {\n      debouncer.cancel()\n    })\n  })\n\n  return {\n    ...debouncer,\n    executionCount,\n    isPending,\n    setOptions,\n  } as SolidDebouncer<TFn>\n}\n"],"names":["debouncer"],"mappings":";;;AAoDgB,SAAA,gBACd,IACA,gBACqB;AACrB,QAAM,YAAY,oBAAoB,IAAI,UAAe,IAAI,cAAc,CAAC;AAEtE,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,UAAU,kBAAkB;AAAA,EAC9B;AACA,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,UAAU,cAAc;AAEvE,WAAS,WAAW,YAA4C;AAC9D,cAAU,WAAW;AAAA,MACnB,GAAG;AAAA,MACH,WAAW,CAACA,eAAc;AACNA,0BAAAA,WAAU,mBAAmB;AAClCA,qBAAAA,WAAU,cAAc;AAE/B,cAAA,YAAY,WAAW,aAAa,eAAe;AACzD,+CAAYA;AAAAA,MAAS;AAAA,IACvB,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAEzB,eAAa,MAAM;AACjB,cAAU,MAAM;AACd,gBAAU,OAAO;AAAA,IAAA,CAClB;AAAA,EAAA,CACF;AAEM,SAAA;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}
+{"version":3,"file":"createDebouncer.js","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":[],"mappings":";;;AA0DO,SAAS,gBAId,IACA,gBACA,UACgC;AAChC,QAAM,iBAAiB,IAAI,UAAe,IAAI,cAAc;AAE5D,QAAM,QAAQ,SAAS,eAAe,OAAO,QAAQ;AAErD,eAAa,MAAM;AACjB,cAAU,MAAM;AACd,qBAAe,OAAA;AAAA,IAAO,CACvB;AAAA,EAAA,CACF;AAED,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EAAA;AAEJ;"}

package/dist/esm/index.d.ts

@@ -2,6 +2,7 @@ export * from '@tanstack/pacer';
 /**
  * Export every hook individually - DON'T export from barrel files
  */
+export * from './async-batcher/createAsyncBatcher.js';
 export * from './async-debouncer/createAsyncDebouncer.js';
 export * from './async-queuer/createAsyncQueuer.js';
 export * from './async-rate-limiter/createAsyncRateLimiter.js';

package/dist/esm/index.js

@@ -1,4 +1,5 @@
 export * from "@tanstack/pacer";
+import { createAsyncBatcher } from "./async-batcher/createAsyncBatcher.js";
 import { createAsyncDebouncer } from "./async-debouncer/createAsyncDebouncer.js";
 import { createAsyncQueuer } from "./async-queuer/createAsyncQueuer.js";
 import { createAsyncRateLimiter } from "./async-rate-limiter/createAsyncRateLimiter.js";
@@ -15,6 +16,7 @@ import { createThrottledSignal } from "./throttler/createThrottledSignal.js";
 import { createThrottledValue } from "./throttler/createThrottledValue.js";
 import { createThrottler } from "./throttler/createThrottler.js";
 export {
+  createAsyncBatcher,
   createAsyncDebouncer,
   createAsyncQueuer,
   createAsyncRateLimiter,

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}

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

@@ -1,42 +1,12 @@
-import { Queuer, QueuerOptions } from '@tanstack/pacer/queuer';
+import { Queuer, QueuerOptions, QueuerState } from '@tanstack/pacer/queuer';
 import { Accessor } from 'solid-js';
-export interface SolidQueuer<TValue> extends Omit<Queuer<TValue>, 'getExecutionCount' | 'getIsEmpty' | 'getIsFull' | 'getIsIdle' | 'getIsRunning' | 'getSize' | 'peekAllItems' | 'peekNextItem'> {
+export interface SolidQueuer<TValue, TSelected = QueuerState<TValue>> extends Omit<Queuer<TValue>, 'store'> {
     /**
-     * Signal version of `peekAllItems`
+     * Reactive state that will be updated when the queuer state changes
+     *
+     * Use this instead of `queuer.store.state`
      */
-    allItems: Accessor<Array<TValue>>;
-    /**
-     * Signal version of `getExecutionCount`
-     */
-    executionCount: Accessor<number>;
-    /**
-     * Signal version of `getIsEmpty`
-     */
-    isEmpty: Accessor<boolean>;
-    /**
-     * Signal version of `getIsFull`
-     */
-    isFull: Accessor<boolean>;
-    /**
-     * Signal version of `getIsIdle`
-     */
-    isIdle: Accessor<boolean>;
-    /**
-     * Signal version of `getIsRunning`
-     */
-    isRunning: Accessor<boolean>;
-    /**
-     * Signal version of `peekNextItem`
-     */
-    nextItem: Accessor<TValue | undefined>;
-    /**
-     * Signal version of `getRejectionCount`
-     */
-    rejectionCount: Accessor<number>;
-    /**
-     * Signal version of `getSize`
-     */
-    size: Accessor<number>;
+    readonly state: Accessor<Readonly<TSelected>>;
 }
 /**
  * Creates a Solid-compatible Queuer instance for managing a synchronous queue of items, exposing Solid signals for all stateful properties.
@@ -89,4 +59,4 @@ export interface SolidQueuer<TValue> extends Omit<Queuer<TValue>, 'getExecutionC
  * console.log('Next item:', queue.nextItem());
  * ```
  */
-export declare function createQueuer<TValue>(fn: (item: TValue) => void, initialOptions?: QueuerOptions<TValue>): SolidQueuer<TValue>;
+export declare function createQueuer<TValue, TSelected = QueuerState<TValue>>(fn: (item: TValue) => void, initialOptions?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): SolidQueuer<TValue, TSelected>;

package/dist/esm/queuer/createQueuer.js

@@ -1,65 +1,11 @@
 import { Queuer } from "@tanstack/pacer/queuer";
-import { createSignal } from "solid-js";
-import { bindInstanceMethods } from "@tanstack/pacer/utils";
-function createQueuer(fn, initialOptions = {}) {
-  const queuer = bindInstanceMethods(new Queuer(fn, initialOptions));
-  const [allItems, setAllItems] = createSignal(
-    queuer.peekAllItems()
-  );
-  const [executionCount, setExecutionCount] = createSignal(
-    queuer.getExecutionCount()
-  );
-  const [rejectionCount, setRejectionCount] = createSignal(
-    queuer.getRejectionCount()
-  );
-  const [isEmpty, setIsEmpty] = createSignal(queuer.getIsEmpty());
-  const [isFull, setIsFull] = createSignal(queuer.getIsFull());
-  const [isIdle, setIsIdle] = createSignal(queuer.getIsIdle());
-  const [isRunning, setIsRunning] = createSignal(queuer.getIsRunning());
-  const [nextItem, setNextItem] = createSignal(
-    queuer.peekNextItem()
-  );
-  const [size, setSize] = createSignal(queuer.getSize());
-  function setOptions(newOptions) {
-    queuer.setOptions({
-      ...newOptions,
-      onItemsChange: (queuer2) => {
-        setAllItems(queuer2.peekAllItems());
-        setExecutionCount(queuer2.getExecutionCount());
-        setIsEmpty(queuer2.getIsEmpty());
-        setIsFull(queuer2.getIsFull());
-        setIsIdle(queuer2.getIsIdle());
-        setNextItem(() => queuer2.peekNextItem());
-        setSize(queuer2.getSize());
-        const onItemsChange = newOptions.onItemsChange ?? initialOptions.onItemsChange;
-        onItemsChange == null ? void 0 : onItemsChange(queuer2);
-      },
-      onIsRunningChange: (queuer2) => {
-        setIsRunning(queuer2.getIsRunning());
-        setIsIdle(queuer2.getIsIdle());
-        const onIsRunningChange = newOptions.onIsRunningChange ?? initialOptions.onIsRunningChange;
-        onIsRunningChange == null ? void 0 : onIsRunningChange(queuer2);
-      },
-      onReject: (item, queuer2) => {
-        setRejectionCount(queuer2.getRejectionCount());
-        const onReject = newOptions.onReject ?? initialOptions.onReject;
-        onReject == null ? void 0 : onReject(item, queuer2);
-      }
-    });
-  }
-  setOptions(initialOptions);
+import { useStore } from "@tanstack/solid-store";
+function createQueuer(fn, initialOptions = {}, selector) {
+  const queuer = new Queuer(fn, initialOptions);
+  const state = useStore(queuer.store, selector);
   return {
     ...queuer,
-    allItems,
-    executionCount,
-    isEmpty,
-    isFull,
-    isIdle,
-    isRunning,
-    nextItem,
-    rejectionCount,
-    size,
-    setOptions
+    state
   };
 }
 export {

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

@@ -1 +1 @@
-{"version":3,"file":"createQueuer.js","sources":["../../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { QueuerOptions } from '@tanstack/pacer/queuer'\n\nexport interface SolidQueuer<TValue>\n  extends Omit<\n    Queuer<TValue>,\n    | 'getExecutionCount'\n    | 'getIsEmpty'\n    | 'getIsFull'\n    | 'getIsIdle'\n    | 'getIsRunning'\n    | 'getSize'\n    | 'peekAllItems'\n    | 'peekNextItem'\n  > {\n  /**\n   * Signal version of `peekAllItems`\n   */\n  allItems: Accessor<Array<TValue>>\n  /**\n   * Signal version of `getExecutionCount`\n   */\n  executionCount: Accessor<number>\n  /**\n   * Signal version of `getIsEmpty`\n   */\n  isEmpty: Accessor<boolean>\n  /**\n   * Signal version of `getIsFull`\n   */\n  isFull: Accessor<boolean>\n  /**\n   * Signal version of `getIsIdle`\n   */\n  isIdle: Accessor<boolean>\n  /**\n   * Signal version of `getIsRunning`\n   */\n  isRunning: Accessor<boolean>\n  /**\n   * Signal version of `peekNextItem`\n   */\n  nextItem: Accessor<TValue | undefined>\n  /**\n   * Signal version of `getRejectionCount`\n   */\n  rejectionCount: Accessor<number>\n  /**\n   * Signal version of `getSize`\n   */\n  size: Accessor<number>\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>(\n  fn: (item: TValue) => void,\n  initialOptions: QueuerOptions<TValue> = {},\n): SolidQueuer<TValue> {\n  const queuer = bindInstanceMethods(new Queuer<TValue>(fn, initialOptions))\n\n  const [allItems, setAllItems] = createSignal<Array<TValue>>(\n    queuer.peekAllItems(),\n  )\n  const [executionCount, setExecutionCount] = createSignal(\n    queuer.getExecutionCount(),\n  )\n  const [rejectionCount, setRejectionCount] = createSignal(\n    queuer.getRejectionCount(),\n  )\n  const [isEmpty, setIsEmpty] = createSignal(queuer.getIsEmpty())\n  const [isFull, setIsFull] = createSignal(queuer.getIsFull())\n  const [isIdle, setIsIdle] = createSignal(queuer.getIsIdle())\n  const [isRunning, setIsRunning] = createSignal(queuer.getIsRunning())\n  const [nextItem, setNextItem] = createSignal<TValue | undefined>(\n    queuer.peekNextItem(),\n  )\n  const [size, setSize] = createSignal(queuer.getSize())\n\n  function setOptions(newOptions: Partial<QueuerOptions<TValue>>) {\n    queuer.setOptions({\n      ...newOptions,\n      onItemsChange: (queuer) => {\n        setAllItems(queuer.peekAllItems())\n        setExecutionCount(queuer.getExecutionCount())\n        setIsEmpty(queuer.getIsEmpty())\n        setIsFull(queuer.getIsFull())\n        setIsIdle(queuer.getIsIdle())\n        setNextItem(() => queuer.peekNextItem())\n        setSize(queuer.getSize())\n\n        const onItemsChange =\n          newOptions.onItemsChange ?? initialOptions.onItemsChange\n        onItemsChange?.(queuer)\n      },\n      onIsRunningChange: (queuer) => {\n        setIsRunning(queuer.getIsRunning())\n        setIsIdle(queuer.getIsIdle())\n\n        const onIsRunningChange =\n          newOptions.onIsRunningChange ?? initialOptions.onIsRunningChange\n        onIsRunningChange?.(queuer)\n      },\n      onReject: (item, queuer) => {\n        setRejectionCount(queuer.getRejectionCount())\n\n        const onReject = newOptions.onReject ?? initialOptions.onReject\n        onReject?.(item, queuer)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...queuer,\n    allItems,\n    executionCount,\n    isEmpty,\n    isFull,\n    isIdle,\n    isRunning,\n    nextItem,\n    rejectionCount,\n    size,\n    setOptions,\n  } as SolidQueuer<TValue>\n}\n"],"names":["queuer"],"mappings":";;;AA2GO,SAAS,aACd,IACA,iBAAwC,IACnB;AACrB,QAAM,SAAS,oBAAoB,IAAI,OAAe,IAAI,cAAc,CAAC;AAEnE,QAAA,CAAC,UAAU,WAAW,IAAI;AAAA,IAC9B,OAAO,aAAa;AAAA,EACtB;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,OAAO,kBAAkB;AAAA,EAC3B;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,OAAO,kBAAkB;AAAA,EAC3B;AACA,QAAM,CAAC,SAAS,UAAU,IAAI,aAAa,OAAO,YAAY;AAC9D,QAAM,CAAC,QAAQ,SAAS,IAAI,aAAa,OAAO,WAAW;AAC3D,QAAM,CAAC,QAAQ,SAAS,IAAI,aAAa,OAAO,WAAW;AAC3D,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,OAAO,cAAc;AAC9D,QAAA,CAAC,UAAU,WAAW,IAAI;AAAA,IAC9B,OAAO,aAAa;AAAA,EACtB;AACA,QAAM,CAAC,MAAM,OAAO,IAAI,aAAa,OAAO,SAAS;AAErD,WAAS,WAAW,YAA4C;AAC9D,WAAO,WAAW;AAAA,MAChB,GAAG;AAAA,MACH,eAAe,CAACA,YAAW;AACbA,oBAAAA,QAAO,cAAc;AACfA,0BAAAA,QAAO,mBAAmB;AACjCA,mBAAAA,QAAO,YAAY;AACpBA,kBAAAA,QAAO,WAAW;AAClBA,kBAAAA,QAAO,WAAW;AAChB,oBAAA,MAAMA,QAAO,cAAc;AAC/BA,gBAAAA,QAAO,SAAS;AAElB,cAAA,gBACJ,WAAW,iBAAiB,eAAe;AAC7C,uDAAgBA;AAAAA,MAClB;AAAA,MACA,mBAAmB,CAACA,YAAW;AAChBA,qBAAAA,QAAO,cAAc;AACxBA,kBAAAA,QAAO,WAAW;AAEtB,cAAA,oBACJ,WAAW,qBAAqB,eAAe;AACjD,+DAAoBA;AAAAA,MACtB;AAAA,MACA,UAAU,CAAC,MAAMA,YAAW;AACRA,0BAAAA,QAAO,mBAAmB;AAEtC,cAAA,WAAW,WAAW,YAAY,eAAe;AACvD,6CAAW,MAAMA;AAAAA,MAAM;AAAA,IACzB,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}
+{"version":3,"file":"createQueuer.js","sources":["../../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { useStore } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer'\n\nexport interface SolidQueuer<TValue, TSelected = QueuerState<TValue>>\n  extends Omit<Queuer<TValue>, 'store'> {\n  /**\n   * Reactive state that will be updated when the queuer state changes\n   *\n   * Use this instead of `queuer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n}\n\n/**\n * Creates a Solid-compatible Queuer instance for managing a synchronous queue of items, exposing Solid signals for all stateful properties.\n *\n * Features:\n * - Synchronous processing of items using the provided `fn` function\n * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior\n * - Priority queueing via `getPriority` or item `priority` property\n * - Item expiration and removal of stale items\n * - Configurable wait time between processing items\n * - Pause/resume processing\n * - Callbacks for queue state changes, execution, rejection, and expiration\n * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * The queue processes items synchronously in order, with optional delays between each item. When started, it will process one item per tick, with an optional wait time between ticks. You can pause and resume processing with `stop()` and `start()`.\n *\n * By default, the queue uses FIFO behavior, but you can configure LIFO or double-ended queueing by specifying the position when adding or removing items.\n *\n * Example usage:\n * ```tsx\n * // Example with Solid signals and scheduling\n * const [items, setItems] = createSignal([]);\n *\n * const queue = createQueuer(\n *   (item) => {\n *     // process item synchronously\n *     console.log('Processing', item);\n *   },\n *   {\n *     started: true, // Start processing immediately\n *     wait: 1000,    // Process one item every second\n *     onItemsChange: (queue) => setItems(queue.peekAllItems()),\n *     getPriority: (item) => item.priority // Process higher priority items first\n *   }\n * );\n *\n * // Add items to process - they'll be handled automatically\n * queue.addItem('task1');\n * queue.addItem('task2');\n *\n * // Control the scheduler\n * queue.stop();  // Pause processing\n * queue.start(); // Resume processing\n *\n * // Access queue state via signals\n * console.log('Items:', queue.allItems());\n * console.log('Size:', queue.size());\n * console.log('Is empty:', queue.isEmpty());\n * console.log('Is running:', queue.isRunning());\n * console.log('Next item:', queue.nextItem());\n * ```\n */\nexport function createQueuer<TValue, TSelected = QueuerState<TValue>>(\n  fn: (item: TValue) => void,\n  initialOptions: QueuerOptions<TValue> = {},\n  selector?: (state: QueuerState<TValue>) => TSelected,\n): SolidQueuer<TValue, TSelected> {\n  const queuer = new Queuer(fn, initialOptions)\n\n  const state = useStore(queuer.store, selector)\n\n  return {\n    ...queuer,\n    state,\n  } as unknown as SolidQueuer<TValue, TSelected> // omit `store` in favor of `state`\n}\n"],"names":[],"mappings":";;AAkEO,SAAS,aACd,IACA,iBAAwC,CAAA,GACxC,UACgC;AAChC,QAAM,SAAS,IAAI,OAAO,IAAI,cAAc;AAE5C,QAAM,QAAQ,SAAS,OAAO,OAAO,QAAQ;AAE7C,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EAAA;AAEJ;"}

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

@@ -1,6 +1,6 @@
 import { SolidRateLimiter } from './createRateLimiter.js';
 import { Accessor, Setter } from 'solid-js';
-import { RateLimiterOptions } from '@tanstack/pacer/rate-limiter';
+import { RateLimiterOptions, RateLimiterState } from '@tanstack/pacer/rate-limiter';
 /**
  * A Solid hook that creates a rate-limited state value that enforces a hard limit on state updates within a time window.
  * This hook combines Solid's createSignal with rate limiting functionality to provide controlled state updates.
@@ -59,4 +59,8 @@ import { RateLimiterOptions } from '@tanstack/pacer/rate-limiter';
  * };
  * ```
  */
-export declare function createRateLimitedSignal<TValue>(value: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>): [Accessor<TValue>, Setter<TValue>, SolidRateLimiter<Setter<TValue>>];
+export declare function createRateLimitedSignal<TValue, TSelected = RateLimiterState>(value: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): [
+    Accessor<TValue>,
+    Setter<TValue>,
+    SolidRateLimiter<Setter<TValue>, TSelected>
+];

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

@@ -1,11 +1,15 @@
 import { createSignal } from "solid-js";
 import { createRateLimiter } from "./createRateLimiter.js";
-function createRateLimitedSignal(value, initialOptions) {
+function createRateLimitedSignal(value, initialOptions, selector) {
   const [rateLimitedValue, setRateLimitedValue] = createSignal(value);
-  const rateLimiter = createRateLimiter(setRateLimitedValue, initialOptions);
+  const rateLimiter = createRateLimiter(
+    setRateLimitedValue,
+    initialOptions,
+    selector
+  );
   return [
     rateLimitedValue,
-    rateLimiter.maybeExecute.bind(rateLimiter),
+    rateLimiter.maybeExecute,
     rateLimiter
   ];
 }

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

@@ -1 +1 @@
-{"version":3,"file":"createRateLimitedSignal.js","sources":["../../../src/rate-limiter/createRateLimitedSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createRateLimiter } from './createRateLimiter'\nimport type { SolidRateLimiter } from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'\n\n/**\n * A Solid hook that creates a rate-limited state value that enforces a hard limit on state updates within a time window.\n * This hook combines Solid's createSignal with rate limiting functionality to provide controlled state updates.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledSignal: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedSignal: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - The rate-limited state value accessor\n * - A rate-limited setter function that respects the configured limits\n * - The rateLimiter instance for additional control\n *\n * For more direct control over rate limiting without state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * @example\n * ```tsx\n * // Basic rate limiting - update state at most 5 times per minute with a sliding window\n * const [value, setValue, rateLimiter] = createRateLimitedSignal(0, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // With rejection callback and fixed window\n * const [value, setValue] = createRateLimitedSignal(0, {\n *   limit: 3,\n *   window: 5000,\n *   windowType: 'fixed',\n *   onReject: (rateLimiter) => {\n *     alert(`Rate limit reached. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access rateLimiter state via signals\n * const handleSubmit = () => {\n *   const remaining = rateLimiter.remainingInWindow();\n *   if (remaining > 0) {\n *     setValue(newValue);\n *   } else {\n *     showRateLimitWarning();\n *   }\n * };\n * ```\n */\nexport function createRateLimitedSignal<TValue>(\n  value: TValue,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n): [Accessor<TValue>, Setter<TValue>, SolidRateLimiter<Setter<TValue>>] {\n  const [rateLimitedValue, setRateLimitedValue] = createSignal<TValue>(value)\n\n  const rateLimiter = createRateLimiter(setRateLimitedValue, initialOptions)\n\n  return [\n    rateLimitedValue,\n    rateLimiter.maybeExecute.bind(rateLimiter) as Setter<TValue>,\n    rateLimiter,\n  ]\n}\n"],"names":[],"mappings":";;AAgEgB,SAAA,wBACd,OACA,gBACsE;AACtE,QAAM,CAAC,kBAAkB,mBAAmB,IAAI,aAAqB,KAAK;AAEpE,QAAA,cAAc,kBAAkB,qBAAqB,cAAc;AAElE,SAAA;AAAA,IACL;AAAA,IACA,YAAY,aAAa,KAAK,WAAW;AAAA,IACzC;AAAA,EACF;AACF;"}
+{"version":3,"file":"createRateLimitedSignal.js","sources":["../../../src/rate-limiter/createRateLimitedSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createRateLimiter } from './createRateLimiter'\nimport type { SolidRateLimiter } from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\n/**\n * A Solid hook that creates a rate-limited state value that enforces a hard limit on state updates within a time window.\n * This hook combines Solid's createSignal with rate limiting functionality to provide controlled state updates.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledSignal: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedSignal: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - The rate-limited state value accessor\n * - A rate-limited setter function that respects the configured limits\n * - The rateLimiter instance for additional control\n *\n * For more direct control over rate limiting without state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * @example\n * ```tsx\n * // Basic rate limiting - update state at most 5 times per minute with a sliding window\n * const [value, setValue, rateLimiter] = createRateLimitedSignal(0, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // With rejection callback and fixed window\n * const [value, setValue] = createRateLimitedSignal(0, {\n *   limit: 3,\n *   window: 5000,\n *   windowType: 'fixed',\n *   onReject: (rateLimiter) => {\n *     alert(`Rate limit reached. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access rateLimiter state via signals\n * const handleSubmit = () => {\n *   const remaining = rateLimiter.remainingInWindow();\n *   if (remaining > 0) {\n *     setValue(newValue);\n *   } else {\n *     showRateLimitWarning();\n *   }\n * };\n * ```\n */\nexport function createRateLimitedSignal<TValue, TSelected = RateLimiterState>(\n  value: TValue,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n  selector?: (state: RateLimiterState) => TSelected,\n): [\n  Accessor<TValue>,\n  Setter<TValue>,\n  SolidRateLimiter<Setter<TValue>, TSelected>,\n] {\n  const [rateLimitedValue, setRateLimitedValue] = createSignal<TValue>(value)\n\n  const rateLimiter = createRateLimiter(\n    setRateLimitedValue,\n    initialOptions,\n    selector,\n  )\n\n  return [\n    rateLimitedValue,\n    rateLimiter.maybeExecute as Setter<TValue>,\n    rateLimiter,\n  ]\n}\n"],"names":[],"mappings":";;AAmEO,SAAS,wBACd,OACA,gBACA,UAKA;AACA,QAAM,CAAC,kBAAkB,mBAAmB,IAAI,aAAqB,KAAK;AAE1E,QAAM,cAAc;AAAA,IAClB;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAGF,SAAO;AAAA,IACL;AAAA,IACA,YAAY;AAAA,IACZ;AAAA,EAAA;AAEJ;"}

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

@@ -1,6 +1,6 @@
 import { SolidRateLimiter } from './createRateLimiter.js';
 import { Accessor, Setter } from 'solid-js';
-import { RateLimiterOptions } from '@tanstack/pacer/rate-limiter';
+import { RateLimiterOptions, RateLimiterState } from '@tanstack/pacer/rate-limiter';
 /**
  * A high-level Solid hook that creates a rate-limited version of a value that updates at most a certain number of times within a time window.
  * This hook uses Solid's createSignal internally to manage the rate-limited state.
@@ -44,4 +44,4 @@ import { RateLimiterOptions } from '@tanstack/pacer/rate-limiter';
  * rateLimiter.reset(); // Reset the rate limit window
  * ```
  */
-export declare function createRateLimitedValue<TValue>(value: Accessor<TValue>, initialOptions: RateLimiterOptions<Setter<TValue>>): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>>];
+export declare function createRateLimitedValue<TValue, TSelected = RateLimiterState>(value: Accessor<TValue>, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>];

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

@@ -1,7 +1,7 @@
 import { createEffect } from "solid-js";
 import { createRateLimitedSignal } from "./createRateLimitedSignal.js";
-function createRateLimitedValue(value, initialOptions) {
-  const [rateLimitedValue, setRateLimitedValue, rateLimiter] = createRateLimitedSignal(value(), initialOptions);
+function createRateLimitedValue(value, initialOptions, selector) {
+  const [rateLimitedValue, setRateLimitedValue, rateLimiter] = createRateLimitedSignal(value(), initialOptions, selector);
   createEffect(() => {
     setRateLimitedValue(value());
   });

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

@@ -1 +1 @@
-{"version":3,"file":"createRateLimitedValue.js","sources":["../../../src/rate-limiter/createRateLimitedValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createRateLimitedSignal } from './createRateLimitedSignal'\nimport type { SolidRateLimiter } from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'\n\n/**\n * A high-level Solid hook that creates a rate-limited version of a value that updates at most a certain number of times within a time window.\n * This hook uses Solid's createSignal internally to manage the rate-limited state.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledValue: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedValue: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - An accessor function that provides the rate-limited value\n * - The rate limiter instance with control methods\n *\n * For more direct control over rate limiting behavior without Solid state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * @example\n * ```tsx\n * // Basic rate limiting - update at most 5 times per minute with a sliding window\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Use the rate-limited value\n * console.log(rateLimitedValue()); // Access the current rate-limited value\n *\n * // Control the rate limiter\n * rateLimiter.reset(); // Reset the rate limit window\n * ```\n */\nexport function createRateLimitedValue<TValue>(\n  value: Accessor<TValue>,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>>] {\n  const [rateLimitedValue, setRateLimitedValue, rateLimiter] =\n    createRateLimitedSignal(value(), initialOptions)\n\n  createEffect(() => {\n    setRateLimitedValue(value() as any)\n  })\n\n  return [rateLimitedValue, rateLimiter]\n}\n"],"names":[],"mappings":";;AAiDgB,SAAA,uBACd,OACA,gBACsD;AAChD,QAAA,CAAC,kBAAkB,qBAAqB,WAAW,IACvD,wBAAwB,SAAS,cAAc;AAEjD,eAAa,MAAM;AACjB,wBAAoB,OAAc;AAAA,EAAA,CACnC;AAEM,SAAA,CAAC,kBAAkB,WAAW;AACvC;"}
+{"version":3,"file":"createRateLimitedValue.js","sources":["../../../src/rate-limiter/createRateLimitedValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createRateLimitedSignal } from './createRateLimitedSignal'\nimport type { SolidRateLimiter } from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\n/**\n * A high-level Solid hook that creates a rate-limited version of a value that updates at most a certain number of times within a time window.\n * This hook uses Solid's createSignal internally to manage the rate-limited state.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledValue: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedValue: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - An accessor function that provides the rate-limited value\n * - The rate limiter instance with control methods\n *\n * For more direct control over rate limiting behavior without Solid state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * @example\n * ```tsx\n * // Basic rate limiting - update at most 5 times per minute with a sliding window\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Use the rate-limited value\n * console.log(rateLimitedValue()); // Access the current rate-limited value\n *\n * // Control the rate limiter\n * rateLimiter.reset(); // Reset the rate limit window\n * ```\n */\nexport function createRateLimitedValue<TValue, TSelected = RateLimiterState>(\n  value: Accessor<TValue>,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n  selector?: (state: RateLimiterState) => TSelected,\n): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>] {\n  const [rateLimitedValue, setRateLimitedValue, rateLimiter] =\n    createRateLimitedSignal(value(), initialOptions, selector)\n\n  createEffect(() => {\n    setRateLimitedValue(value() as any)\n  })\n\n  return [rateLimitedValue, rateLimiter]\n}\n"],"names":[],"mappings":";;AAoDO,SAAS,uBACd,OACA,gBACA,UACiE;AACjE,QAAM,CAAC,kBAAkB,qBAAqB,WAAW,IACvD,wBAAwB,MAAA,GAAS,gBAAgB,QAAQ;AAE3D,eAAa,MAAM;AACjB,wBAAoB,OAAc;AAAA,EAAA,CACnC;AAED,SAAO,CAAC,kBAAkB,WAAW;AACvC;"}

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

@@ -1,11 +1,13 @@
-import { RateLimiter, RateLimiterOptions } from '@tanstack/pacer/rate-limiter';
+import { RateLimiter, RateLimiterOptions, RateLimiterState } from '@tanstack/pacer/rate-limiter';
 import { Accessor } from 'solid-js';
 import { AnyFunction } from '@tanstack/pacer/types';
-export interface SolidRateLimiter<TFn extends AnyFunction> extends Omit<RateLimiter<TFn>, 'getExecutionCount' | 'getMsUntilNextWindow' | 'getRejectionCount' | 'getRemainingInWindow'> {
-    executionCount: Accessor<number>;
-    msUntilNextWindow: Accessor<number>;
-    rejectionCount: Accessor<number>;
-    remainingInWindow: Accessor<number>;
+export interface SolidRateLimiter<TFn extends AnyFunction, TSelected = RateLimiterState> extends Omit<RateLimiter<TFn>, 'store'> {
+    /**
+     * Reactive state that will be updated when the rate limiter state changes
+     *
+     * Use this instead of `rateLimiter.store.state`
+     */
+    readonly state: Accessor<Readonly<TSelected>>;
 }
 /**
  * A low-level Solid hook that creates a `RateLimiter` instance to enforce rate limits on function execution.
@@ -47,4 +49,4 @@ export interface SolidRateLimiter<TFn extends AnyFunction> extends Omit<RateLimi
  * console.log('Next window in:', rateLimiter.msUntilNextWindow());
  * ```
  */
-export declare function createRateLimiter<TFn extends AnyFunction>(fn: TFn, initialOptions: RateLimiterOptions<TFn>): SolidRateLimiter<TFn>;
+export declare function createRateLimiter<TFn extends AnyFunction, TSelected = RateLimiterState>(fn: TFn, initialOptions: RateLimiterOptions<TFn>, selector?: (state: RateLimiterState) => TSelected): SolidRateLimiter<TFn, TSelected>;

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

@@ -1,49 +1,11 @@
 import { RateLimiter } from "@tanstack/pacer/rate-limiter";
-import { createSignal } from "solid-js";
-import { bindInstanceMethods } from "@tanstack/pacer/utils";
-function createRateLimiter(fn, initialOptions) {
-  const rateLimiter = bindInstanceMethods(
-    new RateLimiter(fn, initialOptions)
-  );
-  const [executionCount, setExecutionCount] = createSignal(
-    rateLimiter.getExecutionCount()
-  );
-  const [rejectionCount, setRejectionCount] = createSignal(
-    rateLimiter.getRejectionCount()
-  );
-  const [remainingInWindow, setRemainingInWindow] = createSignal(
-    rateLimiter.getRemainingInWindow()
-  );
-  const [msUntilNextWindow, setMsUntilNextWindow] = createSignal(
-    rateLimiter.getMsUntilNextWindow()
-  );
-  function setOptions(newOptions) {
-    rateLimiter.setOptions({
-      ...newOptions,
-      onExecute: (rateLimiter2) => {
-        setExecutionCount(rateLimiter2.getExecutionCount());
-        setRemainingInWindow(rateLimiter2.getRemainingInWindow());
-        setMsUntilNextWindow(rateLimiter2.getMsUntilNextWindow());
-        const onExecute = newOptions.onExecute ?? initialOptions.onExecute;
-        onExecute == null ? void 0 : onExecute(rateLimiter2);
-      },
-      onReject: (rateLimiter2) => {
-        setRejectionCount(rateLimiter2.getRejectionCount());
-        setRemainingInWindow(rateLimiter2.getRemainingInWindow());
-        setMsUntilNextWindow(rateLimiter2.getMsUntilNextWindow());
-        const onReject = newOptions.onReject ?? initialOptions.onReject;
-        onReject == null ? void 0 : onReject(rateLimiter2);
-      }
-    });
-  }
-  setOptions(initialOptions);
+import { useStore } from "@tanstack/solid-store";
+function createRateLimiter(fn, initialOptions, selector) {
+  const rateLimiter = new RateLimiter(fn, initialOptions);
+  const state = useStore(rateLimiter.store, selector);
   return {
     ...rateLimiter,
-    executionCount,
-    rejectionCount,
-    remainingInWindow,
-    msUntilNextWindow,
-    setOptions
+    state
   };
 }
 export {

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

@@ -1 +1 @@
-{"version":3,"file":"createRateLimiter.js","sources":["../../../src/rate-limiter/createRateLimiter.ts"],"sourcesContent":["import { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'\n\nexport interface SolidRateLimiter<TFn extends AnyFunction>\n  extends Omit<\n    RateLimiter<TFn>,\n    | 'getExecutionCount'\n    | 'getMsUntilNextWindow'\n    | 'getRejectionCount'\n    | 'getRemainingInWindow'\n  > {\n  executionCount: Accessor<number>\n  msUntilNextWindow: Accessor<number>\n  rejectionCount: Accessor<number>\n  remainingInWindow: Accessor<number>\n}\n\n/**\n * A low-level Solid hook that creates a `RateLimiter` instance to enforce rate limits on function execution.\n *\n * This hook is designed to be flexible and state-management agnostic - it simply returns a rate limiter instance that\n * you can integrate with any state management solution (createSignal, etc).\n *\n * Rate limiting is a simple \"hard limit\" approach that allows executions until a maximum count is reached within\n * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,\n * it does not attempt to space out or collapse executions intelligently.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n *   consistent rate of execution over time.\n *\n * For smoother execution patterns:\n * - Use throttling when you want consistent spacing between executions (e.g. UI updates)\n * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)\n * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)\n *\n * @example\n * ```tsx\n * // Basic rate limiting - max 5 calls per minute with a sliding window\n * const rateLimiter = createRateLimiter(apiCall, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding',\n *   onReject: (rateLimiter) => {\n *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access rate limiter state via signals\n * console.log('Executions:', rateLimiter.executionCount());\n * console.log('Rejections:', rateLimiter.rejectionCount());\n * console.log('Remaining:', rateLimiter.remainingInWindow());\n * console.log('Next window in:', rateLimiter.msUntilNextWindow());\n * ```\n */\nexport function createRateLimiter<TFn extends AnyFunction>(\n  fn: TFn,\n  initialOptions: RateLimiterOptions<TFn>,\n): SolidRateLimiter<TFn> {\n  const rateLimiter = bindInstanceMethods(\n    new RateLimiter<TFn>(fn, initialOptions),\n  )\n\n  const [executionCount, setExecutionCount] = createSignal(\n    rateLimiter.getExecutionCount(),\n  )\n  const [rejectionCount, setRejectionCount] = createSignal(\n    rateLimiter.getRejectionCount(),\n  )\n  const [remainingInWindow, setRemainingInWindow] = createSignal(\n    rateLimiter.getRemainingInWindow(),\n  )\n  const [msUntilNextWindow, setMsUntilNextWindow] = createSignal(\n    rateLimiter.getMsUntilNextWindow(),\n  )\n\n  function setOptions(newOptions: Partial<RateLimiterOptions<TFn>>) {\n    rateLimiter.setOptions({\n      ...newOptions,\n      onExecute: (rateLimiter) => {\n        setExecutionCount(rateLimiter.getExecutionCount())\n        setRemainingInWindow(rateLimiter.getRemainingInWindow())\n        setMsUntilNextWindow(rateLimiter.getMsUntilNextWindow())\n\n        const onExecute = newOptions.onExecute ?? initialOptions.onExecute\n        onExecute?.(rateLimiter)\n      },\n      onReject: (rateLimiter) => {\n        setRejectionCount(rateLimiter.getRejectionCount())\n        setRemainingInWindow(rateLimiter.getRemainingInWindow())\n        setMsUntilNextWindow(rateLimiter.getMsUntilNextWindow())\n\n        const onReject = newOptions.onReject ?? initialOptions.onReject\n        onReject?.(rateLimiter)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...rateLimiter,\n    executionCount,\n    rejectionCount,\n    remainingInWindow,\n    msUntilNextWindow,\n    setOptions,\n  } as SolidRateLimiter<TFn>\n}\n"],"names":["rateLimiter"],"mappings":";;;AA6DgB,SAAA,kBACd,IACA,gBACuB;AACvB,QAAM,cAAc;AAAA,IAClB,IAAI,YAAiB,IAAI,cAAc;AAAA,EACzC;AAEM,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,YAAY,kBAAkB;AAAA,EAChC;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,YAAY,kBAAkB;AAAA,EAChC;AACM,QAAA,CAAC,mBAAmB,oBAAoB,IAAI;AAAA,IAChD,YAAY,qBAAqB;AAAA,EACnC;AACM,QAAA,CAAC,mBAAmB,oBAAoB,IAAI;AAAA,IAChD,YAAY,qBAAqB;AAAA,EACnC;AAEA,WAAS,WAAW,YAA8C;AAChE,gBAAY,WAAW;AAAA,MACrB,GAAG;AAAA,MACH,WAAW,CAACA,iBAAgB;AACRA,0BAAAA,aAAY,mBAAmB;AAC5BA,6BAAAA,aAAY,sBAAsB;AAClCA,6BAAAA,aAAY,sBAAsB;AAEjD,cAAA,YAAY,WAAW,aAAa,eAAe;AACzD,+CAAYA;AAAAA,MACd;AAAA,MACA,UAAU,CAACA,iBAAgB;AACPA,0BAAAA,aAAY,mBAAmB;AAC5BA,6BAAAA,aAAY,sBAAsB;AAClCA,6BAAAA,aAAY,sBAAsB;AAEjD,cAAA,WAAW,WAAW,YAAY,eAAe;AACvD,6CAAWA;AAAAA,MAAW;AAAA,IACxB,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}
+{"version":3,"file":"createRateLimiter.js","sources":["../../../src/rate-limiter/createRateLimiter.ts"],"sourcesContent":["import { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { useStore } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\nexport interface SolidRateLimiter<\n  TFn extends AnyFunction,\n  TSelected = RateLimiterState,\n> extends Omit<RateLimiter<TFn>, 'store'> {\n  /**\n   * Reactive state that will be updated when the rate limiter state changes\n   *\n   * Use this instead of `rateLimiter.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n}\n\n/**\n * A low-level Solid hook that creates a `RateLimiter` instance to enforce rate limits on function execution.\n *\n * This hook is designed to be flexible and state-management agnostic - it simply returns a rate limiter instance that\n * you can integrate with any state management solution (createSignal, etc).\n *\n * Rate limiting is a simple \"hard limit\" approach that allows executions until a maximum count is reached within\n * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,\n * it does not attempt to space out or collapse executions intelligently.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n *   consistent rate of execution over time.\n *\n * For smoother execution patterns:\n * - Use throttling when you want consistent spacing between executions (e.g. UI updates)\n * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)\n * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)\n *\n * @example\n * ```tsx\n * // Basic rate limiting - max 5 calls per minute with a sliding window\n * const rateLimiter = createRateLimiter(apiCall, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding',\n *   onReject: (rateLimiter) => {\n *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access rate limiter state via signals\n * console.log('Executions:', rateLimiter.executionCount());\n * console.log('Rejections:', rateLimiter.rejectionCount());\n * console.log('Remaining:', rateLimiter.remainingInWindow());\n * console.log('Next window in:', rateLimiter.msUntilNextWindow());\n * ```\n */\nexport function createRateLimiter<\n  TFn extends AnyFunction,\n  TSelected = RateLimiterState,\n>(\n  fn: TFn,\n  initialOptions: RateLimiterOptions<TFn>,\n  selector?: (state: RateLimiterState) => TSelected,\n): SolidRateLimiter<TFn, TSelected> {\n  const rateLimiter = new RateLimiter<TFn>(fn, initialOptions)\n\n  const state = useStore(rateLimiter.store, selector)\n\n  return {\n    ...rateLimiter,\n    state,\n  } as unknown as SolidRateLimiter<TFn, TSelected> // omit `store` in favor of `state`\n}\n"],"names":[],"mappings":";;AA6DO,SAAS,kBAId,IACA,gBACA,UACkC;AAClC,QAAM,cAAc,IAAI,YAAiB,IAAI,cAAc;AAE3D,QAAM,QAAQ,SAAS,YAAY,OAAO,QAAQ;AAElD,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EAAA;AAEJ;"}

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

@@ -1,6 +1,6 @@
 import { SolidThrottler } from './createThrottler.js';
 import { Accessor, Setter } from 'solid-js';
-import { ThrottlerOptions } from '@tanstack/pacer/throttler';
+import { ThrottlerOptions, ThrottlerState } from '@tanstack/pacer/throttler';
 /**
  * A Solid hook that creates a throttled state value that updates at most once within a specified time window.
  * This hook combines Solid's createSignal with throttling functionality to provide controlled state updates.
@@ -35,4 +35,8 @@ import { ThrottlerOptions } from '@tanstack/pacer/throttler';
  * console.log('Next execution:', throttler.nextExecutionTime());
  * ```
  */
-export declare function createThrottledSignal<TValue>(value: TValue, initialOptions: ThrottlerOptions<Setter<TValue>>): [Accessor<TValue>, Setter<TValue>, SolidThrottler<Setter<TValue>>];
+export declare function createThrottledSignal<TValue, TSelected = ThrottlerState<Setter<TValue>>>(value: TValue, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): [
+    Accessor<TValue>,
+    Setter<TValue>,
+    SolidThrottler<Setter<TValue>, TSelected>
+];

package/dist/esm/throttler/createThrottledSignal.js

@@ -1,8 +1,8 @@
 import { createSignal } from "solid-js";
 import { createThrottler } from "./createThrottler.js";
-function createThrottledSignal(value, initialOptions) {
+function createThrottledSignal(value, initialOptions, selector) {
   const [throttledValue, setThrottledValue] = createSignal(value);
-  const throttler = createThrottler(setThrottledValue, initialOptions);
+  const throttler = createThrottler(setThrottledValue, initialOptions, selector);
   return [throttledValue, throttler.maybeExecute, throttler];
 }
 export {