@tanstack/solid-pacer 0.16.0 → 0.16.1

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@tanstack/solid-pacer",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Utilities for debouncing and throttling functions in Solid.",
   "author": "Tanner Linsley",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/TanStack/pacer.git",
+    "url": "git+https://github.com/TanStack/pacer.git",
     "directory": "packages/solid-pacer"
   },
   "homepage": "https://tanstack.com/pacer",
@@ -23,133 +23,65 @@
     "async"
   ],
   "type": "module",
-  "types": "dist/esm/index.d.ts",
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
-      }
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
     },
     "./async-batcher": {
-      "import": {
-        "types": "./dist/esm/async-batcher/index.d.ts",
-        "default": "./dist/esm/async-batcher/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/async-batcher/index.d.cts",
-        "default": "./dist/cjs/async-batcher/index.cjs"
-      }
+      "require": "./dist/async-batcher/index.cjs",
+      "import": "./dist/async-batcher/index.js"
     },
     "./async-debouncer": {
-      "import": {
-        "types": "./dist/esm/async-debouncer/index.d.ts",
-        "default": "./dist/esm/async-debouncer/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/async-debouncer/index.d.cts",
-        "default": "./dist/cjs/async-debouncer/index.cjs"
-      }
+      "require": "./dist/async-debouncer/index.cjs",
+      "import": "./dist/async-debouncer/index.js"
     },
     "./async-queuer": {
-      "import": {
-        "types": "./dist/esm/async-queuer/index.d.ts",
-        "default": "./dist/esm/async-queuer/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/async-queuer/index.d.cts",
-        "default": "./dist/cjs/async-queuer/index.cjs"
-      }
+      "require": "./dist/async-queuer/index.cjs",
+      "import": "./dist/async-queuer/index.js"
     },
     "./async-rate-limiter": {
-      "import": {
-        "types": "./dist/esm/async-rate-limiter/index.d.ts",
-        "default": "./dist/esm/async-rate-limiter/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/async-rate-limiter/index.d.cts",
-        "default": "./dist/cjs/async-rate-limiter/index.cjs"
-      }
+      "require": "./dist/async-rate-limiter/index.cjs",
+      "import": "./dist/async-rate-limiter/index.js"
     },
     "./async-throttler": {
-      "import": {
-        "types": "./dist/esm/async-throttler/index.d.ts",
-        "default": "./dist/esm/async-throttler/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/async-throttler/index.d.cts",
-        "default": "./dist/cjs/async-throttler/index.cjs"
-      }
+      "require": "./dist/async-throttler/index.cjs",
+      "import": "./dist/async-throttler/index.js"
     },
     "./batcher": {
-      "import": {
-        "types": "./dist/esm/batcher/index.d.ts",
-        "default": "./dist/esm/batcher/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/batcher/index.d.cts",
-        "default": "./dist/cjs/batcher/index.cjs"
-      }
+      "require": "./dist/batcher/index.cjs",
+      "import": "./dist/batcher/index.js"
     },
     "./debouncer": {
-      "import": {
-        "types": "./dist/esm/debouncer/index.d.ts",
-        "default": "./dist/esm/debouncer/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/debouncer/index.d.cts",
-        "default": "./dist/cjs/debouncer/index.cjs"
-      }
+      "require": "./dist/debouncer/index.cjs",
+      "import": "./dist/debouncer/index.js"
+    },
+    "./provider": {
+      "require": "./dist/provider/index.cjs",
+      "import": "./dist/provider/index.js"
     },
     "./queuer": {
-      "import": {
-        "types": "./dist/esm/queuer/index.d.ts",
-        "default": "./dist/esm/queuer/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/queuer/index.d.cts",
-        "default": "./dist/cjs/queuer/index.cjs"
-      }
+      "require": "./dist/queuer/index.cjs",
+      "import": "./dist/queuer/index.js"
     },
     "./rate-limiter": {
-      "import": {
-        "types": "./dist/esm/rate-limiter/index.d.ts",
-        "default": "./dist/esm/rate-limiter/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/rate-limiter/index.d.cts",
-        "default": "./dist/cjs/rate-limiter/index.cjs"
-      }
+      "require": "./dist/rate-limiter/index.cjs",
+      "import": "./dist/rate-limiter/index.js"
     },
     "./throttler": {
-      "import": {
-        "types": "./dist/esm/throttler/index.d.ts",
-        "default": "./dist/esm/throttler/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/throttler/index.d.cts",
-        "default": "./dist/cjs/throttler/index.cjs"
-      }
+      "require": "./dist/throttler/index.cjs",
+      "import": "./dist/throttler/index.js"
     },
     "./types": {
-      "types": "./dist/esm/types/index.d.ts",
-      "default": "./dist/esm/types/index.js"
+      "require": "./dist/types/index.cjs",
+      "import": "./dist/types/index.js"
     },
     "./utils": {
-      "import": {
-        "types": "./dist/esm/utils/index.d.ts",
-        "default": "./dist/esm/utils/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/utils/index.d.cts",
-        "default": "./dist/cjs/utils/index.cjs"
-      }
+      "require": "./dist/utils/index.cjs",
+      "import": "./dist/utils/index.js"
     },
     "./package.json": "./package.json"
   },
@@ -163,7 +95,7 @@
   ],
   "dependencies": {
     "@tanstack/solid-store": "^0.8.0",
-    "@tanstack/pacer": "0.16.3"
+    "@tanstack/pacer": "0.16.4"
   },
   "devDependencies": {
     "solid-js": "^1.9.10",
@@ -178,7 +110,6 @@
     "test:lib": "vitest --passWithNoTests",
     "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "tsc",
-    "test:build": "publint --strict",
-    "build": "vite build"
+    "build": "tsdown"
   }
 }

package/src/async-batcher/createAsyncBatcher.ts

@@ -8,8 +8,10 @@ import type {
   AsyncBatcherState,
 } from '@tanstack/pacer/async-batcher'
 
-export interface SolidAsyncBatcher<TValue, TSelected = {}>
-  extends Omit<AsyncBatcher<TValue>, 'store'> {
+export interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<
+  AsyncBatcher<TValue>,
+  'store'
+> {
   /**
    * Reactive state that will be updated when the batcher state changes
    *

package/src/async-queuer/createAsyncQueuer.ts

@@ -8,8 +8,10 @@ import type {
   AsyncQueuerState,
 } from '@tanstack/pacer/async-queuer'
 
-export interface SolidAsyncQueuer<TValue, TSelected = {}>
-  extends Omit<AsyncQueuer<TValue>, 'store'> {
+export interface SolidAsyncQueuer<TValue, TSelected = {}> extends Omit<
+  AsyncQueuer<TValue>,
+  'store'
+> {
   /**
    * Reactive state that will be updated when the queuer state changes
    *

package/src/batcher/createBatcher.ts

@@ -5,8 +5,10 @@ import type { Store } from '@tanstack/solid-store'
 import type { Accessor } from 'solid-js'
 import type { BatcherOptions, BatcherState } from '@tanstack/pacer/batcher'
 
-export interface SolidBatcher<TValue, TSelected = {}>
-  extends Omit<Batcher<TValue>, 'store'> {
+export interface SolidBatcher<TValue, TSelected = {}> extends Omit<
+  Batcher<TValue>,
+  'store'
+> {
   /**
    * Reactive state that will be updated when the batcher state changes
    *

package/src/debouncer/createDebouncer.ts

@@ -10,8 +10,10 @@ import type {
   DebouncerState,
 } from '@tanstack/pacer/debouncer'
 
-export interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}>
-  extends Omit<Debouncer<TFn>, 'store'> {
+export interface SolidDebouncer<
+  TFn extends AnyFunction,
+  TSelected = {},
+> extends Omit<Debouncer<TFn>, 'store'> {
   /**
    * Reactive state that will be updated when the debouncer state changes
    *

package/src/provider/index.ts

@@ -0,0 +1 @@
+export * from './PacerProvider'

package/src/queuer/createQueuer.ts

@@ -5,8 +5,10 @@ import type { Store } from '@tanstack/solid-store'
 import type { Accessor } from 'solid-js'
 import type { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer'
 
-export interface SolidQueuer<TValue, TSelected = {}>
-  extends Omit<Queuer<TValue>, 'store'> {
+export interface SolidQueuer<TValue, TSelected = {}> extends Omit<
+  Queuer<TValue>,
+  'store'
+> {
   /**
    * Reactive state that will be updated when the queuer state changes
    *

package/src/rate-limiter/createRateLimiter.ts

@@ -9,8 +9,10 @@ import type {
   RateLimiterState,
 } from '@tanstack/pacer/rate-limiter'
 
-export interface SolidRateLimiter<TFn extends AnyFunction, TSelected = {}>
-  extends Omit<RateLimiter<TFn>, 'store'> {
+export interface SolidRateLimiter<
+  TFn extends AnyFunction,
+  TSelected = {},
+> extends Omit<RateLimiter<TFn>, 'store'> {
   /**
    * Reactive state that will be updated when the rate limiter state changes
    *

package/src/throttler/createThrottler.ts

@@ -10,8 +10,10 @@ import type {
   ThrottlerState,
 } from '@tanstack/pacer/throttler'
 
-export interface SolidThrottler<TFn extends AnyFunction, TSelected = {}>
-  extends Omit<Throttler<TFn>, 'store'> {
+export interface SolidThrottler<
+  TFn extends AnyFunction,
+  TSelected = {},
+> extends Omit<Throttler<TFn>, 'store'> {
   /**
    * Reactive state that will be updated when the throttler state changes
    *

package/dist/cjs/async-batcher/createAsyncBatcher.cjs

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncBatcher = require("@tanstack/pacer/async-batcher");
-const solidStore = require("@tanstack/solid-store");
-const PacerProvider = require("../provider/PacerProvider.cjs");
-function createAsyncBatcher(fn, options = {}, selector = () => ({})) {
-  const mergedOptions = {
-    ...PacerProvider.useDefaultPacerOptions().asyncBatcher,
-    ...options
-  };
-  const asyncBatcher$1 = new asyncBatcher.AsyncBatcher(fn, mergedOptions);
-  const state = solidStore.useStore(asyncBatcher$1.store, selector);
-  return {
-    ...asyncBatcher$1,
-    state
-  };
-}
-exports.createAsyncBatcher = createAsyncBatcher;
-//# sourceMappingURL=createAsyncBatcher.cjs.map

package/dist/cjs/async-batcher/createAsyncBatcher.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createAsyncBatcher.cjs","sources":["../../../src/async-batcher/createAsyncBatcher.ts"],"sourcesContent":["import { AsyncBatcher } from '@tanstack/pacer/async-batcher'\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 {\n  AsyncBatcherOptions,\n  AsyncBatcherState,\n} from '@tanstack/pacer/async-batcher'\n\nexport interface SolidAsyncBatcher<TValue, TSelected = {}>\n  extends Omit<AsyncBatcher<TValue>, 'store'> {\n  /**\n   * Reactive state that will be updated when the batcher state changes\n   *\n   * Use this instead of `batcher.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `batcher.state` instead of `batcher.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<AsyncBatcherState<TValue>>>\n}\n\n/**\n * Creates a Solid-compatible AsyncBatcher instance for managing asynchronous batches of items, exposing Solid signals for all stateful properties.\n *\n * This is the async version of the createBatcher hook. Unlike the sync version, this async batcher:\n * - Handles promises and returns results from batch executions\n * - Provides error handling with configurable error behavior\n * - Tracks success, error, and settle counts separately\n * - Has state tracking for when batches are executing\n * - Returns the result of the batch function execution\n *\n * Features:\n * - Configurable batch size and wait time\n * - Custom batch processing logic via getShouldExecute\n * - Event callbacks for monitoring batch operations\n * - Error handling for failed batch operations\n * - Automatic or manual batch processing\n * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * The batcher collects items and processes them in batches based on:\n * - Maximum batch size (number of items per batch)\n * - Time-based batching (process after X milliseconds)\n * - Custom batch processing logic via getShouldExecute\n *\n * Error Handling:\n * - If an `onError` handler is provided, it will be called with the error and batcher instance\n * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown\n * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed\n * - Both onError and throwOnError can be used together; the handler will be called before any error is thrown\n * - The error state can be checked using the underlying AsyncBatcher instance\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 * - `errorCount`: Number of failed batch executions\n * - `executionCount`: Total number of batch execution attempts (successful + failed)\n * - `hasError`: Whether the last batch execution resulted in an error\n * - `isExecuting`: Whether a batch execution is currently in progress\n * - `items`: Array of items currently queued for batching\n * - `lastError`: The error from the most recent failed batch execution (if any)\n * - `lastResult`: The result from the most recent successful batch execution\n * - `settleCount`: Number of batch executions that have completed (successful or failed)\n * - `successCount`: Number of successful batch executions\n *\n * Example usage:\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const asyncBatcher = createAsyncBatcher(\n *   async (items) => {\n *     const results = await Promise.all(items.map(item => processItem(item)));\n *     return results;\n *   },\n *   {\n *     maxSize: 10,\n *     wait: 2000,\n *     onSuccess: (result) => {\n *       console.log('Batch processed successfully:', result);\n *     },\n *     onError: (error) => {\n *       console.error('Batch processing failed:', error);\n *     }\n *   }\n * );\n *\n * // Opt-in to re-render when items or isExecuting changes (optimized for UI updates)\n * const asyncBatcher = createAsyncBatcher(\n *   async (items) => {\n *     const results = await Promise.all(items.map(item => processItem(item)));\n *     return results;\n *   },\n *   { maxSize: 10, wait: 2000 },\n *   (state) => ({ items: state.items, isExecuting: state.isExecuting })\n * );\n *\n * // Opt-in to re-render when error state changes (optimized for error handling)\n * const asyncBatcher = createAsyncBatcher(\n *   async (items) => {\n *     const results = await Promise.all(items.map(item => processItem(item)));\n *     return results;\n *   },\n *   { maxSize: 10, wait: 2000 },\n *   (state) => ({ hasError: state.hasError, lastError: state.lastError })\n * );\n *\n * // Add items to batch\n * asyncBatcher.addItem(newItem);\n *\n * // Manually execute batch\n * const result = await asyncBatcher.execute();\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { items, isExecuting } = asyncBatcher.state();\n * ```\n */\nexport function createAsyncBatcher<TValue, TSelected = {}>(\n  fn: (items: Array<TValue>) => Promise<any>,\n  options: AsyncBatcherOptions<TValue> = {},\n  selector: (state: AsyncBatcherState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): SolidAsyncBatcher<TValue, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().asyncBatcher,\n    ...options,\n  } as AsyncBatcherOptions<TValue>\n\n  const asyncBatcher = new AsyncBatcher<TValue>(fn, mergedOptions)\n\n  const state = useStore(asyncBatcher.store, selector)\n\n  return {\n    ...asyncBatcher,\n    state,\n  } as SolidAsyncBatcher<TValue, TSelected> // omit `store` in favor of `state`\n}\n"],"names":["useDefaultPacerOptions","asyncBatcher","AsyncBatcher","useStore"],"mappings":";;;;;AAgIO,SAAS,mBACd,IACA,UAAuC,CAAA,GACvC,WAA4D,OACzD,CAAA,IACmC;AACtC,QAAM,gBAAgB;AAAA,IACpB,GAAGA,cAAAA,yBAAyB;AAAA,IAC5B,GAAG;AAAA,EAAA;AAGL,QAAMC,iBAAe,IAAIC,0BAAqB,IAAI,aAAa;AAE/D,QAAM,QAAQC,WAAAA,SAASF,eAAa,OAAO,QAAQ;AAEnD,SAAO;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,EAAA;AAEJ;;"}

package/dist/cjs/async-batcher/index.cjs

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncBatcher = require("@tanstack/pacer/async-batcher");
-const createAsyncBatcher = require("./createAsyncBatcher.cjs");
-exports.createAsyncBatcher = createAsyncBatcher.createAsyncBatcher;
-Object.keys(asyncBatcher).forEach((k) => {
-  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: () => asyncBatcher[k]
-  });
-});
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/async-batcher/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/dist/cjs/async-batcher/index.d.cts

@@ -1,2 +0,0 @@
-export * from '@tanstack/pacer/async-batcher';
-export * from './createAsyncBatcher.cjs';

package/dist/cjs/async-debouncer/createAsyncDebouncer.cjs

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncDebouncer = require("@tanstack/pacer/async-debouncer");
-const solidStore = require("@tanstack/solid-store");
-const solidJs = require("solid-js");
-const PacerProvider = require("../provider/PacerProvider.cjs");
-function createAsyncDebouncer(fn, options, selector = () => ({})) {
-  const mergedOptions = {
-    ...PacerProvider.useDefaultPacerOptions().asyncDebouncer,
-    ...options
-  };
-  const asyncDebouncer$1 = new asyncDebouncer.AsyncDebouncer(fn, mergedOptions);
-  const state = solidStore.useStore(asyncDebouncer$1.store, selector);
-  solidJs.createEffect(() => {
-    solidJs.onCleanup(() => {
-      asyncDebouncer$1.cancel();
-    });
-  });
-  return {
-    ...asyncDebouncer$1,
-    state
-  };
-}
-exports.createAsyncDebouncer = createAsyncDebouncer;
-//# sourceMappingURL=createAsyncDebouncer.cjs.map

package/dist/cjs/async-debouncer/createAsyncDebouncer.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createAsyncDebouncer.cjs","sources":["../../../src/async-debouncer/createAsyncDebouncer.ts"],"sourcesContent":["import { AsyncDebouncer } from '@tanstack/pacer/async-debouncer'\nimport { useStore } from '@tanstack/solid-store'\nimport { createEffect, onCleanup } from 'solid-js'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type {\n  AsyncDebouncerOptions,\n  AsyncDebouncerState,\n} from '@tanstack/pacer/async-debouncer'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\n\nexport interface SolidAsyncDebouncer<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncDebouncer<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<AsyncDebouncerState<TFn>>>\n}\n\n/**\n * A low-level Solid hook that creates an `AsyncDebouncer` instance to delay execution of an async function.\n *\n * This hook is designed to be flexible and state-management agnostic - it simply returns a debouncer instance that\n * you can integrate with any state management solution (createSignal, etc).\n *\n * Async debouncing ensures that an async function only executes after a specified delay has passed since its last invocation.\n * Each new invocation resets the delay timer. This is useful for handling frequent events like window resizing\n * or input changes where you only want to execute the handler after the events have stopped occurring.\n *\n * Unlike throttling which allows execution at regular intervals, debouncing prevents any execution until\n * the function stops being called for the specified delay period.\n *\n * Unlike the non-async Debouncer, this async version supports returning values from the debounced function,\n * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call\n * instead of setting the result on a state variable from within the debounced function.\n *\n * Error Handling:\n * - If an `onError` handler is provided, it will be called with the error and debouncer instance\n * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown\n * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed\n * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown\n * - The error state can be checked using the underlying AsyncDebouncer instance\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 * - `hasError`: Whether the last execution resulted in an error\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `isExecuting`: Whether an async function execution is currently in progress\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastError`: The error from the most recent failed execution (if any)\n * - `lastResult`: The result from the most recent successful execution\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const { maybeExecute } = createAsyncDebouncer(\n *   async (query: string) => {\n *     const results = await api.search(query);\n *     return results;\n *   },\n *   { wait: 500 }\n * );\n *\n * // Opt-in to re-render when isPending or isExecuting changes (optimized for loading states)\n * const debouncer = createAsyncDebouncer(\n *   async (query: string) => {\n *     const results = await api.search(query);\n *     return results;\n *   },\n *   { wait: 500 },\n *   (state) => ({ isPending: state.isPending, isExecuting: state.isExecuting })\n * );\n *\n * // Opt-in to re-render when error state changes (optimized for error handling)\n * const debouncer = createAsyncDebouncer(\n *   async (searchTerm) => {\n *     const data = await searchAPI(searchTerm);\n *     return data;\n *   },\n *   {\n *     wait: 300,\n *     leading: true,   // Execute immediately on first call\n *     trailing: false, // Skip trailing edge updates\n *     onError: (error) => {\n *       console.error('API call failed:', error);\n *     }\n *   },\n *   (state) => ({ hasError: state.hasError, lastError: state.lastError })\n * );\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { isPending, isExecuting } = debouncer.state();\n * ```\n */\nexport function createAsyncDebouncer<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AsyncDebouncerOptions<TFn>,\n  selector: (state: AsyncDebouncerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): SolidAsyncDebouncer<TFn, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().asyncDebouncer,\n    ...options,\n  } as AsyncDebouncerOptions<TFn>\n\n  const asyncDebouncer = new AsyncDebouncer<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 SolidAsyncDebouncer<TFn, TSelected> // omit `store` in favor of `state`\n}\n"],"names":["useDefaultPacerOptions","asyncDebouncer","AsyncDebouncer","useStore","createEffect","onCleanup"],"mappings":";;;;;;AAsHO,SAAS,qBAId,IACA,SACA,WAA2D,OACxD,CAAA,IACkC;AACrC,QAAM,gBAAgB;AAAA,IACpB,GAAGA,cAAAA,yBAAyB;AAAA,IAC5B,GAAG;AAAA,EAAA;AAGL,QAAMC,mBAAiB,IAAIC,8BAAoB,IAAI,aAAa;AAEhE,QAAM,QAAQC,WAAAA,SAASF,iBAAe,OAAO,QAAQ;AAErDG,UAAAA,aAAa,MAAM;AACjBC,YAAAA,UAAU,MAAM;AACdJ,uBAAe,OAAA;AAAA,IACjB,CAAC;AAAA,EACH,CAAC;AAED,SAAO;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,EAAA;AAEJ;;"}

package/dist/cjs/async-debouncer/index.cjs

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncDebouncer = require("@tanstack/pacer/async-debouncer");
-const createAsyncDebouncer = require("./createAsyncDebouncer.cjs");
-exports.createAsyncDebouncer = createAsyncDebouncer.createAsyncDebouncer;
-Object.keys(asyncDebouncer).forEach((k) => {
-  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: () => asyncDebouncer[k]
-  });
-});
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/async-debouncer/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/dist/cjs/async-debouncer/index.d.cts

@@ -1,2 +0,0 @@
-export * from '@tanstack/pacer/async-debouncer';
-export * from './createAsyncDebouncer.cjs';

package/dist/cjs/async-queuer/createAsyncQueuer.cjs

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncQueuer = require("@tanstack/pacer/async-queuer");
-const solidStore = require("@tanstack/solid-store");
-const PacerProvider = require("../provider/PacerProvider.cjs");
-function createAsyncQueuer(fn, options = {}, selector = () => ({})) {
-  const mergedOptions = {
-    ...PacerProvider.useDefaultPacerOptions().asyncQueuer,
-    ...options
-  };
-  const asyncQueuer$1 = new asyncQueuer.AsyncQueuer(fn, mergedOptions);
-  const state = solidStore.useStore(asyncQueuer$1.store, selector);
-  return {
-    ...asyncQueuer$1,
-    state
-  };
-}
-exports.createAsyncQueuer = createAsyncQueuer;
-//# sourceMappingURL=createAsyncQueuer.cjs.map

package/dist/cjs/async-queuer/createAsyncQueuer.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createAsyncQueuer.cjs","sources":["../../../src/async-queuer/createAsyncQueuer.ts"],"sourcesContent":["import { AsyncQueuer } from '@tanstack/pacer/async-queuer'\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 {\n  AsyncQueuerOptions,\n  AsyncQueuerState,\n} from '@tanstack/pacer/async-queuer'\n\nexport interface SolidAsyncQueuer<TValue, TSelected = {}>\n  extends Omit<AsyncQueuer<TValue>, 'store'> {\n  /**\n   * Reactive state that will be updated when the queuer state changes\n   *\n   * Use this instead of `queuer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `queuer.state` instead of `queuer.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<AsyncQueuerState<TValue>>>\n}\n\n/**\n * Creates a Solid-compatible AsyncQueuer instance for managing an asynchronous queue of items, exposing Solid signals for all stateful properties.\n *\n * Features:\n * - Priority queueing via `getPriority` or item `priority` property\n * - Configurable concurrency limit\n * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior\n * - Pause/resume processing\n * - Task cancellation\n * - Item expiration\n * - Lifecycle callbacks for success, error, settled, items change, etc.\n * - All stateful properties (active items, pending items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * Tasks are processed concurrently up to the configured concurrency limit. When a task completes,\n * the next pending task is processed if the concurrency limit allows.\n *\n * Error Handling:\n * - If an `onError` handler is provided, it will be called with the error and queuer instance\n * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown\n * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed\n * - Both onError and throwOnError can be used together; the handler will be called before any error is thrown\n * - The error state can be checked using the underlying AsyncQueuer instance\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 * - `activeItems`: Array of items currently being processed\n * - `errorCount`: Number of items that failed processing\n * - `isRunning`: Whether the queuer is currently running (not stopped)\n * - `pendingItems`: Array of items waiting to be processed\n * - `rejectionCount`: Number of items that were rejected (expired or failed validation)\n * - `settleCount`: Number of items that have completed processing (successful or failed)\n * - `successCount`: Number of items that were processed successfully\n *\n * Example usage:\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const asyncQueuer = createAsyncQueuer(async (item) => {\n *   // process item\n *   return await fetchData(item);\n * }, {\n *   initialItems: [],\n *   concurrency: 2,\n *   maxSize: 100,\n *   started: false,\n *   onSuccess: (result) => {\n *     console.log('Item processed:', result);\n *   },\n *   onError: (error) => {\n *     console.error('Processing failed:', error);\n *   }\n * });\n *\n * // Opt-in to re-render when queue state changes (optimized for UI updates)\n * const asyncQueuer = createAsyncQueuer(\n *   async (item) => await fetchData(item),\n *   { concurrency: 2, started: true },\n *   (state) => ({\n *     pendingItems: state.pendingItems,\n *     activeItems: state.activeItems,\n *     isRunning: state.isRunning\n *   })\n * );\n *\n * // Opt-in to re-render when processing metrics change (optimized for tracking progress)\n * const asyncQueuer = createAsyncQueuer(\n *   async (item) => await fetchData(item),\n *   { concurrency: 2, started: true },\n *   (state) => ({\n *     successCount: state.successCount,\n *     errorCount: state.errorCount,\n *     settleCount: state.settleCount\n *   })\n * );\n *\n * // Add items to queue\n * asyncQueuer.addItem(newItem);\n *\n * // Start processing\n * asyncQueuer.start();\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { pendingItems, activeItems } = asyncQueuer.state();\n * ```\n */\nexport function createAsyncQueuer<TValue, TSelected = {}>(\n  fn: (value: TValue) => Promise<any>,\n  options: AsyncQueuerOptions<TValue> = {},\n  selector: (state: AsyncQueuerState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): SolidAsyncQueuer<TValue, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().asyncQueuer,\n    ...options,\n  } as AsyncQueuerOptions<TValue>\n\n  const asyncQueuer = new AsyncQueuer<TValue>(fn, mergedOptions)\n\n  const state = useStore(asyncQueuer.store, selector)\n\n  return {\n    ...asyncQueuer,\n    state,\n  } as SolidAsyncQueuer<TValue, TSelected> // omit `store` in favor of `state`\n}\n"],"names":["useDefaultPacerOptions","asyncQueuer","AsyncQueuer","useStore"],"mappings":";;;;;AAwHO,SAAS,kBACd,IACA,UAAsC,CAAA,GACtC,WAA2D,OACxD,CAAA,IACkC;AACrC,QAAM,gBAAgB;AAAA,IACpB,GAAGA,cAAAA,yBAAyB;AAAA,IAC5B,GAAG;AAAA,EAAA;AAGL,QAAMC,gBAAc,IAAIC,wBAAoB,IAAI,aAAa;AAE7D,QAAM,QAAQC,WAAAA,SAASF,cAAY,OAAO,QAAQ;AAElD,SAAO;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,EAAA;AAEJ;;"}

package/dist/cjs/async-queuer/index.cjs

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncQueuer = require("@tanstack/pacer/async-queuer");
-const createAsyncQueuer = require("./createAsyncQueuer.cjs");
-exports.createAsyncQueuer = createAsyncQueuer.createAsyncQueuer;
-Object.keys(asyncQueuer).forEach((k) => {
-  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: () => asyncQueuer[k]
-  });
-});
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/async-queuer/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/dist/cjs/async-queuer/index.d.cts

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

package/dist/cjs/async-rate-limiter/createAsyncRateLimiter.cjs

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncRateLimiter = require("@tanstack/pacer/async-rate-limiter");
-const solidStore = require("@tanstack/solid-store");
-const PacerProvider = require("../provider/PacerProvider.cjs");
-function createAsyncRateLimiter(fn, options, selector = () => ({})) {
-  const mergedOptions = {
-    ...PacerProvider.useDefaultPacerOptions().asyncRateLimiter,
-    ...options
-  };
-  const asyncRateLimiter$1 = new asyncRateLimiter.AsyncRateLimiter(fn, mergedOptions);
-  const state = solidStore.useStore(asyncRateLimiter$1.store, selector);
-  return {
-    ...asyncRateLimiter$1,
-    state
-  };
-}
-exports.createAsyncRateLimiter = createAsyncRateLimiter;
-//# sourceMappingURL=createAsyncRateLimiter.cjs.map

package/dist/cjs/async-rate-limiter/createAsyncRateLimiter.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createAsyncRateLimiter.cjs","sources":["../../../src/async-rate-limiter/createAsyncRateLimiter.ts"],"sourcesContent":["import { AsyncRateLimiter } from '@tanstack/pacer/async-rate-limiter'\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 { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncRateLimiterOptions,\n  AsyncRateLimiterState,\n} from '@tanstack/pacer/async-rate-limiter'\n\nexport interface SolidAsyncRateLimiter<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncRateLimiter<TFn>, 'store'> {\n  /**\n   * Reactive state that will be updated when the rate limiter state changes\n   *\n   * Use this instead of `rateLimiter.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `rateLimiter.state` instead of `rateLimiter.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<AsyncRateLimiterState<TFn>>>\n}\n\n/**\n * A low-level Solid hook that creates an `AsyncRateLimiter` instance to limit how many times an async function can execute within a time window.\n *\n * This hook is designed to be flexible and state-management agnostic - it simply returns a rate limiter instance that\n * you can integrate with any state management solution (createSignal, etc).\n *\n * Rate limiting is a simple approach that allows a function to execute up to a limit within a time window,\n * then blocks all subsequent calls until the window passes. This can lead to \"bursty\" behavior where\n * all executions happen immediately, followed by a complete block.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n *   consistent rate of execution over time.\n *\n * Unlike the non-async RateLimiter, this async version supports returning values from the rate-limited function,\n * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call\n * instead of setting the result on a state variable from within the rate-limited function.\n *\n * For smoother execution patterns, consider using:\n * - Throttling: Ensures consistent spacing between executions (e.g. max once per 200ms)\n * - Debouncing: Waits for a pause in calls before executing (e.g. after 500ms of no calls)\n *\n * Rate limiting is best used for hard API limits or resource constraints. For UI updates or\n * smoothing out frequent events, throttling or debouncing usually provide better user experience.\n *\n * Error Handling:\n * - If an `onError` handler is provided, it will be called with the error and rate limiter instance\n * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown\n * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed\n * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown\n * - The error state can be checked using the underlying AsyncRateLimiter instance\n * - Rate limit rejections (when limit is exceeded) are handled separately from execution errors via the `onReject` handler\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 * - `currentWindowStart`: Timestamp when the current window started\n * - `executionCount`: Number of function executions that have been completed\n * - `hasError`: Whether the last execution resulted in an error\n * - `isExecuting`: Whether an async function execution is currently in progress\n * - `lastError`: The error from the most recent failed execution (if any)\n * - `lastResult`: The result from the most recent successful execution\n * - `nextWindowTime`: Timestamp when the next window begins\n * - `rejectionCount`: Number of function calls that were rejected due to rate limiting\n * - `remainingInWindow`: Number of executions remaining in the current window\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const { maybeExecute } = createAsyncRateLimiter(\n *   async (id: string) => {\n *     const data = await api.fetchData(id);\n *     return data; // Return value is preserved\n *   },\n *   { limit: 5, window: 1000 } // 5 calls per second\n * );\n *\n * // Opt-in to re-render when rate limit and execution state changes (optimized for UI feedback)\n * const rateLimiter = createAsyncRateLimiter(\n *   async (query) => {\n *     const result = await searchAPI(query);\n *     return result;\n *   },\n *   { limit: 10, window: 60000 },\n *   (state) => ({\n *     remainingInWindow: state.remainingInWindow,\n *     isExecuting: state.isExecuting,\n *     rejectionCount: state.rejectionCount\n *   })\n * );\n *\n * // Opt-in to re-render when error state changes (optimized for error handling)\n * const rateLimiter = createAsyncRateLimiter(\n *   async (query) => {\n *     const result = await searchAPI(query);\n *     return result;\n *   },\n *   {\n *     limit: 10,\n *     window: 60000, // 10 calls per minute\n *     onReject: (info) => console.log(`Rate limit exceeded: ${info.nextValidTime - Date.now()}ms until next window`)\n *   },\n *   (state) => ({ hasError: state.hasError, lastError: state.lastError })\n * );\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { remainingInWindow, isExecuting } = rateLimiter.state();\n * ```\n */\nexport function createAsyncRateLimiter<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AsyncRateLimiterOptions<TFn>,\n  selector: (state: AsyncRateLimiterState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): SolidAsyncRateLimiter<TFn, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().asyncRateLimiter,\n    ...options,\n  } as AsyncRateLimiterOptions<TFn>\n\n  const asyncRateLimiter = new AsyncRateLimiter<TFn>(fn, mergedOptions)\n\n  const state = useStore(asyncRateLimiter.store, selector)\n\n  return {\n    ...asyncRateLimiter,\n    state,\n  } as SolidAsyncRateLimiter<TFn, TSelected>\n}\n"],"names":["useDefaultPacerOptions","asyncRateLimiter","AsyncRateLimiter","useStore"],"mappings":";;;;;AAiIO,SAAS,uBAId,IACA,SACA,WAA6D,OAC1D,CAAA,IACoC;AACvC,QAAM,gBAAgB;AAAA,IACpB,GAAGA,cAAAA,yBAAyB;AAAA,IAC5B,GAAG;AAAA,EAAA;AAGL,QAAMC,qBAAmB,IAAIC,kCAAsB,IAAI,aAAa;AAEpE,QAAM,QAAQC,WAAAA,SAASF,mBAAiB,OAAO,QAAQ;AAEvD,SAAO;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,EAAA;AAEJ;;"}

package/dist/cjs/async-rate-limiter/index.cjs

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncRateLimiter = require("@tanstack/pacer/async-rate-limiter");
-const createAsyncRateLimiter = require("./createAsyncRateLimiter.cjs");
-exports.createAsyncRateLimiter = createAsyncRateLimiter.createAsyncRateLimiter;
-Object.keys(asyncRateLimiter).forEach((k) => {
-  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: () => asyncRateLimiter[k]
-  });
-});
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/async-rate-limiter/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/dist/cjs/async-rate-limiter/index.d.cts

@@ -1,2 +0,0 @@
-export * from '@tanstack/pacer/async-rate-limiter';
-export * from './createAsyncRateLimiter.cjs';

package/dist/cjs/async-throttler/createAsyncThrottler.cjs

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncThrottler = require("@tanstack/pacer/async-throttler");
-const solidStore = require("@tanstack/solid-store");
-const PacerProvider = require("../provider/PacerProvider.cjs");
-function createAsyncThrottler(fn, options, selector = () => ({})) {
-  const mergedOptions = {
-    ...PacerProvider.useDefaultPacerOptions().asyncThrottler,
-    ...options
-  };
-  const asyncThrottler$1 = new asyncThrottler.AsyncThrottler(fn, mergedOptions);
-  const state = solidStore.useStore(asyncThrottler$1.store, selector);
-  return {
-    ...asyncThrottler$1,
-    state
-  };
-}
-exports.createAsyncThrottler = createAsyncThrottler;
-//# sourceMappingURL=createAsyncThrottler.cjs.map

package/dist/cjs/async-throttler/createAsyncThrottler.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createAsyncThrottler.cjs","sources":["../../../src/async-throttler/createAsyncThrottler.ts"],"sourcesContent":["import { AsyncThrottler } from '@tanstack/pacer/async-throttler'\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 { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncThrottlerOptions,\n  AsyncThrottlerState,\n} from '@tanstack/pacer/async-throttler'\n\nexport interface SolidAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncThrottler<TFn>, 'store'> {\n  /**\n   * Reactive state that will be updated when the throttler state changes\n   *\n   * Use this instead of `throttler.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `throttler.state` instead of `throttler.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<AsyncThrottlerState<TFn>>>\n}\n\n/**\n * A low-level Solid hook that creates an `AsyncThrottler` instance to limit how often an async function can execute.\n *\n * This hook is designed to be flexible and state-management agnostic - it simply returns a throttler instance that\n * you can integrate with any state management solution (createSignal, etc).\n *\n * Async throttling ensures an async function executes at most once within a specified time window,\n * regardless of how many times it is called. This is useful for rate-limiting expensive API calls,\n * database operations, or other async tasks.\n *\n * Unlike the non-async Throttler, this async version supports returning values from the throttled function,\n * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call\n * instead of setting the result on a state variable from within the throttled function.\n *\n * Error Handling:\n * - If an `onError` handler is provided, it will be called with the error and throttler instance\n * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown\n * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed\n * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown\n * - The error state can be checked using the underlying AsyncThrottler instance\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 throttler can execute on the leading edge\n * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge\n * - `executionCount`: Number of function executions that have been completed\n * - `hasError`: Whether the last execution resulted in an error\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `isExecuting`: Whether an async function execution is currently in progress\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastError`: The error from the most recent failed execution (if any)\n * - `lastExecutionTime`: Timestamp of the last execution\n * - `lastResult`: The result from the most recent successful execution\n * - `nextExecutionTime`: Timestamp of the next allowed execution\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const { maybeExecute } = createAsyncThrottler(\n *   async (id: string) => {\n *     const data = await api.fetchData(id);\n *     return data;\n *   },\n *   { wait: 1000 }\n * );\n *\n * // Opt-in to re-render when isPending or isExecuting changes (optimized for loading states)\n * const throttler = createAsyncThrottler(\n *   async (query) => {\n *     const result = await searchAPI(query);\n *     return result;\n *   },\n *   { wait: 2000 },\n *   (state) => ({ isPending: state.isPending, isExecuting: state.isExecuting })\n * );\n *\n * // Opt-in to re-render when error state changes (optimized for error handling)\n * const throttler = createAsyncThrottler(\n *   async (query) => {\n *     const result = await searchAPI(query);\n *     return result;\n *   },\n *   {\n *     wait: 2000,\n *     leading: true,   // Execute immediately on first call\n *     trailing: false, // Skip trailing edge updates\n *     onError: (error) => {\n *       console.error('API call failed:', error);\n *     }\n *   },\n *   (state) => ({ hasError: state.hasError, lastError: state.lastError })\n * );\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { isPending, isExecuting } = throttler.state();\n * ```\n */\nexport function createAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AsyncThrottlerOptions<TFn>,\n  selector: (state: AsyncThrottlerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): SolidAsyncThrottler<TFn, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().asyncThrottler,\n    ...options,\n  } as AsyncThrottlerOptions<TFn>\n\n  const asyncThrottler = new AsyncThrottler(fn, mergedOptions)\n\n  const state = useStore(asyncThrottler.store, selector)\n\n  return {\n    ...asyncThrottler,\n    state,\n  } as SolidAsyncThrottler<TFn, TSelected>\n}\n"],"names":["useDefaultPacerOptions","asyncThrottler","AsyncThrottler","useStore"],"mappings":";;;;;AAqHO,SAAS,qBAId,IACA,SACA,WAA2D,OACxD,CAAA,IACkC;AACrC,QAAM,gBAAgB;AAAA,IACpB,GAAGA,cAAAA,yBAAyB;AAAA,IAC5B,GAAG;AAAA,EAAA;AAGL,QAAMC,mBAAiB,IAAIC,8BAAe,IAAI,aAAa;AAE3D,QAAM,QAAQC,WAAAA,SAASF,iBAAe,OAAO,QAAQ;AAErD,SAAO;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,EAAA;AAEJ;;"}

package/dist/cjs/async-throttler/index.cjs

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncThrottler = require("@tanstack/pacer/async-throttler");
-const createAsyncThrottler = require("./createAsyncThrottler.cjs");
-exports.createAsyncThrottler = createAsyncThrottler.createAsyncThrottler;
-Object.keys(asyncThrottler).forEach((k) => {
-  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: () => asyncThrottler[k]
-  });
-});
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/async-throttler/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/dist/cjs/async-throttler/index.d.cts

@@ -1,2 +0,0 @@
-export * from '@tanstack/pacer/async-throttler';
-export * from './createAsyncThrottler.cjs';