@tanstack/solid-pacer 0.2.0

package/src/async-queuer/index.ts

@@ -0,0 +1,3 @@
+export * from '@tanstack/pacer/async-queuer'
+
+export * from './createAsyncQueuer'

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

@@ -0,0 +1,116 @@
+import { AsyncRateLimiter } from '@tanstack/pacer/async-rate-limiter'
+import { createSignal } from 'solid-js'
+import { bindInstanceMethods } from '@tanstack/pacer/utils'
+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'
+    | 'getRejectionCount'
+    | 'getRemainingInWindow'
+    | 'getMsUntilNextWindow'
+  > {
+  executionCount: Accessor<number>
+  rejectionCount: Accessor<number>
+  remainingInWindow: Accessor<number>
+  msUntilNextWindow: Accessor<number>
+}
+
+/**
+ * A low-level Solid hook that creates an `AsyncRateLimiter` instance to limit how many times an async function can execute within a time window.
+ *
+ * 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 allows an async function to execute up to a specified limit within a time window,
+ * then blocks subsequent calls until the window passes. This is useful for respecting API rate limits,
+ * managing resource constraints, or controlling bursts of async operations.
+ *
+ * @example
+ * ```tsx
+ * // Basic API call rate limiting
+ * const { maybeExecute } = createAsyncRateLimiter(
+ *   async (id: string) => {
+ *     const data = await api.fetchData(id);
+ *     return data;
+ *   },
+ *   { limit: 5, window: 1000 } // 5 calls per second
+ * );
+ *
+ * // With state management
+ * const [data, setData] = createSignal(null);
+ * const { maybeExecute } = createAsyncRateLimiter(
+ *   async (query) => {
+ *     const result = await searchAPI(query);
+ *     setData(result);
+ *   },
+ *   {
+ *     limit: 10,
+ *     window: 60000, // 10 calls per minute
+ *     onReject: (info) => console.log(`Rate limit exceeded: ${info.nextValidTime - Date.now()}ms until next window`)
+ *   }
+ * );
+ * ```
+ */
+export function createAsyncRateLimiter<
+  TFn extends AnyAsyncFunction,
+  TArgs extends Parameters<TFn>,
+>(
+  fn: TFn,
+  initialOptions: AsyncRateLimiterOptions<TFn, TArgs>,
+): SolidAsyncRateLimiter<TFn, TArgs> {
+  const asyncRateLimiter = new AsyncRateLimiter<TFn, TArgs>(fn, initialOptions)
+
+  const [executionCount, setExecutionCount] = createSignal(
+    asyncRateLimiter.getExecutionCount(),
+  )
+  const [rejectionCount, setRejectionCount] = createSignal(
+    asyncRateLimiter.getRejectionCount(),
+  )
+  const [remainingInWindow, setRemainingInWindow] = createSignal(
+    asyncRateLimiter.getRemainingInWindow(),
+  )
+  const [msUntilNextWindow, setMsUntilNextWindow] = createSignal(
+    asyncRateLimiter.getMsUntilNextWindow(),
+  )
+
+  function setOptions(
+    newOptions: Partial<AsyncRateLimiterOptions<TFn, TArgs>>,
+  ) {
+    asyncRateLimiter.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)
+
+  return {
+    ...bindInstanceMethods(asyncRateLimiter),
+    executionCount,
+    rejectionCount,
+    remainingInWindow,
+    msUntilNextWindow,
+    setOptions,
+  }
+}

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

@@ -0,0 +1,4 @@
+// re-export everything from the core pacer package, BUT ONLY from the async-rate-limiter module
+export * from '@tanstack/pacer/async-rate-limiter'
+
+export * from './createAsyncRateLimiter'

package/src/async-throttler/createAsyncThrottler.ts

@@ -0,0 +1,106 @@
+import { AsyncThrottler } from '@tanstack/pacer/async-throttler'
+import { createSignal } from 'solid-js'
+import { bindInstanceMethods } from '@tanstack/pacer/utils'
+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'
+    | 'getIsPending'
+    | 'getLastExecutionTime'
+    | 'getNextExecutionTime'
+  > {
+  executionCount: Accessor<number>
+  isPending: Accessor<boolean>
+  lastExecutionTime: Accessor<number>
+  nextExecutionTime: Accessor<number>
+}
+
+/**
+ * A low-level Solid hook that creates an `AsyncThrottler` instance to limit how often an async 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, etc).
+ *
+ * Async throttling ensures an async 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 API calls,
+ * database operations, or other async tasks.
+ *
+ * @example
+ * ```tsx
+ * // Basic API call throttling
+ * const { maybeExecute } = createAsyncThrottler(
+ *   async (id: string) => {
+ *     const data = await api.fetchData(id);
+ *     return data;
+ *   },
+ *   { wait: 1000 }
+ * );
+ *
+ * // With state management
+ * const [data, setData] = createSignal(null);
+ * const { maybeExecute } = createAsyncThrottler(
+ *   async (query) => {
+ *     const result = await searchAPI(query);
+ *     setData(result);
+ *   },
+ *   {
+ *     wait: 2000,
+ *     leading: true,   // Execute immediately on first call
+ *     trailing: false  // Skip trailing edge updates
+ *   }
+ * );
+ * ```
+ */
+
+export function createAsyncThrottler<
+  TFn extends AnyAsyncFunction,
+  TArgs extends Parameters<TFn>,
+>(
+  fn: TFn,
+  initialOptions: AsyncThrottlerOptions<TFn, TArgs>,
+): SolidAsyncThrottler<TFn, TArgs> {
+  const asyncThrottler = new AsyncThrottler<TFn, TArgs>(fn, initialOptions)
+
+  const [executionCount, setExecutionCount] = createSignal(
+    asyncThrottler.getExecutionCount(),
+  )
+  const [isPending, setIsPending] = createSignal(asyncThrottler.getIsPending())
+  const [lastExecutionTime, setLastExecutionTime] = createSignal(
+    asyncThrottler.getLastExecutionTime(),
+  )
+  const [nextExecutionTime, setNextExecutionTime] = createSignal(
+    asyncThrottler.getNextExecutionTime(),
+  )
+
+  function setOptions(newOptions: Partial<AsyncThrottlerOptions<TFn, TArgs>>) {
+    asyncThrottler.setOptions({
+      ...newOptions,
+      onExecute: (throttler) => {
+        setExecutionCount(throttler.getExecutionCount())
+        setIsPending(throttler.getIsPending())
+        setLastExecutionTime(throttler.getLastExecutionTime())
+        setNextExecutionTime(throttler.getNextExecutionTime())
+
+        const onExecute = newOptions.onExecute ?? initialOptions.onExecute
+        onExecute?.(throttler)
+      },
+    })
+  }
+
+  setOptions(initialOptions)
+
+  return {
+    ...bindInstanceMethods(asyncThrottler),
+    executionCount,
+    isPending,
+    lastExecutionTime,
+    nextExecutionTime,
+    setOptions,
+  }
+}

package/src/async-throttler/index.ts

@@ -0,0 +1,4 @@
+// re-export everything from the core pacer package, BUT ONLY from the async-throttler module
+export * from '@tanstack/pacer/async-throttler'
+
+export * from './createAsyncThrottler'

package/src/compare/index.ts

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

package/src/debouncer/createDebouncedSignal.ts

@@ -0,0 +1,59 @@
+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'
+
+/**
+ * A Solid hook that creates a debounced state value, combining Solid's createSignal with debouncing functionality.
+ * This hook provides both the current debounced value and methods to update it.
+ *
+ * The state value is only updated after the specified wait time has elapsed since the last update attempt.
+ * If another update is attempted before the wait time expires, the timer resets and starts waiting again.
+ * This is useful for handling frequent state updates that should be throttled, like search input values
+ * or window resize dimensions.
+ *
+ * The hook returns a tuple containing:
+ * - The current debounced value accessor
+ * - A function to update the debounced value
+ * - The debouncer instance with additional control methods and state signals
+ *
+ * @example
+ * ```tsx
+ * // Debounced search input
+ * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal('', {
+ *   wait: 500 // Wait 500ms after last keystroke
+ * });
+ *
+ * // Update value - will be debounced
+ * const handleChange = (e) => {
+ *   setSearchTerm(e.target.value);
+ * };
+ *
+ * // Access debouncer state via signals
+ * console.log('Executions:', debouncer.executionCount());
+ * console.log('Is pending:', debouncer.isPending());
+ *
+ * // In onExecute callback, use get* methods
+ * const [searchTerm, setSearchTerm, debouncer] = createDebouncedSignal('', {
+ *   wait: 500,
+ *   onExecute: (debouncer) => {
+ *     console.log('Total executions:', debouncer.getExecutionCount());
+ *   }
+ * });
+ * ```
+ */
+export function createDebouncedSignal<TValue>(
+  value: TValue,
+  initialOptions: DebouncerOptions<Setter<TValue>, [Accessor<TValue>]>,
+): [
+  Accessor<TValue>,
+  Setter<TValue>,
+  SolidDebouncer<Setter<TValue>, [Accessor<TValue>]>,
+] {
+  const [debouncedValue, setDebouncedValue] = createSignal<TValue>(value)
+
+  const debouncer = createDebouncer(setDebouncedValue, initialOptions)
+
+  return [debouncedValue, debouncer.maybeExecute as Setter<TValue>, debouncer]
+}

package/src/debouncer/createDebouncedValue.ts

@@ -0,0 +1,64 @@
+import { createEffect, onCleanup } 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'
+
+/**
+ * A Solid hook that creates a debounced value that updates only after a specified delay.
+ * Unlike createDebouncedSignal, this hook automatically tracks changes to the input value
+ * and updates the debounced value accordingly.
+ *
+ * The debounced value will only update after the specified wait time has elapsed since
+ * the last change to the input value. If the input value changes again before the wait
+ * time expires, the timer resets and starts waiting again.
+ *
+ * This is useful for deriving debounced values from props or state that change frequently,
+ * like search queries or form inputs, where you want to limit how often downstream effects
+ * 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
+ *
+ * @example
+ * ```tsx
+ * // Debounce a search query
+ * const [searchQuery, setSearchQuery] = createSignal('');
+ * const [debouncedQuery, debouncer] = createDebouncedValue(searchQuery, {
+ *   wait: 500 // Wait 500ms after last change
+ * });
+ *
+ * // debouncedQuery will update 500ms after searchQuery stops changing
+ * createEffect(() => {
+ *   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);
+ * };
+ * ```
+ */
+export function createDebouncedValue<TValue>(
+  value: Accessor<TValue>,
+  initialOptions: DebouncerOptions<Setter<TValue>, [Accessor<TValue>]>,
+): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, [Accessor<TValue>]>] {
+  const [debouncedValue, setDebouncedValue, debouncer] = createDebouncedSignal(
+    value(),
+    initialOptions,
+  )
+
+  createEffect(() => {
+    setDebouncedValue(value() as any)
+    onCleanup(() => {
+      debouncer.cancel()
+    })
+  })
+
+  return [debouncedValue, debouncer]
+}

package/src/debouncer/createDebouncer.ts

@@ -0,0 +1,90 @@
+import { Debouncer } from '@tanstack/pacer/debouncer'
+import { createSignal } from 'solid-js'
+import { bindInstanceMethods } from '@tanstack/pacer/utils'
+import type { Accessor } from 'solid-js'
+import type { AnyFunction } from '@tanstack/pacer/types'
+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'> {
+  executionCount: Accessor<number>
+  isPending: Accessor<boolean>
+}
+
+/**
+ * A Solid hook that creates and manages a Debouncer instance.
+ *
+ * This is a lower-level hook that provides direct access to the Debouncer's functionality without
+ * any built-in state management. This allows you to integrate it with any state management solution
+ * you prefer (createSignal, Redux, Zustand, etc.).
+ *
+ * This hook provides debouncing functionality to limit how often a function can be called,
+ * waiting for a specified delay before executing the latest call. This is useful for handling
+ * frequent events like window resizing, scroll events, or real-time search inputs.
+ *
+ * The debouncer will only execute the function after the specified wait time has elapsed
+ * since the last call. If the function is called again before the wait time expires, the
+ * timer resets and starts waiting again.
+ *
+ * @example
+ * ```tsx
+ * // Debounce a search function to limit API calls
+ * const debouncer = createDebouncer(
+ *   (query: string) => fetchSearchResults(query),
+ *   { wait: 500 } // Wait 500ms after last keystroke
+ * );
+ *
+ * // In an event handler
+ * const handleChange = (e) => {
+ *   debouncer.maybeExecute(e.target.value);
+ * };
+ *
+ * // Access debouncer state via signals
+ * console.log('Executions:', debouncer.executionCount());
+ * console.log('Is pending:', debouncer.isPending());
+ *
+ * // Update options
+ * debouncer.setOptions({ wait: 1000 });
+ * ```
+ */
+export function createDebouncer<
+  TFn extends AnyFunction,
+  TArgs extends Parameters<TFn>,
+>(
+  fn: TFn,
+  initialOptions: DebouncerOptions<TFn, TArgs>,
+): SolidDebouncer<TFn, TArgs> {
+  const debouncer = new Debouncer<TFn, TArgs>(fn, initialOptions)
+
+  const [executionCount, setExecutionCount] = createSignal(
+    debouncer.getExecutionCount(),
+  )
+  const [isPending, setIsPending] = createSignal(debouncer.getIsPending())
+
+  function setOptions(newOptions: Partial<DebouncerOptions<TFn, TArgs>>) {
+    debouncer.setOptions({
+      ...newOptions,
+      onExecute: (debouncer) => {
+        setExecutionCount(debouncer.getExecutionCount())
+        setIsPending(debouncer.getIsPending())
+
+        const onExecute = newOptions.onExecute ?? initialOptions.onExecute
+        onExecute?.(debouncer)
+      },
+    })
+  }
+
+  setOptions(initialOptions)
+
+  return {
+    ...bindInstanceMethods(debouncer),
+    executionCount,
+    isPending,
+    setOptions,
+  }
+}

package/src/debouncer/index.ts

@@ -0,0 +1,6 @@
+// re-export everything from the core pacer package, BUT ONLY from the debouncer module
+export * from '@tanstack/pacer/debouncer'
+
+export * from './createDebouncedSignal'
+export * from './createDebouncedValue'
+export * from './createDebouncer'

package/src/index.ts

@@ -0,0 +1,36 @@
+// re-export everything from the core pacer package
+export * from '@tanstack/pacer'
+
+/**
+ * Export every hook individually - DON'T export from barrel files
+ */
+
+// async-debouncer
+export * from './async-debouncer/createAsyncDebouncer'
+
+// async-queuer
+export * from './async-queuer/createAsyncQueuer'
+
+// async-rate-limiter
+export * from './async-rate-limiter/createAsyncRateLimiter'
+
+// async-throttler
+export * from './async-throttler/createAsyncThrottler'
+
+// debouncer
+export * from './debouncer/createDebouncedSignal'
+export * from './debouncer/createDebouncedValue'
+export * from './debouncer/createDebouncer'
+
+// queuer
+export * from './queuer/createQueuer'
+
+// rate-limiter
+export * from './rate-limiter/createRateLimiter'
+export * from './rate-limiter/createRateLimitedSignal'
+export * from './rate-limiter/createRateLimitedValue'
+
+// throttler
+export * from './throttler/createThrottledSignal'
+export * from './throttler/createThrottledValue'
+export * from './throttler/createThrottler'

package/src/queuer/createQueuer.ts

@@ -0,0 +1,167 @@
+import { Queuer } from '@tanstack/pacer/queuer'
+import { createSignal } from 'solid-js'
+import { bindInstanceMethods } from '@tanstack/pacer/utils'
+import type { Accessor } from 'solid-js'
+import type { QueuerOptions } from '@tanstack/pacer/queuer'
+
+export interface SolidQueuer<TValue>
+  extends Omit<
+    Queuer<TValue>,
+    | 'getAllItems'
+    | 'getExecutionCount'
+    | 'getIsEmpty'
+    | 'getIsFull'
+    | 'getIsIdle'
+    | 'getIsRunning'
+    | 'getPeek'
+    | 'getSize'
+  > {
+  /**
+   * Signal version of `getAllItems`
+   */
+  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 `getPeek`
+   */
+  peek: Accessor<TValue | undefined>
+  /**
+   * Signal version of `getSize`
+   */
+  size: Accessor<number>
+}
+
+/**
+ * A Solid hook that creates and manages a Queuer instance.
+ *
+ * This is a lower-level hook that provides direct access to the Queuer's functionality without
+ * any built-in state management. This allows you to integrate it with any state management solution
+ * you prefer (createSignal, Redux, Zustand, etc.) by utilizing the onItemsChange callback.
+ *
+ * For a hook with built-in state management, see createQueuerSignal.
+ *
+ * The Queuer extends the base Queue to add processing capabilities. Items are processed
+ * synchronously in order, with optional delays between processing each item. The queuer includes
+ * an internal tick mechanism that can be started and stopped, making it useful as a scheduler.
+ * When started, it will process one item per tick, with an optional wait time between ticks.
+ *
+ * By default uses FIFO (First In First Out) behavior, but can be configured for LIFO
+ * (Last In First Out) by specifying 'front' position when adding items.
+ *
+ * @example
+ * ```tsx
+ * // Example with custom state management and scheduling
+ * const [items, setItems] = createSignal([]);
+ *
+ * const queue = createQueuer({
+ *   started: true, // Start processing immediately
+ *   wait: 1000,    // Process one item every second
+ *   onItemsChange: (queue) => setItems(queue.getAllItems()),
+ *   getPriority: (item) => item.priority // Process higher priority items first
+ * });
+ *
+ * // Add items to process - they'll be handled automatically
+ * queue.addItem('task1');
+ * queue.addItem('task2');
+ *
+ * // Control the scheduler
+ * queue.stop();  // Pause processing
+ * queue.start(); // Resume processing
+ *
+ * // Access queue state via signals
+ * console.log('Items:', queue.allItems());
+ * console.log('Size:', queue.size());
+ * console.log('Is empty:', queue.isEmpty());
+ * console.log('Is running:', queue.isRunning());
+ * console.log('Next item:', queue.peek());
+ * ```
+ */
+export function createQueuer<TValue>(
+  initialOptions: QueuerOptions<TValue> = {},
+): SolidQueuer<TValue> {
+  const queuer = new Queuer<TValue>(initialOptions)
+
+  const [allItems, setAllItems] = createSignal<Array<TValue>>(
+    queuer.getAllItems(),
+  )
+  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 [peek, setPeek] = createSignal<TValue | undefined>(queuer.getPeek())
+  const [size, setSize] = createSignal(queuer.getSize())
+
+  function setOptions(newOptions: Partial<QueuerOptions<TValue>>) {
+    queuer.setOptions({
+      ...newOptions,
+      onItemsChange: (queuer) => {
+        setAllItems(queuer.getAllItems())
+        setExecutionCount(queuer.getExecutionCount())
+        setIsEmpty(queuer.getIsEmpty())
+        setIsFull(queuer.getIsFull())
+        setIsIdle(queuer.getIsIdle())
+        setPeek(() => queuer.getPeek())
+        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)
+      },
+    })
+  }
+
+  setOptions(initialOptions)
+
+  return {
+    ...bindInstanceMethods(queuer),
+    allItems,
+    executionCount,
+    isEmpty,
+    isFull,
+    isIdle,
+    isRunning,
+    peek,
+    rejectionCount,
+    size,
+    setOptions,
+  }
+}

package/src/queuer/index.ts

@@ -0,0 +1,3 @@
+export * from '@tanstack/pacer/queuer'
+
+export * from './createQueuer'