@tanstack/solid-pacer 0.2.0 → 0.3.0

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

@@ -1 +1 @@
-{"version":3,"file":"createThrottledValue.js","sources":["../../../src/throttler/createThrottledValue.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport { createThrottledSignal } from './createThrottledSignal'\nimport type { SolidThrottler } from './createThrottler'\nimport type { Accessor, Setter } from 'solid-js'\nimport type { ThrottlerOptions } from '@tanstack/pacer/throttler'\n\n/**\n * A high-level Solid hook that creates a throttled version of a value that updates at most once within a specified time window.\n * This hook uses Solid's createSignal internally to manage the throttled state.\n *\n * Throttling ensures the value updates occur at a controlled rate regardless of how frequently the input value changes.\n * This is useful for rate-limiting expensive re-renders or API calls that depend on rapidly changing values.\n *\n * The hook returns both the throttled value and the underlying throttler instance for additional control.\n * The throttled value will update according to the leading/trailing edge behavior specified in the options.\n *\n * For more direct control over throttling behavior without Solid state management,\n * consider using the lower-level createThrottler hook instead.\n *\n * @example\n * ```tsx\n * // Basic throttling - update at most once per second\n * const [throttledValue] = createThrottledValue(rawValue, { wait: 1000 });\n *\n * // With custom leading/trailing behavior\n * const [throttledValue, throttler] = createThrottledValue(rawValue, {\n *   wait: 1000,\n *   leading: true,   // Update immediately on first change\n *   trailing: false  // Skip trailing edge updates\n * });\n *\n * // Access throttler state via signals\n * console.log('Executions:', throttler.executionCount());\n * console.log('Is pending:', throttler.isPending());\n * console.log('Last execution:', throttler.lastExecutionTime());\n * console.log('Next execution:', throttler.nextExecutionTime());\n * ```\n */\nexport function createThrottledValue<TValue>(\n  value: Accessor<TValue>,\n  initialOptions: ThrottlerOptions<Setter<TValue>, [Accessor<TValue>]>,\n): [Accessor<TValue>, SolidThrottler<Setter<TValue>, [Accessor<TValue>]>] {\n  const [throttledValue, setThrottledValue, throttler] = createThrottledSignal(\n    value(),\n    initialOptions,\n  )\n\n  createEffect(() => {\n    setThrottledValue(value() as any)\n    onCleanup(() => {\n      throttler.cancel()\n    })\n  })\n\n  return [throttledValue, throttler]\n}\n"],"names":[],"mappings":";;AAsCgB,SAAA,qBACd,OACA,gBACwE;AACxE,QAAM,CAAC,gBAAgB,mBAAmB,SAAS,IAAI;AAAA,IACrD,MAAM;AAAA,IACN;AAAA,EACF;AAEA,eAAa,MAAM;AACjB,sBAAkB,OAAc;AAChC,cAAU,MAAM;AACd,gBAAU,OAAO;AAAA,IAAA,CAClB;AAAA,EAAA,CACF;AAEM,SAAA,CAAC,gBAAgB,SAAS;AACnC;"}
+{"version":3,"file":"createThrottledValue.js","sources":["../../../src/throttler/createThrottledValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createThrottledSignal } from './createThrottledSignal'\nimport type { SolidThrottler } from './createThrottler'\nimport type { Accessor, Setter } from 'solid-js'\nimport type { ThrottlerOptions } from '@tanstack/pacer/throttler'\n\n/**\n * A high-level Solid hook that creates a throttled version of a value that updates at most once within a specified time window.\n * This hook uses Solid's createSignal internally to manage the throttled state.\n *\n * Throttling ensures the value updates occur at a controlled rate regardless of how frequently the input value changes.\n * This is useful for rate-limiting expensive re-renders or API calls that depend on rapidly changing values.\n *\n * The hook returns a tuple containing:\n * - An accessor function that provides the throttled value\n * - The throttler instance with control methods\n *\n * The throttled value will update according to the leading/trailing edge behavior specified in the options.\n *\n * For more direct control over throttling behavior without Solid state management,\n * consider using the lower-level createThrottler hook instead.\n *\n * @example\n * ```tsx\n * // Basic throttling - update at most once per second\n * const [throttledValue, throttler] = createThrottledValue(rawValue, { wait: 1000 });\n *\n * // Use the throttled value\n * console.log(throttledValue()); // Access the current throttled value\n *\n * // Control the throttler\n * throttler.cancel(); // Cancel any pending updates\n * ```\n */\nexport function createThrottledValue<TValue>(\n  value: Accessor<TValue>,\n  initialOptions: ThrottlerOptions<Setter<TValue>>,\n): [Accessor<TValue>, SolidThrottler<Setter<TValue>>] {\n  const [throttledValue, setThrottledValue, throttler] = createThrottledSignal(\n    value(),\n    initialOptions,\n  )\n\n  createEffect(() => {\n    setThrottledValue(value() as any)\n  })\n\n  return [throttledValue, throttler]\n}\n"],"names":[],"mappings":";;AAkCgB,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;"}

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

@@ -4,7 +4,7 @@ import { AnyFunction } from '@tanstack/pacer/types';
 /**
  * An extension of the Throttler class that adds Solid signals to access the internal state of the throttler
  */
-export interface SolidThrottler<TFn extends AnyFunction, TArgs extends Parameters<TFn>> extends Omit<Throttler<TFn, TArgs>, 'getExecutionCount' | 'getIsPending' | 'getLastExecutionTime' | 'getNextExecutionTime'> {
+export interface SolidThrottler<TFn extends AnyFunction> extends Omit<Throttler<TFn>, 'getExecutionCount' | 'getIsPending' | 'getLastExecutionTime' | 'getNextExecutionTime'> {
     executionCount: Accessor<number>;
     isPending: Accessor<boolean>;
     lastExecutionTime: Accessor<number>;
@@ -44,4 +44,4 @@ export interface SolidThrottler<TFn extends AnyFunction, TArgs extends Parameter
  * console.log(throttler.nextExecutionTime()); // timestamp of next allowed execution
  * ```
  */
-export declare function createThrottler<TFn extends AnyFunction, TArgs extends Parameters<TFn>>(fn: TFn, initialOptions: ThrottlerOptions<TFn, TArgs>): SolidThrottler<TFn, TArgs>;
+export declare function createThrottler<TFn extends AnyFunction>(fn: TFn, initialOptions: ThrottlerOptions<TFn>): SolidThrottler<TFn>;

package/dist/esm/throttler/createThrottler.js

@@ -1,8 +1,8 @@
 import { Throttler } from "@tanstack/pacer/throttler";
-import { createSignal } from "solid-js";
+import { createSignal, createEffect, onCleanup } from "solid-js";
 import { bindInstanceMethods } from "@tanstack/pacer/utils";
 function createThrottler(fn, initialOptions) {
-  const throttler = new Throttler(fn, initialOptions);
+  const throttler = bindInstanceMethods(new Throttler(fn, initialOptions));
   const [executionCount, setExecutionCount] = createSignal(
     throttler.getExecutionCount()
   );
@@ -27,8 +27,13 @@ function createThrottler(fn, initialOptions) {
     });
   }
   setOptions(initialOptions);
+  createEffect(() => {
+    onCleanup(() => {
+      throttler.cancel();
+    });
+  });
   return {
-    ...bindInstanceMethods(throttler),
+    ...throttler,
     executionCount,
     isPending,
     lastExecutionTime,

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

@@ -1 +1 @@
-{"version":3,"file":"createThrottler.js","sources":["../../../src/throttler/createThrottler.ts"],"sourcesContent":["import { Throttler } from '@tanstack/pacer/throttler'\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 { ThrottlerOptions } from '@tanstack/pacer/throttler'\n\n/**\n * An extension of the Throttler class that adds Solid signals to access the internal state of the throttler\n */\nexport interface SolidThrottler<\n  TFn extends AnyFunction,\n  TArgs extends Parameters<TFn>,\n> extends Omit<\n    Throttler<TFn, TArgs>,\n    | 'getExecutionCount'\n    | 'getIsPending'\n    | 'getLastExecutionTime'\n    | 'getNextExecutionTime'\n  > {\n  executionCount: Accessor<number>\n  isPending: Accessor<boolean>\n  lastExecutionTime: Accessor<number>\n  nextExecutionTime: Accessor<number>\n}\n\n/**\n * A low-level Solid hook that creates a `Throttler` instance that limits how often the provided function can execute.\n *\n * This hook is designed to be flexible and state-management agnostic - it simply returns a throttler instance that\n * you can integrate with any state management solution (createSignal, Redux, Zustand, Jotai, etc). For a simpler and higher-level hook that\n * integrates directly with Solid's createSignal, see createThrottledSignal.\n *\n * Throttling ensures a function executes at most once within a specified time window,\n * regardless of how many times it is called. This is useful for rate-limiting\n * expensive operations or UI updates.\n *\n * @example\n * ```tsx\n * // Basic throttling with custom state\n * const [value, setValue] = createSignal(0);\n * const throttler = createThrottler(setValue, { wait: 1000 });\n *\n * // With any state manager\n * const throttler = createThrottler(\n *   (value) => stateManager.setState(value),\n *   {\n *     wait: 2000,\n *     leading: true,   // Execute immediately on first call\n *     trailing: false  // Skip trailing edge updates\n *   }\n * );\n *\n * // Access throttler state via signals\n * console.log(throttler.executionCount()); // number of times executed\n * console.log(throttler.isPending());      // whether throttled function is pending\n * console.log(throttler.lastExecutionTime()); // timestamp of last execution\n * console.log(throttler.nextExecutionTime()); // timestamp of next allowed execution\n * ```\n */\nexport function createThrottler<\n  TFn extends AnyFunction,\n  TArgs extends Parameters<TFn>,\n>(\n  fn: TFn,\n  initialOptions: ThrottlerOptions<TFn, TArgs>,\n): SolidThrottler<TFn, TArgs> {\n  const throttler = new Throttler<TFn, TArgs>(fn, initialOptions)\n\n  const [executionCount, setExecutionCount] = createSignal(\n    throttler.getExecutionCount(),\n  )\n  const [isPending, setIsPending] = createSignal(throttler.getIsPending())\n  const [lastExecutionTime, setLastExecutionTime] = createSignal(\n    throttler.getLastExecutionTime(),\n  )\n  const [nextExecutionTime, setNextExecutionTime] = createSignal(\n    throttler.getNextExecutionTime(),\n  )\n\n  function setOptions(newOptions: Partial<ThrottlerOptions<TFn, TArgs>>) {\n    throttler.setOptions({\n      ...newOptions,\n      onExecute: (throttler) => {\n        setExecutionCount(throttler.getExecutionCount())\n        setIsPending(throttler.getIsPending())\n        setLastExecutionTime(throttler.getLastExecutionTime())\n        setNextExecutionTime(throttler.getNextExecutionTime())\n\n        const onExecute = newOptions.onExecute ?? initialOptions.onExecute\n        onExecute?.(throttler)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...bindInstanceMethods(throttler),\n    executionCount,\n    isPending,\n    lastExecutionTime,\n    nextExecutionTime,\n    setOptions,\n  }\n}\n"],"names":["throttler"],"mappings":";;;AA4DgB,SAAA,gBAId,IACA,gBAC4B;AAC5B,QAAM,YAAY,IAAI,UAAsB,IAAI,cAAc;AAExD,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,UAAU,kBAAkB;AAAA,EAC9B;AACA,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,UAAU,cAAc;AACjE,QAAA,CAAC,mBAAmB,oBAAoB,IAAI;AAAA,IAChD,UAAU,qBAAqB;AAAA,EACjC;AACM,QAAA,CAAC,mBAAmB,oBAAoB,IAAI;AAAA,IAChD,UAAU,qBAAqB;AAAA,EACjC;AAEA,WAAS,WAAW,YAAmD;AACrE,cAAU,WAAW;AAAA,MACnB,GAAG;AAAA,MACH,WAAW,CAACA,eAAc;AACNA,0BAAAA,WAAU,mBAAmB;AAClCA,qBAAAA,WAAU,cAAc;AAChBA,6BAAAA,WAAU,sBAAsB;AAChCA,6BAAAA,WAAU,sBAAsB;AAE/C,cAAA,YAAY,WAAW,aAAa,eAAe;AACzD,+CAAYA;AAAAA,MAAS;AAAA,IACvB,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAG,oBAAoB,SAAS;AAAA,IAChC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}
+{"version":3,"file":"createThrottler.js","sources":["../../../src/throttler/createThrottler.ts"],"sourcesContent":["import { Throttler } from '@tanstack/pacer/throttler'\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 { ThrottlerOptions } from '@tanstack/pacer/throttler'\n\n/**\n * An extension of the Throttler class that adds Solid signals to access the internal state of the throttler\n */\nexport interface SolidThrottler<TFn extends AnyFunction>\n  extends Omit<\n    Throttler<TFn>,\n    | 'getExecutionCount'\n    | 'getIsPending'\n    | 'getLastExecutionTime'\n    | 'getNextExecutionTime'\n  > {\n  executionCount: Accessor<number>\n  isPending: Accessor<boolean>\n  lastExecutionTime: Accessor<number>\n  nextExecutionTime: Accessor<number>\n}\n\n/**\n * A low-level Solid hook that creates a `Throttler` instance that limits how often the provided function can execute.\n *\n * This hook is designed to be flexible and state-management agnostic - it simply returns a throttler instance that\n * you can integrate with any state management solution (createSignal, Redux, Zustand, Jotai, etc). For a simpler and higher-level hook that\n * integrates directly with Solid's createSignal, see createThrottledSignal.\n *\n * Throttling ensures a function executes at most once within a specified time window,\n * regardless of how many times it is called. This is useful for rate-limiting\n * expensive operations or UI updates.\n *\n * @example\n * ```tsx\n * // Basic throttling with custom state\n * const [value, setValue] = createSignal(0);\n * const throttler = createThrottler(setValue, { wait: 1000 });\n *\n * // With any state manager\n * const throttler = createThrottler(\n *   (value) => stateManager.setState(value),\n *   {\n *     wait: 2000,\n *     leading: true,   // Execute immediately on first call\n *     trailing: false  // Skip trailing edge updates\n *   }\n * );\n *\n * // Access throttler state via signals\n * console.log(throttler.executionCount()); // number of times executed\n * console.log(throttler.isPending());      // whether throttled function is pending\n * console.log(throttler.lastExecutionTime()); // timestamp of last execution\n * console.log(throttler.nextExecutionTime()); // timestamp of next allowed execution\n * ```\n */\nexport function createThrottler<TFn extends AnyFunction>(\n  fn: TFn,\n  initialOptions: ThrottlerOptions<TFn>,\n): SolidThrottler<TFn> {\n  const throttler = bindInstanceMethods(new Throttler<TFn>(fn, initialOptions))\n\n  const [executionCount, setExecutionCount] = createSignal(\n    throttler.getExecutionCount(),\n  )\n  const [isPending, setIsPending] = createSignal(throttler.getIsPending())\n  const [lastExecutionTime, setLastExecutionTime] = createSignal(\n    throttler.getLastExecutionTime(),\n  )\n  const [nextExecutionTime, setNextExecutionTime] = createSignal(\n    throttler.getNextExecutionTime(),\n  )\n\n  function setOptions(newOptions: Partial<ThrottlerOptions<TFn>>) {\n    throttler.setOptions({\n      ...newOptions,\n      onExecute: (throttler) => {\n        setExecutionCount(throttler.getExecutionCount())\n        setIsPending(throttler.getIsPending())\n        setLastExecutionTime(throttler.getLastExecutionTime())\n        setNextExecutionTime(throttler.getNextExecutionTime())\n\n        const onExecute = newOptions.onExecute ?? initialOptions.onExecute\n        onExecute?.(throttler)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  createEffect(() => {\n    onCleanup(() => {\n      throttler.cancel()\n    })\n  })\n\n  return {\n    ...throttler,\n    executionCount,\n    isPending,\n    lastExecutionTime,\n    nextExecutionTime,\n    setOptions,\n  } as SolidThrottler<TFn>\n}\n"],"names":["throttler"],"mappings":";;;AA0DgB,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;AACjE,QAAA,CAAC,mBAAmB,oBAAoB,IAAI;AAAA,IAChD,UAAU,qBAAqB;AAAA,EACjC;AACM,QAAA,CAAC,mBAAmB,oBAAoB,IAAI;AAAA,IAChD,UAAU,qBAAqB;AAAA,EACjC;AAEA,WAAS,WAAW,YAA4C;AAC9D,cAAU,WAAW;AAAA,MACnB,GAAG;AAAA,MACH,WAAW,CAACA,eAAc;AACNA,0BAAAA,WAAU,mBAAmB;AAClCA,qBAAAA,WAAU,cAAc;AAChBA,6BAAAA,WAAU,sBAAsB;AAChCA,6BAAAA,WAAU,sBAAsB;AAE/C,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,IACA;AAAA,IACA;AAAA,EACF;AACF;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-pacer",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Utilities for debouncing and throttling functions in Solid.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -142,7 +142,7 @@
     "src"
   ],
   "dependencies": {
-    "@tanstack/pacer": "0.2.0"
+    "@tanstack/pacer": "0.3.0"
   },
   "devDependencies": {
     "solid-js": "^1.9.5",

package/src/async-debouncer/createAsyncDebouncer.ts

@@ -5,15 +5,20 @@ import type { AsyncDebouncerOptions } from '@tanstack/pacer/async-debouncer'
 import type { AnyAsyncFunction } from '@tanstack/pacer/types'
 import type { Accessor } from 'solid-js'
 
-export interface SolidAsyncDebouncer<
-  TFn extends AnyAsyncFunction,
-  TArgs extends Parameters<TFn>,
-> extends Omit<
-    AsyncDebouncer<TFn, TArgs>,
-    'getExecutionCount' | 'getIsPending'
+export interface SolidAsyncDebouncer<TFn extends AnyAsyncFunction>
+  extends Omit<
+    AsyncDebouncer<TFn>,
+    | 'getErrorCount'
+    | 'getIsPending'
+    | 'getLastResult'
+    | 'getSettleCount'
+    | 'getSuccessCount'
   > {
-  executionCount: Accessor<number>
+  errorCount: Accessor<number>
   isPending: Accessor<boolean>
+  lastResult: Accessor<ReturnType<TFn> | undefined>
+  settleCount: Accessor<number>
+  successCount: Accessor<number>
 }
 
 /**
@@ -51,29 +56,37 @@ export interface SolidAsyncDebouncer<
  * ```
  */
 
-export function createAsyncDebouncer<
-  TFn extends AnyAsyncFunction,
-  TArgs extends Parameters<TFn>,
->(
+export function createAsyncDebouncer<TFn extends AnyAsyncFunction>(
   fn: TFn,
-  initialOptions: AsyncDebouncerOptions<TFn, TArgs>,
-): SolidAsyncDebouncer<TFn, TArgs> {
-  const asyncDebouncer = new AsyncDebouncer<TFn, TArgs>(fn, initialOptions)
+  initialOptions: AsyncDebouncerOptions<TFn>,
+): SolidAsyncDebouncer<TFn> {
+  const asyncDebouncer = new AsyncDebouncer<TFn>(fn, initialOptions)
 
-  const [executionCount, setExecutionCount] = createSignal(
-    asyncDebouncer.getExecutionCount(),
+  const [errorCount, setErrorCount] = createSignal(
+    asyncDebouncer.getErrorCount(),
+  )
+  const [settleCount, setSettleCount] = createSignal(
+    asyncDebouncer.getSettleCount(),
+  )
+  const [successCount, setSuccessCount] = createSignal(
+    asyncDebouncer.getSuccessCount(),
   )
   const [isPending, setIsPending] = createSignal(asyncDebouncer.getIsPending())
+  const [lastResult, setLastResult] = createSignal(
+    asyncDebouncer.getLastResult(),
+  )
 
-  function setOptions(newOptions: Partial<AsyncDebouncerOptions<TFn, TArgs>>) {
+  function setOptions(newOptions: Partial<AsyncDebouncerOptions<TFn>>) {
     asyncDebouncer.setOptions({
       ...newOptions,
-      onExecute: (asyncDebouncer) => {
-        setExecutionCount(asyncDebouncer.getExecutionCount())
+      onSettled: (asyncDebouncer) => {
+        setSuccessCount(asyncDebouncer.getSuccessCount())
+        setErrorCount(asyncDebouncer.getErrorCount())
+        setSettleCount(asyncDebouncer.getSettleCount())
         setIsPending(asyncDebouncer.getIsPending())
-
-        const onExecute = newOptions.onExecute ?? initialOptions.onExecute
-        onExecute?.(asyncDebouncer)
+        setLastResult(asyncDebouncer.getLastResult())
+        const onSettled = newOptions.onSettled ?? initialOptions.onSettled
+        onSettled?.(asyncDebouncer)
       },
     })
   }
@@ -82,8 +95,11 @@ export function createAsyncDebouncer<
 
   return {
     ...bindInstanceMethods(asyncDebouncer),
-    executionCount,
+    errorCount,
     isPending,
+    lastResult,
+    settleCount,
+    successCount,
     setOptions,
-  }
+  } as SolidAsyncDebouncer<TFn>
 }

package/src/async-queuer/createAsyncQueuer.ts

@@ -49,11 +49,15 @@ export interface SolidAsyncQueuer<TValue>
   /**
    * Signal version of `getPeek`
    */
-  peek: Accessor<TValue | undefined>
+  peek: Accessor<(() => Promise<TValue>) | undefined>
   /**
    * Signal version of `getPendingItems`
    */
   pendingItems: Accessor<Array<() => Promise<TValue>>>
+  /**
+   * Signal version of `getRejectionCount`
+   */
+  rejectionCount: Accessor<number>
   /**
    * Signal version of `getSize`
    */
@@ -171,5 +175,5 @@ export function createAsyncQueuer<TValue>(
     pendingItems,
     rejectionCount,
     size,
-  }
+  } as SolidAsyncQueuer<TValue>
 }

package/src/async-rate-limiter/createAsyncRateLimiter.ts

@@ -5,17 +5,19 @@ import type { Accessor } from 'solid-js'
 import type { AnyAsyncFunction } from '@tanstack/pacer/types'
 import type { AsyncRateLimiterOptions } from '@tanstack/pacer/async-rate-limiter'
 
-export interface SolidAsyncRateLimiter<
-  TFn extends AnyAsyncFunction,
-  TArgs extends Parameters<TFn>,
-> extends Omit<
-    AsyncRateLimiter<TFn, TArgs>,
-    | 'getExecutionCount'
+export interface SolidAsyncRateLimiter<TFn extends AnyAsyncFunction>
+  extends Omit<
+    AsyncRateLimiter<TFn>,
+    | 'getSuccessCount'
+    | 'getSettleCount'
+    | 'getErrorCount'
     | 'getRejectionCount'
     | 'getRemainingInWindow'
     | 'getMsUntilNextWindow'
   > {
-  executionCount: Accessor<number>
+  successCount: Accessor<number>
+  settleCount: Accessor<number>
+  errorCount: Accessor<number>
   rejectionCount: Accessor<number>
   remainingInWindow: Accessor<number>
   msUntilNextWindow: Accessor<number>
@@ -57,21 +59,24 @@ export interface SolidAsyncRateLimiter<
  * );
  * ```
  */
-export function createAsyncRateLimiter<
-  TFn extends AnyAsyncFunction,
-  TArgs extends Parameters<TFn>,
->(
+export function createAsyncRateLimiter<TFn extends AnyAsyncFunction>(
   fn: TFn,
-  initialOptions: AsyncRateLimiterOptions<TFn, TArgs>,
-): SolidAsyncRateLimiter<TFn, TArgs> {
-  const asyncRateLimiter = new AsyncRateLimiter<TFn, TArgs>(fn, initialOptions)
+  initialOptions: AsyncRateLimiterOptions<TFn>,
+): SolidAsyncRateLimiter<TFn> {
+  const asyncRateLimiter = new AsyncRateLimiter<TFn>(fn, initialOptions)
 
-  const [executionCount, setExecutionCount] = createSignal(
-    asyncRateLimiter.getExecutionCount(),
+  const [successCount, setSuccessCount] = createSignal(
+    asyncRateLimiter.getSuccessCount(),
   )
   const [rejectionCount, setRejectionCount] = createSignal(
     asyncRateLimiter.getRejectionCount(),
   )
+  const [errorCount, setErrorCount] = createSignal(
+    asyncRateLimiter.getErrorCount(),
+  )
+  const [settleCount, setSettleCount] = createSignal(
+    asyncRateLimiter.getSettleCount(),
+  )
   const [remainingInWindow, setRemainingInWindow] = createSignal(
     asyncRateLimiter.getRemainingInWindow(),
   )
@@ -79,18 +84,19 @@ export function createAsyncRateLimiter<
     asyncRateLimiter.getMsUntilNextWindow(),
   )
 
-  function setOptions(
-    newOptions: Partial<AsyncRateLimiterOptions<TFn, TArgs>>,
-  ) {
+  function setOptions(newOptions: Partial<AsyncRateLimiterOptions<TFn>>) {
     asyncRateLimiter.setOptions({
       ...newOptions,
-      onExecute: (rateLimiter) => {
-        setExecutionCount(rateLimiter.getExecutionCount())
+      onSettled: (rateLimiter) => {
+        setSuccessCount(rateLimiter.getSuccessCount())
+        setSettleCount(rateLimiter.getSettleCount())
+        setErrorCount(rateLimiter.getErrorCount())
+        setRejectionCount(rateLimiter.getRejectionCount())
         setRemainingInWindow(rateLimiter.getRemainingInWindow())
         setMsUntilNextWindow(rateLimiter.getMsUntilNextWindow())
 
-        const onExecute = newOptions.onExecute ?? initialOptions.onExecute
-        onExecute?.(rateLimiter)
+        const onSettled = newOptions.onSettled ?? initialOptions.onSettled
+        onSettled?.(rateLimiter)
       },
       onReject: (rateLimiter) => {
         setRejectionCount(rateLimiter.getRejectionCount())
@@ -107,10 +113,12 @@ export function createAsyncRateLimiter<
 
   return {
     ...bindInstanceMethods(asyncRateLimiter),
-    executionCount,
-    rejectionCount,
+    errorCount,
     remainingInWindow,
     msUntilNextWindow,
+    rejectionCount,
     setOptions,
-  }
+    settleCount,
+    successCount,
+  } as SolidAsyncRateLimiter<TFn>
 }

package/src/async-throttler/createAsyncThrottler.ts

@@ -5,18 +5,24 @@ import type { Accessor } from 'solid-js'
 import type { AnyAsyncFunction } from '@tanstack/pacer/types'
 import type { AsyncThrottlerOptions } from '@tanstack/pacer/async-throttler'
 
-export interface SolidAsyncThrottler<
-  TFn extends AnyAsyncFunction,
-  TArgs extends Parameters<TFn>,
-> extends Omit<
-    AsyncThrottler<TFn, TArgs>,
-    | 'getExecutionCount'
+export interface SolidAsyncThrottler<TFn extends AnyAsyncFunction>
+  extends Omit<
+    AsyncThrottler<TFn>,
+    | 'getSuccessCount'
+    | 'getSettleCount'
+    | 'getErrorCount'
     | 'getIsPending'
+    | 'getIsExecuting'
+    | 'getLastResult'
     | 'getLastExecutionTime'
     | 'getNextExecutionTime'
   > {
-  executionCount: Accessor<number>
+  successCount: Accessor<number>
+  settleCount: Accessor<number>
+  errorCount: Accessor<number>
   isPending: Accessor<boolean>
+  isExecuting: Accessor<boolean>
+  lastResult: Accessor<ReturnType<TFn> | undefined>
   lastExecutionTime: Accessor<number>
   nextExecutionTime: Accessor<number>
 }
@@ -58,19 +64,30 @@ export interface SolidAsyncThrottler<
  * ```
  */
 
-export function createAsyncThrottler<
-  TFn extends AnyAsyncFunction,
-  TArgs extends Parameters<TFn>,
->(
+export function createAsyncThrottler<TFn extends AnyAsyncFunction>(
   fn: TFn,
-  initialOptions: AsyncThrottlerOptions<TFn, TArgs>,
-): SolidAsyncThrottler<TFn, TArgs> {
-  const asyncThrottler = new AsyncThrottler<TFn, TArgs>(fn, initialOptions)
+  initialOptions: AsyncThrottlerOptions<TFn>,
+): SolidAsyncThrottler<TFn> {
+  const asyncThrottler = bindInstanceMethods(
+    new AsyncThrottler<TFn>(fn, initialOptions),
+  )
 
-  const [executionCount, setExecutionCount] = createSignal(
-    asyncThrottler.getExecutionCount(),
+  const [successCount, setSuccessCount] = createSignal(
+    asyncThrottler.getSuccessCount(),
+  )
+  const [settleCount, setSettleCount] = createSignal(
+    asyncThrottler.getSettleCount(),
+  )
+  const [errorCount, setErrorCount] = createSignal(
+    asyncThrottler.getErrorCount(),
   )
   const [isPending, setIsPending] = createSignal(asyncThrottler.getIsPending())
+  const [isExecuting, setIsExecuting] = createSignal(
+    asyncThrottler.getIsExecuting(),
+  )
+  const [lastResult, setLastResult] = createSignal(
+    asyncThrottler.getLastResult(),
+  )
   const [lastExecutionTime, setLastExecutionTime] = createSignal(
     asyncThrottler.getLastExecutionTime(),
   )
@@ -78,17 +95,21 @@ export function createAsyncThrottler<
     asyncThrottler.getNextExecutionTime(),
   )
 
-  function setOptions(newOptions: Partial<AsyncThrottlerOptions<TFn, TArgs>>) {
+  function setOptions(newOptions: Partial<AsyncThrottlerOptions<TFn>>) {
     asyncThrottler.setOptions({
       ...newOptions,
-      onExecute: (throttler) => {
-        setExecutionCount(throttler.getExecutionCount())
+      onSettled: (throttler) => {
+        setSuccessCount(throttler.getSuccessCount())
+        setSettleCount(throttler.getSettleCount())
+        setErrorCount(throttler.getErrorCount())
         setIsPending(throttler.getIsPending())
+        setIsExecuting(throttler.getIsExecuting())
         setLastExecutionTime(throttler.getLastExecutionTime())
         setNextExecutionTime(throttler.getNextExecutionTime())
+        setLastResult(throttler.getLastResult())
 
-        const onExecute = newOptions.onExecute ?? initialOptions.onExecute
-        onExecute?.(throttler)
+        const onSettled = newOptions.onSettled ?? initialOptions.onSettled
+        onSettled?.(throttler)
       },
     })
   }
@@ -96,11 +117,15 @@ export function createAsyncThrottler<
   setOptions(initialOptions)
 
   return {
-    ...bindInstanceMethods(asyncThrottler),
-    executionCount,
+    ...asyncThrottler,
+    errorCount,
+    isExecuting,
     isPending,
     lastExecutionTime,
+    lastResult,
     nextExecutionTime,
     setOptions,
-  }
+    settleCount,
+    successCount,
+  } as SolidAsyncThrottler<TFn>
 }

package/src/debouncer/createDebouncedSignal.ts

@@ -45,12 +45,8 @@ import type { DebouncerOptions } from '@tanstack/pacer/debouncer'
  */
 export function createDebouncedSignal<TValue>(
   value: TValue,
-  initialOptions: DebouncerOptions<Setter<TValue>, [Accessor<TValue>]>,
-): [
-  Accessor<TValue>,
-  Setter<TValue>,
-  SolidDebouncer<Setter<TValue>, [Accessor<TValue>]>,
-] {
+  initialOptions: DebouncerOptions<Setter<TValue>>,
+): [Accessor<TValue>, Setter<TValue>, SolidDebouncer<Setter<TValue>>] {
   const [debouncedValue, setDebouncedValue] = createSignal<TValue>(value)
 
   const debouncer = createDebouncer(setDebouncedValue, initialOptions)

package/src/debouncer/createDebouncedValue.ts

@@ -1,4 +1,4 @@
-import { createEffect, onCleanup } from 'solid-js'
+import { createEffect } from 'solid-js'
 import { createDebouncedSignal } from './createDebouncedSignal'
 import type { SolidDebouncer } from './createDebouncer'
 import type { Accessor, Setter } from 'solid-js'
@@ -18,8 +18,8 @@ import type { DebouncerOptions } from '@tanstack/pacer/debouncer'
  * or calculations occur.
  *
  * The hook returns a tuple containing:
- * - The current debounced value (as an Accessor)
- * - The debouncer instance with control methods and state signals
+ * - An Accessor that provides the current debounced value
+ * - The debouncer instance with control methods
  *
  * @example
  * ```tsx
@@ -34,20 +34,14 @@ import type { DebouncerOptions } from '@tanstack/pacer/debouncer'
  *   fetchSearchResults(debouncedQuery());
  * });
  *
- * // Access debouncer state via signals
- * console.log('Executions:', debouncer.executionCount());
- * console.log('Is pending:', debouncer.isPending());
- *
- * // Handle input changes
- * const handleChange = (e) => {
- *   setSearchQuery(e.target.value);
- * };
+ * // Control the debouncer
+ * debouncer.cancel(); // Cancel any pending updates
  * ```
  */
 export function createDebouncedValue<TValue>(
   value: Accessor<TValue>,
-  initialOptions: DebouncerOptions<Setter<TValue>, [Accessor<TValue>]>,
-): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, [Accessor<TValue>]>] {
+  initialOptions: DebouncerOptions<Setter<TValue>>,
+): [Accessor<TValue>, SolidDebouncer<Setter<TValue>>] {
   const [debouncedValue, setDebouncedValue, debouncer] = createDebouncedSignal(
     value(),
     initialOptions,
@@ -55,9 +49,6 @@ export function createDebouncedValue<TValue>(
 
   createEffect(() => {
     setDebouncedValue(value() as any)
-    onCleanup(() => {
-      debouncer.cancel()
-    })
   })
 
   return [debouncedValue, debouncer]

package/src/debouncer/createDebouncer.ts

@@ -1,5 +1,5 @@
 import { Debouncer } from '@tanstack/pacer/debouncer'
-import { createSignal } from 'solid-js'
+import { createEffect, createSignal, onCleanup } from 'solid-js'
 import { bindInstanceMethods } from '@tanstack/pacer/utils'
 import type { Accessor } from 'solid-js'
 import type { AnyFunction } from '@tanstack/pacer/types'
@@ -8,10 +8,8 @@ import type { DebouncerOptions } from '@tanstack/pacer/debouncer'
 /**
  * An extension of the Debouncer class that adds Solid signals to access the internal state of the debouncer
  */
-export interface SolidDebouncer<
-  TFn extends AnyFunction,
-  TArgs extends Parameters<TFn>,
-> extends Omit<Debouncer<TFn, TArgs>, 'getExecutionCount' | 'getIsPending'> {
+export interface SolidDebouncer<TFn extends AnyFunction>
+  extends Omit<Debouncer<TFn>, 'getExecutionCount' | 'getIsPending'> {
   executionCount: Accessor<number>
   isPending: Accessor<boolean>
 }
@@ -52,21 +50,18 @@ export interface SolidDebouncer<
  * debouncer.setOptions({ wait: 1000 });
  * ```
  */
-export function createDebouncer<
-  TFn extends AnyFunction,
-  TArgs extends Parameters<TFn>,
->(
+export function createDebouncer<TFn extends AnyFunction>(
   fn: TFn,
-  initialOptions: DebouncerOptions<TFn, TArgs>,
-): SolidDebouncer<TFn, TArgs> {
-  const debouncer = new Debouncer<TFn, TArgs>(fn, initialOptions)
+  initialOptions: DebouncerOptions<TFn>,
+): SolidDebouncer<TFn> {
+  const debouncer = bindInstanceMethods(new Debouncer<TFn>(fn, initialOptions))
 
   const [executionCount, setExecutionCount] = createSignal(
     debouncer.getExecutionCount(),
   )
   const [isPending, setIsPending] = createSignal(debouncer.getIsPending())
 
-  function setOptions(newOptions: Partial<DebouncerOptions<TFn, TArgs>>) {
+  function setOptions(newOptions: Partial<DebouncerOptions<TFn>>) {
     debouncer.setOptions({
       ...newOptions,
       onExecute: (debouncer) => {
@@ -81,10 +76,16 @@ export function createDebouncer<
 
   setOptions(initialOptions)
 
+  createEffect(() => {
+    onCleanup(() => {
+      debouncer.cancel()
+    })
+  })
+
   return {
-    ...bindInstanceMethods(debouncer),
+    ...debouncer,
     executionCount,
     isPending,
     setOptions,
-  }
+  } as SolidDebouncer<TFn>
 }

package/src/queuer/createQueuer.ts

@@ -44,6 +44,10 @@ export interface SolidQueuer<TValue>
    * Signal version of `getPeek`
    */
   peek: Accessor<TValue | undefined>
+  /**
+   * Signal version of `getRejectionCount`
+   */
+  rejectionCount: Accessor<number>
   /**
    * Signal version of `getSize`
    */
@@ -98,7 +102,7 @@ export interface SolidQueuer<TValue>
 export function createQueuer<TValue>(
   initialOptions: QueuerOptions<TValue> = {},
 ): SolidQueuer<TValue> {
-  const queuer = new Queuer<TValue>(initialOptions)
+  const queuer = bindInstanceMethods(new Queuer<TValue>(initialOptions))
 
   const [allItems, setAllItems] = createSignal<Array<TValue>>(
     queuer.getAllItems(),
@@ -152,7 +156,7 @@ export function createQueuer<TValue>(
   setOptions(initialOptions)
 
   return {
-    ...bindInstanceMethods(queuer),
+    ...queuer,
     allItems,
     executionCount,
     isEmpty,
@@ -163,5 +167,5 @@ export function createQueuer<TValue>(
     rejectionCount,
     size,
     setOptions,
-  }
+  } as SolidQueuer<TValue>
 }

package/src/rate-limiter/createRateLimitedSignal.ts

@@ -56,12 +56,8 @@ import type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'
  */
 export function createRateLimitedSignal<TValue>(
   value: TValue,
-  initialOptions: RateLimiterOptions<Setter<TValue>, [Accessor<TValue>]>,
-): [
-  Accessor<TValue>,
-  Setter<TValue>,
-  SolidRateLimiter<Setter<TValue>, [Accessor<TValue>]>,
-] {
+  initialOptions: RateLimiterOptions<Setter<TValue>>,
+): [Accessor<TValue>, Setter<TValue>, SolidRateLimiter<Setter<TValue>>] {
   const [rateLimitedValue, setRateLimitedValue] = createSignal<TValue>(value)
 
   const rateLimiter = createRateLimiter(setRateLimitedValue, initialOptions)