@tanstack/solid-pacer 0.7.0 → 0.9.0

package/src/async-queuer/createAsyncQueuer.ts

@@ -1,78 +1,19 @@
 import { AsyncQueuer } from '@tanstack/pacer/async-queuer'
-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 { AsyncQueuerOptions } from '@tanstack/pacer/async-queuer'
+import type {
+  AsyncQueuerOptions,
+  AsyncQueuerState,
+} from '@tanstack/pacer/async-queuer'
 
-export interface SolidAsyncQueuer<TValue>
-  extends Omit<
-    AsyncQueuer<TValue>,
-    | 'getActiveItems'
-    | 'getAllItems'
-    | 'getErrorCount'
-    | 'getIsEmpty'
-    | 'getIsFull'
-    | 'getIsIdle'
-    | 'getIsRunning'
-    | 'getPeek'
-    | 'getPendingItems'
-    | 'getRejectionCount'
-    | 'getSettledCount'
-    | 'getSize'
-    | 'getSuccessCount'
-  > {
+export interface SolidAsyncQueuer<TValue, TSelected = AsyncQueuerState<TValue>>
+  extends Omit<AsyncQueuer<TValue>, 'store'> {
   /**
-   * Signal version of `getActiveItems`
+   * Reactive state that will be updated and re-rendered when the queuer state changes
+   *
+   * Use this instead of `queuer.store.state`
    */
-  activeItems: Accessor<Array<TValue>>
-  /**
-   * Signal version of `getAllItems`
-   */
-  allItems: Accessor<Array<TValue>>
-  /**
-   * Signal version of `getErrorCount`
-   */
-  errorCount: 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 `getPeek`
-   */
-  peek: Accessor<TValue | undefined>
-  /**
-   * Signal version of `getPendingItems`
-   */
-  pendingItems: Accessor<Array<TValue>>
-  /**
-   * Signal version of `getRejectionCount`
-   */
-  rejectionCount: Accessor<number>
-  /**
-   * Signal version of `getSettledCount`
-   */
-  settledCount: Accessor<number>
-  /**
-   * Signal version of `getSize`
-   */
-  size: Accessor<number>
-  /**
-   * Signal version of `getSuccessCount`
-   */
-  successCount: Accessor<number>
+  readonly state: Accessor<Readonly<TSelected>>
 }
 
 /**
@@ -127,81 +68,17 @@ export interface SolidAsyncQueuer<TValue>
  * const pending = asyncQueuer.pendingItems();
  * ```
  */
-export function createAsyncQueuer<TValue>(
+export function createAsyncQueuer<TValue, TSelected = AsyncQueuerState<TValue>>(
   fn: (value: TValue) => Promise<any>,
   initialOptions: AsyncQueuerOptions<TValue> = {},
-): SolidAsyncQueuer<TValue> {
+  selector?: (state: AsyncQueuerState<TValue>) => TSelected,
+): SolidAsyncQueuer<TValue, TSelected> {
   const asyncQueuer = new AsyncQueuer<TValue>(fn, initialOptions)
 
-  const [successCount, setSuccessCount] = createSignal(
-    asyncQueuer.getSuccessCount(),
-  )
-  const [errorCount, setErrorCount] = createSignal(asyncQueuer.getErrorCount())
-  const [settledCount, setSettledCount] = createSignal(
-    asyncQueuer.getSettledCount(),
-  )
-  const [rejectionCount, setRejectionCount] = createSignal(
-    asyncQueuer.getRejectionCount(),
-  )
-  const [isEmpty, setIsEmpty] = createSignal(asyncQueuer.getIsEmpty())
-  const [isFull, setIsFull] = createSignal(asyncQueuer.getIsFull())
-  const [isIdle, setIsIdle] = createSignal(asyncQueuer.getIsIdle())
-  const [isRunning, setIsRunning] = createSignal(asyncQueuer.getIsRunning())
-  const [allItems, setAllItems] = createSignal<Array<TValue>>(
-    asyncQueuer.getAllItems(),
-  )
-  const [activeItems, setActiveItems] = createSignal<Array<TValue>>(
-    asyncQueuer.getActiveItems(),
-  )
-  const [pendingItems, setPendingItems] = createSignal<Array<TValue>>(
-    asyncQueuer.getPendingItems(),
-  )
-  const [peek, setPeek] = createSignal<TValue | undefined>(
-    asyncQueuer.getPeek(),
-  )
-  const [size, setSize] = createSignal(asyncQueuer.getSize())
-
-  asyncQueuer.setOptions({
-    onItemsChange: (queuer) => {
-      setActiveItems(queuer.getActiveItems())
-      setAllItems(queuer.getAllItems())
-      setErrorCount(queuer.getErrorCount())
-      setIsEmpty(queuer.getIsEmpty())
-      setIsFull(queuer.getIsFull())
-      setIsIdle(queuer.getIsIdle())
-      setPeek(() => queuer.getPeek())
-      setPendingItems(queuer.getPendingItems())
-      setRejectionCount(queuer.getRejectionCount())
-      setSettledCount(queuer.getSettledCount())
-      setSize(queuer.getSize())
-      setSuccessCount(queuer.getSuccessCount())
-      initialOptions.onItemsChange?.(queuer)
-    },
-    onIsRunningChange: (queuer) => {
-      setIsRunning(queuer.getIsRunning())
-      setIsIdle(queuer.getIsIdle())
-      initialOptions.onIsRunningChange?.(queuer)
-    },
-    onReject: (item, queuer) => {
-      setRejectionCount(queuer.getRejectionCount())
-      initialOptions.onReject?.(item, queuer)
-    },
-  })
+  const state = useStore(asyncQueuer.store, selector)
 
   return {
-    ...bindInstanceMethods(asyncQueuer),
-    activeItems,
-    allItems,
-    errorCount,
-    isEmpty,
-    isFull,
-    isIdle,
-    isRunning,
-    peek,
-    pendingItems,
-    rejectionCount,
-    settledCount,
-    size,
-    successCount,
-  } as SolidAsyncQueuer<TValue>
+    ...asyncQueuer,
+    state,
+  } as unknown as SolidAsyncQueuer<TValue, TSelected> // omit `store` in favor of `state`
 }

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>,
-    | 'getAllItems'
-    | 'getBatchExecutionCount'
-    | 'getIsEmpty'
-    | 'getIsRunning'
-    | 'getItemExecutionCount'
-    | 'getSize'
-  > {
+export interface SolidBatcher<TValue, TSelected = BatcherState<TValue>>
+  extends Omit<Batcher<TValue>, 'store'> {
   /**
-   * Signal version of `getAllItems`
+   * 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.getAllItems(),
-  )
-  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.getAllItems())
-        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(() => {