@tanstack/solid-pacer 0.5.0 → 0.7.0

package/dist/cjs/batcher/index.cjs

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

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

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

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

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

package/dist/cjs/index.cjs

@@ -5,6 +5,7 @@ const createAsyncDebouncer = require("./async-debouncer/createAsyncDebouncer.cjs
 const createAsyncQueuer = require("./async-queuer/createAsyncQueuer.cjs");
 const createAsyncRateLimiter = require("./async-rate-limiter/createAsyncRateLimiter.cjs");
 const createAsyncThrottler = require("./async-throttler/createAsyncThrottler.cjs");
+const createBatcher = require("./batcher/createBatcher.cjs");
 const createDebouncedSignal = require("./debouncer/createDebouncedSignal.cjs");
 const createDebouncedValue = require("./debouncer/createDebouncedValue.cjs");
 const createDebouncer = require("./debouncer/createDebouncer.cjs");
@@ -19,6 +20,7 @@ exports.createAsyncDebouncer = createAsyncDebouncer.createAsyncDebouncer;
 exports.createAsyncQueuer = createAsyncQueuer.createAsyncQueuer;
 exports.createAsyncRateLimiter = createAsyncRateLimiter.createAsyncRateLimiter;
 exports.createAsyncThrottler = createAsyncThrottler.createAsyncThrottler;
+exports.createBatcher = createBatcher.createBatcher;
 exports.createDebouncedSignal = createDebouncedSignal.createDebouncedSignal;
 exports.createDebouncedValue = createDebouncedValue.createDebouncedValue;
 exports.createDebouncer = createDebouncer.createDebouncer;

package/dist/cjs/index.cjs.map

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

package/dist/cjs/index.d.cts

@@ -6,6 +6,7 @@ export * from './async-debouncer/createAsyncDebouncer.cjs';
 export * from './async-queuer/createAsyncQueuer.cjs';
 export * from './async-rate-limiter/createAsyncRateLimiter.cjs';
 export * from './async-throttler/createAsyncThrottler.cjs';
+export * from './batcher/createBatcher.cjs';
 export * from './debouncer/createDebouncedSignal.cjs';
 export * from './debouncer/createDebouncedValue.cjs';
 export * from './debouncer/createDebouncer.cjs';

package/dist/cjs/queuer/createQueuer.cjs

@@ -3,8 +3,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const queuer = require("@tanstack/pacer/queuer");
 const solidJs = require("solid-js");
 const utils = require("@tanstack/pacer/utils");
-function createQueuer(initialOptions = {}) {
-  const queuer$1 = utils.bindInstanceMethods(new queuer.Queuer(initialOptions));
+function createQueuer(fn, initialOptions = {}) {
+  const queuer$1 = utils.bindInstanceMethods(new queuer.Queuer(fn, initialOptions));
   const [allItems, setAllItems] = solidJs.createSignal(
     queuer$1.getAllItems()
   );

package/dist/cjs/queuer/createQueuer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createQueuer.cjs","sources":["../../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { QueuerOptions } from '@tanstack/pacer/queuer'\n\nexport interface SolidQueuer<TValue>\n  extends Omit<\n    Queuer<TValue>,\n    | 'getAllItems'\n    | 'getExecutionCount'\n    | 'getIsEmpty'\n    | 'getIsFull'\n    | 'getIsIdle'\n    | 'getIsRunning'\n    | 'getPeek'\n    | 'getSize'\n  > {\n  /**\n   * Signal version of `getAllItems`\n   */\n  allItems: Accessor<Array<TValue>>\n  /**\n   * Signal version of `getExecutionCount`\n   */\n  executionCount: Accessor<number>\n  /**\n   * Signal version of `getIsEmpty`\n   */\n  isEmpty: Accessor<boolean>\n  /**\n   * Signal version of `getIsFull`\n   */\n  isFull: Accessor<boolean>\n  /**\n   * Signal version of `getIsIdle`\n   */\n  isIdle: Accessor<boolean>\n  /**\n   * Signal version of `getIsRunning`\n   */\n  isRunning: Accessor<boolean>\n  /**\n   * Signal version of `getPeek`\n   */\n  peek: Accessor<TValue | undefined>\n  /**\n   * Signal version of `getRejectionCount`\n   */\n  rejectionCount: Accessor<number>\n  /**\n   * Signal version of `getSize`\n   */\n  size: Accessor<number>\n}\n\n/**\n * A Solid hook that creates and manages a Queuer instance.\n *\n * This is a lower-level hook that provides direct access to the Queuer'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.) by utilizing the onItemsChange callback.\n *\n * For a hook with built-in state management, see createQueuerSignal.\n *\n * The Queuer extends the base Queue to add processing capabilities. Items are processed\n * synchronously in order, with optional delays between processing each item. The queuer includes\n * an internal tick mechanism that can be started and stopped, making it useful as a scheduler.\n * When started, it will process one item per tick, with an optional wait time between ticks.\n *\n * By default uses FIFO (First In First Out) behavior, but can be configured for LIFO\n * (Last In First Out) by specifying 'front' position when adding items.\n *\n * @example\n * ```tsx\n * // Example with custom state management and scheduling\n * const [items, setItems] = createSignal([]);\n *\n * const queue = createQueuer({\n *   started: true, // Start processing immediately\n *   wait: 1000,    // Process one item every second\n *   onItemsChange: (queue) => setItems(queue.getAllItems()),\n *   getPriority: (item) => item.priority // Process higher priority items first\n * });\n *\n * // Add items to process - they'll be handled automatically\n * queue.addItem('task1');\n * queue.addItem('task2');\n *\n * // Control the scheduler\n * queue.stop();  // Pause processing\n * queue.start(); // Resume processing\n *\n * // Access queue state via signals\n * console.log('Items:', queue.allItems());\n * console.log('Size:', queue.size());\n * console.log('Is empty:', queue.isEmpty());\n * console.log('Is running:', queue.isRunning());\n * console.log('Next item:', queue.peek());\n * ```\n */\nexport function createQueuer<TValue>(\n  initialOptions: QueuerOptions<TValue> = {},\n): SolidQueuer<TValue> {\n  const queuer = bindInstanceMethods(new Queuer<TValue>(initialOptions))\n\n  const [allItems, setAllItems] = createSignal<Array<TValue>>(\n    queuer.getAllItems(),\n  )\n  const [executionCount, setExecutionCount] = createSignal(\n    queuer.getExecutionCount(),\n  )\n  const [rejectionCount, setRejectionCount] = createSignal(\n    queuer.getRejectionCount(),\n  )\n  const [isEmpty, setIsEmpty] = createSignal(queuer.getIsEmpty())\n  const [isFull, setIsFull] = createSignal(queuer.getIsFull())\n  const [isIdle, setIsIdle] = createSignal(queuer.getIsIdle())\n  const [isRunning, setIsRunning] = createSignal(queuer.getIsRunning())\n  const [peek, setPeek] = createSignal<TValue | undefined>(queuer.getPeek())\n  const [size, setSize] = createSignal(queuer.getSize())\n\n  function setOptions(newOptions: Partial<QueuerOptions<TValue>>) {\n    queuer.setOptions({\n      ...newOptions,\n      onItemsChange: (queuer) => {\n        setAllItems(queuer.getAllItems())\n        setExecutionCount(queuer.getExecutionCount())\n        setIsEmpty(queuer.getIsEmpty())\n        setIsFull(queuer.getIsFull())\n        setIsIdle(queuer.getIsIdle())\n        setPeek(() => queuer.getPeek())\n        setSize(queuer.getSize())\n\n        const onItemsChange =\n          newOptions.onItemsChange ?? initialOptions.onItemsChange\n        onItemsChange?.(queuer)\n      },\n      onIsRunningChange: (queuer) => {\n        setIsRunning(queuer.getIsRunning())\n        setIsIdle(queuer.getIsIdle())\n\n        const onIsRunningChange =\n          newOptions.onIsRunningChange ?? initialOptions.onIsRunningChange\n        onIsRunningChange?.(queuer)\n      },\n      onReject: (item, queuer) => {\n        setRejectionCount(queuer.getRejectionCount())\n\n        const onReject = newOptions.onReject ?? initialOptions.onReject\n        onReject?.(item, queuer)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...queuer,\n    allItems,\n    executionCount,\n    isEmpty,\n    isFull,\n    isIdle,\n    isRunning,\n    peek,\n    rejectionCount,\n    size,\n    setOptions,\n  } as SolidQueuer<TValue>\n}\n"],"names":["queuer","bindInstanceMethods","Queuer","createSignal"],"mappings":";;;;;AAqGgB,SAAA,aACd,iBAAwC,IACnB;AACrB,QAAMA,WAASC,MAAA,oBAAoB,IAAIC,OAAA,OAAe,cAAc,CAAC;AAE/D,QAAA,CAAC,UAAU,WAAW,IAAIC,QAAA;AAAA,IAC9BH,SAAO,YAAY;AAAA,EACrB;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAIG,QAAA;AAAA,IAC1CH,SAAO,kBAAkB;AAAA,EAC3B;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAIG,QAAA;AAAA,IAC1CH,SAAO,kBAAkB;AAAA,EAC3B;AACA,QAAM,CAAC,SAAS,UAAU,IAAIG,QAAAA,aAAaH,SAAO,YAAY;AAC9D,QAAM,CAAC,QAAQ,SAAS,IAAIG,QAAAA,aAAaH,SAAO,WAAW;AAC3D,QAAM,CAAC,QAAQ,SAAS,IAAIG,QAAAA,aAAaH,SAAO,WAAW;AAC3D,QAAM,CAAC,WAAW,YAAY,IAAIG,QAAAA,aAAaH,SAAO,cAAc;AACpE,QAAM,CAAC,MAAM,OAAO,IAAIG,QAAAA,aAAiCH,SAAO,SAAS;AACzE,QAAM,CAAC,MAAM,OAAO,IAAIG,QAAAA,aAAaH,SAAO,SAAS;AAErD,WAAS,WAAW,YAA4C;AAC9DA,aAAO,WAAW;AAAA,MAChB,GAAG;AAAA,MACH,eAAe,CAACA,YAAW;AACbA,oBAAAA,QAAO,aAAa;AACdA,0BAAAA,QAAO,mBAAmB;AACjCA,mBAAAA,QAAO,YAAY;AACpBA,kBAAAA,QAAO,WAAW;AAClBA,kBAAAA,QAAO,WAAW;AACpB,gBAAA,MAAMA,QAAO,SAAS;AACtBA,gBAAAA,QAAO,SAAS;AAElB,cAAA,gBACJ,WAAW,iBAAiB,eAAe;AAC7C,uDAAgBA;AAAAA,MAClB;AAAA,MACA,mBAAmB,CAACA,YAAW;AAChBA,qBAAAA,QAAO,cAAc;AACxBA,kBAAAA,QAAO,WAAW;AAEtB,cAAA,oBACJ,WAAW,qBAAqB,eAAe;AACjD,+DAAoBA;AAAAA,MACtB;AAAA,MACA,UAAU,CAAC,MAAMA,YAAW;AACRA,0BAAAA,QAAO,mBAAmB;AAEtC,cAAA,WAAW,WAAW,YAAY,eAAe;AACvD,6CAAW,MAAMA;AAAAA,MAAM;AAAA,IACzB,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;"}
+{"version":3,"file":"createQueuer.cjs","sources":["../../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { QueuerOptions } from '@tanstack/pacer/queuer'\n\nexport interface SolidQueuer<TValue>\n  extends Omit<\n    Queuer<TValue>,\n    | 'getAllItems'\n    | 'getExecutionCount'\n    | 'getIsEmpty'\n    | 'getIsFull'\n    | 'getIsIdle'\n    | 'getIsRunning'\n    | 'getPeek'\n    | 'getSize'\n  > {\n  /**\n   * Signal version of `getAllItems`\n   */\n  allItems: Accessor<Array<TValue>>\n  /**\n   * Signal version of `getExecutionCount`\n   */\n  executionCount: Accessor<number>\n  /**\n   * Signal version of `getIsEmpty`\n   */\n  isEmpty: Accessor<boolean>\n  /**\n   * Signal version of `getIsFull`\n   */\n  isFull: Accessor<boolean>\n  /**\n   * Signal version of `getIsIdle`\n   */\n  isIdle: Accessor<boolean>\n  /**\n   * Signal version of `getIsRunning`\n   */\n  isRunning: Accessor<boolean>\n  /**\n   * Signal version of `getPeek`\n   */\n  peek: Accessor<TValue | undefined>\n  /**\n   * Signal version of `getRejectionCount`\n   */\n  rejectionCount: Accessor<number>\n  /**\n   * Signal version of `getSize`\n   */\n  size: Accessor<number>\n}\n\n/**\n * Creates a Solid-compatible Queuer instance for managing a synchronous queue of items, exposing Solid signals for all stateful properties.\n *\n * Features:\n * - Synchronous processing of items using the provided `fn` function\n * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior\n * - Priority queueing via `getPriority` or item `priority` property\n * - Item expiration and removal of stale items\n * - Configurable wait time between processing items\n * - Pause/resume processing\n * - Callbacks for queue state changes, execution, rejection, and expiration\n * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * The queue processes items synchronously in order, with optional delays between each item. When started, it will process one item per tick, with an optional wait time between ticks. You can pause and resume processing with `stop()` and `start()`.\n *\n * By default, the queue uses FIFO behavior, but you can configure LIFO or double-ended queueing by specifying the position when adding or removing items.\n *\n * Example usage:\n * ```tsx\n * // Example with Solid signals and scheduling\n * const [items, setItems] = createSignal([]);\n *\n * const queue = createQueuer(\n *   (item) => {\n *     // process item synchronously\n *     console.log('Processing', item);\n *   },\n *   {\n *     started: true, // Start processing immediately\n *     wait: 1000,    // Process one item every second\n *     onItemsChange: (queue) => setItems(queue.getAllItems()),\n *     getPriority: (item) => item.priority // Process higher priority items first\n *   }\n * );\n *\n * // Add items to process - they'll be handled automatically\n * queue.addItem('task1');\n * queue.addItem('task2');\n *\n * // Control the scheduler\n * queue.stop();  // Pause processing\n * queue.start(); // Resume processing\n *\n * // Access queue state via signals\n * console.log('Items:', queue.allItems());\n * console.log('Size:', queue.size());\n * console.log('Is empty:', queue.isEmpty());\n * console.log('Is running:', queue.isRunning());\n * console.log('Next item:', queue.peek());\n * ```\n */\nexport function createQueuer<TValue>(\n  fn: (item: TValue) => void,\n  initialOptions: QueuerOptions<TValue> = {},\n): SolidQueuer<TValue> {\n  const queuer = bindInstanceMethods(new Queuer<TValue>(fn, initialOptions))\n\n  const [allItems, setAllItems] = createSignal<Array<TValue>>(\n    queuer.getAllItems(),\n  )\n  const [executionCount, setExecutionCount] = createSignal(\n    queuer.getExecutionCount(),\n  )\n  const [rejectionCount, setRejectionCount] = createSignal(\n    queuer.getRejectionCount(),\n  )\n  const [isEmpty, setIsEmpty] = createSignal(queuer.getIsEmpty())\n  const [isFull, setIsFull] = createSignal(queuer.getIsFull())\n  const [isIdle, setIsIdle] = createSignal(queuer.getIsIdle())\n  const [isRunning, setIsRunning] = createSignal(queuer.getIsRunning())\n  const [peek, setPeek] = createSignal<TValue | undefined>(queuer.getPeek())\n  const [size, setSize] = createSignal(queuer.getSize())\n\n  function setOptions(newOptions: Partial<QueuerOptions<TValue>>) {\n    queuer.setOptions({\n      ...newOptions,\n      onItemsChange: (queuer) => {\n        setAllItems(queuer.getAllItems())\n        setExecutionCount(queuer.getExecutionCount())\n        setIsEmpty(queuer.getIsEmpty())\n        setIsFull(queuer.getIsFull())\n        setIsIdle(queuer.getIsIdle())\n        setPeek(() => queuer.getPeek())\n        setSize(queuer.getSize())\n\n        const onItemsChange =\n          newOptions.onItemsChange ?? initialOptions.onItemsChange\n        onItemsChange?.(queuer)\n      },\n      onIsRunningChange: (queuer) => {\n        setIsRunning(queuer.getIsRunning())\n        setIsIdle(queuer.getIsIdle())\n\n        const onIsRunningChange =\n          newOptions.onIsRunningChange ?? initialOptions.onIsRunningChange\n        onIsRunningChange?.(queuer)\n      },\n      onReject: (item, queuer) => {\n        setRejectionCount(queuer.getRejectionCount())\n\n        const onReject = newOptions.onReject ?? initialOptions.onReject\n        onReject?.(item, queuer)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...queuer,\n    allItems,\n    executionCount,\n    isEmpty,\n    isFull,\n    isIdle,\n    isRunning,\n    peek,\n    rejectionCount,\n    size,\n    setOptions,\n  } as SolidQueuer<TValue>\n}\n"],"names":["queuer","bindInstanceMethods","Queuer","createSignal"],"mappings":";;;;;AA2GO,SAAS,aACd,IACA,iBAAwC,IACnB;AACrB,QAAMA,WAASC,MAAAA,oBAAoB,IAAIC,OAAe,OAAA,IAAI,cAAc,CAAC;AAEnE,QAAA,CAAC,UAAU,WAAW,IAAIC,QAAA;AAAA,IAC9BH,SAAO,YAAY;AAAA,EACrB;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAIG,QAAA;AAAA,IAC1CH,SAAO,kBAAkB;AAAA,EAC3B;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAIG,QAAA;AAAA,IAC1CH,SAAO,kBAAkB;AAAA,EAC3B;AACA,QAAM,CAAC,SAAS,UAAU,IAAIG,QAAAA,aAAaH,SAAO,YAAY;AAC9D,QAAM,CAAC,QAAQ,SAAS,IAAIG,QAAAA,aAAaH,SAAO,WAAW;AAC3D,QAAM,CAAC,QAAQ,SAAS,IAAIG,QAAAA,aAAaH,SAAO,WAAW;AAC3D,QAAM,CAAC,WAAW,YAAY,IAAIG,QAAAA,aAAaH,SAAO,cAAc;AACpE,QAAM,CAAC,MAAM,OAAO,IAAIG,QAAAA,aAAiCH,SAAO,SAAS;AACzE,QAAM,CAAC,MAAM,OAAO,IAAIG,QAAAA,aAAaH,SAAO,SAAS;AAErD,WAAS,WAAW,YAA4C;AAC9DA,aAAO,WAAW;AAAA,MAChB,GAAG;AAAA,MACH,eAAe,CAACA,YAAW;AACbA,oBAAAA,QAAO,aAAa;AACdA,0BAAAA,QAAO,mBAAmB;AACjCA,mBAAAA,QAAO,YAAY;AACpBA,kBAAAA,QAAO,WAAW;AAClBA,kBAAAA,QAAO,WAAW;AACpB,gBAAA,MAAMA,QAAO,SAAS;AACtBA,gBAAAA,QAAO,SAAS;AAElB,cAAA,gBACJ,WAAW,iBAAiB,eAAe;AAC7C,uDAAgBA;AAAAA,MAClB;AAAA,MACA,mBAAmB,CAACA,YAAW;AAChBA,qBAAAA,QAAO,cAAc;AACxBA,kBAAAA,QAAO,WAAW;AAEtB,cAAA,oBACJ,WAAW,qBAAqB,eAAe;AACjD,+DAAoBA;AAAAA,MACtB;AAAA,MACA,UAAU,CAAC,MAAMA,YAAW;AACRA,0BAAAA,QAAO,mBAAmB;AAEtC,cAAA,WAAW,WAAW,YAAY,eAAe;AACvD,6CAAW,MAAMA;AAAAA,MAAM;AAAA,IACzB,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;"}

package/dist/cjs/queuer/createQueuer.d.cts

@@ -39,33 +39,39 @@ export interface SolidQueuer<TValue> extends Omit<Queuer<TValue>, 'getAllItems'
     size: Accessor<number>;
 }
 /**
- * A Solid hook that creates and manages a Queuer instance.
+ * Creates a Solid-compatible Queuer instance for managing a synchronous queue of items, exposing Solid signals for all stateful properties.
  *
- * This is a lower-level hook that provides direct access to the Queuer's functionality without
- * any built-in state management. This allows you to integrate it with any state management solution
- * you prefer (createSignal, Redux, Zustand, etc.) by utilizing the onItemsChange callback.
+ * Features:
+ * - Synchronous processing of items using the provided `fn` function
+ * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior
+ * - Priority queueing via `getPriority` or item `priority` property
+ * - Item expiration and removal of stale items
+ * - Configurable wait time between processing items
+ * - Pause/resume processing
+ * - Callbacks for queue state changes, execution, rejection, and expiration
+ * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity
  *
- * For a hook with built-in state management, see createQueuerSignal.
+ * The queue processes items synchronously in order, with optional delays between each item. When started, it will process one item per tick, with an optional wait time between ticks. You can pause and resume processing with `stop()` and `start()`.
  *
- * The Queuer extends the base Queue to add processing capabilities. Items are processed
- * synchronously in order, with optional delays between processing each item. The queuer includes
- * an internal tick mechanism that can be started and stopped, making it useful as a scheduler.
- * When started, it will process one item per tick, with an optional wait time between ticks.
+ * By default, the queue uses FIFO behavior, but you can configure LIFO or double-ended queueing by specifying the position when adding or removing items.
  *
- * By default uses FIFO (First In First Out) behavior, but can be configured for LIFO
- * (Last In First Out) by specifying 'front' position when adding items.
- *
- * @example
+ * Example usage:
  * ```tsx
- * // Example with custom state management and scheduling
+ * // Example with Solid signals and scheduling
  * const [items, setItems] = createSignal([]);
  *
- * const queue = createQueuer({
- *   started: true, // Start processing immediately
- *   wait: 1000,    // Process one item every second
- *   onItemsChange: (queue) => setItems(queue.getAllItems()),
- *   getPriority: (item) => item.priority // Process higher priority items first
- * });
+ * const queue = createQueuer(
+ *   (item) => {
+ *     // process item synchronously
+ *     console.log('Processing', item);
+ *   },
+ *   {
+ *     started: true, // Start processing immediately
+ *     wait: 1000,    // Process one item every second
+ *     onItemsChange: (queue) => setItems(queue.getAllItems()),
+ *     getPriority: (item) => item.priority // Process higher priority items first
+ *   }
+ * );
  *
  * // Add items to process - they'll be handled automatically
  * queue.addItem('task1');
@@ -83,4 +89,4 @@ export interface SolidQueuer<TValue> extends Omit<Queuer<TValue>, 'getAllItems'
  * console.log('Next item:', queue.peek());
  * ```
  */
-export declare function createQueuer<TValue>(initialOptions?: QueuerOptions<TValue>): SolidQueuer<TValue>;
+export declare function createQueuer<TValue>(fn: (item: TValue) => void, initialOptions?: QueuerOptions<TValue>): SolidQueuer<TValue>;

package/dist/cjs/rate-limiter/createRateLimiter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createRateLimiter.cjs","sources":["../../../src/rate-limiter/createRateLimiter.ts"],"sourcesContent":["import { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'\n\nexport interface SolidRateLimiter<TFn extends AnyFunction>\n  extends Omit<\n    RateLimiter<TFn>,\n    | 'getExecutionCount'\n    | 'getMsUntilNextWindow'\n    | 'getRejectionCount'\n    | 'getRemainingInWindow'\n  > {\n  executionCount: Accessor<number>\n  msUntilNextWindow: Accessor<number>\n  rejectionCount: Accessor<number>\n  remainingInWindow: Accessor<number>\n}\n\n/**\n * A low-level Solid hook that creates a `RateLimiter` instance to enforce rate limits on function execution.\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 \"hard limit\" approach that allows executions until a maximum count is reached within\n * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,\n * it does not attempt to space out or collapse executions intelligently.\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 * For smoother execution patterns:\n * - Use throttling when you want consistent spacing between executions (e.g. UI updates)\n * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)\n * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)\n *\n * @example\n * ```tsx\n * // Basic rate limiting - max 5 calls per minute with a sliding window\n * const rateLimiter = createRateLimiter(apiCall, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Monitor rate limit status\n * const handleClick = () => {\n *   if (rateLimiter.remainingInWindow() > 0) {\n *     rateLimiter.maybeExecute(data);\n *   } else {\n *     showRateLimitWarning();\n *   }\n * };\n *\n * // Access rate limiter state via signals\n * console.log('Executions:', rateLimiter.executionCount());\n * console.log('Rejections:', rateLimiter.rejectionCount());\n * console.log('Remaining:', rateLimiter.remainingInWindow());\n * console.log('Next window in:', rateLimiter.msUntilNextWindow());\n * ```\n */\nexport function createRateLimiter<TFn extends AnyFunction>(\n  fn: TFn,\n  initialOptions: RateLimiterOptions<TFn>,\n): SolidRateLimiter<TFn> {\n  const rateLimiter = bindInstanceMethods(\n    new RateLimiter<TFn>(fn, initialOptions),\n  )\n\n  const [executionCount, setExecutionCount] = createSignal(\n    rateLimiter.getExecutionCount(),\n  )\n  const [rejectionCount, setRejectionCount] = createSignal(\n    rateLimiter.getRejectionCount(),\n  )\n  const [remainingInWindow, setRemainingInWindow] = createSignal(\n    rateLimiter.getRemainingInWindow(),\n  )\n  const [msUntilNextWindow, setMsUntilNextWindow] = createSignal(\n    rateLimiter.getMsUntilNextWindow(),\n  )\n\n  function setOptions(newOptions: Partial<RateLimiterOptions<TFn>>) {\n    rateLimiter.setOptions({\n      ...newOptions,\n      onExecute: (rateLimiter) => {\n        setExecutionCount(rateLimiter.getExecutionCount())\n        setRemainingInWindow(rateLimiter.getRemainingInWindow())\n        setMsUntilNextWindow(rateLimiter.getMsUntilNextWindow())\n\n        const onExecute = newOptions.onExecute ?? initialOptions.onExecute\n        onExecute?.(rateLimiter)\n      },\n      onReject: (rateLimiter) => {\n        setRejectionCount(rateLimiter.getRejectionCount())\n        setRemainingInWindow(rateLimiter.getRemainingInWindow())\n        setMsUntilNextWindow(rateLimiter.getMsUntilNextWindow())\n\n        const onReject = newOptions.onReject ?? initialOptions.onReject\n        onReject?.(rateLimiter)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...rateLimiter,\n    executionCount,\n    rejectionCount,\n    remainingInWindow,\n    msUntilNextWindow,\n    setOptions,\n  } as SolidRateLimiter<TFn>\n}\n"],"names":["rateLimiter","bindInstanceMethods","RateLimiter","createSignal"],"mappings":";;;;;AAmEgB,SAAA,kBACd,IACA,gBACuB;AACvB,QAAMA,gBAAcC,MAAA;AAAA,IAClB,IAAIC,YAAAA,YAAiB,IAAI,cAAc;AAAA,EACzC;AAEM,QAAA,CAAC,gBAAgB,iBAAiB,IAAIC,QAAA;AAAA,IAC1CH,cAAY,kBAAkB;AAAA,EAChC;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAIG,QAAA;AAAA,IAC1CH,cAAY,kBAAkB;AAAA,EAChC;AACM,QAAA,CAAC,mBAAmB,oBAAoB,IAAIG,QAAA;AAAA,IAChDH,cAAY,qBAAqB;AAAA,EACnC;AACM,QAAA,CAAC,mBAAmB,oBAAoB,IAAIG,QAAA;AAAA,IAChDH,cAAY,qBAAqB;AAAA,EACnC;AAEA,WAAS,WAAW,YAA8C;AAChEA,kBAAY,WAAW;AAAA,MACrB,GAAG;AAAA,MACH,WAAW,CAACA,iBAAgB;AACRA,0BAAAA,aAAY,mBAAmB;AAC5BA,6BAAAA,aAAY,sBAAsB;AAClCA,6BAAAA,aAAY,sBAAsB;AAEjD,cAAA,YAAY,WAAW,aAAa,eAAe;AACzD,+CAAYA;AAAAA,MACd;AAAA,MACA,UAAU,CAACA,iBAAgB;AACPA,0BAAAA,aAAY,mBAAmB;AAC5BA,6BAAAA,aAAY,sBAAsB;AAClCA,6BAAAA,aAAY,sBAAsB;AAEjD,cAAA,WAAW,WAAW,YAAY,eAAe;AACvD,6CAAWA;AAAAA,MAAW;AAAA,IACxB,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;"}
+{"version":3,"file":"createRateLimiter.cjs","sources":["../../../src/rate-limiter/createRateLimiter.ts"],"sourcesContent":["import { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'\n\nexport interface SolidRateLimiter<TFn extends AnyFunction>\n  extends Omit<\n    RateLimiter<TFn>,\n    | 'getExecutionCount'\n    | 'getMsUntilNextWindow'\n    | 'getRejectionCount'\n    | 'getRemainingInWindow'\n  > {\n  executionCount: Accessor<number>\n  msUntilNextWindow: Accessor<number>\n  rejectionCount: Accessor<number>\n  remainingInWindow: Accessor<number>\n}\n\n/**\n * A low-level Solid hook that creates a `RateLimiter` instance to enforce rate limits on function execution.\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 \"hard limit\" approach that allows executions until a maximum count is reached within\n * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,\n * it does not attempt to space out or collapse executions intelligently.\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 * For smoother execution patterns:\n * - Use throttling when you want consistent spacing between executions (e.g. UI updates)\n * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)\n * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)\n *\n * @example\n * ```tsx\n * // Basic rate limiting - max 5 calls per minute with a sliding window\n * const rateLimiter = createRateLimiter(apiCall, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding',\n *   onReject: (rateLimiter) => {\n *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access rate limiter state via signals\n * console.log('Executions:', rateLimiter.executionCount());\n * console.log('Rejections:', rateLimiter.rejectionCount());\n * console.log('Remaining:', rateLimiter.remainingInWindow());\n * console.log('Next window in:', rateLimiter.msUntilNextWindow());\n * ```\n */\nexport function createRateLimiter<TFn extends AnyFunction>(\n  fn: TFn,\n  initialOptions: RateLimiterOptions<TFn>,\n): SolidRateLimiter<TFn> {\n  const rateLimiter = bindInstanceMethods(\n    new RateLimiter<TFn>(fn, initialOptions),\n  )\n\n  const [executionCount, setExecutionCount] = createSignal(\n    rateLimiter.getExecutionCount(),\n  )\n  const [rejectionCount, setRejectionCount] = createSignal(\n    rateLimiter.getRejectionCount(),\n  )\n  const [remainingInWindow, setRemainingInWindow] = createSignal(\n    rateLimiter.getRemainingInWindow(),\n  )\n  const [msUntilNextWindow, setMsUntilNextWindow] = createSignal(\n    rateLimiter.getMsUntilNextWindow(),\n  )\n\n  function setOptions(newOptions: Partial<RateLimiterOptions<TFn>>) {\n    rateLimiter.setOptions({\n      ...newOptions,\n      onExecute: (rateLimiter) => {\n        setExecutionCount(rateLimiter.getExecutionCount())\n        setRemainingInWindow(rateLimiter.getRemainingInWindow())\n        setMsUntilNextWindow(rateLimiter.getMsUntilNextWindow())\n\n        const onExecute = newOptions.onExecute ?? initialOptions.onExecute\n        onExecute?.(rateLimiter)\n      },\n      onReject: (rateLimiter) => {\n        setRejectionCount(rateLimiter.getRejectionCount())\n        setRemainingInWindow(rateLimiter.getRemainingInWindow())\n        setMsUntilNextWindow(rateLimiter.getMsUntilNextWindow())\n\n        const onReject = newOptions.onReject ?? initialOptions.onReject\n        onReject?.(rateLimiter)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...rateLimiter,\n    executionCount,\n    rejectionCount,\n    remainingInWindow,\n    msUntilNextWindow,\n    setOptions,\n  } as SolidRateLimiter<TFn>\n}\n"],"names":["rateLimiter","bindInstanceMethods","RateLimiter","createSignal"],"mappings":";;;;;AA6DgB,SAAA,kBACd,IACA,gBACuB;AACvB,QAAMA,gBAAcC,MAAA;AAAA,IAClB,IAAIC,YAAAA,YAAiB,IAAI,cAAc;AAAA,EACzC;AAEM,QAAA,CAAC,gBAAgB,iBAAiB,IAAIC,QAAA;AAAA,IAC1CH,cAAY,kBAAkB;AAAA,EAChC;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAIG,QAAA;AAAA,IAC1CH,cAAY,kBAAkB;AAAA,EAChC;AACM,QAAA,CAAC,mBAAmB,oBAAoB,IAAIG,QAAA;AAAA,IAChDH,cAAY,qBAAqB;AAAA,EACnC;AACM,QAAA,CAAC,mBAAmB,oBAAoB,IAAIG,QAAA;AAAA,IAChDH,cAAY,qBAAqB;AAAA,EACnC;AAEA,WAAS,WAAW,YAA8C;AAChEA,kBAAY,WAAW;AAAA,MACrB,GAAG;AAAA,MACH,WAAW,CAACA,iBAAgB;AACRA,0BAAAA,aAAY,mBAAmB;AAC5BA,6BAAAA,aAAY,sBAAsB;AAClCA,6BAAAA,aAAY,sBAAsB;AAEjD,cAAA,YAAY,WAAW,aAAa,eAAe;AACzD,+CAAYA;AAAAA,MACd;AAAA,MACA,UAAU,CAACA,iBAAgB;AACPA,0BAAAA,aAAY,mBAAmB;AAC5BA,6BAAAA,aAAY,sBAAsB;AAClCA,6BAAAA,aAAY,sBAAsB;AAEjD,cAAA,WAAW,WAAW,YAAY,eAAe;AACvD,6CAAWA;AAAAA,MAAW;AAAA,IACxB,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAGA;AAAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;"}

package/dist/cjs/rate-limiter/createRateLimiter.d.cts

@@ -34,17 +34,11 @@ export interface SolidRateLimiter<TFn extends AnyFunction> extends Omit<RateLimi
  * const rateLimiter = createRateLimiter(apiCall, {
  *   limit: 5,
  *   window: 60000,
- *   windowType: 'sliding'
- * });
- *
- * // Monitor rate limit status
- * const handleClick = () => {
- *   if (rateLimiter.remainingInWindow() > 0) {
- *     rateLimiter.maybeExecute(data);
- *   } else {
- *     showRateLimitWarning();
+ *   windowType: 'sliding',
+ *   onReject: (rateLimiter) => {
+ *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);
  *   }
- * };
+ * });
  *
  * // Access rate limiter state via signals
  * console.log('Executions:', rateLimiter.executionCount());

package/dist/esm/async-debouncer/createAsyncDebouncer.d.ts

@@ -15,8 +15,22 @@ export interface SolidAsyncDebouncer<TFn extends AnyAsyncFunction> extends Omit<
  * you can integrate with any state management solution (createSignal, etc).
  *
  * Async debouncing ensures that an async function only executes after a specified delay has passed since its last invocation.
- * This is useful for handling fast-changing inputs like search fields, form validation, or any scenario where you want to
- * wait for user input to settle before making expensive async calls.
+ * Each new invocation resets the delay timer. This is useful for handling frequent events like window resizing
+ * or input changes where you only want to execute the handler after the events have stopped occurring.
+ *
+ * Unlike throttling which allows execution at regular intervals, debouncing prevents any execution until
+ * the function stops being called for the specified delay period.
+ *
+ * Unlike the non-async Debouncer, this async version supports returning values from the debounced function,
+ * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call
+ * instead of setting the result on a state variable from within the debounced function.
+ *
+ * Error Handling:
+ * - If an `onError` handler is provided, it will be called with the error and debouncer instance
+ * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown
+ * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed
+ * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown
+ * - The error state can be checked using the underlying AsyncDebouncer instance
  *
  * @example
  * ```tsx
@@ -38,6 +52,11 @@ export interface SolidAsyncDebouncer<TFn extends AnyAsyncFunction> extends Omit<
  *   },
  *   {
  *     wait: 300,
+ *     leading: true,   // Execute immediately on first call
+ *     trailing: false, // Skip trailing edge updates
+ *     onError: (error) => {
+ *       console.error('API call failed:', error);
+ *     }
  *   }
  * );
  * ```

package/dist/esm/async-debouncer/createAsyncDebouncer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createAsyncDebouncer.js","sources":["../../../src/async-debouncer/createAsyncDebouncer.ts"],"sourcesContent":["import { AsyncDebouncer } from '@tanstack/pacer/async-debouncer'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { AsyncDebouncerOptions } from '@tanstack/pacer/async-debouncer'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type { Accessor } from 'solid-js'\n\nexport interface SolidAsyncDebouncer<TFn extends AnyAsyncFunction>\n  extends Omit<\n    AsyncDebouncer<TFn>,\n    | 'getErrorCount'\n    | 'getIsPending'\n    | 'getLastResult'\n    | 'getSettleCount'\n    | 'getSuccessCount'\n  > {\n  errorCount: Accessor<number>\n  isPending: Accessor<boolean>\n  lastResult: Accessor<ReturnType<TFn> | undefined>\n  settleCount: Accessor<number>\n  successCount: Accessor<number>\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 * This is useful for handling fast-changing inputs like search fields, form validation, or any scenario where you want to\n * wait for user input to settle before making expensive async calls.\n *\n * @example\n * ```tsx\n * // Basic API call debouncing\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 * // With state management\n * const [results, setResults] = createSignal([]);\n * const { maybeExecute } = createAsyncDebouncer(\n *   async (searchTerm) => {\n *     const data = await searchAPI(searchTerm);\n *     setResults(data);\n *   },\n *   {\n *     wait: 300,\n *   }\n * );\n * ```\n */\n\nexport function createAsyncDebouncer<TFn extends AnyAsyncFunction>(\n  fn: TFn,\n  initialOptions: AsyncDebouncerOptions<TFn>,\n): SolidAsyncDebouncer<TFn> {\n  const asyncDebouncer = new AsyncDebouncer<TFn>(fn, initialOptions)\n\n  const [errorCount, setErrorCount] = createSignal(\n    asyncDebouncer.getErrorCount(),\n  )\n  const [settleCount, setSettleCount] = createSignal(\n    asyncDebouncer.getSettleCount(),\n  )\n  const [successCount, setSuccessCount] = createSignal(\n    asyncDebouncer.getSuccessCount(),\n  )\n  const [isPending, setIsPending] = createSignal(asyncDebouncer.getIsPending())\n  const [lastResult, setLastResult] = createSignal(\n    asyncDebouncer.getLastResult(),\n  )\n\n  function setOptions(newOptions: Partial<AsyncDebouncerOptions<TFn>>) {\n    asyncDebouncer.setOptions({\n      ...newOptions,\n      onSettled: (asyncDebouncer) => {\n        setSuccessCount(asyncDebouncer.getSuccessCount())\n        setErrorCount(asyncDebouncer.getErrorCount())\n        setSettleCount(asyncDebouncer.getSettleCount())\n        setIsPending(asyncDebouncer.getIsPending())\n        setLastResult(asyncDebouncer.getLastResult())\n        const onSettled = newOptions.onSettled ?? initialOptions.onSettled\n        onSettled?.(asyncDebouncer)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...bindInstanceMethods(asyncDebouncer),\n    errorCount,\n    isPending,\n    lastResult,\n    settleCount,\n    successCount,\n    setOptions,\n  } as SolidAsyncDebouncer<TFn>\n}\n"],"names":["asyncDebouncer"],"mappings":";;;AA0DgB,SAAA,qBACd,IACA,gBAC0B;AAC1B,QAAM,iBAAiB,IAAI,eAAoB,IAAI,cAAc;AAE3D,QAAA,CAAC,YAAY,aAAa,IAAI;AAAA,IAClC,eAAe,cAAc;AAAA,EAC/B;AACM,QAAA,CAAC,aAAa,cAAc,IAAI;AAAA,IACpC,eAAe,eAAe;AAAA,EAChC;AACM,QAAA,CAAC,cAAc,eAAe,IAAI;AAAA,IACtC,eAAe,gBAAgB;AAAA,EACjC;AACA,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,eAAe,cAAc;AACtE,QAAA,CAAC,YAAY,aAAa,IAAI;AAAA,IAClC,eAAe,cAAc;AAAA,EAC/B;AAEA,WAAS,WAAW,YAAiD;AACnE,mBAAe,WAAW;AAAA,MACxB,GAAG;AAAA,MACH,WAAW,CAACA,oBAAmB;AACbA,wBAAAA,gBAAe,iBAAiB;AAClCA,sBAAAA,gBAAe,eAAe;AAC7BA,uBAAAA,gBAAe,gBAAgB;AACjCA,qBAAAA,gBAAe,cAAc;AAC5BA,sBAAAA,gBAAe,eAAe;AACtC,cAAA,YAAY,WAAW,aAAa,eAAe;AACzD,+CAAYA;AAAAA,MAAc;AAAA,IAC5B,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAG,oBAAoB,cAAc;AAAA,IACrC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}
+{"version":3,"file":"createAsyncDebouncer.js","sources":["../../../src/async-debouncer/createAsyncDebouncer.ts"],"sourcesContent":["import { AsyncDebouncer } from '@tanstack/pacer/async-debouncer'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { AsyncDebouncerOptions } from '@tanstack/pacer/async-debouncer'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type { Accessor } from 'solid-js'\n\nexport interface SolidAsyncDebouncer<TFn extends AnyAsyncFunction>\n  extends Omit<\n    AsyncDebouncer<TFn>,\n    | 'getErrorCount'\n    | 'getIsPending'\n    | 'getLastResult'\n    | 'getSettleCount'\n    | 'getSuccessCount'\n  > {\n  errorCount: Accessor<number>\n  isPending: Accessor<boolean>\n  lastResult: Accessor<ReturnType<TFn> | undefined>\n  settleCount: Accessor<number>\n  successCount: Accessor<number>\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 * @example\n * ```tsx\n * // Basic API call debouncing\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 * // With state management\n * const [results, setResults] = createSignal([]);\n * const { maybeExecute } = createAsyncDebouncer(\n *   async (searchTerm) => {\n *     const data = await searchAPI(searchTerm);\n *     setResults(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 * );\n * ```\n */\nexport function createAsyncDebouncer<TFn extends AnyAsyncFunction>(\n  fn: TFn,\n  initialOptions: AsyncDebouncerOptions<TFn>,\n): SolidAsyncDebouncer<TFn> {\n  const asyncDebouncer = new AsyncDebouncer<TFn>(fn, initialOptions)\n\n  const [errorCount, setErrorCount] = createSignal(\n    asyncDebouncer.getErrorCount(),\n  )\n  const [settleCount, setSettleCount] = createSignal(\n    asyncDebouncer.getSettleCount(),\n  )\n  const [successCount, setSuccessCount] = createSignal(\n    asyncDebouncer.getSuccessCount(),\n  )\n  const [isPending, setIsPending] = createSignal(asyncDebouncer.getIsPending())\n  const [lastResult, setLastResult] = createSignal(\n    asyncDebouncer.getLastResult(),\n  )\n\n  function setOptions(newOptions: Partial<AsyncDebouncerOptions<TFn>>) {\n    asyncDebouncer.setOptions({\n      ...newOptions,\n      onSettled: (asyncDebouncer) => {\n        setSuccessCount(asyncDebouncer.getSuccessCount())\n        setErrorCount(asyncDebouncer.getErrorCount())\n        setSettleCount(asyncDebouncer.getSettleCount())\n        setIsPending(asyncDebouncer.getIsPending())\n        setLastResult(asyncDebouncer.getLastResult())\n        const onSettled = newOptions.onSettled ?? initialOptions.onSettled\n        onSettled?.(asyncDebouncer)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...bindInstanceMethods(asyncDebouncer),\n    errorCount,\n    isPending,\n    lastResult,\n    settleCount,\n    successCount,\n    setOptions,\n  } as SolidAsyncDebouncer<TFn>\n}\n"],"names":["asyncDebouncer"],"mappings":";;;AA4EgB,SAAA,qBACd,IACA,gBAC0B;AAC1B,QAAM,iBAAiB,IAAI,eAAoB,IAAI,cAAc;AAE3D,QAAA,CAAC,YAAY,aAAa,IAAI;AAAA,IAClC,eAAe,cAAc;AAAA,EAC/B;AACM,QAAA,CAAC,aAAa,cAAc,IAAI;AAAA,IACpC,eAAe,eAAe;AAAA,EAChC;AACM,QAAA,CAAC,cAAc,eAAe,IAAI;AAAA,IACtC,eAAe,gBAAgB;AAAA,EACjC;AACA,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,eAAe,cAAc;AACtE,QAAA,CAAC,YAAY,aAAa,IAAI;AAAA,IAClC,eAAe,cAAc;AAAA,EAC/B;AAEA,WAAS,WAAW,YAAiD;AACnE,mBAAe,WAAW;AAAA,MACxB,GAAG;AAAA,MACH,WAAW,CAACA,oBAAmB;AACbA,wBAAAA,gBAAe,iBAAiB;AAClCA,sBAAAA,gBAAe,eAAe;AAC7BA,uBAAAA,gBAAe,gBAAgB;AACjCA,qBAAAA,gBAAe,cAAc;AAC5BA,sBAAAA,gBAAe,eAAe;AACtC,cAAA,YAAY,WAAW,aAAa,eAAe;AACzD,+CAAYA;AAAAA,MAAc;AAAA,IAC5B,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAG,oBAAoB,cAAc;AAAA,IACrC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}

package/dist/esm/async-queuer/createAsyncQueuer.d.ts

@@ -1,18 +1,18 @@
 import { AsyncQueuer, AsyncQueuerOptions } from '@tanstack/pacer/async-queuer';
 import { Accessor } from 'solid-js';
-export interface SolidAsyncQueuer<TValue> extends Omit<AsyncQueuer<TValue>, 'getActiveItems' | 'getAllItems' | 'getExecutionCount' | 'getIsEmpty' | 'getIsFull' | 'getIsIdle' | 'getIsRunning' | 'getPeek' | 'getPendingItems' | 'getSize'> {
+export interface SolidAsyncQueuer<TValue> extends Omit<AsyncQueuer<TValue>, 'getActiveItems' | 'getAllItems' | 'getErrorCount' | 'getIsEmpty' | 'getIsFull' | 'getIsIdle' | 'getIsRunning' | 'getPeek' | 'getPendingItems' | 'getRejectionCount' | 'getSettledCount' | 'getSize' | 'getSuccessCount'> {
     /**
      * Signal version of `getActiveItems`
      */
-    activeItems: Accessor<Array<() => Promise<TValue>>>;
+    activeItems: Accessor<Array<TValue>>;
     /**
      * Signal version of `getAllItems`
      */
-    allItems: Accessor<Array<() => Promise<TValue>>>;
+    allItems: Accessor<Array<TValue>>;
     /**
-     * Signal version of `getExecutionCount`
+     * Signal version of `getErrorCount`
      */
-    executionCount: Accessor<number>;
+    errorCount: Accessor<number>;
     /**
      * Signal version of `getIsEmpty`
      */
@@ -32,47 +32,68 @@ export interface SolidAsyncQueuer<TValue> extends Omit<AsyncQueuer<TValue>, 'get
     /**
      * Signal version of `getPeek`
      */
-    peek: Accessor<(() => Promise<TValue>) | undefined>;
+    peek: Accessor<TValue | undefined>;
     /**
      * Signal version of `getPendingItems`
      */
-    pendingItems: Accessor<Array<() => Promise<TValue>>>;
+    pendingItems: Accessor<Array<TValue>>;
     /**
      * Signal version of `getRejectionCount`
      */
     rejectionCount: Accessor<number>;
+    /**
+     * Signal version of `getSettledCount`
+     */
+    settledCount: Accessor<number>;
     /**
      * Signal version of `getSize`
      */
     size: Accessor<number>;
+    /**
+     * Signal version of `getSuccessCount`
+     */
+    successCount: Accessor<number>;
 }
 /**
- * A lower-level React hook that creates an `AsyncQueuer` instance for managing an async queue of items.
+ * Creates a Solid-compatible AsyncQueuer instance for managing an asynchronous queue of items, exposing Solid signals for all stateful properties.
  *
- * This hook provides a flexible, state-management agnostic way to handle queued async operations.
- * It returns a queuer instance with methods to add items, control queue execution, and monitor queue state.
+ * Features:
+ * - Priority queueing via `getPriority` or item `priority` property
+ * - Configurable concurrency limit
+ * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior
+ * - Pause/resume processing
+ * - Task cancellation
+ * - Item expiration
+ * - Lifecycle callbacks for success, error, settled, items change, etc.
+ * - All stateful properties (active items, pending items, counts, etc.) are exposed as Solid signals for reactivity
  *
- * The queue can be configured with:
- * - Maximum concurrent operations
- * - Maximum queue size
- * - Processing function for queue items
- * - Various lifecycle callbacks
+ * Tasks are processed concurrently up to the configured concurrency limit. When a task completes,
+ * the next pending task is processed if the concurrency limit allows.
  *
- * The hook returns an object containing methods to:
- * - Add/remove items from the queue
- * - Start/stop queue processing
- * - Get queue status and items
- * - Register event handlers
- * - Control execution throttling
+ * Error Handling:
+ * - If an `onError` handler is provided, it will be called with the error and queuer instance
+ * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown
+ * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed
+ * - Both onError and throwOnError can be used together; the handler will be called before any error is thrown
+ * - The error state can be checked using the underlying AsyncQueuer instance
  *
- * @example
+ * Example usage:
  * ```tsx
  * // Basic async queuer for API requests
- * const asyncQueuer = createAsyncQueuer({
+ * const asyncQueuer = createAsyncQueuer(async (item) => {
+ *   // process item
+ *   return await fetchData(item);
+ * }, {
  *   initialItems: [],
  *   concurrency: 2,
  *   maxSize: 100,
  *   started: false,
+ *   onSuccess: (result) => {
+ *     console.log('Item processed:', result);
+ *   },
+ *   onError: (error) => {
+ *     console.error('Processing failed:', error);
+ *   }
  * });
  *
  * // Add items to queue
@@ -81,14 +102,8 @@ export interface SolidAsyncQueuer<TValue> extends Omit<AsyncQueuer<TValue>, 'get
  * // Start processing
  * asyncQueuer.start();
  *
- * // Handle results
- * asyncQueuer.onSuccess((result) => {
- *   console.log('Item processed:', result);
- * });
- *
- * asyncQueuer.onError((error) => {
- *   console.error('Processing failed:', error);
- * });
+ * // Use Solid signals in your UI
+ * const pending = asyncQueuer.pendingItems();
  * ```
  */
-export declare function createAsyncQueuer<TValue>(initialOptions?: AsyncQueuerOptions<TValue>): SolidAsyncQueuer<TValue>;
+export declare function createAsyncQueuer<TValue>(fn: (value: TValue) => Promise<any>, initialOptions?: AsyncQueuerOptions<TValue>): SolidAsyncQueuer<TValue>;

package/dist/esm/async-queuer/createAsyncQueuer.js

@@ -1,10 +1,14 @@
 import { AsyncQueuer } from "@tanstack/pacer/async-queuer";
 import { createSignal } from "solid-js";
 import { bindInstanceMethods } from "@tanstack/pacer/utils";
-function createAsyncQueuer(initialOptions = {}) {
-  const asyncQueuer = new AsyncQueuer(initialOptions);
-  const [executionCount, setExecutionCount] = createSignal(
-    asyncQueuer.getExecutionCount()
+function createAsyncQueuer(fn, initialOptions = {}) {
+  const asyncQueuer = new AsyncQueuer(fn, initialOptions);
+  const [successCount, setSuccessCount] = createSignal(
+    asyncQueuer.getSuccessCount()
+  );
+  const [errorCount, setErrorCount] = createSignal(asyncQueuer.getErrorCount());
+  const [settledCount, setSettledCount] = createSignal(
+    asyncQueuer.getSettledCount()
   );
   const [rejectionCount, setRejectionCount] = createSignal(
     asyncQueuer.getRejectionCount()
@@ -16,8 +20,12 @@ function createAsyncQueuer(initialOptions = {}) {
   const [allItems, setAllItems] = createSignal(
     asyncQueuer.getAllItems()
   );
-  const [activeItems, setActiveItems] = createSignal(asyncQueuer.getActiveItems());
-  const [pendingItems, setPendingItems] = createSignal(asyncQueuer.getPendingItems());
+  const [activeItems, setActiveItems] = createSignal(
+    asyncQueuer.getActiveItems()
+  );
+  const [pendingItems, setPendingItems] = createSignal(
+    asyncQueuer.getPendingItems()
+  );
   const [peek, setPeek] = createSignal(
     asyncQueuer.getPeek()
   );
@@ -25,15 +33,18 @@ function createAsyncQueuer(initialOptions = {}) {
   asyncQueuer.setOptions({
     onItemsChange: (queuer) => {
       var _a;
-      setExecutionCount(queuer.getExecutionCount());
+      setActiveItems(queuer.getActiveItems());
+      setAllItems(queuer.getAllItems());
+      setErrorCount(queuer.getErrorCount());
       setIsEmpty(queuer.getIsEmpty());
       setIsFull(queuer.getIsFull());
       setIsIdle(queuer.getIsIdle());
-      setAllItems(queuer.getAllItems());
-      setActiveItems(queuer.getActiveItems());
-      setPendingItems(queuer.getPendingItems());
       setPeek(() => queuer.getPeek());
+      setPendingItems(queuer.getPendingItems());
+      setRejectionCount(queuer.getRejectionCount());
+      setSettledCount(queuer.getSettledCount());
       setSize(queuer.getSize());
+      setSuccessCount(queuer.getSuccessCount());
       (_a = initialOptions.onItemsChange) == null ? void 0 : _a.call(initialOptions, queuer);
     },
     onIsRunningChange: (queuer) => {
@@ -51,16 +62,18 @@ function createAsyncQueuer(initialOptions = {}) {
   return {
     ...bindInstanceMethods(asyncQueuer),
     activeItems,
-    executionCount,
+    allItems,
+    errorCount,
     isEmpty,
     isFull,
     isIdle,
     isRunning,
-    allItems,
     peek,
     pendingItems,
     rejectionCount,
-    size
+    settledCount,
+    size,
+    successCount
   };
 }
 export {

package/dist/esm/async-queuer/createAsyncQueuer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createAsyncQueuer.js","sources":["../../../src/async-queuer/createAsyncQueuer.ts"],"sourcesContent":["import { AsyncQueuer } from '@tanstack/pacer/async-queuer'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { AsyncQueuerOptions } from '@tanstack/pacer/async-queuer'\n\nexport interface SolidAsyncQueuer<TValue>\n  extends Omit<\n    AsyncQueuer<TValue>,\n    | 'getActiveItems'\n    | 'getAllItems'\n    | 'getExecutionCount'\n    | 'getIsEmpty'\n    | 'getIsFull'\n    | 'getIsIdle'\n    | 'getIsRunning'\n    | 'getPeek'\n    | 'getPendingItems'\n    | 'getSize'\n  > {\n  /**\n   * Signal version of `getActiveItems`\n   */\n  activeItems: Accessor<Array<() => Promise<TValue>>>\n  /**\n   * Signal version of `getAllItems`\n   */\n  allItems: Accessor<Array<() => Promise<TValue>>>\n  /**\n   * Signal version of `getExecutionCount`\n   */\n  executionCount: Accessor<number>\n  /**\n   * Signal version of `getIsEmpty`\n   */\n  isEmpty: Accessor<boolean>\n  /**\n   * Signal version of `getIsFull`\n   */\n  isFull: Accessor<boolean>\n  /**\n   * Signal version of `getIsIdle`\n   */\n  isIdle: Accessor<boolean>\n  /**\n   * Signal version of `getIsRunning`\n   */\n  isRunning: Accessor<boolean>\n  /**\n   * Signal version of `getPeek`\n   */\n  peek: Accessor<(() => Promise<TValue>) | undefined>\n  /**\n   * Signal version of `getPendingItems`\n   */\n  pendingItems: Accessor<Array<() => Promise<TValue>>>\n  /**\n   * Signal version of `getRejectionCount`\n   */\n  rejectionCount: Accessor<number>\n  /**\n   * Signal version of `getSize`\n   */\n  size: Accessor<number>\n}\n\n/**\n * A lower-level React hook that creates an `AsyncQueuer` instance for managing an async queue of items.\n *\n * This hook provides a flexible, state-management agnostic way to handle queued async operations.\n * It returns a queuer instance with methods to add items, control queue execution, and monitor queue state.\n *\n * The queue can be configured with:\n * - Maximum concurrent operations\n * - Maximum queue size\n * - Processing function for queue items\n * - Various lifecycle callbacks\n *\n * The hook returns an object containing methods to:\n * - Add/remove items from the queue\n * - Start/stop queue processing\n * - Get queue status and items\n * - Register event handlers\n * - Control execution throttling\n *\n * @example\n * ```tsx\n * // Basic async queuer for API requests\n * const asyncQueuer = createAsyncQueuer({\n *   initialItems: [],\n *   concurrency: 2,\n *   maxSize: 100,\n *   started: false,\n * });\n *\n * // Add items to queue\n * asyncQueuer.addItem(newItem);\n *\n * // Start processing\n * asyncQueuer.start();\n *\n * // Handle results\n * asyncQueuer.onSuccess((result) => {\n *   console.log('Item processed:', result);\n * });\n *\n * asyncQueuer.onError((error) => {\n *   console.error('Processing failed:', error);\n * });\n * ```\n */\nexport function createAsyncQueuer<TValue>(\n  initialOptions: AsyncQueuerOptions<TValue> = {},\n): SolidAsyncQueuer<TValue> {\n  const asyncQueuer = new AsyncQueuer<TValue>(initialOptions)\n\n  const [executionCount, setExecutionCount] = createSignal(\n    asyncQueuer.getExecutionCount(),\n  )\n  const [rejectionCount, setRejectionCount] = createSignal(\n    asyncQueuer.getRejectionCount(),\n  )\n  const [isEmpty, setIsEmpty] = createSignal(asyncQueuer.getIsEmpty())\n  const [isFull, setIsFull] = createSignal(asyncQueuer.getIsFull())\n  const [isIdle, setIsIdle] = createSignal(asyncQueuer.getIsIdle())\n  const [isRunning, setIsRunning] = createSignal(asyncQueuer.getIsRunning())\n  const [allItems, setAllItems] = createSignal<Array<() => Promise<TValue>>>(\n    asyncQueuer.getAllItems(),\n  )\n  const [activeItems, setActiveItems] = createSignal<\n    Array<() => Promise<TValue>>\n  >(asyncQueuer.getActiveItems())\n  const [pendingItems, setPendingItems] = createSignal<\n    Array<() => Promise<TValue>>\n  >(asyncQueuer.getPendingItems())\n  const [peek, setPeek] = createSignal<(() => Promise<TValue>) | undefined>(\n    asyncQueuer.getPeek(),\n  )\n  const [size, setSize] = createSignal(asyncQueuer.getSize())\n\n  asyncQueuer.setOptions({\n    onItemsChange: (queuer) => {\n      setExecutionCount(queuer.getExecutionCount())\n      setIsEmpty(queuer.getIsEmpty())\n      setIsFull(queuer.getIsFull())\n      setIsIdle(queuer.getIsIdle())\n      setAllItems(queuer.getAllItems())\n      setActiveItems(queuer.getActiveItems())\n      setPendingItems(queuer.getPendingItems())\n      setPeek(() => queuer.getPeek())\n      setSize(queuer.getSize())\n      initialOptions.onItemsChange?.(queuer)\n    },\n    onIsRunningChange: (queuer) => {\n      setIsRunning(queuer.getIsRunning())\n      setIsIdle(queuer.getIsIdle())\n      initialOptions.onIsRunningChange?.(queuer)\n    },\n    onReject: (item, queuer) => {\n      setRejectionCount(queuer.getRejectionCount())\n      initialOptions.onReject?.(item, queuer)\n    },\n  })\n\n  return {\n    ...bindInstanceMethods(asyncQueuer),\n    activeItems,\n    executionCount,\n    isEmpty,\n    isFull,\n    isIdle,\n    isRunning,\n    allItems,\n    peek,\n    pendingItems,\n    rejectionCount,\n    size,\n  } as SolidAsyncQueuer<TValue>\n}\n"],"names":[],"mappings":";;;AA+GgB,SAAA,kBACd,iBAA6C,IACnB;AACpB,QAAA,cAAc,IAAI,YAAoB,cAAc;AAEpD,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,YAAY,kBAAkB;AAAA,EAChC;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,YAAY,kBAAkB;AAAA,EAChC;AACA,QAAM,CAAC,SAAS,UAAU,IAAI,aAAa,YAAY,YAAY;AACnE,QAAM,CAAC,QAAQ,SAAS,IAAI,aAAa,YAAY,WAAW;AAChE,QAAM,CAAC,QAAQ,SAAS,IAAI,aAAa,YAAY,WAAW;AAChE,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,YAAY,cAAc;AACnE,QAAA,CAAC,UAAU,WAAW,IAAI;AAAA,IAC9B,YAAY,YAAY;AAAA,EAC1B;AACA,QAAM,CAAC,aAAa,cAAc,IAAI,aAEpC,YAAY,gBAAgB;AAC9B,QAAM,CAAC,cAAc,eAAe,IAAI,aAEtC,YAAY,iBAAiB;AACzB,QAAA,CAAC,MAAM,OAAO,IAAI;AAAA,IACtB,YAAY,QAAQ;AAAA,EACtB;AACA,QAAM,CAAC,MAAM,OAAO,IAAI,aAAa,YAAY,SAAS;AAE1D,cAAY,WAAW;AAAA,IACrB,eAAe,CAAC,WAAW;;AACP,wBAAA,OAAO,mBAAmB;AACjC,iBAAA,OAAO,YAAY;AACpB,gBAAA,OAAO,WAAW;AAClB,gBAAA,OAAO,WAAW;AAChB,kBAAA,OAAO,aAAa;AACjB,qBAAA,OAAO,gBAAgB;AACtB,sBAAA,OAAO,iBAAiB;AAChC,cAAA,MAAM,OAAO,SAAS;AACtB,cAAA,OAAO,SAAS;AACxB,2BAAe,kBAAf,wCAA+B;AAAA,IACjC;AAAA,IACA,mBAAmB,CAAC,WAAW;;AAChB,mBAAA,OAAO,cAAc;AACxB,gBAAA,OAAO,WAAW;AAC5B,2BAAe,sBAAf,wCAAmC;AAAA,IACrC;AAAA,IACA,UAAU,CAAC,MAAM,WAAW;;AACR,wBAAA,OAAO,mBAAmB;AAC7B,2BAAA,aAAA,wCAAW,MAAM;AAAA,IAAM;AAAA,EACxC,CACD;AAEM,SAAA;AAAA,IACL,GAAG,oBAAoB,WAAW;AAAA,IAClC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}
+{"version":3,"file":"createAsyncQueuer.js","sources":["../../../src/async-queuer/createAsyncQueuer.ts"],"sourcesContent":["import { AsyncQueuer } from '@tanstack/pacer/async-queuer'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { AsyncQueuerOptions } from '@tanstack/pacer/async-queuer'\n\nexport interface SolidAsyncQueuer<TValue>\n  extends Omit<\n    AsyncQueuer<TValue>,\n    | 'getActiveItems'\n    | 'getAllItems'\n    | 'getErrorCount'\n    | 'getIsEmpty'\n    | 'getIsFull'\n    | 'getIsIdle'\n    | 'getIsRunning'\n    | 'getPeek'\n    | 'getPendingItems'\n    | 'getRejectionCount'\n    | 'getSettledCount'\n    | 'getSize'\n    | 'getSuccessCount'\n  > {\n  /**\n   * Signal version of `getActiveItems`\n   */\n  activeItems: Accessor<Array<TValue>>\n  /**\n   * Signal version of `getAllItems`\n   */\n  allItems: Accessor<Array<TValue>>\n  /**\n   * Signal version of `getErrorCount`\n   */\n  errorCount: Accessor<number>\n  /**\n   * Signal version of `getIsEmpty`\n   */\n  isEmpty: Accessor<boolean>\n  /**\n   * Signal version of `getIsFull`\n   */\n  isFull: Accessor<boolean>\n  /**\n   * Signal version of `getIsIdle`\n   */\n  isIdle: Accessor<boolean>\n  /**\n   * Signal version of `getIsRunning`\n   */\n  isRunning: Accessor<boolean>\n  /**\n   * Signal version of `getPeek`\n   */\n  peek: Accessor<TValue | undefined>\n  /**\n   * Signal version of `getPendingItems`\n   */\n  pendingItems: Accessor<Array<TValue>>\n  /**\n   * Signal version of `getRejectionCount`\n   */\n  rejectionCount: Accessor<number>\n  /**\n   * Signal version of `getSettledCount`\n   */\n  settledCount: Accessor<number>\n  /**\n   * Signal version of `getSize`\n   */\n  size: Accessor<number>\n  /**\n   * Signal version of `getSuccessCount`\n   */\n  successCount: Accessor<number>\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 * Example usage:\n * ```tsx\n * // Basic async queuer for API requests\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 * // Add items to queue\n * asyncQueuer.addItem(newItem);\n *\n * // Start processing\n * asyncQueuer.start();\n *\n * // Use Solid signals in your UI\n * const pending = asyncQueuer.pendingItems();\n * ```\n */\nexport function createAsyncQueuer<TValue>(\n  fn: (value: TValue) => Promise<any>,\n  initialOptions: AsyncQueuerOptions<TValue> = {},\n): SolidAsyncQueuer<TValue> {\n  const asyncQueuer = new AsyncQueuer<TValue>(fn, initialOptions)\n\n  const [successCount, setSuccessCount] = createSignal(\n    asyncQueuer.getSuccessCount(),\n  )\n  const [errorCount, setErrorCount] = createSignal(asyncQueuer.getErrorCount())\n  const [settledCount, setSettledCount] = createSignal(\n    asyncQueuer.getSettledCount(),\n  )\n  const [rejectionCount, setRejectionCount] = createSignal(\n    asyncQueuer.getRejectionCount(),\n  )\n  const [isEmpty, setIsEmpty] = createSignal(asyncQueuer.getIsEmpty())\n  const [isFull, setIsFull] = createSignal(asyncQueuer.getIsFull())\n  const [isIdle, setIsIdle] = createSignal(asyncQueuer.getIsIdle())\n  const [isRunning, setIsRunning] = createSignal(asyncQueuer.getIsRunning())\n  const [allItems, setAllItems] = createSignal<Array<TValue>>(\n    asyncQueuer.getAllItems(),\n  )\n  const [activeItems, setActiveItems] = createSignal<Array<TValue>>(\n    asyncQueuer.getActiveItems(),\n  )\n  const [pendingItems, setPendingItems] = createSignal<Array<TValue>>(\n    asyncQueuer.getPendingItems(),\n  )\n  const [peek, setPeek] = createSignal<TValue | undefined>(\n    asyncQueuer.getPeek(),\n  )\n  const [size, setSize] = createSignal(asyncQueuer.getSize())\n\n  asyncQueuer.setOptions({\n    onItemsChange: (queuer) => {\n      setActiveItems(queuer.getActiveItems())\n      setAllItems(queuer.getAllItems())\n      setErrorCount(queuer.getErrorCount())\n      setIsEmpty(queuer.getIsEmpty())\n      setIsFull(queuer.getIsFull())\n      setIsIdle(queuer.getIsIdle())\n      setPeek(() => queuer.getPeek())\n      setPendingItems(queuer.getPendingItems())\n      setRejectionCount(queuer.getRejectionCount())\n      setSettledCount(queuer.getSettledCount())\n      setSize(queuer.getSize())\n      setSuccessCount(queuer.getSuccessCount())\n      initialOptions.onItemsChange?.(queuer)\n    },\n    onIsRunningChange: (queuer) => {\n      setIsRunning(queuer.getIsRunning())\n      setIsIdle(queuer.getIsIdle())\n      initialOptions.onIsRunningChange?.(queuer)\n    },\n    onReject: (item, queuer) => {\n      setRejectionCount(queuer.getRejectionCount())\n      initialOptions.onReject?.(item, queuer)\n    },\n  })\n\n  return {\n    ...bindInstanceMethods(asyncQueuer),\n    activeItems,\n    allItems,\n    errorCount,\n    isEmpty,\n    isFull,\n    isIdle,\n    isRunning,\n    peek,\n    pendingItems,\n    rejectionCount,\n    settledCount,\n    size,\n    successCount,\n  } as SolidAsyncQueuer<TValue>\n}\n"],"names":[],"mappings":";;;AAiIO,SAAS,kBACd,IACA,iBAA6C,IACnB;AAC1B,QAAM,cAAc,IAAI,YAAoB,IAAI,cAAc;AAExD,QAAA,CAAC,cAAc,eAAe,IAAI;AAAA,IACtC,YAAY,gBAAgB;AAAA,EAC9B;AACA,QAAM,CAAC,YAAY,aAAa,IAAI,aAAa,YAAY,eAAe;AACtE,QAAA,CAAC,cAAc,eAAe,IAAI;AAAA,IACtC,YAAY,gBAAgB;AAAA,EAC9B;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,YAAY,kBAAkB;AAAA,EAChC;AACA,QAAM,CAAC,SAAS,UAAU,IAAI,aAAa,YAAY,YAAY;AACnE,QAAM,CAAC,QAAQ,SAAS,IAAI,aAAa,YAAY,WAAW;AAChE,QAAM,CAAC,QAAQ,SAAS,IAAI,aAAa,YAAY,WAAW;AAChE,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,YAAY,cAAc;AACnE,QAAA,CAAC,UAAU,WAAW,IAAI;AAAA,IAC9B,YAAY,YAAY;AAAA,EAC1B;AACM,QAAA,CAAC,aAAa,cAAc,IAAI;AAAA,IACpC,YAAY,eAAe;AAAA,EAC7B;AACM,QAAA,CAAC,cAAc,eAAe,IAAI;AAAA,IACtC,YAAY,gBAAgB;AAAA,EAC9B;AACM,QAAA,CAAC,MAAM,OAAO,IAAI;AAAA,IACtB,YAAY,QAAQ;AAAA,EACtB;AACA,QAAM,CAAC,MAAM,OAAO,IAAI,aAAa,YAAY,SAAS;AAE1D,cAAY,WAAW;AAAA,IACrB,eAAe,CAAC,WAAW;;AACV,qBAAA,OAAO,gBAAgB;AAC1B,kBAAA,OAAO,aAAa;AAClB,oBAAA,OAAO,eAAe;AACzB,iBAAA,OAAO,YAAY;AACpB,gBAAA,OAAO,WAAW;AAClB,gBAAA,OAAO,WAAW;AACpB,cAAA,MAAM,OAAO,SAAS;AACd,sBAAA,OAAO,iBAAiB;AACtB,wBAAA,OAAO,mBAAmB;AAC5B,sBAAA,OAAO,iBAAiB;AAChC,cAAA,OAAO,SAAS;AACR,sBAAA,OAAO,iBAAiB;AACxC,2BAAe,kBAAf,wCAA+B;AAAA,IACjC;AAAA,IACA,mBAAmB,CAAC,WAAW;;AAChB,mBAAA,OAAO,cAAc;AACxB,gBAAA,OAAO,WAAW;AAC5B,2BAAe,sBAAf,wCAAmC;AAAA,IACrC;AAAA,IACA,UAAU,CAAC,MAAM,WAAW;;AACR,wBAAA,OAAO,mBAAmB;AAC7B,2BAAA,aAAA,wCAAW,MAAM;AAAA,IAAM;AAAA,EACxC,CACD;AAEM,SAAA;AAAA,IACL,GAAG,oBAAoB,WAAW;AAAA,IAClC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}

package/dist/esm/async-rate-limiter/createAsyncRateLimiter.d.ts

@@ -15,13 +15,9 @@ export interface SolidAsyncRateLimiter<TFn extends AnyAsyncFunction> extends Omi
  * This hook is designed to be flexible and state-management agnostic - it simply returns a rate limiter instance that
  * you can integrate with any state management solution (createSignal, etc).
  *
- * Rate limiting allows an async function to execute up to a specified limit within a time window,
- * then blocks subsequent calls until the window passes. This is useful for respecting API rate limits,
- * managing resource constraints, or controlling bursts of async operations.
- *
- * Unlike the non-async RateLimiter, this async version supports returning values from the rate-limited function,
- * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call
- * instead of setting the result on a state variable from within the rate-limited function.
+ * Rate limiting is a simple approach that allows a function to execute up to a limit within a time window,
+ * then blocks all subsequent calls until the window passes. This can lead to "bursty" behavior where
+ * all executions happen immediately, followed by a complete block.
  *
  * The rate limiter supports two types of windows:
  * - 'fixed': A strict window that resets after the window period. All executions within the window count
@@ -29,6 +25,25 @@ export interface SolidAsyncRateLimiter<TFn extends AnyAsyncFunction> extends Omi
  * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
  *   consistent rate of execution over time.
  *
+ * Unlike the non-async RateLimiter, this async version supports returning values from the rate-limited function,
+ * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call
+ * instead of setting the result on a state variable from within the rate-limited function.
+ *
+ * For smoother execution patterns, consider using:
+ * - Throttling: Ensures consistent spacing between executions (e.g. max once per 200ms)
+ * - Debouncing: Waits for a pause in calls before executing (e.g. after 500ms of no calls)
+ *
+ * Rate limiting is best used for hard API limits or resource constraints. For UI updates or
+ * smoothing out frequent events, throttling or debouncing usually provide better user experience.
+ *
+ * Error Handling:
+ * - If an `onError` handler is provided, it will be called with the error and rate limiter instance
+ * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown
+ * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed
+ * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown
+ * - The error state can be checked using the underlying AsyncRateLimiter instance
+ * - Rate limit rejections (when limit is exceeded) are handled separately from execution errors via the `onReject` handler
+ *
  * @example
  * ```tsx
  * // Basic API call rate limiting with return value