@tanstack/solid-pacer 0.8.0 → 0.9.0

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

@@ -1,26 +1,17 @@
 import { AsyncRateLimiter } from '@tanstack/pacer/async-rate-limiter'
-import { createSignal } from 'solid-js'
-import { bindInstanceMethods } from '@tanstack/pacer/utils'
+import { useStore } from '@tanstack/solid-store'
 import type { Accessor } from 'solid-js'
 import type { AnyAsyncFunction } from '@tanstack/pacer/types'
-import type { AsyncRateLimiterOptions } from '@tanstack/pacer/async-rate-limiter'
+import type {
+  AsyncRateLimiterOptions,
+  AsyncRateLimiterState,
+} from '@tanstack/pacer/async-rate-limiter'
 
-export interface SolidAsyncRateLimiter<TFn extends AnyAsyncFunction>
-  extends Omit<
-    AsyncRateLimiter<TFn>,
-    | 'getSuccessCount'
-    | 'getSettleCount'
-    | 'getErrorCount'
-    | 'getRejectionCount'
-    | 'getRemainingInWindow'
-    | 'getMsUntilNextWindow'
-  > {
-  successCount: Accessor<number>
-  settleCount: Accessor<number>
-  errorCount: Accessor<number>
-  rejectionCount: Accessor<number>
-  remainingInWindow: Accessor<number>
-  msUntilNextWindow: Accessor<number>
+export interface SolidAsyncRateLimiter<
+  TFn extends AnyAsyncFunction,
+  TSelected = AsyncRateLimiterState<TFn>,
+> extends Omit<AsyncRateLimiter<TFn>, 'store'> {
+  readonly state: Accessor<Readonly<TSelected>>
 }
 
 /**
@@ -85,66 +76,20 @@ export interface SolidAsyncRateLimiter<TFn extends AnyAsyncFunction>
  * );
  * ```
  */
-export function createAsyncRateLimiter<TFn extends AnyAsyncFunction>(
+export function createAsyncRateLimiter<
+  TFn extends AnyAsyncFunction,
+  TSelected = AsyncRateLimiterState<TFn>,
+>(
   fn: TFn,
   initialOptions: AsyncRateLimiterOptions<TFn>,
-): SolidAsyncRateLimiter<TFn> {
+  selector?: (state: AsyncRateLimiterState<TFn>) => TSelected,
+): SolidAsyncRateLimiter<TFn, TSelected> {
   const asyncRateLimiter = new AsyncRateLimiter<TFn>(fn, initialOptions)
 
-  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(),
-  )
-  const [msUntilNextWindow, setMsUntilNextWindow] = createSignal(
-    asyncRateLimiter.getMsUntilNextWindow(),
-  )
-
-  function setOptions(newOptions: Partial<AsyncRateLimiterOptions<TFn>>) {
-    asyncRateLimiter.setOptions({
-      ...newOptions,
-      onSettled: (rateLimiter) => {
-        setSuccessCount(rateLimiter.getSuccessCount())
-        setSettleCount(rateLimiter.getSettleCount())
-        setErrorCount(rateLimiter.getErrorCount())
-        setRejectionCount(rateLimiter.getRejectionCount())
-        setRemainingInWindow(rateLimiter.getRemainingInWindow())
-        setMsUntilNextWindow(rateLimiter.getMsUntilNextWindow())
-
-        const onSettled = newOptions.onSettled ?? initialOptions.onSettled
-        onSettled?.(rateLimiter)
-      },
-      onReject: (rateLimiter) => {
-        setRejectionCount(rateLimiter.getRejectionCount())
-        setRemainingInWindow(rateLimiter.getRemainingInWindow())
-        setMsUntilNextWindow(rateLimiter.getMsUntilNextWindow())
-
-        const onReject = newOptions.onReject ?? initialOptions.onReject
-        onReject?.(rateLimiter)
-      },
-    })
-  }
-
-  setOptions(initialOptions)
+  const state = useStore(asyncRateLimiter.store, selector)
 
   return {
-    ...bindInstanceMethods(asyncRateLimiter),
-    errorCount,
-    remainingInWindow,
-    msUntilNextWindow,
-    rejectionCount,
-    setOptions,
-    settleCount,
-    successCount,
-  } as SolidAsyncRateLimiter<TFn>
+    ...asyncRateLimiter,
+    state,
+  } as SolidAsyncRateLimiter<TFn, TSelected>
 }

package/src/async-throttler/createAsyncThrottler.ts

@@ -1,30 +1,22 @@
 import { AsyncThrottler } from '@tanstack/pacer/async-throttler'
-import { createSignal } from 'solid-js'
-import { bindInstanceMethods } from '@tanstack/pacer/utils'
+import { useStore } from '@tanstack/solid-store'
 import type { Accessor } from 'solid-js'
 import type { AnyAsyncFunction } from '@tanstack/pacer/types'
-import type { AsyncThrottlerOptions } from '@tanstack/pacer/async-throttler'
+import type {
+  AsyncThrottlerOptions,
+  AsyncThrottlerState,
+} from '@tanstack/pacer/async-throttler'
 
-export interface SolidAsyncThrottler<TFn extends AnyAsyncFunction>
-  extends Omit<
-    AsyncThrottler<TFn>,
-    | 'getSuccessCount'
-    | 'getSettleCount'
-    | 'getErrorCount'
-    | 'getIsPending'
-    | 'getIsExecuting'
-    | 'getLastResult'
-    | 'getLastExecutionTime'
-    | 'getNextExecutionTime'
-  > {
-  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>
+export interface SolidAsyncThrottler<
+  TFn extends AnyAsyncFunction,
+  TSelected = AsyncThrottlerState<TFn>,
+> extends Omit<AsyncThrottler<TFn>, 'store'> {
+  /**
+   * Reactive state that will be updated and re-rendered when the throttler state changes
+   *
+   * Use this instead of `throttler.store.state`
+   */
+  readonly state: Accessor<Readonly<TSelected>>
 }
 
 /**
@@ -77,68 +69,20 @@ export interface SolidAsyncThrottler<TFn extends AnyAsyncFunction>
  * );
  * ```
  */
-export function createAsyncThrottler<TFn extends AnyAsyncFunction>(
+export function createAsyncThrottler<
+  TFn extends AnyAsyncFunction,
+  TSelected = AsyncThrottlerState<TFn>,
+>(
   fn: TFn,
   initialOptions: AsyncThrottlerOptions<TFn>,
-): SolidAsyncThrottler<TFn> {
-  const asyncThrottler = bindInstanceMethods(
-    new AsyncThrottler<TFn>(fn, initialOptions),
-  )
+  selector?: (state: AsyncThrottlerState<TFn>) => TSelected,
+): SolidAsyncThrottler<TFn, TSelected> {
+  const asyncThrottler = new AsyncThrottler(fn, initialOptions)
 
-  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(),
-  )
-  const [nextExecutionTime, setNextExecutionTime] = createSignal(
-    asyncThrottler.getNextExecutionTime(),
-  )
-
-  function setOptions(newOptions: Partial<AsyncThrottlerOptions<TFn>>) {
-    asyncThrottler.setOptions({
-      ...newOptions,
-      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 onSettled = newOptions.onSettled ?? initialOptions.onSettled
-        onSettled?.(throttler)
-      },
-    })
-  }
-
-  setOptions(initialOptions)
+  const state = useStore(asyncThrottler.store, selector)
 
   return {
     ...asyncThrottler,
-    errorCount,
-    isExecuting,
-    isPending,
-    lastExecutionTime,
-    lastResult,
-    nextExecutionTime,
-    setOptions,
-    settleCount,
-    successCount,
-  } as SolidAsyncThrottler<TFn>
+    state,
+  } as SolidAsyncThrottler<TFn, TSelected>
 }

package/src/batcher/createBatcher.ts

@@ -1,43 +1,16 @@
 import { Batcher } from '@tanstack/pacer/batcher'
-import { createSignal } from 'solid-js'
-import { bindInstanceMethods } from '@tanstack/pacer/utils'
+import { useStore } from '@tanstack/solid-store'
 import type { Accessor } from 'solid-js'
-import type { BatcherOptions } from '@tanstack/pacer/batcher'
+import type { BatcherOptions, BatcherState } from '@tanstack/pacer/batcher'
 
-export interface SolidBatcher<TValue>
-  extends Omit<
-    Batcher<TValue>,
-    | 'peekAllItems'
-    | 'getBatchExecutionCount'
-    | 'getIsEmpty'
-    | 'getIsRunning'
-    | 'getItemExecutionCount'
-    | 'getSize'
-  > {
+export interface SolidBatcher<TValue, TSelected = BatcherState<TValue>>
+  extends Omit<Batcher<TValue>, 'store'> {
   /**
-   * Signal version of `peekAllItems`
+   * Reactive state that will be updated when the batcher state changes
+   *
+   * Use this instead of `batcher.store.state`
    */
-  allItems: Accessor<Array<TValue>>
-  /**
-   * Signal version of `getBatchExecutionCount`
-   */
-  batchExecutionCount: Accessor<number>
-  /**
-   * Signal version of `getIsEmpty`
-   */
-  isEmpty: Accessor<boolean>
-  /**
-   * Signal version of `getIsRunning`
-   */
-  isRunning: Accessor<boolean>
-  /**
-   * Signal version of `getItemExecutionCount`
-   */
-  itemExecutionCount: Accessor<number>
-  /**
-   * Signal version of `getSize`
-   */
-  size: Accessor<number>
+  readonly state: Accessor<Readonly<TSelected>>
 }
 
 /**
@@ -83,70 +56,20 @@ export interface SolidBatcher<TValue>
  * console.log('Size:', batcher.size());
  * console.log('Is empty:', batcher.isEmpty());
  * console.log('Is running:', batcher.isRunning());
- * console.log('Batch count:', batcher.batchExecutionCount());
- * console.log('Item count:', batcher.itemExecutionCount());
+ * console.log('Batch count:', batcher.executionCount());
+ * console.log('Item count:', batcher.totalItemsProcessed());
  * ```
  */
-export function createBatcher<TValue>(
+export function createBatcher<TValue, TSelected = BatcherState<TValue>>(
   fn: (items: Array<TValue>) => void,
   initialOptions: BatcherOptions<TValue> = {},
-): SolidBatcher<TValue> {
-  const batcher = bindInstanceMethods(new Batcher<TValue>(fn, initialOptions))
-
-  const [allItems, setAllItems] = createSignal<Array<TValue>>(
-    batcher.peekAllItems(),
-  )
-  const [batchExecutionCount, setBatchExecutionCount] = createSignal(
-    batcher.getBatchExecutionCount(),
-  )
-  const [itemExecutionCount, setItemExecutionCount] = createSignal(
-    batcher.getItemExecutionCount(),
-  )
-  const [isEmpty, setIsEmpty] = createSignal(batcher.getIsEmpty())
-  const [isRunning, setIsRunning] = createSignal(batcher.getIsRunning())
-  const [size, setSize] = createSignal(batcher.getSize())
-
-  function setOptions(newOptions: Partial<BatcherOptions<TValue>>) {
-    batcher.setOptions({
-      ...newOptions,
-      onItemsChange: (batcher) => {
-        setAllItems(batcher.peekAllItems())
-        setBatchExecutionCount(batcher.getBatchExecutionCount())
-        setItemExecutionCount(batcher.getItemExecutionCount())
-        setIsEmpty(batcher.getIsEmpty())
-        setSize(batcher.getSize())
-
-        const onItemsChange =
-          newOptions.onItemsChange ?? initialOptions.onItemsChange
-        onItemsChange?.(batcher)
-      },
-      onExecute: (batcher) => {
-        setBatchExecutionCount(batcher.getBatchExecutionCount())
-        setItemExecutionCount(batcher.getItemExecutionCount())
-
-        const onExecute = newOptions.onExecute ?? initialOptions.onExecute
-        onExecute?.(batcher)
-      },
-      onIsRunningChange: (batcher) => {
-        setIsRunning(batcher.getIsRunning())
-
-        const onIsRunningChange =
-          newOptions.onIsRunningChange ?? initialOptions.onIsRunningChange
-        onIsRunningChange?.(batcher)
-      },
-    })
-  }
-
-  setOptions(initialOptions)
+  selector?: (state: BatcherState<TValue>) => TSelected,
+): SolidBatcher<TValue, TSelected> {
+  const batcher = new Batcher(fn, initialOptions)
 
+  const state = useStore(batcher.store, selector)
   return {
     ...batcher,
-    allItems,
-    batchExecutionCount,
-    isEmpty,
-    isRunning,
-    itemExecutionCount,
-    size,
-    setOptions,
-  } as SolidBatcher<TValue>
+    state,
+  } as SolidBatcher<TValue, TSelected>
 }

package/src/debouncer/createDebouncedSignal.ts

@@ -2,7 +2,10 @@ import { createSignal } from 'solid-js'
 import { createDebouncer } from './createDebouncer'
 import type { SolidDebouncer } from './createDebouncer'
 import type { Accessor, Setter } from 'solid-js'
-import type { DebouncerOptions } from '@tanstack/pacer/debouncer'
+import type {
+  DebouncerOptions,
+  DebouncerState,
+} from '@tanstack/pacer/debouncer'
 
 /**
  * A Solid hook that creates a debounced state value, combining Solid's createSignal with debouncing functionality.
@@ -43,13 +46,21 @@ import type { DebouncerOptions } from '@tanstack/pacer/debouncer'
  * });
  * ```
  */
-export function createDebouncedSignal<TValue>(
+export function createDebouncedSignal<
+  TValue,
+  TSelected = DebouncerState<Setter<TValue>>,
+>(
   value: TValue,
   initialOptions: DebouncerOptions<Setter<TValue>>,
-): [Accessor<TValue>, Setter<TValue>, SolidDebouncer<Setter<TValue>>] {
+  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,
+): [
+  Accessor<TValue>,
+  Setter<TValue>,
+  SolidDebouncer<Setter<TValue>, TSelected>,
+] {
   const [debouncedValue, setDebouncedValue] = createSignal<TValue>(value)
 
-  const debouncer = createDebouncer(setDebouncedValue, initialOptions)
+  const debouncer = createDebouncer(setDebouncedValue, initialOptions, selector)
 
   return [debouncedValue, debouncer.maybeExecute as Setter<TValue>, debouncer]
 }

package/src/debouncer/createDebouncedValue.ts

@@ -2,7 +2,10 @@ import { createEffect } from 'solid-js'
 import { createDebouncedSignal } from './createDebouncedSignal'
 import type { SolidDebouncer } from './createDebouncer'
 import type { Accessor, Setter } from 'solid-js'
-import type { DebouncerOptions } from '@tanstack/pacer/debouncer'
+import type {
+  DebouncerOptions,
+  DebouncerState,
+} from '@tanstack/pacer/debouncer'
 
 /**
  * A Solid hook that creates a debounced value that updates only after a specified delay.
@@ -38,13 +41,18 @@ import type { DebouncerOptions } from '@tanstack/pacer/debouncer'
  * debouncer.cancel(); // Cancel any pending updates
  * ```
  */
-export function createDebouncedValue<TValue>(
+export function createDebouncedValue<
+  TValue,
+  TSelected = DebouncerState<Setter<TValue>>,
+>(
   value: Accessor<TValue>,
   initialOptions: DebouncerOptions<Setter<TValue>>,
-): [Accessor<TValue>, SolidDebouncer<Setter<TValue>>] {
+  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,
+): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, TSelected>] {
   const [debouncedValue, setDebouncedValue, debouncer] = createDebouncedSignal(
     value(),
     initialOptions,
+    selector,
   )
 
   createEffect(() => {

package/src/debouncer/createDebouncer.ts

@@ -1,17 +1,23 @@
 import { Debouncer } from '@tanstack/pacer/debouncer'
-import { createEffect, createSignal, onCleanup } from 'solid-js'
-import { bindInstanceMethods } from '@tanstack/pacer/utils'
+import { createEffect, onCleanup } from 'solid-js'
+import { useStore } from '@tanstack/solid-store'
 import type { Accessor } from 'solid-js'
 import type { AnyFunction } from '@tanstack/pacer/types'
-import type { DebouncerOptions } from '@tanstack/pacer/debouncer'
+import type {
+  DebouncerOptions,
+  DebouncerState,
+} 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>
-  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>>
 }
 
 /**
@@ -50,42 +56,26 @@ export interface SolidDebouncer<TFn extends AnyFunction>
  * debouncer.setOptions({ wait: 1000 });
  * ```
  */
-export function createDebouncer<TFn extends AnyFunction>(
+export function createDebouncer<
+  TFn extends AnyFunction,
+  TSelected = DebouncerState<TFn>,
+>(
   fn: TFn,
   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>>) {
-    debouncer.setOptions({
-      ...newOptions,
-      onExecute: (debouncer) => {
-        setExecutionCount(debouncer.getExecutionCount())
-        setIsPending(debouncer.getIsPending())
-
-        const onExecute = newOptions.onExecute ?? initialOptions.onExecute
-        onExecute?.(debouncer)
-      },
-    })
-  }
+  selector?: (state: DebouncerState<TFn>) => TSelected,
+): SolidDebouncer<TFn, TSelected> {
+  const asyncDebouncer = new Debouncer<TFn>(fn, initialOptions)
 
-  setOptions(initialOptions)
+  const state = useStore(asyncDebouncer.store, selector)
 
   createEffect(() => {
     onCleanup(() => {
-      debouncer.cancel()
+      asyncDebouncer.cancel()
     })
   })
 
   return {
-    ...debouncer,
-    executionCount,
-    isPending,
-    setOptions,
-  } as SolidDebouncer<TFn>
+    ...asyncDebouncer,
+    state,
+  } as SolidDebouncer<TFn, TSelected> // omit `store` in favor of `state`
 }

package/src/index.ts

@@ -5,6 +5,9 @@ export * from '@tanstack/pacer'
  * Export every hook individually - DON'T export from barrel files
  */
 
+// async-batcher
+export * from './async-batcher/createAsyncBatcher'
+
 // async-debouncer
 export * from './async-debouncer/createAsyncDebouncer'