@tanstack/solid-pacer 0.21.1 → 0.23.0

package/src/rate-limiter/createRateLimiter.ts

@@ -1,226 +0,0 @@
-import { RateLimiter } from '@tanstack/pacer/rate-limiter'
-import { createEffect, onCleanup } from 'solid-js'
-import { shallow, useSelector } from '@tanstack/solid-store'
-import { useDefaultPacerOptions } from '../provider/PacerProvider'
-import type { Store } from '@tanstack/solid-store'
-import type { Accessor, JSX } from 'solid-js'
-import type { AnyFunction } from '@tanstack/pacer/types'
-import type {
-  RateLimiterOptions,
-  RateLimiterState,
-} from '@tanstack/pacer/rate-limiter'
-
-export interface SolidRateLimiterOptions<
-  TFn extends AnyFunction,
-  TSelected = {},
-> extends RateLimiterOptions<TFn> {
-  /**
-   * Optional callback invoked when the owning component unmounts. Receives the rate limiter instance.
-   * When provided, replaces the default cleanup; use it to call reset(), add logging, etc.
-   */
-  onUnmount?: (rateLimiter: SolidRateLimiter<TFn, TSelected>) => void
-}
-
-export interface SolidRateLimiter<
-  TFn extends AnyFunction,
-  TSelected = {},
-> extends Omit<RateLimiter<TFn>, 'store'> {
-  /**
-   * A Solid component that allows you to subscribe to the rate limiter state.
-   *
-   * This is useful for tracking specific parts of the rate limiter state
-   * deep in your component tree without needing to pass a selector to the hook.
-   *
-   * @example
-   * <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>
-   *   {(state) => (
-   *     <div>Rejections: {state().rejectionCount}</div>
-   *   )}
-   * </rateLimiter.Subscribe>
-   */
-  Subscribe: <TSelected>(props: {
-    selector: (state: RateLimiterState) => TSelected
-    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element
-  }) => JSX.Element
-  /**
-   * Reactive state that will be updated when the rate limiter state changes
-   *
-   * Use this instead of `rateLimiter.store.state`
-   */
-  readonly state: Accessor<Readonly<TSelected>>
-  /**
-   * @deprecated Use `rateLimiter.state` instead of `rateLimiter.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.
-   * Although, you can make the state reactive by using the `useSelector` in your own usage.
-   */
-  readonly store: Store<Readonly<RateLimiterState>>
-}
-
-/**
- * A low-level Solid hook that creates a `RateLimiter` instance to enforce rate limits on function execution.
- *
- * This hook is designed to be flexible and state-management agnostic - it simply returns a rate limiter instance that
- * you can integrate with any state management solution (createSignal, etc).
- *
- * Rate limiting is a simple "hard limit" approach that allows executions until a maximum count is reached within
- * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,
- * it does not attempt to space out or collapse executions intelligently.
- *
- * The rate limiter supports two types of windows:
- * - 'fixed': A strict window that resets after the window period. All executions within the window count
- *   towards the limit, and the window resets completely after the period.
- * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
- *   consistent rate of execution over time.
- *
- * For smoother execution patterns:
- * - Use throttling when you want consistent spacing between executions (e.g. UI updates)
- * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)
- * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)
- *
- * ## State Management and Selector
- *
- * The hook uses TanStack Store for reactive state management. You can subscribe to state changes
- * in two ways:
- *
- * **1. Using `rateLimiter.Subscribe` component (Recommended for component tree subscriptions)**
- *
- * Use the `Subscribe` component to subscribe to state changes deep in your component tree without
- * needing to pass a selector to the hook. This is ideal when you want to subscribe to state
- * in child components.
- *
- * **2. Using the `selector` parameter (For hook-level subscriptions)**
- *
- * The `selector` parameter allows you to specify which state changes will trigger reactive updates
- * at the hook level, optimizing performance by preventing unnecessary updates when irrelevant
- * state changes occur.
- *
- * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary
- * updates and gives you full control over when your component tracks state changes.
- *
- * Available state properties:
- * - `executionCount`: Number of function executions that have been completed
- * - `rejectionCount`: Number of function calls that were rejected due to rate limiting
- * - `remainingInWindow`: Number of executions remaining in the current window
- * - `nextWindowTime`: Timestamp when the next window begins
- * - `currentWindowStart`: Timestamp when the current window started
- *
- * @example
- * ```tsx
- * // Default behavior - no reactive state subscriptions
- * const rateLimiter = createRateLimiter(apiCall, {
- *   limit: 5,
- *   window: 60000,
- *   windowType: 'sliding',
- * });
- *
- * // Subscribe to state changes deep in component tree using Subscribe component
- * <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>
- *   {(state) => (
- *     <div>Rejections: {state().rejectionCount}</div>
- *   )}
- * </rateLimiter.Subscribe>
- *
- * // Opt-in to track execution count changes at hook level (optimized for tracking successful executions)
- * const rateLimiter = createRateLimiter(
- *   apiCall,
- *   {
- *     limit: 5,
- *     window: 60000,
- *     windowType: 'sliding',
- *   },
- *   (state) => ({ executionCount: state.executionCount })
- * );
- *
- * // Opt-in to track rejection count changes (optimized for tracking rate limit violations)
- * const rateLimiter = createRateLimiter(
- *   apiCall,
- *   {
- *     limit: 5,
- *     window: 60000,
- *     windowType: 'sliding',
- *   },
- *   (state) => ({ rejectionCount: state.rejectionCount })
- * );
- *
- * // Opt-in to track execution times changes (optimized for window calculations)
- * const rateLimiter = createRateLimiter(
- *   apiCall,
- *   {
- *     limit: 5,
- *     window: 60000,
- *     windowType: 'sliding',
- *   },
- *   (state) => ({ executionTimes: state.executionTimes })
- * );
- *
- * // Multiple state properties - track when any of these change
- * const rateLimiter = createRateLimiter(
- *   apiCall,
- *   {
- *     limit: 5,
- *     window: 60000,
- *     windowType: 'sliding',
- *   },
- *   (state) => ({
- *     executionCount: state.executionCount,
- *     rejectionCount: state.rejectionCount
- *   })
- * );
- *
- * // Monitor rate limit status
- * const handleClick = () => {
- *   const remaining = rateLimiter.getRemainingInWindow();
- *   if (remaining > 0) {
- *     rateLimiter.maybeExecute(data);
- *   } else {
- *     showRateLimitWarning();
- *   }
- * };
- *
- * // Access the selected state (will be empty object {} unless selector provided)
- * const { executionCount, rejectionCount } = rateLimiter.state();
- * ```
- */
-export function createRateLimiter<TFn extends AnyFunction, TSelected = {}>(
-  fn: TFn,
-  options: SolidRateLimiterOptions<TFn, TSelected>,
-  selector: (state: RateLimiterState) => TSelected = () => ({}) as TSelected,
-): SolidRateLimiter<TFn, TSelected> {
-  const mergedOptions = {
-    ...useDefaultPacerOptions().rateLimiter,
-    ...options,
-  } as SolidRateLimiterOptions<TFn, TSelected>
-  const rateLimiter = new RateLimiter<TFn>(
-    fn,
-    mergedOptions,
-  ) as unknown as SolidRateLimiter<TFn, TSelected>
-
-  rateLimiter.Subscribe = function Subscribe<TSelected>(props: {
-    selector: (state: RateLimiterState) => TSelected
-    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element
-  }) {
-    const selected = useSelector(rateLimiter.store, props.selector, {
-      compare: shallow,
-    })
-
-    return typeof props.children === 'function'
-      ? props.children(selected)
-      : props.children
-  }
-
-  const state = useSelector(rateLimiter.store, selector, { compare: shallow })
-
-  createEffect(() => {
-    onCleanup(() => {
-      if (mergedOptions.onUnmount) {
-        mergedOptions.onUnmount(rateLimiter)
-      }
-    })
-  })
-
-  return {
-    ...rateLimiter,
-    state,
-  } as SolidRateLimiter<TFn, TSelected> // omit `store` in favor of `state`
-}

package/src/rate-limiter/index.ts

@@ -1,5 +0,0 @@
-export * from '@tanstack/pacer/rate-limiter'
-
-export * from './createRateLimiter'
-export * from './createRateLimitedSignal'
-export * from './createRateLimitedValue'

package/src/throttler/createThrottledSignal.ts

@@ -1,81 +0,0 @@
-import { createSignal } from 'solid-js'
-import { createThrottler } from './createThrottler'
-import type { SolidThrottler, SolidThrottlerOptions } from './createThrottler'
-import type { Accessor, Setter } from 'solid-js'
-import type { ThrottlerState } from '@tanstack/pacer/throttler'
-
-/**
- * A Solid hook that creates a throttled state value that updates at most once within a specified time window.
- * This hook combines Solid's createSignal with throttling functionality to provide controlled state updates.
- *
- * Throttling ensures state updates occur at a controlled rate regardless of how frequently the setter is called.
- * This is useful for rate-limiting expensive updates or operations that depend on rapidly changing state.
- *
- * The hook returns a tuple containing:
- * - The throttled state value accessor
- * - A throttled setter function that respects the configured wait time
- * - The throttler instance for additional control
- *
- * For more direct control over throttling without state management,
- * consider using the lower-level createThrottler hook instead.
- *
- * ## State Management and Selector
- *
- * The hook uses TanStack Store for reactive state management via the underlying throttler instance.
- * The `selector` parameter allows you to specify which throttler state changes will trigger reactive updates,
- * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.
- *
- * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you
- * full control over when your component subscribes to state changes. Only when you provide a selector will
- * the reactive system track the selected state values.
- *
- * Available throttler state properties:
- * - `canLeadingExecute`: Whether the throttler can execute on the leading edge
- * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
- * - `executionCount`: Number of function executions that have been completed
- * - `isPending`: Whether the throttler is waiting for the timeout to trigger trailing execution
- * - `lastArgs`: The arguments from the most recent call to maybeExecute
- * - `lastExecutionTime`: Unix timestamp of the last execution
- * - `nextExecutionTime`: Unix timestamp of the next allowed execution
- * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
- *
- * @example
- * ```tsx
- * // Default behavior - no reactive state subscriptions
- * const [value, setValue, throttler] = createThrottledSignal(0, { wait: 1000 });
- *
- * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)
- * const [value, setValue, throttler] = createThrottledSignal(
- *   0,
- *   { wait: 1000 },
- *   (state) => ({ isPending: state.isPending })
- * );
- *
- * // With custom leading/trailing behavior
- * const [value, setValue] = createThrottledSignal(0, {
- *   wait: 1000,
- *   leading: true,   // Update immediately on first change
- *   trailing: false  // Skip trailing edge updates
- * });
- *
- * // Access throttler state via signals
- * console.log('Executions:', throttler.state().executionCount);
- * console.log('Is pending:', throttler.state().isPending);
- * console.log('Last execution:', throttler.state().lastExecutionTime);
- * console.log('Next execution:', throttler.state().nextExecutionTime);
- * ```
- */
-export function createThrottledSignal<TValue, TSelected = {}>(
-  value: TValue,
-  initialOptions: SolidThrottlerOptions<Setter<TValue>, TSelected>,
-  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, selector)
-  return [throttledValue, throttler.maybeExecute as Setter<TValue>, throttler]
-}

package/src/throttler/createThrottledValue.ts

@@ -1,82 +0,0 @@
-import { createEffect } from 'solid-js'
-import { createThrottledSignal } from './createThrottledSignal'
-import type { SolidThrottler, SolidThrottlerOptions } from './createThrottler'
-import type { Accessor, Setter } from 'solid-js'
-import type { 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.
- * This hook uses Solid's createSignal internally to manage the throttled state.
- *
- * Throttling ensures the value updates occur at a controlled rate regardless of how frequently the input value changes.
- * This is useful for rate-limiting expensive updates or API calls that depend on rapidly changing values.
- *
- * The hook returns a tuple containing:
- * - An accessor function that provides the throttled value
- * - The throttler instance with control methods
- *
- * The throttled value will update according to the leading/trailing edge behavior specified in the options.
- *
- * For more direct control over throttling behavior without Solid state management,
- * consider using the lower-level createThrottler hook instead.
- *
- * ## State Management and Selector
- *
- * The hook uses TanStack Store for reactive state management via the underlying throttler instance.
- * The `selector` parameter allows you to specify which throttler state changes will trigger reactive updates,
- * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.
- *
- * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you
- * full control over when your component subscribes to state changes. Only when you provide a selector will
- * the reactive system track the selected state values.
- *
- * Available throttler state properties:
- * - `canLeadingExecute`: Whether the throttler can execute on the leading edge
- * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
- * - `executionCount`: Number of function executions that have been completed
- * - `isPending`: Whether the throttler is waiting for the timeout to trigger trailing execution
- * - `lastArgs`: The arguments from the most recent call to maybeExecute
- * - `lastExecutionTime`: Unix timestamp of the last execution
- * - `nextExecutionTime`: Unix timestamp of the next allowed execution
- * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
- *
- * @example
- * ```tsx
- * // Default behavior - no reactive state subscriptions
- * const [throttledValue, throttler] = createThrottledValue(rawValue, { wait: 1000 });
- *
- * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)
- * const [throttledValue, throttler] = createThrottledValue(
- *   rawValue,
- *   { wait: 1000 },
- *   (state) => ({ isPending: state.isPending })
- * );
- *
- * // Use the throttled value
- * console.log(throttledValue()); // Access the current throttled value
- *
- * // Access throttler state via signals
- * console.log('Is pending:', throttler.state().isPending);
- *
- * // Control the throttler
- * throttler.cancel(); // Cancel any pending updates
- * ```
- */
-export function createThrottledValue<TValue, TSelected = {}>(
-  value: Accessor<TValue>,
-  initialOptions: SolidThrottlerOptions<Setter<TValue>, TSelected>,
-  selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected,
-): [Accessor<TValue>, SolidThrottler<Setter<TValue>, TSelected>] {
-  const [throttledValue, setThrottledValue, throttler] = createThrottledSignal(
-    value(),
-    initialOptions,
-    selector,
-  )
-
-  createEffect(() => {
-    setThrottledValue(value() as any)
-  })
-
-  return [throttledValue, throttler]
-}

package/src/throttler/createThrottler.ts

@@ -1,204 +0,0 @@
-import { Throttler } from '@tanstack/pacer/throttler'
-import { createEffect, onCleanup } from 'solid-js'
-import { shallow, useSelector } from '@tanstack/solid-store'
-import { useDefaultPacerOptions } from '../provider/PacerProvider'
-import type { Store } from '@tanstack/solid-store'
-import type { Accessor, JSX } from 'solid-js'
-import type { AnyFunction } from '@tanstack/pacer/types'
-import type {
-  ThrottlerOptions,
-  ThrottlerState,
-} from '@tanstack/pacer/throttler'
-
-export interface SolidThrottlerOptions<
-  TFn extends AnyFunction,
-  TSelected = {},
-> extends ThrottlerOptions<TFn> {
-  /**
-   * Optional callback invoked when the owning component unmounts. Receives the throttler instance.
-   * When provided, replaces the default cleanup (cancel); use it to call flush(), reset(), cancel(), add logging, etc.
-   */
-  onUnmount?: (throttler: SolidThrottler<TFn, TSelected>) => void
-}
-
-export interface SolidThrottler<
-  TFn extends AnyFunction,
-  TSelected = {},
-> extends Omit<Throttler<TFn>, 'store'> {
-  /**
-   * A Solid component that allows you to subscribe to the throttler state.
-   *
-   * This is useful for tracking specific parts of the throttler state
-   * deep in your component tree without needing to pass a selector to the hook.
-   *
-   * @example
-   * <throttler.Subscribe selector={(state) => ({ isPending: state.isPending })}>
-   *   {(state) => (
-   *     <div>{state().isPending ? 'Loading...' : 'Ready'}</div>
-   *   )}
-   * </throttler.Subscribe>
-   */
-  Subscribe: <TSelected>(props: {
-    selector: (state: ThrottlerState<TFn>) => TSelected
-    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element
-  }) => JSX.Element
-  /**
-   * Reactive state that will be updated when the throttler state changes
-   *
-   * Use this instead of `throttler.store.state`
-   */
-  readonly state: Accessor<Readonly<TSelected>>
-  /**
-   * @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.
-   * Although, you can make the state reactive by using the `useSelector` in your own usage.
-   */
-  readonly store: Store<Readonly<ThrottlerState<TFn>>>
-}
-
-/**
- * A low-level Solid hook that creates a `Throttler` instance that limits how often the provided function can execute.
- *
- * This hook is designed to be flexible and state-management agnostic - it simply returns a throttler instance that
- * you can integrate with any state management solution (createSignal, Redux, Zustand, Jotai, etc). For a simpler and higher-level hook that
- * integrates directly with Solid's createSignal, see createThrottledSignal.
- *
- * Throttling ensures a function executes at most once within a specified time window,
- * regardless of how many times it is called. This is useful for rate-limiting
- * expensive operations or UI updates.
- *
- * ## State Management and Selector
- *
- * The hook uses TanStack Store for reactive state management. You can subscribe to state changes
- * in two ways:
- *
- * **1. Using `throttler.Subscribe` component (Recommended for component tree subscriptions)**
- *
- * Use the `Subscribe` component to subscribe to state changes deep in your component tree without
- * needing to pass a selector to the hook. This is ideal when you want to subscribe to state
- * in child components.
- *
- * **2. Using the `selector` parameter (For hook-level subscriptions)**
- *
- * The `selector` parameter allows you to specify which state changes will trigger reactive updates
- * at the hook level, optimizing performance by preventing unnecessary updates when irrelevant
- * state changes occur.
- *
- * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary
- * updates and gives you full control over when your component tracks state changes.
- *
- * Available state properties:
- * - `canLeadingExecute`: Whether the throttler can execute on the leading edge
- * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
- * - `executionCount`: Number of function executions that have been completed
- * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
- * - `lastArgs`: The arguments from the most recent call to maybeExecute
- * - `lastExecutionTime`: Timestamp of the last execution
- * - `nextExecutionTime`: Timestamp of the next allowed execution
- * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
- *
- * ## Unmount behavior
- *
- * By default, the primitive cancels any pending execution when the owning component unmounts.
- * Use the `onUnmount` option to customize this. For example, to flush pending work instead:
- *
- * ```tsx
- * const throttler = createThrottler(fn, {
- *   wait: 1000,
- *   onUnmount: (t) => t.flush()
- * });
- * ```
- *
- * @example
- * ```tsx
- * // Default behavior - no reactive state subscriptions
- * const throttler = createThrottler(setValue, { wait: 1000 });
- *
- * // Subscribe to state changes deep in component tree using Subscribe component
- * <throttler.Subscribe selector={(state) => ({ isPending: state.isPending })}>
- *   {(state) => (
- *     <div>{state().isPending ? 'Loading...' : 'Ready'}</div>
- *   )}
- * </throttler.Subscribe>
- *
- * // Opt-in to track isPending changes at hook level (optimized for loading states)
- * const throttler = createThrottler(
- *   setValue,
- *   { wait: 1000 },
- *   (state) => ({ isPending: state.isPending })
- * );
- *
- * // Opt-in to track executionCount changes (optimized for tracking execution)
- * const throttler = createThrottler(
- *   setValue,
- *   { wait: 1000 },
- *   (state) => ({ executionCount: state.executionCount })
- * );
- *
- * // Multiple state properties - track when any of these change
- * const throttler = createThrottler(
- *   setValue,
- *   {
- *     wait: 2000,
- *     leading: true,   // Execute immediately on first call
- *     trailing: false  // Skip trailing edge updates
- *   },
- *   (state) => ({
- *     isPending: state.isPending,
- *     executionCount: state.executionCount,
- *     lastExecutionTime: state.lastExecutionTime,
- *     nextExecutionTime: state.nextExecutionTime
- *   })
- * );
- *
- * // Access the selected state (will be empty object {} unless selector provided)
- * const { isPending, executionCount } = throttler.state();
- * ```
- */
-export function createThrottler<TFn extends AnyFunction, TSelected = {}>(
-  fn: TFn,
-  options: SolidThrottlerOptions<TFn, TSelected>,
-  selector: (state: ThrottlerState<TFn>) => TSelected = () => ({}) as TSelected,
-): SolidThrottler<TFn, TSelected> {
-  const mergedOptions = {
-    ...useDefaultPacerOptions().throttler,
-    ...options,
-  } as SolidThrottlerOptions<TFn, TSelected>
-  const asyncThrottler = new Throttler<TFn>(
-    fn,
-    mergedOptions,
-  ) as unknown as SolidThrottler<TFn, TSelected>
-
-  asyncThrottler.Subscribe = function Subscribe<TSelected>(props: {
-    selector: (state: ThrottlerState<TFn>) => TSelected
-    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element
-  }) {
-    const selected = useSelector(asyncThrottler.store, props.selector, {
-      compare: shallow,
-    })
-
-    return typeof props.children === 'function'
-      ? props.children(selected)
-      : props.children
-  }
-
-  const state = useSelector(asyncThrottler.store, selector, {
-    compare: shallow,
-  })
-
-  createEffect(() => {
-    onCleanup(() => {
-      if (mergedOptions.onUnmount) {
-        mergedOptions.onUnmount(asyncThrottler)
-      } else {
-        asyncThrottler.cancel()
-      }
-    })
-  })
-
-  return {
-    ...asyncThrottler,
-    state,
-  } as SolidThrottler<TFn, TSelected> // omit `store` in favor of `state`
-}

package/src/throttler/index.ts

@@ -1,6 +0,0 @@
-// re-export everything from the core pacer package, BUT ONLY from the throttler module
-export * from '@tanstack/pacer/throttler'
-
-export * from './createThrottledSignal'
-export * from './createThrottledValue'
-export * from './createThrottler'

package/src/types/index.ts

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

package/src/utils/index.ts

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