@tanstack/solid-pacer 0.6.0 → 0.8.0

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

@@ -1,14 +1,14 @@
-import { AsyncQueuer, AsyncQueuerFn, AsyncQueuerOptions } from '@tanstack/pacer/async-queuer';
+import { AsyncQueuer, AsyncQueuerOptions } from '@tanstack/pacer/async-queuer';
 import { Accessor } from 'solid-js';
-export interface SolidAsyncQueuer<TFn extends AsyncQueuerFn> extends Omit<AsyncQueuer<TFn>, 'getActiveItems' | 'getAllItems' | 'getErrorCount' | 'getIsEmpty' | 'getIsFull' | 'getIsIdle' | 'getIsRunning' | 'getPeek' | 'getPendingItems' | 'getRejectionCount' | 'getSettledCount' | 'getSize' | 'getSuccessCount'> {
+export interface SolidAsyncQueuer<TValue> extends Omit<AsyncQueuer<TValue>, 'getErrorCount' | 'getIsEmpty' | 'getIsFull' | 'getIsIdle' | 'getIsRunning' | 'getRejectionCount' | 'getSettledCount' | 'getSize' | 'getSuccessCount' | 'peekActiveItems' | 'peekAllItems' | 'peekNextItem' | 'peekPendingItems'> {
     /**
-     * Signal version of `getActiveItems`
+     * Signal version of `peekActiveItems`
      */
-    activeItems: Accessor<Array<TFn>>;
+    activeItems: Accessor<Array<TValue>>;
     /**
-     * Signal version of `getAllItems`
+     * Signal version of `peekAllItems`
      */
-    allItems: Accessor<Array<TFn>>;
+    allItems: Accessor<Array<TValue>>;
     /**
      * Signal version of `getErrorCount`
      */
@@ -30,13 +30,13 @@ export interface SolidAsyncQueuer<TFn extends AsyncQueuerFn> extends Omit<AsyncQ
      */
     isRunning: Accessor<boolean>;
     /**
-     * Signal version of `getPeek`
+     * Signal version of `peekNextItem`
      */
-    peek: Accessor<TFn | undefined>;
+    nextItem: Accessor<TValue | undefined>;
     /**
-     * Signal version of `getPendingItems`
+     * Signal version of `peekPendingItems`
      */
-    pendingItems: Accessor<Array<TFn>>;
+    pendingItems: Accessor<Array<TValue>>;
     /**
      * Signal version of `getRejectionCount`
      */
@@ -55,31 +55,35 @@ export interface SolidAsyncQueuer<TFn extends AsyncQueuerFn> extends Omit<AsyncQ
     successCount: Accessor<number>;
 }
 /**
- * A lower-level Solid 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.
  *
  * Features:
- * - Priority queue support via getPriority option
+ * - Priority queueing via `getPriority` or item `priority` property
  * - Configurable concurrency limit
- * - Task success/error/completion callbacks
  * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior
- * - Pause/resume task processing
+ * - Pause/resume processing
  * - Task cancellation
- * - Item expiration to clear stale items from the queue
+ * - 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
  *
  * Tasks are processed concurrently up to the configured concurrency limit. When a task completes,
- * the next pending task is processed if below the concurrency limit.
+ * the next pending task is processed if the concurrency limit allows.
  *
  * 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
+ * - 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,
@@ -97,6 +101,9 @@ export interface SolidAsyncQueuer<TFn extends AsyncQueuerFn> extends Omit<AsyncQ
  *
  * // Start processing
  * asyncQueuer.start();
+ *
+ * // Use Solid signals in your UI
+ * const pending = asyncQueuer.pendingItems();
  * ```
  */
-export declare function createAsyncQueuer<TFn extends AsyncQueuerFn>(initialOptions?: AsyncQueuerOptions<TFn>): SolidAsyncQueuer<TFn>;
+export declare function createAsyncQueuer<TValue>(fn: (value: TValue) => Promise<any>, initialOptions?: AsyncQueuerOptions<TValue>): SolidAsyncQueuer<TValue>;

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

@@ -1,8 +1,8 @@
 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);
+function createAsyncQueuer(fn, initialOptions = {}) {
+  const asyncQueuer = new AsyncQueuer(fn, initialOptions);
   const [successCount, setSuccessCount] = createSignal(
     asyncQueuer.getSuccessCount()
   );
@@ -18,27 +18,29 @@ function createAsyncQueuer(initialOptions = {}) {
   const [isIdle, setIsIdle] = createSignal(asyncQueuer.getIsIdle());
   const [isRunning, setIsRunning] = createSignal(asyncQueuer.getIsRunning());
   const [allItems, setAllItems] = createSignal(
-    asyncQueuer.getAllItems()
+    asyncQueuer.peekAllItems()
   );
   const [activeItems, setActiveItems] = createSignal(
-    asyncQueuer.getActiveItems()
+    asyncQueuer.peekActiveItems()
   );
   const [pendingItems, setPendingItems] = createSignal(
-    asyncQueuer.getPendingItems()
+    asyncQueuer.peekPendingItems()
+  );
+  const [nextItem, setNextItem] = createSignal(
+    asyncQueuer.peekNextItem()
   );
-  const [peek, setPeek] = createSignal(asyncQueuer.getPeek());
   const [size, setSize] = createSignal(asyncQueuer.getSize());
   asyncQueuer.setOptions({
     onItemsChange: (queuer) => {
       var _a;
-      setActiveItems(queuer.getActiveItems());
-      setAllItems(queuer.getAllItems());
+      setActiveItems(queuer.peekActiveItems());
+      setAllItems(queuer.peekAllItems());
       setErrorCount(queuer.getErrorCount());
       setIsEmpty(queuer.getIsEmpty());
       setIsFull(queuer.getIsFull());
       setIsIdle(queuer.getIsIdle());
-      setPeek(() => queuer.getPeek());
-      setPendingItems(queuer.getPendingItems());
+      setNextItem(() => queuer.peekNextItem());
+      setPendingItems(queuer.peekPendingItems());
       setRejectionCount(queuer.getRejectionCount());
       setSettledCount(queuer.getSettledCount());
       setSize(queuer.getSize());
@@ -66,7 +68,7 @@ function createAsyncQueuer(initialOptions = {}) {
     isFull,
     isIdle,
     isRunning,
-    peek,
+    nextItem,
     pendingItems,
     rejectionCount,
     settledCount,

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 {\n  AsyncQueuerFn,\n  AsyncQueuerOptions,\n} from '@tanstack/pacer/async-queuer'\n\nexport interface SolidAsyncQueuer<TFn extends AsyncQueuerFn>\n  extends Omit<\n    AsyncQueuer<TFn>,\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<TFn>>\n  /**\n   * Signal version of `getAllItems`\n   */\n  allItems: Accessor<Array<TFn>>\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<TFn | undefined>\n  /**\n   * Signal version of `getPendingItems`\n   */\n  pendingItems: Accessor<Array<TFn>>\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 * A lower-level Solid hook that creates an `AsyncQueuer` instance for managing an async queue of items.\n *\n * Features:\n * - Priority queue support via getPriority option\n * - Configurable concurrency limit\n * - Task success/error/completion callbacks\n * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior\n * - Pause/resume task processing\n * - Task cancellation\n * - Item expiration to clear stale items from the queue\n *\n * Tasks are processed concurrently up to the configured concurrency limit. When a task completes,\n * the next pending task is processed if below the concurrency limit.\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\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 *   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 */\nexport function createAsyncQueuer<TFn extends AsyncQueuerFn>(\n  initialOptions: AsyncQueuerOptions<TFn> = {},\n): SolidAsyncQueuer<TFn> {\n  const asyncQueuer = new AsyncQueuer<TFn>(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<TFn>>(\n    asyncQueuer.getAllItems(),\n  )\n  const [activeItems, setActiveItems] = createSignal<Array<TFn>>(\n    asyncQueuer.getActiveItems(),\n  )\n  const [pendingItems, setPendingItems] = createSignal<Array<TFn>>(\n    asyncQueuer.getPendingItems(),\n  )\n  const [peek, setPeek] = createSignal<TFn | undefined>(asyncQueuer.getPeek())\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<TFn>\n}\n"],"names":[],"mappings":";;;AA6HgB,SAAA,kBACd,iBAA0C,IACnB;AACjB,QAAA,cAAc,IAAI,YAAiB,cAAc;AAEjD,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;AACA,QAAM,CAAC,MAAM,OAAO,IAAI,aAA8B,YAAY,SAAS;AAC3E,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;"}
+{"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    | 'getErrorCount'\n    | 'getIsEmpty'\n    | 'getIsFull'\n    | 'getIsIdle'\n    | 'getIsRunning'\n    | 'getRejectionCount'\n    | 'getSettledCount'\n    | 'getSize'\n    | 'getSuccessCount'\n    | 'peekActiveItems'\n    | 'peekAllItems'\n    | 'peekNextItem'\n    | 'peekPendingItems'\n  > {\n  /**\n   * Signal version of `peekActiveItems`\n   */\n  activeItems: Accessor<Array<TValue>>\n  /**\n   * Signal version of `peekAllItems`\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 `peekNextItem`\n   */\n  nextItem: Accessor<TValue | undefined>\n  /**\n   * Signal version of `peekPendingItems`\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.peekAllItems(),\n  )\n  const [activeItems, setActiveItems] = createSignal<Array<TValue>>(\n    asyncQueuer.peekActiveItems(),\n  )\n  const [pendingItems, setPendingItems] = createSignal<Array<TValue>>(\n    asyncQueuer.peekPendingItems(),\n  )\n  const [nextItem, setNextItem] = createSignal<TValue | undefined>(\n    asyncQueuer.peekNextItem(),\n  )\n  const [size, setSize] = createSignal(asyncQueuer.getSize())\n\n  asyncQueuer.setOptions({\n    onItemsChange: (queuer) => {\n      setActiveItems(queuer.peekActiveItems())\n      setAllItems(queuer.peekAllItems())\n      setErrorCount(queuer.getErrorCount())\n      setIsEmpty(queuer.getIsEmpty())\n      setIsFull(queuer.getIsFull())\n      setIsIdle(queuer.getIsIdle())\n      setNextItem(() => queuer.peekNextItem())\n      setPendingItems(queuer.peekPendingItems())\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    nextItem,\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,aAAa;AAAA,EAC3B;AACM,QAAA,CAAC,aAAa,cAAc,IAAI;AAAA,IACpC,YAAY,gBAAgB;AAAA,EAC9B;AACM,QAAA,CAAC,cAAc,eAAe,IAAI;AAAA,IACtC,YAAY,iBAAiB;AAAA,EAC/B;AACM,QAAA,CAAC,UAAU,WAAW,IAAI;AAAA,IAC9B,YAAY,aAAa;AAAA,EAC3B;AACA,QAAM,CAAC,MAAM,OAAO,IAAI,aAAa,YAAY,SAAS;AAE1D,cAAY,WAAW;AAAA,IACrB,eAAe,CAAC,WAAW;;AACV,qBAAA,OAAO,iBAAiB;AAC3B,kBAAA,OAAO,cAAc;AACnB,oBAAA,OAAO,eAAe;AACzB,iBAAA,OAAO,YAAY;AACpB,gBAAA,OAAO,WAAW;AAClB,gBAAA,OAAO,WAAW;AAChB,kBAAA,MAAM,OAAO,cAAc;AACvB,sBAAA,OAAO,kBAAkB;AACvB,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/batcher/createBatcher.d.ts

@@ -0,0 +1,76 @@
+import { Batcher, BatcherOptions } from '@tanstack/pacer/batcher';
+import { Accessor } from 'solid-js';
+export interface SolidBatcher<TValue> extends Omit<Batcher<TValue>, 'peekAllItems' | 'getBatchExecutionCount' | 'getIsEmpty' | 'getIsRunning' | 'getItemExecutionCount' | 'getSize'> {
+    /**
+     * Signal version of `peekAllItems`
+     */
+    allItems: Accessor<Array<TValue>>;
+    /**
+     * Signal version of `getBatchExecutionCount`
+     */
+    batchExecutionCount: Accessor<number>;
+    /**
+     * Signal version of `getIsEmpty`
+     */
+    isEmpty: Accessor<boolean>;
+    /**
+     * Signal version of `getIsRunning`
+     */
+    isRunning: Accessor<boolean>;
+    /**
+     * Signal version of `getItemExecutionCount`
+     */
+    itemExecutionCount: Accessor<number>;
+    /**
+     * Signal version of `getSize`
+     */
+    size: Accessor<number>;
+}
+/**
+ * Creates a Solid-compatible Batcher instance for managing batches of items, exposing Solid signals for all stateful properties.
+ *
+ * Features:
+ * - Batch processing of items using the provided `fn` function
+ * - Configurable batch size and wait time
+ * - Custom batch processing logic via getShouldExecute
+ * - Event callbacks for monitoring batch operations
+ * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity
+ *
+ * The batcher collects items and processes them in batches based on:
+ * - Maximum batch size
+ * - Time-based batching (process after X milliseconds)
+ * - Custom batch processing logic via getShouldExecute
+ *
+ * Example usage:
+ * ```tsx
+ * const batcher = createBatcher(
+ *   (items) => {
+ *     // Process batch of items
+ *     console.log('Processing batch:', items);
+ *   },
+ *   {
+ *     maxSize: 5,
+ *     wait: 2000,
+ *     onExecute: (batcher) => console.log('Batch executed'),
+ *     getShouldExecute: (items) => items.length >= 3
+ *   }
+ * );
+ *
+ * // Add items to batch
+ * batcher.addItem('task1');
+ * batcher.addItem('task2');
+ *
+ * // Control the batcher
+ * batcher.stop();  // Pause processing
+ * batcher.start(); // Resume processing
+ *
+ * // Access batcher state via signals
+ * console.log('Items:', batcher.allItems());
+ * console.log('Size:', batcher.size());
+ * console.log('Is empty:', batcher.isEmpty());
+ * console.log('Is running:', batcher.isRunning());
+ * console.log('Batch count:', batcher.batchExecutionCount());
+ * console.log('Item count:', batcher.itemExecutionCount());
+ * ```
+ */
+export declare function createBatcher<TValue>(fn: (items: Array<TValue>) => void, initialOptions?: BatcherOptions<TValue>): SolidBatcher<TValue>;

package/dist/esm/batcher/createBatcher.js

@@ -0,0 +1,58 @@
+import { Batcher } from "@tanstack/pacer/batcher";
+import { createSignal } from "solid-js";
+import { bindInstanceMethods } from "@tanstack/pacer/utils";
+function createBatcher(fn, initialOptions = {}) {
+  const batcher = bindInstanceMethods(new Batcher(fn, initialOptions));
+  const [allItems, setAllItems] = createSignal(
+    batcher.peekAllItems()
+  );
+  const [batchExecutionCount, setBatchExecutionCount] = createSignal(
+    batcher.getBatchExecutionCount()
+  );
+  const [itemExecutionCount, setItemExecutionCount] = createSignal(
+    batcher.getItemExecutionCount()
+  );
+  const [isEmpty, setIsEmpty] = createSignal(batcher.getIsEmpty());
+  const [isRunning, setIsRunning] = createSignal(batcher.getIsRunning());
+  const [size, setSize] = createSignal(batcher.getSize());
+  function setOptions(newOptions) {
+    batcher.setOptions({
+      ...newOptions,
+      onItemsChange: (batcher2) => {
+        setAllItems(batcher2.peekAllItems());
+        setBatchExecutionCount(batcher2.getBatchExecutionCount());
+        setItemExecutionCount(batcher2.getItemExecutionCount());
+        setIsEmpty(batcher2.getIsEmpty());
+        setSize(batcher2.getSize());
+        const onItemsChange = newOptions.onItemsChange ?? initialOptions.onItemsChange;
+        onItemsChange == null ? void 0 : onItemsChange(batcher2);
+      },
+      onExecute: (batcher2) => {
+        setBatchExecutionCount(batcher2.getBatchExecutionCount());
+        setItemExecutionCount(batcher2.getItemExecutionCount());
+        const onExecute = newOptions.onExecute ?? initialOptions.onExecute;
+        onExecute == null ? void 0 : onExecute(batcher2);
+      },
+      onIsRunningChange: (batcher2) => {
+        setIsRunning(batcher2.getIsRunning());
+        const onIsRunningChange = newOptions.onIsRunningChange ?? initialOptions.onIsRunningChange;
+        onIsRunningChange == null ? void 0 : onIsRunningChange(batcher2);
+      }
+    });
+  }
+  setOptions(initialOptions);
+  return {
+    ...batcher,
+    allItems,
+    batchExecutionCount,
+    isEmpty,
+    isRunning,
+    itemExecutionCount,
+    size,
+    setOptions
+  };
+}
+export {
+  createBatcher
+};
+//# sourceMappingURL=createBatcher.js.map

package/dist/esm/batcher/createBatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBatcher.js","sources":["../../../src/batcher/createBatcher.ts"],"sourcesContent":["import { Batcher } from '@tanstack/pacer/batcher'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { BatcherOptions } from '@tanstack/pacer/batcher'\n\nexport interface SolidBatcher<TValue>\n  extends Omit<\n    Batcher<TValue>,\n    | 'peekAllItems'\n    | 'getBatchExecutionCount'\n    | 'getIsEmpty'\n    | 'getIsRunning'\n    | 'getItemExecutionCount'\n    | 'getSize'\n  > {\n  /**\n   * Signal version of `peekAllItems`\n   */\n  allItems: Accessor<Array<TValue>>\n  /**\n   * Signal version of `getBatchExecutionCount`\n   */\n  batchExecutionCount: Accessor<number>\n  /**\n   * Signal version of `getIsEmpty`\n   */\n  isEmpty: Accessor<boolean>\n  /**\n   * Signal version of `getIsRunning`\n   */\n  isRunning: Accessor<boolean>\n  /**\n   * Signal version of `getItemExecutionCount`\n   */\n  itemExecutionCount: Accessor<number>\n  /**\n   * Signal version of `getSize`\n   */\n  size: Accessor<number>\n}\n\n/**\n * Creates a Solid-compatible Batcher instance for managing batches of items, exposing Solid signals for all stateful properties.\n *\n * Features:\n * - Batch processing of items using the provided `fn` function\n * - Configurable batch size and wait time\n * - Custom batch processing logic via getShouldExecute\n * - Event callbacks for monitoring batch operations\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\n * - Time-based batching (process after X milliseconds)\n * - Custom batch processing logic via getShouldExecute\n *\n * Example usage:\n * ```tsx\n * const batcher = createBatcher(\n *   (items) => {\n *     // Process batch of items\n *     console.log('Processing batch:', items);\n *   },\n *   {\n *     maxSize: 5,\n *     wait: 2000,\n *     onExecute: (batcher) => console.log('Batch executed'),\n *     getShouldExecute: (items) => items.length >= 3\n *   }\n * );\n *\n * // Add items to batch\n * batcher.addItem('task1');\n * batcher.addItem('task2');\n *\n * // Control the batcher\n * batcher.stop();  // Pause processing\n * batcher.start(); // Resume processing\n *\n * // Access batcher state via signals\n * console.log('Items:', batcher.allItems());\n * console.log('Size:', batcher.size());\n * console.log('Is empty:', batcher.isEmpty());\n * console.log('Is running:', batcher.isRunning());\n * console.log('Batch count:', batcher.batchExecutionCount());\n * console.log('Item count:', batcher.itemExecutionCount());\n * ```\n */\nexport function createBatcher<TValue>(\n  fn: (items: Array<TValue>) => void,\n  initialOptions: BatcherOptions<TValue> = {},\n): SolidBatcher<TValue> {\n  const batcher = bindInstanceMethods(new Batcher<TValue>(fn, initialOptions))\n\n  const [allItems, setAllItems] = createSignal<Array<TValue>>(\n    batcher.peekAllItems(),\n  )\n  const [batchExecutionCount, setBatchExecutionCount] = createSignal(\n    batcher.getBatchExecutionCount(),\n  )\n  const [itemExecutionCount, setItemExecutionCount] = createSignal(\n    batcher.getItemExecutionCount(),\n  )\n  const [isEmpty, setIsEmpty] = createSignal(batcher.getIsEmpty())\n  const [isRunning, setIsRunning] = createSignal(batcher.getIsRunning())\n  const [size, setSize] = createSignal(batcher.getSize())\n\n  function setOptions(newOptions: Partial<BatcherOptions<TValue>>) {\n    batcher.setOptions({\n      ...newOptions,\n      onItemsChange: (batcher) => {\n        setAllItems(batcher.peekAllItems())\n        setBatchExecutionCount(batcher.getBatchExecutionCount())\n        setItemExecutionCount(batcher.getItemExecutionCount())\n        setIsEmpty(batcher.getIsEmpty())\n        setSize(batcher.getSize())\n\n        const onItemsChange =\n          newOptions.onItemsChange ?? initialOptions.onItemsChange\n        onItemsChange?.(batcher)\n      },\n      onExecute: (batcher) => {\n        setBatchExecutionCount(batcher.getBatchExecutionCount())\n        setItemExecutionCount(batcher.getItemExecutionCount())\n\n        const onExecute = newOptions.onExecute ?? initialOptions.onExecute\n        onExecute?.(batcher)\n      },\n      onIsRunningChange: (batcher) => {\n        setIsRunning(batcher.getIsRunning())\n\n        const onIsRunningChange =\n          newOptions.onIsRunningChange ?? initialOptions.onIsRunningChange\n        onIsRunningChange?.(batcher)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...batcher,\n    allItems,\n    batchExecutionCount,\n    isEmpty,\n    isRunning,\n    itemExecutionCount,\n    size,\n    setOptions,\n  } as SolidBatcher<TValue>\n}\n"],"names":["batcher"],"mappings":";;;AAyFO,SAAS,cACd,IACA,iBAAyC,IACnB;AACtB,QAAM,UAAU,oBAAoB,IAAI,QAAgB,IAAI,cAAc,CAAC;AAErE,QAAA,CAAC,UAAU,WAAW,IAAI;AAAA,IAC9B,QAAQ,aAAa;AAAA,EACvB;AACM,QAAA,CAAC,qBAAqB,sBAAsB,IAAI;AAAA,IACpD,QAAQ,uBAAuB;AAAA,EACjC;AACM,QAAA,CAAC,oBAAoB,qBAAqB,IAAI;AAAA,IAClD,QAAQ,sBAAsB;AAAA,EAChC;AACA,QAAM,CAAC,SAAS,UAAU,IAAI,aAAa,QAAQ,YAAY;AAC/D,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,QAAQ,cAAc;AACrE,QAAM,CAAC,MAAM,OAAO,IAAI,aAAa,QAAQ,SAAS;AAEtD,WAAS,WAAW,YAA6C;AAC/D,YAAQ,WAAW;AAAA,MACjB,GAAG;AAAA,MACH,eAAe,CAACA,aAAY;AACdA,oBAAAA,SAAQ,cAAc;AACXA,+BAAAA,SAAQ,wBAAwB;AACjCA,8BAAAA,SAAQ,uBAAuB;AAC1CA,mBAAAA,SAAQ,YAAY;AACvBA,gBAAAA,SAAQ,SAAS;AAEnB,cAAA,gBACJ,WAAW,iBAAiB,eAAe;AAC7C,uDAAgBA;AAAAA,MAClB;AAAA,MACA,WAAW,CAACA,aAAY;AACCA,+BAAAA,SAAQ,wBAAwB;AACjCA,8BAAAA,SAAQ,uBAAuB;AAE/C,cAAA,YAAY,WAAW,aAAa,eAAe;AACzD,+CAAYA;AAAAA,MACd;AAAA,MACA,mBAAmB,CAACA,aAAY;AACjBA,qBAAAA,SAAQ,cAAc;AAE7B,cAAA,oBACJ,WAAW,qBAAqB,eAAe;AACjD,+DAAoBA;AAAAA,MAAO;AAAA,IAC7B,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}

package/dist/esm/batcher/index.d.ts

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

package/dist/esm/batcher/index.js

@@ -0,0 +1,6 @@
+export * from "@tanstack/pacer/batcher";
+import { createBatcher } from "./createBatcher.js";
+export {
+  createBatcher
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/batcher/index.js.map

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

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

@@ -3,6 +3,7 @@ import { createAsyncDebouncer } from "./async-debouncer/createAsyncDebouncer.js"
 import { createAsyncQueuer } from "./async-queuer/createAsyncQueuer.js";
 import { createAsyncRateLimiter } from "./async-rate-limiter/createAsyncRateLimiter.js";
 import { createAsyncThrottler } from "./async-throttler/createAsyncThrottler.js";
+import { createBatcher } from "./batcher/createBatcher.js";
 import { createDebouncedSignal } from "./debouncer/createDebouncedSignal.js";
 import { createDebouncedValue } from "./debouncer/createDebouncedValue.js";
 import { createDebouncer } from "./debouncer/createDebouncer.js";
@@ -18,6 +19,7 @@ export {
   createAsyncQueuer,
   createAsyncRateLimiter,
   createAsyncThrottler,
+  createBatcher,
   createDebouncedSignal,
   createDebouncedValue,
   createDebouncer,

package/dist/esm/index.js.map

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

package/dist/esm/queuer/createQueuer.d.ts

@@ -1,8 +1,8 @@
 import { Queuer, QueuerOptions } from '@tanstack/pacer/queuer';
 import { Accessor } from 'solid-js';
-export interface SolidQueuer<TValue> extends Omit<Queuer<TValue>, 'getAllItems' | 'getExecutionCount' | 'getIsEmpty' | 'getIsFull' | 'getIsIdle' | 'getIsRunning' | 'getPeek' | 'getSize'> {
+export interface SolidQueuer<TValue> extends Omit<Queuer<TValue>, 'getExecutionCount' | 'getIsEmpty' | 'getIsFull' | 'getIsIdle' | 'getIsRunning' | 'getSize' | 'peekAllItems' | 'peekNextItem'> {
     /**
-     * Signal version of `getAllItems`
+     * Signal version of `peekAllItems`
      */
     allItems: Accessor<Array<TValue>>;
     /**
@@ -26,9 +26,9 @@ export interface SolidQueuer<TValue> extends Omit<Queuer<TValue>, 'getAllItems'
      */
     isRunning: Accessor<boolean>;
     /**
-     * Signal version of `getPeek`
+     * Signal version of `peekNextItem`
      */
-    peek: Accessor<TValue | undefined>;
+    nextItem: Accessor<TValue | undefined>;
     /**
      * Signal version of `getRejectionCount`
      */
@@ -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.peekAllItems()),
+ *     getPriority: (item) => item.priority // Process higher priority items first
+ *   }
+ * );
  *
  * // Add items to process - they'll be handled automatically
  * queue.addItem('task1');
@@ -80,7 +86,7 @@ export interface SolidQueuer<TValue> extends Omit<Queuer<TValue>, 'getAllItems'
  * console.log('Size:', queue.size());
  * console.log('Is empty:', queue.isEmpty());
  * console.log('Is running:', queue.isRunning());
- * console.log('Next item:', queue.peek());
+ * console.log('Next item:', queue.nextItem());
  * ```
  */
-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/esm/queuer/createQueuer.js

@@ -1,10 +1,10 @@
 import { Queuer } from "@tanstack/pacer/queuer";
 import { createSignal } from "solid-js";
 import { bindInstanceMethods } from "@tanstack/pacer/utils";
-function createQueuer(initialOptions = {}) {
-  const queuer = bindInstanceMethods(new Queuer(initialOptions));
+function createQueuer(fn, initialOptions = {}) {
+  const queuer = bindInstanceMethods(new Queuer(fn, initialOptions));
   const [allItems, setAllItems] = createSignal(
-    queuer.getAllItems()
+    queuer.peekAllItems()
   );
   const [executionCount, setExecutionCount] = createSignal(
     queuer.getExecutionCount()
@@ -16,18 +16,20 @@ function createQueuer(initialOptions = {}) {
   const [isFull, setIsFull] = createSignal(queuer.getIsFull());
   const [isIdle, setIsIdle] = createSignal(queuer.getIsIdle());
   const [isRunning, setIsRunning] = createSignal(queuer.getIsRunning());
-  const [peek, setPeek] = createSignal(queuer.getPeek());
+  const [nextItem, setNextItem] = createSignal(
+    queuer.peekNextItem()
+  );
   const [size, setSize] = createSignal(queuer.getSize());
   function setOptions(newOptions) {
     queuer.setOptions({
       ...newOptions,
       onItemsChange: (queuer2) => {
-        setAllItems(queuer2.getAllItems());
+        setAllItems(queuer2.peekAllItems());
         setExecutionCount(queuer2.getExecutionCount());
         setIsEmpty(queuer2.getIsEmpty());
         setIsFull(queuer2.getIsFull());
         setIsIdle(queuer2.getIsIdle());
-        setPeek(() => queuer2.getPeek());
+        setNextItem(() => queuer2.peekNextItem());
         setSize(queuer2.getSize());
         const onItemsChange = newOptions.onItemsChange ?? initialOptions.onItemsChange;
         onItemsChange == null ? void 0 : onItemsChange(queuer2);
@@ -54,7 +56,7 @@ function createQueuer(initialOptions = {}) {
     isFull,
     isIdle,
     isRunning,
-    peek,
+    nextItem,
     rejectionCount,
     size,
     setOptions

package/dist/esm/queuer/createQueuer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createQueuer.js","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"],"mappings":";;;AAqGgB,SAAA,aACd,iBAAwC,IACnB;AACrB,QAAM,SAAS,oBAAoB,IAAI,OAAe,cAAc,CAAC;AAE/D,QAAA,CAAC,UAAU,WAAW,IAAI;AAAA,IAC9B,OAAO,YAAY;AAAA,EACrB;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,OAAO,kBAAkB;AAAA,EAC3B;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,OAAO,kBAAkB;AAAA,EAC3B;AACA,QAAM,CAAC,SAAS,UAAU,IAAI,aAAa,OAAO,YAAY;AAC9D,QAAM,CAAC,QAAQ,SAAS,IAAI,aAAa,OAAO,WAAW;AAC3D,QAAM,CAAC,QAAQ,SAAS,IAAI,aAAa,OAAO,WAAW;AAC3D,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,OAAO,cAAc;AACpE,QAAM,CAAC,MAAM,OAAO,IAAI,aAAiC,OAAO,SAAS;AACzE,QAAM,CAAC,MAAM,OAAO,IAAI,aAAa,OAAO,SAAS;AAErD,WAAS,WAAW,YAA4C;AAC9D,WAAO,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,GAAG;AAAA,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.js","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    | 'getExecutionCount'\n    | 'getIsEmpty'\n    | 'getIsFull'\n    | 'getIsIdle'\n    | 'getIsRunning'\n    | 'getSize'\n    | 'peekAllItems'\n    | 'peekNextItem'\n  > {\n  /**\n   * Signal version of `peekAllItems`\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 `peekNextItem`\n   */\n  nextItem: 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.peekAllItems()),\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.nextItem());\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.peekAllItems(),\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 [nextItem, setNextItem] = createSignal<TValue | undefined>(\n    queuer.peekNextItem(),\n  )\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.peekAllItems())\n        setExecutionCount(queuer.getExecutionCount())\n        setIsEmpty(queuer.getIsEmpty())\n        setIsFull(queuer.getIsFull())\n        setIsIdle(queuer.getIsIdle())\n        setNextItem(() => queuer.peekNextItem())\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    nextItem,\n    rejectionCount,\n    size,\n    setOptions,\n  } as SolidQueuer<TValue>\n}\n"],"names":["queuer"],"mappings":";;;AA2GO,SAAS,aACd,IACA,iBAAwC,IACnB;AACrB,QAAM,SAAS,oBAAoB,IAAI,OAAe,IAAI,cAAc,CAAC;AAEnE,QAAA,CAAC,UAAU,WAAW,IAAI;AAAA,IAC9B,OAAO,aAAa;AAAA,EACtB;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,OAAO,kBAAkB;AAAA,EAC3B;AACM,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,OAAO,kBAAkB;AAAA,EAC3B;AACA,QAAM,CAAC,SAAS,UAAU,IAAI,aAAa,OAAO,YAAY;AAC9D,QAAM,CAAC,QAAQ,SAAS,IAAI,aAAa,OAAO,WAAW;AAC3D,QAAM,CAAC,QAAQ,SAAS,IAAI,aAAa,OAAO,WAAW;AAC3D,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,OAAO,cAAc;AAC9D,QAAA,CAAC,UAAU,WAAW,IAAI;AAAA,IAC9B,OAAO,aAAa;AAAA,EACtB;AACA,QAAM,CAAC,MAAM,OAAO,IAAI,aAAa,OAAO,SAAS;AAErD,WAAS,WAAW,YAA4C;AAC9D,WAAO,WAAW;AAAA,MAChB,GAAG;AAAA,MACH,eAAe,CAACA,YAAW;AACbA,oBAAAA,QAAO,cAAc;AACfA,0BAAAA,QAAO,mBAAmB;AACjCA,mBAAAA,QAAO,YAAY;AACpBA,kBAAAA,QAAO,WAAW;AAClBA,kBAAAA,QAAO,WAAW;AAChB,oBAAA,MAAMA,QAAO,cAAc;AAC/BA,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,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-pacer",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Utilities for debouncing and throttling functions in Solid.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -77,6 +77,16 @@
         "default": "./dist/cjs/async-throttler/index.cjs"
       }
     },
+    "./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"
+      }
+    },
     "./debouncer": {
       "import": {
         "types": "./dist/esm/debouncer/index.d.ts",
@@ -142,10 +152,10 @@
     "src"
   ],
   "dependencies": {
-    "@tanstack/pacer": "0.6.0"
+    "@tanstack/pacer": "0.8.0"
   },
   "devDependencies": {
-    "solid-js": "^1.9.6",
+    "solid-js": "^1.9.7",
     "vite-plugin-solid": "^2.11.6"
   },
   "peerDependencies": {