@tanstack/solid-pacer 0.8.0 → 0.9.0

package/src/queuer/createQueuer.ts

@@ -1,57 +1,16 @@
 import { Queuer } from '@tanstack/pacer/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 { QueuerOptions } from '@tanstack/pacer/queuer'
+import type { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer'
 
-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>>
 }
 
 /**
@@ -105,76 +64,17 @@ export interface SolidQueuer<TValue>
  * console.log('Next item:', queue.nextItem());
  * ```
  */
-export function createQueuer<TValue>(
+export function createQueuer<TValue, TSelected = QueuerState<TValue>>(
   fn: (item: TValue) => void,
   initialOptions: QueuerOptions<TValue> = {},
-): SolidQueuer<TValue> {
-  const queuer = bindInstanceMethods(new Queuer<TValue>(fn, initialOptions))
-
-  const [allItems, setAllItems] = createSignal<Array<TValue>>(
-    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<TValue | undefined>(
-    queuer.peekNextItem(),
-  )
-  const [size, setSize] = createSignal(queuer.getSize())
-
-  function setOptions(newOptions: Partial<QueuerOptions<TValue>>) {
-    queuer.setOptions({
-      ...newOptions,
-      onItemsChange: (queuer) => {
-        setAllItems(queuer.peekAllItems())
-        setExecutionCount(queuer.getExecutionCount())
-        setIsEmpty(queuer.getIsEmpty())
-        setIsFull(queuer.getIsFull())
-        setIsIdle(queuer.getIsIdle())
-        setNextItem(() => queuer.peekNextItem())
-        setSize(queuer.getSize())
-
-        const onItemsChange =
-          newOptions.onItemsChange ?? initialOptions.onItemsChange
-        onItemsChange?.(queuer)
-      },
-      onIsRunningChange: (queuer) => {
-        setIsRunning(queuer.getIsRunning())
-        setIsIdle(queuer.getIsIdle())
-
-        const onIsRunningChange =
-          newOptions.onIsRunningChange ?? initialOptions.onIsRunningChange
-        onIsRunningChange?.(queuer)
-      },
-      onReject: (item, queuer) => {
-        setRejectionCount(queuer.getRejectionCount())
-
-        const onReject = newOptions.onReject ?? initialOptions.onReject
-        onReject?.(item, queuer)
-      },
-    })
-  }
+  selector?: (state: QueuerState<TValue>) => TSelected,
+): SolidQueuer<TValue, TSelected> {
+  const queuer = new Queuer(fn, initialOptions)
 
-  setOptions(initialOptions)
+  const state = useStore(queuer.store, selector)
 
   return {
     ...queuer,
-    allItems,
-    executionCount,
-    isEmpty,
-    isFull,
-    isIdle,
-    isRunning,
-    nextItem,
-    rejectionCount,
-    size,
-    setOptions,
-  } as SolidQueuer<TValue>
+    state,
+  } as unknown as SolidQueuer<TValue, TSelected> // omit `store` in favor of `state`
 }

package/src/rate-limiter/createRateLimitedSignal.ts

@@ -2,7 +2,10 @@ import { createSignal } from 'solid-js'
 import { createRateLimiter } from './createRateLimiter'
 import type { SolidRateLimiter } from './createRateLimiter'
 import type { Accessor, Setter } from 'solid-js'
-import type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'
+import type {
+  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.
@@ -62,17 +65,26 @@ import type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'
  * };
  * ```
  */
-export function createRateLimitedSignal<TValue>(
+export function createRateLimitedSignal<TValue, TSelected = RateLimiterState>(
   value: TValue,
   initialOptions: RateLimiterOptions<Setter<TValue>>,
-): [Accessor<TValue>, Setter<TValue>, SolidRateLimiter<Setter<TValue>>] {
+  selector?: (state: RateLimiterState) => TSelected,
+): [
+  Accessor<TValue>,
+  Setter<TValue>,
+  SolidRateLimiter<Setter<TValue>, TSelected>,
+] {
   const [rateLimitedValue, setRateLimitedValue] = createSignal<TValue>(value)
 
-  const rateLimiter = createRateLimiter(setRateLimitedValue, initialOptions)
+  const rateLimiter = createRateLimiter(
+    setRateLimitedValue,
+    initialOptions,
+    selector,
+  )
 
   return [
     rateLimitedValue,
-    rateLimiter.maybeExecute.bind(rateLimiter) as Setter<TValue>,
+    rateLimiter.maybeExecute as Setter<TValue>,
     rateLimiter,
   ]
 }

package/src/rate-limiter/createRateLimitedValue.ts

@@ -2,7 +2,10 @@ import { createEffect } from 'solid-js'
 import { createRateLimitedSignal } from './createRateLimitedSignal'
 import type { SolidRateLimiter } from './createRateLimiter'
 import type { Accessor, Setter } from 'solid-js'
-import type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'
+import type {
+  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.
@@ -47,12 +50,13 @@ import type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'
  * rateLimiter.reset(); // Reset the rate limit window
  * ```
  */
-export function createRateLimitedValue<TValue>(
+export function createRateLimitedValue<TValue, TSelected = RateLimiterState>(
   value: Accessor<TValue>,
   initialOptions: RateLimiterOptions<Setter<TValue>>,
-): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>>] {
+  selector?: (state: RateLimiterState) => TSelected,
+): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>] {
   const [rateLimitedValue, setRateLimitedValue, rateLimiter] =
-    createRateLimitedSignal(value(), initialOptions)
+    createRateLimitedSignal(value(), initialOptions, selector)
 
   createEffect(() => {
     setRateLimitedValue(value() as any)

package/src/rate-limiter/createRateLimiter.ts

@@ -1,22 +1,22 @@
 import { RateLimiter } from '@tanstack/pacer/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 { AnyFunction } from '@tanstack/pacer/types'
-import type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'
+import type {
+  RateLimiterOptions,
+  RateLimiterState,
+} from '@tanstack/pacer/rate-limiter'
 
-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>>
 }
 
 /**
@@ -59,57 +59,20 @@ export interface SolidRateLimiter<TFn extends AnyFunction>
  * console.log('Next window in:', rateLimiter.msUntilNextWindow());
  * ```
  */
-export function createRateLimiter<TFn extends AnyFunction>(
+export function createRateLimiter<
+  TFn extends AnyFunction,
+  TSelected = RateLimiterState,
+>(
   fn: TFn,
   initialOptions: RateLimiterOptions<TFn>,
-): SolidRateLimiter<TFn> {
-  const rateLimiter = bindInstanceMethods(
-    new RateLimiter<TFn>(fn, initialOptions),
-  )
+  selector?: (state: RateLimiterState) => TSelected,
+): SolidRateLimiter<TFn, TSelected> {
+  const rateLimiter = new RateLimiter<TFn>(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: Partial<RateLimiterOptions<TFn>>) {
-    rateLimiter.setOptions({
-      ...newOptions,
-      onExecute: (rateLimiter) => {
-        setExecutionCount(rateLimiter.getExecutionCount())
-        setRemainingInWindow(rateLimiter.getRemainingInWindow())
-        setMsUntilNextWindow(rateLimiter.getMsUntilNextWindow())
-
-        const onExecute = newOptions.onExecute ?? initialOptions.onExecute
-        onExecute?.(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(rateLimiter.store, selector)
 
   return {
     ...rateLimiter,
-    executionCount,
-    rejectionCount,
-    remainingInWindow,
-    msUntilNextWindow,
-    setOptions,
-  } as SolidRateLimiter<TFn>
+    state,
+  } as unknown as SolidRateLimiter<TFn, TSelected> // omit `store` in favor of `state`
 }

package/src/throttler/createThrottledSignal.ts

@@ -2,7 +2,10 @@ import { createSignal } from 'solid-js'
 import { createThrottler } from './createThrottler'
 import type { SolidThrottler } from './createThrottler'
 import type { Accessor, Setter } from 'solid-js'
-import type { ThrottlerOptions } from '@tanstack/pacer/throttler'
+import type {
+  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.
@@ -38,11 +41,19 @@ import type { ThrottlerOptions } from '@tanstack/pacer/throttler'
  * console.log('Next execution:', throttler.nextExecutionTime());
  * ```
  */
-export function createThrottledSignal<TValue>(
+export function createThrottledSignal<
+  TValue,
+  TSelected = ThrottlerState<Setter<TValue>>,
+>(
   value: TValue,
   initialOptions: ThrottlerOptions<Setter<TValue>>,
-): [Accessor<TValue>, Setter<TValue>, SolidThrottler<Setter<TValue>>] {
+  selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected,
+): [
+  Accessor<TValue>,
+  Setter<TValue>,
+  SolidThrottler<Setter<TValue>, TSelected>,
+] {
   const [throttledValue, setThrottledValue] = createSignal<TValue>(value)
-  const throttler = createThrottler(setThrottledValue, initialOptions)
+  const throttler = createThrottler(setThrottledValue, initialOptions, selector)
   return [throttledValue, throttler.maybeExecute as Setter<TValue>, throttler]
 }

package/src/throttler/createThrottledValue.ts

@@ -2,7 +2,10 @@ import { createEffect } from 'solid-js'
 import { createThrottledSignal } from './createThrottledSignal'
 import type { SolidThrottler } from './createThrottler'
 import type { Accessor, Setter } from 'solid-js'
-import type { ThrottlerOptions } from '@tanstack/pacer/throttler'
+import type {
+  ThrottlerOptions,
+  ThrottlerState,
+} from '@tanstack/pacer/throttler'
 
 /**
  * A high-level Solid hook that creates a throttled version of a value that updates at most once within a specified time window.
@@ -32,13 +35,18 @@ import type { ThrottlerOptions } from '@tanstack/pacer/throttler'
  * throttler.cancel(); // Cancel any pending updates
  * ```
  */
-export function createThrottledValue<TValue>(
+export function createThrottledValue<
+  TValue,
+  TSelected = ThrottlerState<Setter<TValue>>,
+>(
   value: Accessor<TValue>,
   initialOptions: ThrottlerOptions<Setter<TValue>>,
-): [Accessor<TValue>, SolidThrottler<Setter<TValue>>] {
+  selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected,
+): [Accessor<TValue>, SolidThrottler<Setter<TValue>, TSelected>] {
   const [throttledValue, setThrottledValue, throttler] = createThrottledSignal(
     value(),
     initialOptions,
+    selector,
   )
 
   createEffect(() => {

package/src/throttler/createThrottler.ts

@@ -1,25 +1,23 @@
 import { Throttler } from '@tanstack/pacer/throttler'
-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 { ThrottlerOptions } from '@tanstack/pacer/throttler'
+import type {
+  ThrottlerOptions,
+  ThrottlerState,
+} from '@tanstack/pacer/throttler'
 
-/**
- * An extension of the Throttler class that adds Solid signals to access the internal state of the throttler
- */
-export interface SolidThrottler<TFn extends AnyFunction>
-  extends Omit<
-    Throttler<TFn>,
-    | 'getExecutionCount'
-    | 'getIsPending'
-    | 'getLastExecutionTime'
-    | 'getNextExecutionTime'
-  > {
-  executionCount: Accessor<number>
-  isPending: Accessor<boolean>
-  lastExecutionTime: Accessor<number>
-  nextExecutionTime: Accessor<number>
+export interface SolidThrottler<
+  TFn extends AnyFunction,
+  TSelected = ThrottlerState<TFn>,
+> extends Omit<Throttler<TFn>, 'store'> {
+  /**
+   * Reactive state that will be updated when the throttler state changes
+   *
+   * Use this instead of `throttler.store.state`
+   */
+  readonly state: Accessor<Readonly<TSelected>>
 }
 
 /**
@@ -56,52 +54,26 @@ export interface SolidThrottler<TFn extends AnyFunction>
  * console.log(throttler.nextExecutionTime()); // timestamp of next allowed execution
  * ```
  */
-export function createThrottler<TFn extends AnyFunction>(
+export function createThrottler<
+  TFn extends AnyFunction,
+  TSelected = ThrottlerState<TFn>,
+>(
   fn: TFn,
   initialOptions: ThrottlerOptions<TFn>,
-): SolidThrottler<TFn> {
-  const throttler = bindInstanceMethods(new Throttler<TFn>(fn, initialOptions))
-
-  const [executionCount, setExecutionCount] = createSignal(
-    throttler.getExecutionCount(),
-  )
-  const [isPending, setIsPending] = createSignal(throttler.getIsPending())
-  const [lastExecutionTime, setLastExecutionTime] = createSignal(
-    throttler.getLastExecutionTime(),
-  )
-  const [nextExecutionTime, setNextExecutionTime] = createSignal(
-    throttler.getNextExecutionTime(),
-  )
-
-  function setOptions(newOptions: Partial<ThrottlerOptions<TFn>>) {
-    throttler.setOptions({
-      ...newOptions,
-      onExecute: (throttler) => {
-        setExecutionCount(throttler.getExecutionCount())
-        setIsPending(throttler.getIsPending())
-        setLastExecutionTime(throttler.getLastExecutionTime())
-        setNextExecutionTime(throttler.getNextExecutionTime())
-
-        const onExecute = newOptions.onExecute ?? initialOptions.onExecute
-        onExecute?.(throttler)
-      },
-    })
-  }
+  selector?: (state: ThrottlerState<TFn>) => TSelected,
+): SolidThrottler<TFn, TSelected> {
+  const asyncThrottler = new Throttler<TFn>(fn, initialOptions)
 
-  setOptions(initialOptions)
+  const state = useStore(asyncThrottler.store, selector)
 
   createEffect(() => {
     onCleanup(() => {
-      throttler.cancel()
+      asyncThrottler.cancel()
     })
   })
 
   return {
-    ...throttler,
-    executionCount,
-    isPending,
-    lastExecutionTime,
-    nextExecutionTime,
-    setOptions,
-  } as SolidThrottler<TFn>
+    ...asyncThrottler,
+    state,
+  } as SolidThrottler<TFn, TSelected> // omit `store` in favor of `state`
 }

package/dist/cjs/compare/index.cjs

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const compare = require("@tanstack/pacer/compare");
-Object.keys(compare).forEach((k) => {
-  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: () => compare[k]
-  });
-});
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/compare/index.d.cts

@@ -1 +0,0 @@
-export * from '@tanstack/pacer/compare';

package/dist/esm/compare/index.d.ts

@@ -1 +0,0 @@
-export * from '@tanstack/pacer/compare';

package/dist/esm/compare/index.js

@@ -1,2 +0,0 @@
-export * from "@tanstack/pacer/compare";
-//# sourceMappingURL=index.js.map

package/src/compare/index.ts

@@ -1 +0,0 @@
-export * from '@tanstack/pacer/compare'