@tanstack/solid-pacer 0.16.0 → 0.17.0

package/dist/debouncer/createDebouncer.js

@@ -0,0 +1,101 @@
+import { useDefaultPacerOptions } from "../provider/PacerProvider.js";
+import { createEffect, onCleanup } from "solid-js";
+import { useStore } from "@tanstack/solid-store";
+import { Debouncer } from "@tanstack/pacer/debouncer";
+
+//#region src/debouncer/createDebouncer.ts
+/**
+* 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.
+*
+* ## State Management and Selector
+*
+* The hook uses TanStack Store for reactive state management. The `selector` parameter allows you
+* to specify which 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 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 debouncer = createDebouncer(
+*   (query: string) => fetchSearchResults(query),
+*   { wait: 500 }
+* );
+*
+* // Opt-in to re-render when isPending changes (optimized for loading states)
+* const debouncer = createDebouncer(
+*   (query: string) => fetchSearchResults(query),
+*   { wait: 500 },
+*   (state) => ({ isPending: state.isPending })
+* );
+*
+* // Opt-in to re-render when executionCount changes (optimized for tracking execution)
+* const debouncer = createDebouncer(
+*   (query: string) => fetchSearchResults(query),
+*   { wait: 500 },
+*   (state) => ({ executionCount: state.executionCount })
+* );
+*
+* // Multiple state properties - re-render when any of these change
+* const debouncer = createDebouncer(
+*   (query: string) => fetchSearchResults(query),
+*   { wait: 500 },
+*   (state) => ({
+*     isPending: state.isPending,
+*     executionCount: state.executionCount,
+*     status: state.status
+*   })
+* );
+*
+* // In an event handler
+* const handleChange = (e) => {
+*   debouncer.maybeExecute(e.target.value);
+* };
+*
+* // Access the selected state (will be empty object {} unless selector provided)
+* const { isPending } = debouncer.state();
+* ```
+*/
+function createDebouncer(fn, options, selector = () => ({})) {
+	const asyncDebouncer = new Debouncer(fn, {
+		...useDefaultPacerOptions().debouncer,
+		...options
+	});
+	const state = useStore(asyncDebouncer.store, selector);
+	createEffect(() => {
+		onCleanup(() => {
+			asyncDebouncer.cancel();
+		});
+	});
+	return {
+		...asyncDebouncer,
+		state
+	};
+}
+
+//#endregion
+export { createDebouncer };
+//# sourceMappingURL=createDebouncer.js.map

package/dist/debouncer/createDebouncer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDebouncer.js","names":[],"sources":["../../src/debouncer/createDebouncer.ts"],"sourcesContent":["import { Debouncer } from '@tanstack/pacer/debouncer'\nimport { createEffect, onCleanup } from 'solid-js'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\nexport interface SolidDebouncer<\n  TFn extends AnyFunction,\n  TSelected = {},\n> extends Omit<Debouncer<TFn>, 'store'> {\n  /**\n   * Reactive state that will be updated when the debouncer state changes\n   *\n   * Use this instead of `debouncer.store.state`\n   */\n  readonly state: Accessor<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 Solid 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 (createSignal, 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. The `selector` parameter allows you\n * to specify which state changes will trigger a re-render, optimizing performance by preventing\n * unnecessary re-renders when irrelevant 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. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\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 debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 }\n * );\n *\n * // Opt-in to re-render when isPending changes (optimized for loading states)\n * const debouncer = createDebouncer(\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 debouncer = createDebouncer(\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 debouncer = createDebouncer(\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 *   debouncer.maybeExecute(e.target.value);\n * };\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { isPending } = debouncer.state();\n * ```\n */\nexport function createDebouncer<TFn extends AnyFunction, TSelected = {}>(\n  fn: TFn,\n  options: DebouncerOptions<TFn>,\n  selector: (state: DebouncerState<TFn>) => TSelected = () => ({}) as TSelected,\n): SolidDebouncer<TFn, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().debouncer,\n    ...options,\n  } as DebouncerOptions<TFn>\n\n  const asyncDebouncer = new Debouncer<TFn>(fn, mergedOptions)\n\n  const state = useStore(asyncDebouncer.store, selector)\n\n  createEffect(() => {\n    onCleanup(() => {\n      asyncDebouncer.cancel()\n    })\n  })\n\n  return {\n    ...asyncDebouncer,\n    state,\n  } as SolidDebouncer<TFn, TSelected> // omit `store` in favor of `state`\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyGA,SAAgB,gBACd,IACA,SACA,kBAA6D,EAAE,GAC/B;CAMhC,MAAM,iBAAiB,IAAI,UAAe,IALpB;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ,CAE2D;CAE5D,MAAM,QAAQ,SAAS,eAAe,OAAO,SAAS;AAEtD,oBAAmB;AACjB,kBAAgB;AACd,kBAAe,QAAQ;IACvB;GACF;AAEF,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/debouncer/index.cjs

@@ -0,0 +1,14 @@
+const require_createDebouncer = require('./createDebouncer.cjs');
+const require_createDebouncedSignal = require('./createDebouncedSignal.cjs');
+const require_createDebouncedValue = require('./createDebouncedValue.cjs');
+
+exports.createDebouncedSignal = require_createDebouncedSignal.createDebouncedSignal;
+exports.createDebouncedValue = require_createDebouncedValue.createDebouncedValue;
+exports.createDebouncer = require_createDebouncer.createDebouncer;
+var __tanstack_pacer_debouncer = require("@tanstack/pacer/debouncer");
+Object.keys(__tanstack_pacer_debouncer).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return __tanstack_pacer_debouncer[k]; }
+  });
+});

package/dist/debouncer/index.d.cts

@@ -0,0 +1,5 @@
+import { SolidDebouncer, createDebouncer } from "./createDebouncer.cjs";
+import { createDebouncedSignal } from "./createDebouncedSignal.cjs";
+import { createDebouncedValue } from "./createDebouncedValue.cjs";
+export * from "@tanstack/pacer/debouncer";
+export { SolidDebouncer, createDebouncedSignal, createDebouncedValue, createDebouncer };

package/dist/debouncer/index.d.ts

@@ -0,0 +1,5 @@
+import { SolidDebouncer, createDebouncer } from "./createDebouncer.js";
+import { createDebouncedSignal } from "./createDebouncedSignal.js";
+import { createDebouncedValue } from "./createDebouncedValue.js";
+export * from "@tanstack/pacer/debouncer";
+export { SolidDebouncer, createDebouncedSignal, createDebouncedValue, createDebouncer };

package/dist/{esm/debouncer → debouncer}/index.js

@@ -1,10 +1,7 @@
-export * from "@tanstack/pacer/debouncer";
+import { createDebouncer } from "./createDebouncer.js";
 import { createDebouncedSignal } from "./createDebouncedSignal.js";
 import { createDebouncedValue } from "./createDebouncedValue.js";
-import { createDebouncer } from "./createDebouncer.js";
-export {
-  createDebouncedSignal,
-  createDebouncedValue,
-  createDebouncer
-};
-//# sourceMappingURL=index.js.map
+
+export * from "@tanstack/pacer/debouncer"
+
+export { createDebouncedSignal, createDebouncedValue, createDebouncer };

package/dist/index.cjs

@@ -0,0 +1,46 @@
+const require_PacerProvider = require('./provider/PacerProvider.cjs');
+const require_createAsyncBatcher = require('./async-batcher/createAsyncBatcher.cjs');
+const require_createAsyncDebouncer = require('./async-debouncer/createAsyncDebouncer.cjs');
+const require_createAsyncQueuer = require('./async-queuer/createAsyncQueuer.cjs');
+const require_createAsyncRateLimiter = require('./async-rate-limiter/createAsyncRateLimiter.cjs');
+const require_createAsyncThrottler = require('./async-throttler/createAsyncThrottler.cjs');
+const require_createBatcher = require('./batcher/createBatcher.cjs');
+const require_createDebouncer = require('./debouncer/createDebouncer.cjs');
+const require_createDebouncedSignal = require('./debouncer/createDebouncedSignal.cjs');
+const require_createDebouncedValue = require('./debouncer/createDebouncedValue.cjs');
+const require_createQueuer = require('./queuer/createQueuer.cjs');
+const require_createQueuedSignal = require('./queuer/createQueuedSignal.cjs');
+const require_createRateLimiter = require('./rate-limiter/createRateLimiter.cjs');
+const require_createRateLimitedSignal = require('./rate-limiter/createRateLimitedSignal.cjs');
+const require_createRateLimitedValue = require('./rate-limiter/createRateLimitedValue.cjs');
+const require_createThrottler = require('./throttler/createThrottler.cjs');
+const require_createThrottledSignal = require('./throttler/createThrottledSignal.cjs');
+const require_createThrottledValue = require('./throttler/createThrottledValue.cjs');
+
+exports.PacerProvider = require_PacerProvider.PacerProvider;
+exports.createAsyncBatcher = require_createAsyncBatcher.createAsyncBatcher;
+exports.createAsyncDebouncer = require_createAsyncDebouncer.createAsyncDebouncer;
+exports.createAsyncQueuer = require_createAsyncQueuer.createAsyncQueuer;
+exports.createAsyncRateLimiter = require_createAsyncRateLimiter.createAsyncRateLimiter;
+exports.createAsyncThrottler = require_createAsyncThrottler.createAsyncThrottler;
+exports.createBatcher = require_createBatcher.createBatcher;
+exports.createDebouncedSignal = require_createDebouncedSignal.createDebouncedSignal;
+exports.createDebouncedValue = require_createDebouncedValue.createDebouncedValue;
+exports.createDebouncer = require_createDebouncer.createDebouncer;
+exports.createQueuedSignal = require_createQueuedSignal.createQueuedSignal;
+exports.createQueuer = require_createQueuer.createQueuer;
+exports.createRateLimitedSignal = require_createRateLimitedSignal.createRateLimitedSignal;
+exports.createRateLimitedValue = require_createRateLimitedValue.createRateLimitedValue;
+exports.createRateLimiter = require_createRateLimiter.createRateLimiter;
+exports.createThrottledSignal = require_createThrottledSignal.createThrottledSignal;
+exports.createThrottledValue = require_createThrottledValue.createThrottledValue;
+exports.createThrottler = require_createThrottler.createThrottler;
+exports.useDefaultPacerOptions = require_PacerProvider.useDefaultPacerOptions;
+exports.usePacerContext = require_PacerProvider.usePacerContext;
+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,20 @@
+import { SolidAsyncBatcher, createAsyncBatcher } from "./async-batcher/createAsyncBatcher.cjs";
+import { SolidAsyncDebouncer, createAsyncDebouncer } from "./async-debouncer/createAsyncDebouncer.cjs";
+import { SolidAsyncQueuer, createAsyncQueuer } from "./async-queuer/createAsyncQueuer.cjs";
+import { SolidAsyncRateLimiter, createAsyncRateLimiter } from "./async-rate-limiter/createAsyncRateLimiter.cjs";
+import { SolidAsyncThrottler, createAsyncThrottler } from "./async-throttler/createAsyncThrottler.cjs";
+import { SolidBatcher, createBatcher } from "./batcher/createBatcher.cjs";
+import { SolidDebouncer, createDebouncer } from "./debouncer/createDebouncer.cjs";
+import { createDebouncedSignal } from "./debouncer/createDebouncedSignal.cjs";
+import { createDebouncedValue } from "./debouncer/createDebouncedValue.cjs";
+import { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext } from "./provider/PacerProvider.cjs";
+import { SolidQueuer, createQueuer } from "./queuer/createQueuer.cjs";
+import { createQueuedSignal } from "./queuer/createQueuedSignal.cjs";
+import { SolidRateLimiter, createRateLimiter } from "./rate-limiter/createRateLimiter.cjs";
+import { createRateLimitedSignal } from "./rate-limiter/createRateLimitedSignal.cjs";
+import { createRateLimitedValue } from "./rate-limiter/createRateLimitedValue.cjs";
+import { SolidThrottler, createThrottler } from "./throttler/createThrottler.cjs";
+import { createThrottledSignal } from "./throttler/createThrottledSignal.cjs";
+import { createThrottledValue } from "./throttler/createThrottledValue.cjs";
+export * from "@tanstack/pacer";
+export { PacerProvider, PacerProviderOptions, PacerProviderProps, SolidAsyncBatcher, SolidAsyncDebouncer, SolidAsyncQueuer, SolidAsyncRateLimiter, SolidAsyncThrottler, SolidBatcher, SolidDebouncer, SolidQueuer, SolidRateLimiter, SolidThrottler, createAsyncBatcher, createAsyncDebouncer, createAsyncQueuer, createAsyncRateLimiter, createAsyncThrottler, createBatcher, createDebouncedSignal, createDebouncedValue, createDebouncer, createQueuedSignal, createQueuer, createRateLimitedSignal, createRateLimitedValue, createRateLimiter, createThrottledSignal, createThrottledValue, createThrottler, useDefaultPacerOptions, usePacerContext };

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { SolidAsyncBatcher, createAsyncBatcher } from "./async-batcher/createAsyncBatcher.js";
+import { SolidAsyncDebouncer, createAsyncDebouncer } from "./async-debouncer/createAsyncDebouncer.js";
+import { SolidAsyncQueuer, createAsyncQueuer } from "./async-queuer/createAsyncQueuer.js";
+import { SolidAsyncRateLimiter, createAsyncRateLimiter } from "./async-rate-limiter/createAsyncRateLimiter.js";
+import { SolidAsyncThrottler, createAsyncThrottler } from "./async-throttler/createAsyncThrottler.js";
+import { SolidBatcher, createBatcher } from "./batcher/createBatcher.js";
+import { SolidDebouncer, createDebouncer } from "./debouncer/createDebouncer.js";
+import { createDebouncedSignal } from "./debouncer/createDebouncedSignal.js";
+import { createDebouncedValue } from "./debouncer/createDebouncedValue.js";
+import { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext } from "./provider/PacerProvider.js";
+import { SolidQueuer, createQueuer } from "./queuer/createQueuer.js";
+import { createQueuedSignal } from "./queuer/createQueuedSignal.js";
+import { SolidRateLimiter, createRateLimiter } from "./rate-limiter/createRateLimiter.js";
+import { createRateLimitedSignal } from "./rate-limiter/createRateLimitedSignal.js";
+import { createRateLimitedValue } from "./rate-limiter/createRateLimitedValue.js";
+import { SolidThrottler, createThrottler } from "./throttler/createThrottler.js";
+import { createThrottledSignal } from "./throttler/createThrottledSignal.js";
+import { createThrottledValue } from "./throttler/createThrottledValue.js";
+export * from "@tanstack/pacer";
+export { PacerProvider, PacerProviderOptions, PacerProviderProps, SolidAsyncBatcher, SolidAsyncDebouncer, SolidAsyncQueuer, SolidAsyncRateLimiter, SolidAsyncThrottler, SolidBatcher, SolidDebouncer, SolidQueuer, SolidRateLimiter, SolidThrottler, createAsyncBatcher, createAsyncDebouncer, createAsyncQueuer, createAsyncRateLimiter, createAsyncThrottler, createBatcher, createDebouncedSignal, createDebouncedValue, createDebouncer, createQueuedSignal, createQueuer, createRateLimitedSignal, createRateLimitedValue, createRateLimiter, createThrottledSignal, createThrottledValue, createThrottler, useDefaultPacerOptions, usePacerContext };

package/dist/{esm/index.js → index.js}

@@ -1,4 +1,3 @@
-export * from "@tanstack/pacer";
 import { PacerProvider, useDefaultPacerOptions, usePacerContext } from "./provider/PacerProvider.js";
 import { createAsyncBatcher } from "./async-batcher/createAsyncBatcher.js";
 import { createAsyncDebouncer } from "./async-debouncer/createAsyncDebouncer.js";
@@ -6,37 +5,18 @@ import { createAsyncQueuer } from "./async-queuer/createAsyncQueuer.js";
 import { createAsyncRateLimiter } from "./async-rate-limiter/createAsyncRateLimiter.js";
 import { createAsyncThrottler } from "./async-throttler/createAsyncThrottler.js";
 import { createBatcher } from "./batcher/createBatcher.js";
+import { createDebouncer } from "./debouncer/createDebouncer.js";
 import { createDebouncedSignal } from "./debouncer/createDebouncedSignal.js";
 import { createDebouncedValue } from "./debouncer/createDebouncedValue.js";
-import { createDebouncer } from "./debouncer/createDebouncer.js";
 import { createQueuer } from "./queuer/createQueuer.js";
 import { createQueuedSignal } from "./queuer/createQueuedSignal.js";
 import { createRateLimiter } from "./rate-limiter/createRateLimiter.js";
 import { createRateLimitedSignal } from "./rate-limiter/createRateLimitedSignal.js";
 import { createRateLimitedValue } from "./rate-limiter/createRateLimitedValue.js";
+import { createThrottler } from "./throttler/createThrottler.js";
 import { createThrottledSignal } from "./throttler/createThrottledSignal.js";
 import { createThrottledValue } from "./throttler/createThrottledValue.js";
-import { createThrottler } from "./throttler/createThrottler.js";
-export {
-  PacerProvider,
-  createAsyncBatcher,
-  createAsyncDebouncer,
-  createAsyncQueuer,
-  createAsyncRateLimiter,
-  createAsyncThrottler,
-  createBatcher,
-  createDebouncedSignal,
-  createDebouncedValue,
-  createDebouncer,
-  createQueuedSignal,
-  createQueuer,
-  createRateLimitedSignal,
-  createRateLimitedValue,
-  createRateLimiter,
-  createThrottledSignal,
-  createThrottledValue,
-  createThrottler,
-  useDefaultPacerOptions,
-  usePacerContext
-};
-//# sourceMappingURL=index.js.map
+
+export * from "@tanstack/pacer"
+
+export { PacerProvider, createAsyncBatcher, createAsyncDebouncer, createAsyncQueuer, createAsyncRateLimiter, createAsyncThrottler, createBatcher, createDebouncedSignal, createDebouncedValue, createDebouncer, createQueuedSignal, createQueuer, createRateLimitedSignal, createRateLimitedValue, createRateLimiter, createThrottledSignal, createThrottledValue, createThrottler, useDefaultPacerOptions, usePacerContext };

package/dist/provider/PacerProvider.cjs

@@ -0,0 +1,27 @@
+let solid_js_web = require("solid-js/web");
+let solid_js = require("solid-js");
+
+//#region src/provider/PacerProvider.tsx
+const PacerContext = (0, solid_js.createContext)(null);
+const DEFAULT_OPTIONS = {};
+function PacerProvider(props) {
+	const contextValue = { defaultOptions: props.defaultOptions ?? DEFAULT_OPTIONS };
+	return (0, solid_js_web.createComponent)(PacerContext.Provider, {
+		value: contextValue,
+		get children() {
+			return props.children;
+		}
+	});
+}
+function usePacerContext() {
+	return (0, solid_js.useContext)(PacerContext);
+}
+function useDefaultPacerOptions() {
+	return (0, solid_js.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":["createContext","useContext","JSX","AnyAsyncFunction","AnyFunction","AsyncBatcherOptions","AsyncDebouncerOptions","AsyncQueuerOptions","AsyncRateLimiterOptions","AsyncThrottlerOptions","BatcherOptions","DebouncerOptions","QueuerOptions","RateLimiterOptions","ThrottlerOptions","PacerProviderOptions","asyncBatcher","Partial","asyncDebouncer","asyncQueuer","asyncRateLimiter","asyncThrottler","batcher","debouncer","queuer","rateLimiter","throttler","PacerContextValue","defaultOptions","PacerContext","PacerProviderProps","children","Element","DEFAULT_OPTIONS","PacerProvider","props","contextValue","_$createComponent","Provider","value","usePacerContext","useDefaultPacerOptions","context"],"sources":["../../src/provider/PacerProvider.tsx"],"sourcesContent":["import { createContext, useContext } from 'solid-js'\nimport type { JSX } from 'solid-js'\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: JSX.Element\n  defaultOptions?: PacerProviderOptions\n}\n\nconst DEFAULT_OPTIONS: PacerProviderOptions = {}\n\nexport function PacerProvider(props: PacerProviderProps) {\n  const contextValue: PacerContextValue = {\n    defaultOptions: props.defaultOptions ?? DEFAULT_OPTIONS,\n  }\n\n  return (\n    <PacerContext.Provider value={contextValue}>\n      {props.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":";;;;AAkCA,MAAM6B,2CAAuD,KAAK;AAOlE,MAAMI,kBAAwC,EAAE;AAEhD,SAAgBC,cAAcC,OAA2B;CACvD,MAAMC,eAAkC,EACtCR,gBAAgBO,MAAMP,kBAAkBK,iBACzC;AAED,0CACGJ,aAAaS,UAAQ;EAACC,OAAOH;EAAY,IAAAL,WAAA;AAAA,UACvCI,MAAMJ;;EAAQ,CAAA;;AAKrB,SAAgBS,kBAAkB;AAChC,iCAAkBX,aAAa;;AAGjC,SAAgBY,yBAAyB;AAEvC,iCAD2BZ,aAAa,EACxBD,kBAAkB,EAAE"}

package/dist/provider/PacerProvider.d.cts

@@ -0,0 +1,29 @@
+import { JSX } from "solid-js";
+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: JSX.Element;
+  defaultOptions?: PacerProviderOptions;
+}
+declare function PacerProvider(props: PacerProviderProps): 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,29 @@
+import { AnyAsyncFunction, AnyFunction, AsyncBatcherOptions, AsyncDebouncerOptions, AsyncQueuerOptions, AsyncRateLimiterOptions, AsyncThrottlerOptions, BatcherOptions, DebouncerOptions, QueuerOptions, RateLimiterOptions, ThrottlerOptions } from "@tanstack/pacer";
+import { JSX } from "solid-js";
+
+//#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: JSX.Element;
+  defaultOptions?: PacerProviderOptions;
+}
+declare function PacerProvider(props: PacerProviderProps): 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,25 @@
+import { createComponent } from "solid-js/web";
+import { createContext, useContext } from "solid-js";
+
+//#region src/provider/PacerProvider.tsx
+const PacerContext = createContext(null);
+const DEFAULT_OPTIONS = {};
+function PacerProvider(props) {
+	const contextValue = { defaultOptions: props.defaultOptions ?? DEFAULT_OPTIONS };
+	return createComponent(PacerContext.Provider, {
+		value: contextValue,
+		get children() {
+			return props.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":["createContext","useContext","JSX","AnyAsyncFunction","AnyFunction","AsyncBatcherOptions","AsyncDebouncerOptions","AsyncQueuerOptions","AsyncRateLimiterOptions","AsyncThrottlerOptions","BatcherOptions","DebouncerOptions","QueuerOptions","RateLimiterOptions","ThrottlerOptions","PacerProviderOptions","asyncBatcher","Partial","asyncDebouncer","asyncQueuer","asyncRateLimiter","asyncThrottler","batcher","debouncer","queuer","rateLimiter","throttler","PacerContextValue","defaultOptions","PacerContext","PacerProviderProps","children","Element","DEFAULT_OPTIONS","PacerProvider","props","contextValue","_$createComponent","Provider","value","usePacerContext","useDefaultPacerOptions","context"],"sources":["../../src/provider/PacerProvider.tsx"],"sourcesContent":["import { createContext, useContext } from 'solid-js'\nimport type { JSX } from 'solid-js'\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: JSX.Element\n  defaultOptions?: PacerProviderOptions\n}\n\nconst DEFAULT_OPTIONS: PacerProviderOptions = {}\n\nexport function PacerProvider(props: PacerProviderProps) {\n  const contextValue: PacerContextValue = {\n    defaultOptions: props.defaultOptions ?? DEFAULT_OPTIONS,\n  }\n\n  return (\n    <PacerContext.Provider value={contextValue}>\n      {props.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":";;;;AAkCA,MAAM6B,eAAe7B,cAAwC,KAAK;AAOlE,MAAMiC,kBAAwC,EAAE;AAEhD,SAAgBC,cAAcC,OAA2B;CACvD,MAAMC,eAAkC,EACtCR,gBAAgBO,MAAMP,kBAAkBK,iBACzC;AAED,QAAAI,gBACGR,aAAaS,UAAQ;EAACC,OAAOH;EAAY,IAAAL,WAAA;AAAA,UACvCI,MAAMJ;;EAAQ,CAAA;;AAKrB,SAAgBS,kBAAkB;AAChC,QAAOvC,WAAW4B,aAAa;;AAGjC,SAAgBY,yBAAyB;AAEvC,QADgBxC,WAAW4B,aAAa,EACxBD,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/createQueuedSignal.cjs

@@ -0,0 +1,129 @@
+const require_createQueuer = require('./createQueuer.cjs');
+
+//#region src/queuer/createQueuedSignal.ts
+/**
+* A Solid primitive that creates a queuer with managed state, combining Solid's signals with queuing functionality.
+* This primitive 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 primitive.
+*
+* 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 primitive returns a tuple containing:
+* - The current queue state as an array
+* - The queue instance with methods for queue manipulation
+*
+* ## State Management and Selector
+*
+* The primitive uses Solid's 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] = createQueuedSignal(
+*   (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] = createQueuedSignal(
+*   (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] = createQueuedSignal(
+*   (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] = createQueuedSignal(
+*   (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 createQueuedSignal(fn, options = {}, selector = (state) => ({ items: state.items })) {
+	const queue = require_createQueuer.createQueuer(fn, options, selector);
+	return [
+		() => queue.state().items,
+		queue.addItem,
+		queue
+	];
+}
+
+//#endregion
+exports.createQueuedSignal = createQueuedSignal;
+//# sourceMappingURL=createQueuedSignal.cjs.map

package/dist/queuer/createQueuedSignal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createQueuedSignal.cjs","names":["createQueuer"],"sources":["../../src/queuer/createQueuedSignal.ts"],"sourcesContent":["import { createQueuer } from './createQueuer'\nimport type { SolidQueuer } from './createQueuer'\nimport type { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer'\n\n/**\n * A Solid primitive that creates a queuer with managed state, combining Solid's signals with queuing functionality.\n * This primitive provides both the current queue state and queue control methods.\n *\n * The queue state is automatically updated whenever items are added, removed, or reordered in the queue.\n * All queue operations are reflected in the state array returned by the primitive.\n *\n * The queue can be started and stopped to automatically process items at a specified interval,\n * making it useful as a scheduler. When started, it will process one item per tick, with an\n * optional wait time between ticks.\n *\n * The primitive returns a tuple containing:\n * - The current queue state as an array\n * - The queue instance with methods for queue manipulation\n *\n * ## State Management and Selector\n *\n * The primitive uses Solid's reactive state management via the underlying queuer instance.\n * The `selector` parameter allows you to specify which queuer state changes will trigger a re-render,\n * optimizing performance by preventing unnecessary re-renders when irrelevant 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. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n *\n * Available queuer state properties:\n * - `executionCount`: Number of items that have been processed by the queuer\n * - `expirationCount`: Number of items that have been removed due to expiration\n * - `isEmpty`: Whether the queuer has no items to process\n * - `isFull`: Whether the queuer has reached its maximum capacity\n * - `isIdle`: Whether the queuer is not currently processing any items\n * - `isRunning`: Whether the queuer is active and will process items automatically\n * - `items`: Array of items currently waiting to be processed\n * - `itemTimestamps`: Timestamps when items were added for expiration tracking\n * - `pendingTick`: Whether the queuer has a pending timeout for processing the next item\n * - `rejectionCount`: Number of items that have been rejected from being added\n * - `size`: Number of items currently in the queue\n * - `status`: Current processing status ('idle' | 'running' | 'stopped')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [items, addItem, queue] = createQueuedSignal(\n *   (item) => console.log('Processing:', item),\n *   {\n *     initialItems: ['item1', 'item2'],\n *     started: true,\n *     wait: 1000,\n *     getPriority: (item) => item.priority\n *   }\n * );\n *\n * // Opt-in to re-render when queue contents change (optimized for displaying queue items)\n * const [items, addItem, queue] = createQueuedSignal(\n *   (item) => console.log('Processing:', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({\n *     items: state.items,\n *     size: state.size,\n *     isEmpty: state.isEmpty\n *   })\n * );\n *\n * // Opt-in to re-render when processing state changes (optimized for loading indicators)\n * const [items, addItem, queue] = createQueuedSignal(\n *   (item) => console.log('Processing:', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({\n *     isRunning: state.isRunning,\n *     isIdle: state.isIdle,\n *     status: state.status,\n *     pendingTick: state.pendingTick\n *   })\n * );\n *\n * // Opt-in to re-render when execution metrics change (optimized for stats display)\n * const [items, addItem, queue] = createQueuedSignal(\n *   (item) => console.log('Processing:', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({\n *     executionCount: state.executionCount,\n *     expirationCount: state.expirationCount,\n *     rejectionCount: state.rejectionCount\n *   })\n * );\n *\n * // Add items to queue\n * const handleAdd = (item) => {\n *   addItem(item);\n * };\n *\n * // Start automatic processing\n * const startProcessing = () => {\n *   queue.start();\n * };\n *\n * // Stop automatic processing\n * const stopProcessing = () => {\n *   queue.stop();\n * };\n *\n * // Manual processing still available\n * const handleProcess = () => {\n *   const nextItem = queue.getNextItem();\n *   if (nextItem) {\n *     processItem(nextItem);\n *   }\n * };\n *\n * // Access the selected queuer state (will be empty object {} unless selector provided)\n * const { size, isRunning, executionCount } = queue.state;\n * ```\n */\nexport function createQueuedSignal<\n  TValue,\n  TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<\n    QueuerState<TValue>,\n    'items'\n  >,\n>(\n  fn: (item: TValue) => void,\n  options: QueuerOptions<TValue> = {},\n  selector: (state: QueuerState<TValue>) => TSelected = (state) =>\n    ({ items: state.items }) as TSelected,\n): [\n  () => Array<TValue>,\n  SolidQueuer<TValue, TSelected>['addItem'],\n  SolidQueuer<TValue, TSelected>,\n] {\n  const queue = createQueuer(fn, options, selector)\n\n  return [() => queue.state().items, queue.addItem, queue]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHA,SAAgB,mBAOd,IACA,UAAiC,EAAE,EACnC,YAAuD,WACpD,EAAE,OAAO,MAAM,OAAO,GAKzB;CACA,MAAM,QAAQA,kCAAa,IAAI,SAAS,SAAS;AAEjD,QAAO;QAAO,MAAM,OAAO,CAAC;EAAO,MAAM;EAAS;EAAM"}

package/dist/{cjs/queuer → queuer}/createQueuedSignal.d.cts

@@ -1,5 +1,8 @@
-import { SolidQueuer } from './createQueuer.cjs';
-import { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer';
+import { SolidQueuer } from "./createQueuer.cjs";
+import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
+
+//#region src/queuer/createQueuedSignal.d.ts
+
 /**
  * A Solid primitive that creates a queuer with managed state, combining Solid's signals with queuing functionality.
  * This primitive provides both the current queue state and queue control methods.
@@ -114,8 +117,7 @@ import { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer';
  * const { size, isRunning, executionCount } = queue.state;
  * ```
  */
-export declare function createQueuedSignal<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(fn: (item: TValue) => void, options?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): [
-    () => Array<TValue>,
-    SolidQueuer<TValue, TSelected>['addItem'],
-    SolidQueuer<TValue, TSelected>
-];
+declare function createQueuedSignal<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(fn: (item: TValue) => void, options?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): [() => Array<TValue>, SolidQueuer<TValue, TSelected>['addItem'], SolidQueuer<TValue, TSelected>];
+//#endregion
+export { createQueuedSignal };
+//# sourceMappingURL=createQueuedSignal.d.cts.map