@tanstack/solid-pacer 0.15.3 → 0.16.1

package/dist/debouncer/createDebouncer.cjs

@@ -0,0 +1,101 @@
+const require_PacerProvider = require('../provider/PacerProvider.cjs');
+let solid_js = require("solid-js");
+let __tanstack_solid_store = require("@tanstack/solid-store");
+let __tanstack_pacer_debouncer = require("@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 __tanstack_pacer_debouncer.Debouncer(fn, {
+		...require_PacerProvider.useDefaultPacerOptions().debouncer,
+		...options
+	});
+	const state = (0, __tanstack_solid_store.useStore)(asyncDebouncer.store, selector);
+	(0, solid_js.createEffect)(() => {
+		(0, solid_js.onCleanup)(() => {
+			asyncDebouncer.cancel();
+		});
+	});
+	return {
+		...asyncDebouncer,
+		state
+	};
+}
+
+//#endregion
+exports.createDebouncer = createDebouncer;
+//# sourceMappingURL=createDebouncer.cjs.map

package/dist/debouncer/createDebouncer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDebouncer.cjs","names":["Debouncer","useDefaultPacerOptions"],"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,IAAIA,qCAAe,IALpB;EACpB,GAAGC,8CAAwB,CAAC;EAC5B,GAAG;EACJ,CAE2D;CAE5D,MAAM,6CAAiB,eAAe,OAAO,SAAS;AAEtD,kCAAmB;AACjB,gCAAgB;AACd,kBAAe,QAAQ;IACvB;GACF;AAEF,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/{cjs/debouncer → debouncer}/createDebouncer.d.cts

@@ -1,20 +1,22 @@
-import { Debouncer, DebouncerOptions, DebouncerState } from '@tanstack/pacer/debouncer';
-import { Store } from '@tanstack/solid-store';
-import { Accessor } from 'solid-js';
-import { AnyFunction } from '@tanstack/pacer/types';
-export interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
-    /**
-     * Reactive state that will be updated when the debouncer state changes
-     *
-     * Use this instead of `debouncer.store.state`
-     */
-    readonly state: Accessor<Readonly<TSelected>>;
-    /**
-     * @deprecated Use `debouncer.state` instead of `debouncer.store.state` if you want to read reactive state.
-     * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-     * Although, you can make the state reactive by using the `useStore` in your own usage.
-     */
-    readonly store: Store<Readonly<DebouncerState<TFn>>>;
+import { Store } from "@tanstack/solid-store";
+import { Accessor } from "solid-js";
+import { AnyFunction } from "@tanstack/pacer/types";
+import { Debouncer, DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
+
+//#region src/debouncer/createDebouncer.d.ts
+interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
+  /**
+   * Reactive state that will be updated when the debouncer state changes
+   *
+   * Use this instead of `debouncer.store.state`
+   */
+  readonly state: Accessor<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `debouncer.state` instead of `debouncer.store.state` if you want to read reactive state.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
+   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   */
+  readonly store: Store<Readonly<DebouncerState<TFn>>>;
 }
 /**
  * A Solid hook that creates and manages a Debouncer instance.
@@ -91,4 +93,7 @@ export interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends
  * const { isPending } = debouncer.state();
  * ```
  */
-export declare function createDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, initialOptions: DebouncerOptions<TFn>, selector?: (state: DebouncerState<TFn>) => TSelected): SolidDebouncer<TFn, TSelected>;
+declare function createDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: DebouncerOptions<TFn>, selector?: (state: DebouncerState<TFn>) => TSelected): SolidDebouncer<TFn, TSelected>;
+//#endregion
+export { SolidDebouncer, createDebouncer };
+//# sourceMappingURL=createDebouncer.d.cts.map

package/dist/{esm/debouncer → debouncer}/createDebouncer.d.ts

@@ -1,20 +1,22 @@
-import { Debouncer, DebouncerOptions, DebouncerState } from '@tanstack/pacer/debouncer';
-import { Store } from '@tanstack/solid-store';
-import { Accessor } from 'solid-js';
-import { AnyFunction } from '@tanstack/pacer/types';
-export interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
-    /**
-     * Reactive state that will be updated when the debouncer state changes
-     *
-     * Use this instead of `debouncer.store.state`
-     */
-    readonly state: Accessor<Readonly<TSelected>>;
-    /**
-     * @deprecated Use `debouncer.state` instead of `debouncer.store.state` if you want to read reactive state.
-     * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-     * Although, you can make the state reactive by using the `useStore` in your own usage.
-     */
-    readonly store: Store<Readonly<DebouncerState<TFn>>>;
+import { Accessor } from "solid-js";
+import { Store } from "@tanstack/solid-store";
+import { Debouncer, DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
+import { AnyFunction } from "@tanstack/pacer/types";
+
+//#region src/debouncer/createDebouncer.d.ts
+interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
+  /**
+   * Reactive state that will be updated when the debouncer state changes
+   *
+   * Use this instead of `debouncer.store.state`
+   */
+  readonly state: Accessor<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `debouncer.state` instead of `debouncer.store.state` if you want to read reactive state.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
+   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   */
+  readonly store: Store<Readonly<DebouncerState<TFn>>>;
 }
 /**
  * A Solid hook that creates and manages a Debouncer instance.
@@ -91,4 +93,7 @@ export interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends
  * const { isPending } = debouncer.state();
  * ```
  */
-export declare function createDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, initialOptions: DebouncerOptions<TFn>, selector?: (state: DebouncerState<TFn>) => TSelected): SolidDebouncer<TFn, TSelected>;
+declare function createDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: DebouncerOptions<TFn>, selector?: (state: DebouncerState<TFn>) => TSelected): SolidDebouncer<TFn, TSelected>;
+//#endregion
+export { SolidDebouncer, createDebouncer };
+//# sourceMappingURL=createDebouncer.d.ts.map

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,36 +1,22 @@
-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";
 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 {
-  createAsyncBatcher,
-  createAsyncDebouncer,
-  createAsyncQueuer,
-  createAsyncRateLimiter,
-  createAsyncThrottler,
-  createBatcher,
-  createDebouncedSignal,
-  createDebouncedValue,
-  createDebouncer,
-  createQueuer,
-  createRateLimitedSignal,
-  createRateLimitedValue,
-  createRateLimiter,
-  createThrottledSignal,
-  createThrottledValue,
-  createThrottler
-};
-//# 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