@tanstack/preact-pacer 0.0.1 → 0.19.0

package/dist/debouncer/useDebouncer.js

@@ -0,0 +1,128 @@
+import { useDefaultPacerOptions } from "../provider/PacerProvider.js";
+import { useEffect, useMemo, useState } from "preact/hooks";
+import { useStore } from "@tanstack/preact-store";
+import { Debouncer } from "@tanstack/pacer/debouncer";
+
+//#region src/debouncer/useDebouncer.ts
+/**
+* A Preact 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 (useState, 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.
+*
+* ## State Management and Selector
+*
+* The hook uses TanStack Store for reactive state management. You can subscribe to state changes
+* in two ways:
+*
+* **1. Using `debouncer.Subscribe` HOC (Recommended for component tree subscriptions)**
+*
+* Use the `Subscribe` HOC 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 a re-render
+* at the hook level, optimizing performance by preventing unnecessary re-renders 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` HOC. This prevents unnecessary
+* re-renders and gives you full control over when your component updates.
+*
+* Available state properties:
+* - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+* - `executionCount`: Number of function executions that have been completed
+* - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+* - `lastArgs`: The arguments from the most recent call to maybeExecute
+* - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+*
+* @example
+* ```tsx
+* // Default behavior - no reactive state subscriptions
+* const searchDebouncer = useDebouncer(
+*   (query: string) => fetchSearchResults(query),
+*   { wait: 500 }
+* );
+*
+* // Subscribe to state changes deep in component tree using Subscribe HOC
+* <searchDebouncer.Subscribe selector={(state) => ({ isPending: state.isPending })}>
+*   {({ isPending }) => (
+*     <div>{isPending ? 'Searching...' : 'Ready'}</div>
+*   )}
+* </searchDebouncer.Subscribe>
+*
+* // Opt-in to re-render when isPending changes at hook level (optimized for loading states)
+* const searchDebouncer = useDebouncer(
+*   (query: string) => fetchSearchResults(query),
+*   { wait: 500 },
+*   (state) => ({ isPending: state.isPending })
+* );
+*
+* // Opt-in to re-render when executionCount changes (optimized for tracking execution)
+* const searchDebouncer = useDebouncer(
+*   (query: string) => fetchSearchResults(query),
+*   { wait: 500 },
+*   (state) => ({ executionCount: state.executionCount })
+* );
+*
+* // Multiple state properties - re-render when any of these change
+* const searchDebouncer = useDebouncer(
+*   (query: string) => fetchSearchResults(query),
+*   { wait: 500 },
+*   (state) => ({
+*     isPending: state.isPending,
+*     executionCount: state.executionCount,
+*     status: state.status
+*   })
+* );
+*
+* // In an event handler
+* const handleChange = (e) => {
+*   searchDebouncer.maybeExecute(e.target.value);
+* };
+*
+* // Access the selected state (will be empty object {} unless selector provided)
+* const { isPending } = searchDebouncer.state;
+* ```
+*/
+function useDebouncer(fn, options, selector = () => ({})) {
+	const mergedOptions = {
+		...useDefaultPacerOptions().debouncer,
+		...options
+	};
+	const [debouncer] = useState(() => {
+		const debouncerInstance = new Debouncer(fn, mergedOptions);
+		debouncerInstance.Subscribe = function Subscribe(props) {
+			const selected = useStore(debouncerInstance.store, props.selector);
+			return typeof props.children === "function" ? props.children(selected) : props.children;
+		};
+		return debouncerInstance;
+	});
+	debouncer.fn = fn;
+	debouncer.setOptions(mergedOptions);
+	useEffect(() => {
+		return () => {
+			debouncer.cancel();
+		};
+	}, [debouncer]);
+	const state = useStore(debouncer.store, selector);
+	return useMemo(() => ({
+		...debouncer,
+		state
+	}), [debouncer, state]);
+}
+
+//#endregion
+export { useDebouncer };
+//# sourceMappingURL=useDebouncer.js.map

package/dist/debouncer/useDebouncer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDebouncer.js","names":[],"sources":["../../src/debouncer/useDebouncer.ts"],"sourcesContent":["import { useEffect, useMemo, useState } from 'preact/hooks'\nimport { Debouncer } from '@tanstack/pacer/debouncer'\nimport { useStore } from '@tanstack/preact-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/preact-store'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type { ComponentChildren } from 'preact'\n\nexport interface PreactDebouncer<\n  TFn extends AnyFunction,\n  TSelected = {},\n> extends Omit<Debouncer<TFn>, 'store'> {\n  /**\n   * A Preact HOC (Higher Order Component) that allows you to subscribe to the debouncer state.\n   *\n   * This is useful for opting into state re-renders for specific parts of the debouncer state\n   * deep in your component tree without needing to pass a selector to the hook.\n   *\n   * @example\n   * <debouncer.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n   *   {({ isPending }) => (\n   *     <div>{isPending ? 'Loading...' : 'Ready'}</div>\n   *   )}\n   * </debouncer.Subscribe>\n   */\n  Subscribe: <TSelected>(props: {\n    selector: (state: DebouncerState<TFn>) => TSelected\n    children: ((state: TSelected) => ComponentChildren) | ComponentChildren\n  }) => ComponentChildren\n  /**\n   * Reactive state that will be updated and re-rendered when the debouncer state changes\n   *\n   * Use this instead of `debouncer.store.state`\n   */\n  readonly state: Readonly<TSelected>\n  /**\n   * @deprecated Use `debouncer.state` instead of `debouncer.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.\n   * Although, you can make the state reactive by using the `useStore` in your own usage.\n   */\n  readonly store: Store<Readonly<DebouncerState<TFn>>>\n}\n\n/**\n * A Preact hook that creates and manages a Debouncer instance.\n *\n * This is a lower-level hook that provides direct access to the Debouncer's functionality without\n * any built-in state management. This allows you to integrate it with any state management solution\n * you prefer (useState, Redux, Zustand, etc.).\n *\n * This hook provides debouncing functionality to limit how often a function can be called,\n * waiting for a specified delay before executing the latest call. This is useful for handling\n * frequent events like window resizing, scroll events, or real-time search inputs.\n *\n * The debouncer will only execute the function after the specified wait time has elapsed\n * since the last call. If the function is called again before the wait time expires, the\n * timer resets and starts waiting again.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management. You can subscribe to state changes\n * in two ways:\n *\n * **1. Using `debouncer.Subscribe` HOC (Recommended for component tree subscriptions)**\n *\n * Use the `Subscribe` HOC to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n *\n * **2. Using the `selector` parameter (For hook-level subscriptions)**\n *\n * The `selector` parameter allows you to specify which state changes will trigger a re-render\n * at the hook level, optimizing performance by preventing unnecessary re-renders when irrelevant\n * state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function or using the `Subscribe` HOC. This prevents unnecessary\n * re-renders and gives you full control over when your component updates.\n *\n * Available state properties:\n * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const searchDebouncer = useDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 }\n * );\n *\n * // Subscribe to state changes deep in component tree using Subscribe HOC\n * <searchDebouncer.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n *   {({ isPending }) => (\n *     <div>{isPending ? 'Searching...' : 'Ready'}</div>\n *   )}\n * </searchDebouncer.Subscribe>\n *\n * // Opt-in to re-render when isPending changes at hook level (optimized for loading states)\n * const searchDebouncer = useDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({ isPending: state.isPending })\n * );\n *\n * // Opt-in to re-render when executionCount changes (optimized for tracking execution)\n * const searchDebouncer = useDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({ executionCount: state.executionCount })\n * );\n *\n * // Multiple state properties - re-render when any of these change\n * const searchDebouncer = useDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({\n *     isPending: state.isPending,\n *     executionCount: state.executionCount,\n *     status: state.status\n *   })\n * );\n *\n * // In an event handler\n * const handleChange = (e) => {\n *   searchDebouncer.maybeExecute(e.target.value);\n * };\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { isPending } = searchDebouncer.state;\n * ```\n */\nexport function useDebouncer<TFn extends AnyFunction, TSelected = {}>(\n  fn: TFn,\n  options: DebouncerOptions<TFn>,\n  selector: (state: DebouncerState<TFn>) => TSelected = () => ({}) as TSelected,\n): PreactDebouncer<TFn, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().debouncer,\n    ...options,\n  } as DebouncerOptions<TFn>\n\n  const [debouncer] = useState(() => {\n    const debouncerInstance = new Debouncer(\n      fn,\n      mergedOptions,\n    ) as unknown as PreactDebouncer<TFn, TSelected>\n\n    debouncerInstance.Subscribe = function Subscribe<TSelected>(props: {\n      selector: (state: DebouncerState<TFn>) => TSelected\n      children: ((state: TSelected) => ComponentChildren) | ComponentChildren\n    }) {\n      const selected = useStore(debouncerInstance.store, props.selector)\n\n      return typeof props.children === 'function'\n        ? props.children(selected)\n        : props.children\n    }\n\n    return debouncerInstance\n  })\n\n  debouncer.fn = fn\n  debouncer.setOptions(mergedOptions)\n\n  useEffect(() => {\n    return () => {\n      debouncer.cancel()\n    }\n  }, [debouncer])\n\n  const state = useStore(debouncer.store, selector)\n\n  return useMemo(\n    () =>\n      ({\n        ...debouncer,\n        state,\n      }) as PreactDebouncer<TFn, TSelected>, // omit `store` in favor of `state`\n    [debouncer, state],\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2IA,SAAgB,aACd,IACA,SACA,kBAA6D,EAAE,GAC9B;CACjC,MAAM,gBAAgB;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ;CAED,MAAM,CAAC,aAAa,eAAe;EACjC,MAAM,oBAAoB,IAAI,UAC5B,IACA,cACD;AAED,oBAAkB,YAAY,SAAS,UAAqB,OAGzD;GACD,MAAM,WAAW,SAAS,kBAAkB,OAAO,MAAM,SAAS;AAElE,UAAO,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;AAGZ,SAAO;GACP;AAEF,WAAU,KAAK;AACf,WAAU,WAAW,cAAc;AAEnC,iBAAgB;AACd,eAAa;AACX,aAAU,QAAQ;;IAEnB,CAAC,UAAU,CAAC;CAEf,MAAM,QAAQ,SAAS,UAAU,OAAO,SAAS;AAEjD,QAAO,eAEF;EACC,GAAG;EACH;EACD,GACH,CAAC,WAAW,MAAM,CACnB"}

package/dist/index.cjs

@@ -0,0 +1,66 @@
+const require_PacerProvider = require('./provider/PacerProvider.cjs');
+const require_useAsyncBatcher = require('./async-batcher/useAsyncBatcher.cjs');
+const require_useAsyncBatchedCallback = require('./async-batcher/useAsyncBatchedCallback.cjs');
+const require_useAsyncDebouncer = require('./async-debouncer/useAsyncDebouncer.cjs');
+const require_useAsyncDebouncedCallback = require('./async-debouncer/useAsyncDebouncedCallback.cjs');
+const require_useAsyncQueuer = require('./async-queuer/useAsyncQueuer.cjs');
+const require_useAsyncQueuedState = require('./async-queuer/useAsyncQueuedState.cjs');
+const require_useAsyncRateLimiter = require('./async-rate-limiter/useAsyncRateLimiter.cjs');
+const require_useAsyncRateLimitedCallback = require('./async-rate-limiter/useAsyncRateLimitedCallback.cjs');
+const require_useAsyncThrottler = require('./async-throttler/useAsyncThrottler.cjs');
+const require_useAsyncThrottledCallback = require('./async-throttler/useAsyncThrottledCallback.cjs');
+const require_useBatcher = require('./batcher/useBatcher.cjs');
+const require_useBatchedCallback = require('./batcher/useBatchedCallback.cjs');
+const require_useDebouncer = require('./debouncer/useDebouncer.cjs');
+const require_useDebouncedCallback = require('./debouncer/useDebouncedCallback.cjs');
+const require_useDebouncedState = require('./debouncer/useDebouncedState.cjs');
+const require_useDebouncedValue = require('./debouncer/useDebouncedValue.cjs');
+const require_useQueuer = require('./queuer/useQueuer.cjs');
+const require_useQueuedState = require('./queuer/useQueuedState.cjs');
+const require_useQueuedValue = require('./queuer/useQueuedValue.cjs');
+const require_useRateLimiter = require('./rate-limiter/useRateLimiter.cjs');
+const require_useRateLimitedCallback = require('./rate-limiter/useRateLimitedCallback.cjs');
+const require_useRateLimitedState = require('./rate-limiter/useRateLimitedState.cjs');
+const require_useRateLimitedValue = require('./rate-limiter/useRateLimitedValue.cjs');
+const require_useThrottler = require('./throttler/useThrottler.cjs');
+const require_useThrottledCallback = require('./throttler/useThrottledCallback.cjs');
+const require_useThrottledState = require('./throttler/useThrottledState.cjs');
+const require_useThrottledValue = require('./throttler/useThrottledValue.cjs');
+
+exports.PacerProvider = require_PacerProvider.PacerProvider;
+exports.useAsyncBatchedCallback = require_useAsyncBatchedCallback.useAsyncBatchedCallback;
+exports.useAsyncBatcher = require_useAsyncBatcher.useAsyncBatcher;
+exports.useAsyncDebouncedCallback = require_useAsyncDebouncedCallback.useAsyncDebouncedCallback;
+exports.useAsyncDebouncer = require_useAsyncDebouncer.useAsyncDebouncer;
+exports.useAsyncQueuedState = require_useAsyncQueuedState.useAsyncQueuedState;
+exports.useAsyncQueuer = require_useAsyncQueuer.useAsyncQueuer;
+exports.useAsyncRateLimitedCallback = require_useAsyncRateLimitedCallback.useAsyncRateLimitedCallback;
+exports.useAsyncRateLimiter = require_useAsyncRateLimiter.useAsyncRateLimiter;
+exports.useAsyncThrottledCallback = require_useAsyncThrottledCallback.useAsyncThrottledCallback;
+exports.useAsyncThrottler = require_useAsyncThrottler.useAsyncThrottler;
+exports.useBatchedCallback = require_useBatchedCallback.useBatchedCallback;
+exports.useBatcher = require_useBatcher.useBatcher;
+exports.useDebouncedCallback = require_useDebouncedCallback.useDebouncedCallback;
+exports.useDebouncedState = require_useDebouncedState.useDebouncedState;
+exports.useDebouncedValue = require_useDebouncedValue.useDebouncedValue;
+exports.useDebouncer = require_useDebouncer.useDebouncer;
+exports.useDefaultPacerOptions = require_PacerProvider.useDefaultPacerOptions;
+exports.usePacerContext = require_PacerProvider.usePacerContext;
+exports.useQueuedState = require_useQueuedState.useQueuedState;
+exports.useQueuedValue = require_useQueuedValue.useQueuedValue;
+exports.useQueuer = require_useQueuer.useQueuer;
+exports.useRateLimitedCallback = require_useRateLimitedCallback.useRateLimitedCallback;
+exports.useRateLimitedState = require_useRateLimitedState.useRateLimitedState;
+exports.useRateLimitedValue = require_useRateLimitedValue.useRateLimitedValue;
+exports.useRateLimiter = require_useRateLimiter.useRateLimiter;
+exports.useThrottledCallback = require_useThrottledCallback.useThrottledCallback;
+exports.useThrottledState = require_useThrottledState.useThrottledState;
+exports.useThrottledValue = require_useThrottledValue.useThrottledValue;
+exports.useThrottler = require_useThrottler.useThrottler;
+var _tanstack_pacer = require("@tanstack/pacer");
+Object.keys(_tanstack_pacer).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _tanstack_pacer[k]; }
+  });
+});

package/dist/index.d.cts

@@ -0,0 +1,30 @@
+import { PreactAsyncBatcher, useAsyncBatcher } from "./async-batcher/useAsyncBatcher.cjs";
+import { useAsyncBatchedCallback } from "./async-batcher/useAsyncBatchedCallback.cjs";
+import { PreactAsyncDebouncer, useAsyncDebouncer } from "./async-debouncer/useAsyncDebouncer.cjs";
+import { useAsyncDebouncedCallback } from "./async-debouncer/useAsyncDebouncedCallback.cjs";
+import { PreactAsyncQueuer, useAsyncQueuer } from "./async-queuer/useAsyncQueuer.cjs";
+import { useAsyncQueuedState } from "./async-queuer/useAsyncQueuedState.cjs";
+import { PreactAsyncRateLimiter, useAsyncRateLimiter } from "./async-rate-limiter/useAsyncRateLimiter.cjs";
+import { useAsyncRateLimitedCallback } from "./async-rate-limiter/useAsyncRateLimitedCallback.cjs";
+import { PreactAsyncThrottler, useAsyncThrottler } from "./async-throttler/useAsyncThrottler.cjs";
+import { useAsyncThrottledCallback } from "./async-throttler/useAsyncThrottledCallback.cjs";
+import { PreactBatcher, useBatcher } from "./batcher/useBatcher.cjs";
+import { useBatchedCallback } from "./batcher/useBatchedCallback.cjs";
+import { useDebouncedCallback } from "./debouncer/useDebouncedCallback.cjs";
+import { PreactDebouncer, useDebouncer } from "./debouncer/useDebouncer.cjs";
+import { useDebouncedState } from "./debouncer/useDebouncedState.cjs";
+import { useDebouncedValue } from "./debouncer/useDebouncedValue.cjs";
+import { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext } from "./provider/PacerProvider.cjs";
+import { PreactQueuer, useQueuer } from "./queuer/useQueuer.cjs";
+import { useQueuedState } from "./queuer/useQueuedState.cjs";
+import { useQueuedValue } from "./queuer/useQueuedValue.cjs";
+import { useRateLimitedCallback } from "./rate-limiter/useRateLimitedCallback.cjs";
+import { PreactRateLimiter, useRateLimiter } from "./rate-limiter/useRateLimiter.cjs";
+import { useRateLimitedState } from "./rate-limiter/useRateLimitedState.cjs";
+import { useRateLimitedValue } from "./rate-limiter/useRateLimitedValue.cjs";
+import { useThrottledCallback } from "./throttler/useThrottledCallback.cjs";
+import { PreactThrottler, useThrottler } from "./throttler/useThrottler.cjs";
+import { useThrottledState } from "./throttler/useThrottledState.cjs";
+import { useThrottledValue } from "./throttler/useThrottledValue.cjs";
+export * from "@tanstack/pacer";
+export { PacerProvider, PacerProviderOptions, PacerProviderProps, PreactAsyncBatcher, PreactAsyncDebouncer, PreactAsyncQueuer, PreactAsyncRateLimiter, PreactAsyncThrottler, PreactBatcher, PreactDebouncer, PreactQueuer, PreactRateLimiter, PreactThrottler, useAsyncBatchedCallback, useAsyncBatcher, useAsyncDebouncedCallback, useAsyncDebouncer, useAsyncQueuedState, useAsyncQueuer, useAsyncRateLimitedCallback, useAsyncRateLimiter, useAsyncThrottledCallback, useAsyncThrottler, useBatchedCallback, useBatcher, useDebouncedCallback, useDebouncedState, useDebouncedValue, useDebouncer, useDefaultPacerOptions, usePacerContext, useQueuedState, useQueuedValue, useQueuer, useRateLimitedCallback, useRateLimitedState, useRateLimitedValue, useRateLimiter, useThrottledCallback, useThrottledState, useThrottledValue, useThrottler };

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { PreactAsyncBatcher, useAsyncBatcher } from "./async-batcher/useAsyncBatcher.js";
+import { useAsyncBatchedCallback } from "./async-batcher/useAsyncBatchedCallback.js";
+import { PreactAsyncDebouncer, useAsyncDebouncer } from "./async-debouncer/useAsyncDebouncer.js";
+import { useAsyncDebouncedCallback } from "./async-debouncer/useAsyncDebouncedCallback.js";
+import { PreactAsyncQueuer, useAsyncQueuer } from "./async-queuer/useAsyncQueuer.js";
+import { useAsyncQueuedState } from "./async-queuer/useAsyncQueuedState.js";
+import { PreactAsyncRateLimiter, useAsyncRateLimiter } from "./async-rate-limiter/useAsyncRateLimiter.js";
+import { useAsyncRateLimitedCallback } from "./async-rate-limiter/useAsyncRateLimitedCallback.js";
+import { PreactAsyncThrottler, useAsyncThrottler } from "./async-throttler/useAsyncThrottler.js";
+import { useAsyncThrottledCallback } from "./async-throttler/useAsyncThrottledCallback.js";
+import { PreactBatcher, useBatcher } from "./batcher/useBatcher.js";
+import { useBatchedCallback } from "./batcher/useBatchedCallback.js";
+import { useDebouncedCallback } from "./debouncer/useDebouncedCallback.js";
+import { PreactDebouncer, useDebouncer } from "./debouncer/useDebouncer.js";
+import { useDebouncedState } from "./debouncer/useDebouncedState.js";
+import { useDebouncedValue } from "./debouncer/useDebouncedValue.js";
+import { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext } from "./provider/PacerProvider.js";
+import { PreactQueuer, useQueuer } from "./queuer/useQueuer.js";
+import { useQueuedState } from "./queuer/useQueuedState.js";
+import { useQueuedValue } from "./queuer/useQueuedValue.js";
+import { useRateLimitedCallback } from "./rate-limiter/useRateLimitedCallback.js";
+import { PreactRateLimiter, useRateLimiter } from "./rate-limiter/useRateLimiter.js";
+import { useRateLimitedState } from "./rate-limiter/useRateLimitedState.js";
+import { useRateLimitedValue } from "./rate-limiter/useRateLimitedValue.js";
+import { useThrottledCallback } from "./throttler/useThrottledCallback.js";
+import { PreactThrottler, useThrottler } from "./throttler/useThrottler.js";
+import { useThrottledState } from "./throttler/useThrottledState.js";
+import { useThrottledValue } from "./throttler/useThrottledValue.js";
+export * from "@tanstack/pacer";
+export { PacerProvider, PacerProviderOptions, PacerProviderProps, PreactAsyncBatcher, PreactAsyncDebouncer, PreactAsyncQueuer, PreactAsyncRateLimiter, PreactAsyncThrottler, PreactBatcher, PreactDebouncer, PreactQueuer, PreactRateLimiter, PreactThrottler, useAsyncBatchedCallback, useAsyncBatcher, useAsyncDebouncedCallback, useAsyncDebouncer, useAsyncQueuedState, useAsyncQueuer, useAsyncRateLimitedCallback, useAsyncRateLimiter, useAsyncThrottledCallback, useAsyncThrottler, useBatchedCallback, useBatcher, useDebouncedCallback, useDebouncedState, useDebouncedValue, useDebouncer, useDefaultPacerOptions, usePacerContext, useQueuedState, useQueuedValue, useQueuer, useRateLimitedCallback, useRateLimitedState, useRateLimitedValue, useRateLimiter, useThrottledCallback, useThrottledState, useThrottledValue, useThrottler };

package/dist/index.js

@@ -0,0 +1,32 @@
+import { PacerProvider, useDefaultPacerOptions, usePacerContext } from "./provider/PacerProvider.js";
+import { useAsyncBatcher } from "./async-batcher/useAsyncBatcher.js";
+import { useAsyncBatchedCallback } from "./async-batcher/useAsyncBatchedCallback.js";
+import { useAsyncDebouncer } from "./async-debouncer/useAsyncDebouncer.js";
+import { useAsyncDebouncedCallback } from "./async-debouncer/useAsyncDebouncedCallback.js";
+import { useAsyncQueuer } from "./async-queuer/useAsyncQueuer.js";
+import { useAsyncQueuedState } from "./async-queuer/useAsyncQueuedState.js";
+import { useAsyncRateLimiter } from "./async-rate-limiter/useAsyncRateLimiter.js";
+import { useAsyncRateLimitedCallback } from "./async-rate-limiter/useAsyncRateLimitedCallback.js";
+import { useAsyncThrottler } from "./async-throttler/useAsyncThrottler.js";
+import { useAsyncThrottledCallback } from "./async-throttler/useAsyncThrottledCallback.js";
+import { useBatcher } from "./batcher/useBatcher.js";
+import { useBatchedCallback } from "./batcher/useBatchedCallback.js";
+import { useDebouncer } from "./debouncer/useDebouncer.js";
+import { useDebouncedCallback } from "./debouncer/useDebouncedCallback.js";
+import { useDebouncedState } from "./debouncer/useDebouncedState.js";
+import { useDebouncedValue } from "./debouncer/useDebouncedValue.js";
+import { useQueuer } from "./queuer/useQueuer.js";
+import { useQueuedState } from "./queuer/useQueuedState.js";
+import { useQueuedValue } from "./queuer/useQueuedValue.js";
+import { useRateLimiter } from "./rate-limiter/useRateLimiter.js";
+import { useRateLimitedCallback } from "./rate-limiter/useRateLimitedCallback.js";
+import { useRateLimitedState } from "./rate-limiter/useRateLimitedState.js";
+import { useRateLimitedValue } from "./rate-limiter/useRateLimitedValue.js";
+import { useThrottler } from "./throttler/useThrottler.js";
+import { useThrottledCallback } from "./throttler/useThrottledCallback.js";
+import { useThrottledState } from "./throttler/useThrottledState.js";
+import { useThrottledValue } from "./throttler/useThrottledValue.js";
+
+export * from "@tanstack/pacer"
+
+export { PacerProvider, useAsyncBatchedCallback, useAsyncBatcher, useAsyncDebouncedCallback, useAsyncDebouncer, useAsyncQueuedState, useAsyncQueuer, useAsyncRateLimitedCallback, useAsyncRateLimiter, useAsyncThrottledCallback, useAsyncThrottler, useBatchedCallback, useBatcher, useDebouncedCallback, useDebouncedState, useDebouncedValue, useDebouncer, useDefaultPacerOptions, usePacerContext, useQueuedState, useQueuedValue, useQueuer, useRateLimitedCallback, useRateLimitedState, useRateLimitedValue, useRateLimiter, useThrottledCallback, useThrottledState, useThrottledValue, useThrottler };

package/dist/provider/PacerProvider.cjs

@@ -0,0 +1,26 @@
+let preact_hooks = require("preact/hooks");
+let preact = require("preact");
+let preact_jsx_runtime = require("preact/jsx-runtime");
+
+//#region src/provider/PacerProvider.tsx
+const PacerContext = (0, preact.createContext)(null);
+const DEFAULT_OPTIONS = {};
+function PacerProvider({ children, defaultOptions = DEFAULT_OPTIONS }) {
+	const contextValue = (0, preact_hooks.useMemo)(() => ({ defaultOptions }), [defaultOptions]);
+	return /* @__PURE__ */ (0, preact_jsx_runtime.jsx)(PacerContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+function usePacerContext() {
+	return (0, preact_hooks.useContext)(PacerContext);
+}
+function useDefaultPacerOptions() {
+	return (0, preact_hooks.useContext)(PacerContext)?.defaultOptions ?? {};
+}
+
+//#endregion
+exports.PacerProvider = PacerProvider;
+exports.useDefaultPacerOptions = useDefaultPacerOptions;
+exports.usePacerContext = usePacerContext;
+//# sourceMappingURL=PacerProvider.cjs.map

package/dist/provider/PacerProvider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PacerProvider.cjs","names":["DEFAULT_OPTIONS: PacerProviderOptions","contextValue: PacerContextValue"],"sources":["../../src/provider/PacerProvider.tsx"],"sourcesContent":["import { useContext, useMemo } from 'preact/hooks'\nimport { createContext } from 'preact'\nimport type { ComponentChildren } from 'preact'\nimport type {\n  AnyAsyncFunction,\n  AnyFunction,\n  AsyncBatcherOptions,\n  AsyncDebouncerOptions,\n  AsyncQueuerOptions,\n  AsyncRateLimiterOptions,\n  AsyncThrottlerOptions,\n  BatcherOptions,\n  DebouncerOptions,\n  QueuerOptions,\n  RateLimiterOptions,\n  ThrottlerOptions,\n} from '@tanstack/pacer'\n\nexport interface PacerProviderOptions {\n  asyncBatcher?: Partial<AsyncBatcherOptions<any>>\n  asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>\n  asyncQueuer?: Partial<AsyncQueuerOptions<any>>\n  asyncRateLimiter?: Partial<AsyncRateLimiterOptions<AnyAsyncFunction>>\n  asyncThrottler?: Partial<AsyncThrottlerOptions<AnyAsyncFunction>>\n  batcher?: Partial<BatcherOptions<any>>\n  debouncer?: Partial<DebouncerOptions<AnyFunction>>\n  queuer?: Partial<QueuerOptions<any>>\n  rateLimiter?: Partial<RateLimiterOptions<AnyFunction>>\n  throttler?: Partial<ThrottlerOptions<AnyFunction>>\n}\n\ninterface PacerContextValue {\n  defaultOptions: PacerProviderOptions\n}\n\nconst PacerContext = createContext<PacerContextValue | null>(null)\n\nexport interface PacerProviderProps {\n  children: ComponentChildren\n  defaultOptions?: PacerProviderOptions\n}\n\nconst DEFAULT_OPTIONS: PacerProviderOptions = {}\n\nexport function PacerProvider({\n  children,\n  defaultOptions = DEFAULT_OPTIONS,\n}: PacerProviderProps) {\n  const contextValue: PacerContextValue = useMemo(\n    () => ({\n      defaultOptions,\n    }),\n    [defaultOptions],\n  )\n\n  return (\n    <PacerContext.Provider value={contextValue}>\n      {children}\n    </PacerContext.Provider>\n  )\n}\n\nexport function usePacerContext() {\n  return useContext(PacerContext)\n}\n\nexport function useDefaultPacerOptions() {\n  const context = useContext(PacerContext)\n  return context?.defaultOptions ?? {}\n}\n"],"mappings":";;;;;AAmCA,MAAM,yCAAuD,KAAK;AAOlE,MAAMA,kBAAwC,EAAE;AAEhD,SAAgB,cAAc,EAC5B,UACA,iBAAiB,mBACI;CACrB,MAAMC,gDACG,EACL,gBACD,GACD,CAAC,eAAe,CACjB;AAED,QACE,4CAAC,aAAa;EAAS,OAAO;EAC3B;GACqB;;AAI5B,SAAgB,kBAAkB;AAChC,qCAAkB,aAAa;;AAGjC,SAAgB,yBAAyB;AAEvC,qCAD2B,aAAa,EACxB,kBAAkB,EAAE"}

package/dist/provider/PacerProvider.d.cts

@@ -0,0 +1,33 @@
+import * as preact0 from "preact";
+import { ComponentChildren } from "preact";
+import { AnyAsyncFunction, AnyFunction, AsyncBatcherOptions, AsyncDebouncerOptions, AsyncQueuerOptions, AsyncRateLimiterOptions, AsyncThrottlerOptions, BatcherOptions, DebouncerOptions, QueuerOptions, RateLimiterOptions, ThrottlerOptions } from "@tanstack/pacer";
+
+//#region src/provider/PacerProvider.d.ts
+interface PacerProviderOptions {
+  asyncBatcher?: Partial<AsyncBatcherOptions<any>>;
+  asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>;
+  asyncQueuer?: Partial<AsyncQueuerOptions<any>>;
+  asyncRateLimiter?: Partial<AsyncRateLimiterOptions<AnyAsyncFunction>>;
+  asyncThrottler?: Partial<AsyncThrottlerOptions<AnyAsyncFunction>>;
+  batcher?: Partial<BatcherOptions<any>>;
+  debouncer?: Partial<DebouncerOptions<AnyFunction>>;
+  queuer?: Partial<QueuerOptions<any>>;
+  rateLimiter?: Partial<RateLimiterOptions<AnyFunction>>;
+  throttler?: Partial<ThrottlerOptions<AnyFunction>>;
+}
+interface PacerContextValue {
+  defaultOptions: PacerProviderOptions;
+}
+interface PacerProviderProps {
+  children: ComponentChildren;
+  defaultOptions?: PacerProviderOptions;
+}
+declare function PacerProvider({
+  children,
+  defaultOptions
+}: PacerProviderProps): preact0.JSX.Element;
+declare function usePacerContext(): PacerContextValue | null;
+declare function useDefaultPacerOptions(): PacerProviderOptions;
+//#endregion
+export { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext };
+//# sourceMappingURL=PacerProvider.d.cts.map

package/dist/provider/PacerProvider.d.ts

@@ -0,0 +1,33 @@
+import { AnyAsyncFunction, AnyFunction, AsyncBatcherOptions, AsyncDebouncerOptions, AsyncQueuerOptions, AsyncRateLimiterOptions, AsyncThrottlerOptions, BatcherOptions, DebouncerOptions, QueuerOptions, RateLimiterOptions, ThrottlerOptions } from "@tanstack/pacer";
+import * as preact0 from "preact";
+import { ComponentChildren } from "preact";
+
+//#region src/provider/PacerProvider.d.ts
+interface PacerProviderOptions {
+  asyncBatcher?: Partial<AsyncBatcherOptions<any>>;
+  asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>;
+  asyncQueuer?: Partial<AsyncQueuerOptions<any>>;
+  asyncRateLimiter?: Partial<AsyncRateLimiterOptions<AnyAsyncFunction>>;
+  asyncThrottler?: Partial<AsyncThrottlerOptions<AnyAsyncFunction>>;
+  batcher?: Partial<BatcherOptions<any>>;
+  debouncer?: Partial<DebouncerOptions<AnyFunction>>;
+  queuer?: Partial<QueuerOptions<any>>;
+  rateLimiter?: Partial<RateLimiterOptions<AnyFunction>>;
+  throttler?: Partial<ThrottlerOptions<AnyFunction>>;
+}
+interface PacerContextValue {
+  defaultOptions: PacerProviderOptions;
+}
+interface PacerProviderProps {
+  children: ComponentChildren;
+  defaultOptions?: PacerProviderOptions;
+}
+declare function PacerProvider({
+  children,
+  defaultOptions
+}: PacerProviderProps): preact0.JSX.Element;
+declare function usePacerContext(): PacerContextValue | null;
+declare function useDefaultPacerOptions(): PacerProviderOptions;
+//#endregion
+export { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext };
+//# sourceMappingURL=PacerProvider.d.ts.map

package/dist/provider/PacerProvider.js

@@ -0,0 +1,24 @@
+import { useContext, useMemo } from "preact/hooks";
+import { createContext } from "preact";
+import { jsx } from "preact/jsx-runtime";
+
+//#region src/provider/PacerProvider.tsx
+const PacerContext = createContext(null);
+const DEFAULT_OPTIONS = {};
+function PacerProvider({ children, defaultOptions = DEFAULT_OPTIONS }) {
+	const contextValue = useMemo(() => ({ defaultOptions }), [defaultOptions]);
+	return /* @__PURE__ */ jsx(PacerContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+function usePacerContext() {
+	return useContext(PacerContext);
+}
+function useDefaultPacerOptions() {
+	return useContext(PacerContext)?.defaultOptions ?? {};
+}
+
+//#endregion
+export { PacerProvider, useDefaultPacerOptions, usePacerContext };
+//# sourceMappingURL=PacerProvider.js.map

package/dist/provider/PacerProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PacerProvider.js","names":["DEFAULT_OPTIONS: PacerProviderOptions","contextValue: PacerContextValue"],"sources":["../../src/provider/PacerProvider.tsx"],"sourcesContent":["import { useContext, useMemo } from 'preact/hooks'\nimport { createContext } from 'preact'\nimport type { ComponentChildren } from 'preact'\nimport type {\n  AnyAsyncFunction,\n  AnyFunction,\n  AsyncBatcherOptions,\n  AsyncDebouncerOptions,\n  AsyncQueuerOptions,\n  AsyncRateLimiterOptions,\n  AsyncThrottlerOptions,\n  BatcherOptions,\n  DebouncerOptions,\n  QueuerOptions,\n  RateLimiterOptions,\n  ThrottlerOptions,\n} from '@tanstack/pacer'\n\nexport interface PacerProviderOptions {\n  asyncBatcher?: Partial<AsyncBatcherOptions<any>>\n  asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>\n  asyncQueuer?: Partial<AsyncQueuerOptions<any>>\n  asyncRateLimiter?: Partial<AsyncRateLimiterOptions<AnyAsyncFunction>>\n  asyncThrottler?: Partial<AsyncThrottlerOptions<AnyAsyncFunction>>\n  batcher?: Partial<BatcherOptions<any>>\n  debouncer?: Partial<DebouncerOptions<AnyFunction>>\n  queuer?: Partial<QueuerOptions<any>>\n  rateLimiter?: Partial<RateLimiterOptions<AnyFunction>>\n  throttler?: Partial<ThrottlerOptions<AnyFunction>>\n}\n\ninterface PacerContextValue {\n  defaultOptions: PacerProviderOptions\n}\n\nconst PacerContext = createContext<PacerContextValue | null>(null)\n\nexport interface PacerProviderProps {\n  children: ComponentChildren\n  defaultOptions?: PacerProviderOptions\n}\n\nconst DEFAULT_OPTIONS: PacerProviderOptions = {}\n\nexport function PacerProvider({\n  children,\n  defaultOptions = DEFAULT_OPTIONS,\n}: PacerProviderProps) {\n  const contextValue: PacerContextValue = useMemo(\n    () => ({\n      defaultOptions,\n    }),\n    [defaultOptions],\n  )\n\n  return (\n    <PacerContext.Provider value={contextValue}>\n      {children}\n    </PacerContext.Provider>\n  )\n}\n\nexport function usePacerContext() {\n  return useContext(PacerContext)\n}\n\nexport function useDefaultPacerOptions() {\n  const context = useContext(PacerContext)\n  return context?.defaultOptions ?? {}\n}\n"],"mappings":";;;;;AAmCA,MAAM,eAAe,cAAwC,KAAK;AAOlE,MAAMA,kBAAwC,EAAE;AAEhD,SAAgB,cAAc,EAC5B,UACA,iBAAiB,mBACI;CACrB,MAAMC,eAAkC,eAC/B,EACL,gBACD,GACD,CAAC,eAAe,CACjB;AAED,QACE,oBAAC,aAAa;EAAS,OAAO;EAC3B;GACqB;;AAI5B,SAAgB,kBAAkB;AAChC,QAAO,WAAW,aAAa;;AAGjC,SAAgB,yBAAyB;AAEvC,QADgB,WAAW,aAAa,EACxB,kBAAkB,EAAE"}

package/dist/provider/index.cjs

@@ -0,0 +1,5 @@
+const require_PacerProvider = require('./PacerProvider.cjs');
+
+exports.PacerProvider = require_PacerProvider.PacerProvider;
+exports.useDefaultPacerOptions = require_PacerProvider.useDefaultPacerOptions;
+exports.usePacerContext = require_PacerProvider.usePacerContext;

package/dist/provider/index.d.cts

@@ -0,0 +1,2 @@
+import { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext } from "./PacerProvider.cjs";
+export { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext };

package/dist/provider/index.d.ts

@@ -0,0 +1,2 @@
+import { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext } from "./PacerProvider.js";
+export { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext };

package/dist/provider/index.js

@@ -0,0 +1,3 @@
+import { PacerProvider, useDefaultPacerOptions, usePacerContext } from "./PacerProvider.js";
+
+export { PacerProvider, useDefaultPacerOptions, usePacerContext };

package/dist/queuer/index.cjs

@@ -0,0 +1,14 @@
+const require_useQueuer = require('./useQueuer.cjs');
+const require_useQueuedState = require('./useQueuedState.cjs');
+const require_useQueuedValue = require('./useQueuedValue.cjs');
+
+exports.useQueuedState = require_useQueuedState.useQueuedState;
+exports.useQueuedValue = require_useQueuedValue.useQueuedValue;
+exports.useQueuer = require_useQueuer.useQueuer;
+var _tanstack_pacer_queuer = require("@tanstack/pacer/queuer");
+Object.keys(_tanstack_pacer_queuer).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _tanstack_pacer_queuer[k]; }
+  });
+});

package/dist/queuer/index.d.cts

@@ -0,0 +1,5 @@
+import { PreactQueuer, useQueuer } from "./useQueuer.cjs";
+import { useQueuedState } from "./useQueuedState.cjs";
+import { useQueuedValue } from "./useQueuedValue.cjs";
+export * from "@tanstack/pacer/queuer";
+export { PreactQueuer, useQueuedState, useQueuedValue, useQueuer };

package/dist/queuer/index.d.ts

@@ -0,0 +1,5 @@
+import { PreactQueuer, useQueuer } from "./useQueuer.js";
+import { useQueuedState } from "./useQueuedState.js";
+import { useQueuedValue } from "./useQueuedValue.js";
+export * from "@tanstack/pacer/queuer";
+export { PreactQueuer, useQueuedState, useQueuedValue, useQueuer };

package/dist/queuer/index.js

@@ -0,0 +1,7 @@
+import { useQueuer } from "./useQueuer.js";
+import { useQueuedState } from "./useQueuedState.js";
+import { useQueuedValue } from "./useQueuedValue.js";
+
+export * from "@tanstack/pacer/queuer"
+
+export { useQueuedState, useQueuedValue, useQueuer };

package/dist/queuer/useQueuedState.cjs

@@ -0,0 +1,129 @@
+const require_useQueuer = require('./useQueuer.cjs');
+
+//#region src/queuer/useQueuedState.ts
+/**
+* A Preact hook that creates a queuer with managed state, combining Preact's useState with queuing functionality.
+* This hook provides both the current queue state and queue control methods.
+*
+* The queue state is automatically updated whenever items are added, removed, or reordered in the queue.
+* All queue operations are reflected in the state array returned by the hook.
+*
+* The queue can be started and stopped to automatically process items at a specified interval,
+* making it useful as a scheduler. When started, it will process one item per tick, with an
+* optional wait time between ticks.
+*
+* The hook returns a tuple containing:
+* - The current queue state as an array
+* - The queue instance with methods for queue manipulation
+*
+* ## State Management and Selector
+*
+* The hook uses TanStack Store for reactive state management via the underlying queuer instance.
+* The `selector` parameter allows you to specify which queuer state changes will trigger a re-render,
+* optimizing performance by preventing unnecessary re-renders 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 re-renders and gives you
+* full control over when your component updates. Only when you provide a selector will the
+* component re-render when the selected state values change.
+*
+* Available queuer state properties:
+* - `executionCount`: Number of items that have been processed by the queuer
+* - `expirationCount`: Number of items that have been removed due to expiration
+* - `isEmpty`: Whether the queuer has no items to process
+* - `isFull`: Whether the queuer has reached its maximum capacity
+* - `isIdle`: Whether the queuer is not currently processing any items
+* - `isRunning`: Whether the queuer is active and will process items automatically
+* - `items`: Array of items currently waiting to be processed
+* - `itemTimestamps`: Timestamps when items were added for expiration tracking
+* - `pendingTick`: Whether the queuer has a pending timeout for processing the next item
+* - `rejectionCount`: Number of items that have been rejected from being added
+* - `size`: Number of items currently in the queue
+* - `status`: Current processing status ('idle' | 'running' | 'stopped')
+*
+* @example
+* ```tsx
+* // Default behavior - no reactive state subscriptions
+* const [items, addItem, queue] = useQueuedState(
+*   (item) => console.log('Processing:', item),
+*   {
+*     initialItems: ['item1', 'item2'],
+*     started: true,
+*     wait: 1000,
+*     getPriority: (item) => item.priority
+*   }
+* );
+*
+* // Opt-in to re-render when queue contents change (optimized for displaying queue items)
+* const [items, addItem, queue] = useQueuedState(
+*   (item) => console.log('Processing:', item),
+*   { started: true, wait: 1000 },
+*   (state) => ({
+*     items: state.items,
+*     size: state.size,
+*     isEmpty: state.isEmpty
+*   })
+* );
+*
+* // Opt-in to re-render when processing state changes (optimized for loading indicators)
+* const [items, addItem, queue] = useQueuedState(
+*   (item) => console.log('Processing:', item),
+*   { started: true, wait: 1000 },
+*   (state) => ({
+*     isRunning: state.isRunning,
+*     isIdle: state.isIdle,
+*     status: state.status,
+*     pendingTick: state.pendingTick
+*   })
+* );
+*
+* // Opt-in to re-render when execution metrics change (optimized for stats display)
+* const [items, addItem, queue] = useQueuedState(
+*   (item) => console.log('Processing:', item),
+*   { started: true, wait: 1000 },
+*   (state) => ({
+*     executionCount: state.executionCount,
+*     expirationCount: state.expirationCount,
+*     rejectionCount: state.rejectionCount
+*   })
+* );
+*
+* // Add items to queue
+* const handleAdd = (item) => {
+*   addItem(item);
+* };
+*
+* // Start automatic processing
+* const startProcessing = () => {
+*   queue.start();
+* };
+*
+* // Stop automatic processing
+* const stopProcessing = () => {
+*   queue.stop();
+* };
+*
+* // Manual processing still available
+* const handleProcess = () => {
+*   const nextItem = queue.getNextItem();
+*   if (nextItem) {
+*     processItem(nextItem);
+*   }
+* };
+*
+* // Access the selected queuer state (will be empty object {} unless selector provided)
+* const { size, isRunning, executionCount } = queue.state;
+* ```
+*/
+function useQueuedState(fn, options = {}, selector) {
+	const queue = require_useQueuer.useQueuer(fn, options, selector);
+	return [
+		queue.state.items,
+		queue.addItem,
+		queue
+	];
+}
+
+//#endregion
+exports.useQueuedState = useQueuedState;
+//# sourceMappingURL=useQueuedState.cjs.map