@tanstack/solid-pacer 0.17.0 → 0.18.0

package/dist/debouncer/createDebouncer.d.ts

@@ -1,10 +1,27 @@
-import { Accessor } from "solid-js";
+import { Accessor, JSX } from "solid-js";
 import { Store } from "@tanstack/solid-store";
 import { Debouncer, DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
 import { AnyFunction } from "@tanstack/pacer/types";
 
 //#region src/debouncer/createDebouncer.d.ts
 interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
+  /**
+   * A Solid component that allows you to subscribe to the debouncer state.
+   *
+   * This is useful for tracking specific parts of the debouncer state
+   * deep in your component tree without needing to pass a selector to the hook.
+   *
+   * @example
+   * <debouncer.Subscribe selector={(state) => ({ isPending: state.isPending })}>
+   *   {(state) => (
+   *     <div>{state().isPending ? 'Waiting...' : 'Ready'}</div>
+   *   )}
+   * </debouncer.Subscribe>
+   */
+  Subscribe: <TSelected>(props: {
+    selector: (state: DebouncerState<TFn>) => TSelected;
+    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element;
+  }) => JSX.Element;
   /**
    * Reactive state that will be updated when the debouncer state changes
    *
@@ -35,14 +52,24 @@ interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<D
  *
  * ## State Management and Selector
  *
- * The hook uses TanStack Store for reactive state management. The `selector` parameter allows you
- * to specify which state changes will trigger a re-render, optimizing performance by preventing
- * unnecessary re-renders when irrelevant state changes occur.
+ * The hook uses TanStack Store for reactive state management. You can subscribe to state changes
+ * in two ways:
+ *
+ * **1. Using `debouncer.Subscribe` component (Recommended for component tree subscriptions)**
+ *
+ * Use the `Subscribe` component to subscribe to state changes deep in your component tree without
+ * needing to pass a selector to the hook. This is ideal when you want to subscribe to state
+ * in child components.
+ *
+ * **2. Using the `selector` parameter (For hook-level subscriptions)**
+ *
+ * The `selector` parameter allows you to specify which state changes will trigger reactive updates
+ * at the hook level, optimizing performance by preventing unnecessary updates when irrelevant
+ * state changes occur.
  *
  * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function. This prevents unnecessary re-renders and gives you
- * full control over when your component updates. Only when you provide a selector will the
- * component re-render when the selected state values change.
+ * tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary
+ * updates and gives you full control over when your component tracks state changes.
  *
  * Available state properties:
  * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
@@ -59,21 +86,21 @@ interface SolidDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<D
  *   { wait: 500 }
  * );
  *
- * // Opt-in to re-render when isPending changes (optimized for loading states)
+ * // Opt-in to track isPending changes (optimized for loading states)
  * const debouncer = createDebouncer(
  *   (query: string) => fetchSearchResults(query),
  *   { wait: 500 },
  *   (state) => ({ isPending: state.isPending })
  * );
  *
- * // Opt-in to re-render when executionCount changes (optimized for tracking execution)
+ * // Opt-in to track executionCount changes (optimized for tracking execution)
  * const debouncer = createDebouncer(
  *   (query: string) => fetchSearchResults(query),
  *   { wait: 500 },
  *   (state) => ({ executionCount: state.executionCount })
  * );
  *
- * // Multiple state properties - re-render when any of these change
+ * // Multiple state properties - track when any of these change
  * const debouncer = createDebouncer(
  *   (query: string) => fetchSearchResults(query),
  *   { wait: 500 },

package/dist/debouncer/createDebouncer.js

@@ -21,14 +21,24 @@ import { Debouncer } from "@tanstack/pacer/debouncer";
 *
 * ## State Management and Selector
 *
-* The hook uses TanStack Store for reactive state management. The `selector` parameter allows you
-* to specify which state changes will trigger a re-render, optimizing performance by preventing
-* unnecessary re-renders when irrelevant state changes occur.
+* The hook uses TanStack Store for reactive state management. You can subscribe to state changes
+* in two ways:
+*
+* **1. Using `debouncer.Subscribe` component (Recommended for component tree subscriptions)**
+*
+* Use the `Subscribe` component to subscribe to state changes deep in your component tree without
+* needing to pass a selector to the hook. This is ideal when you want to subscribe to state
+* in child components.
+*
+* **2. Using the `selector` parameter (For hook-level subscriptions)**
+*
+* The `selector` parameter allows you to specify which state changes will trigger reactive updates
+* at the hook level, optimizing performance by preventing unnecessary updates when irrelevant
+* state changes occur.
 *
 * **By default, there will be no reactive state subscriptions** and you must opt-in to state
-* tracking by providing a selector function. This prevents unnecessary re-renders and gives you
-* full control over when your component updates. Only when you provide a selector will the
-* component re-render when the selected state values change.
+* tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary
+* updates and gives you full control over when your component tracks state changes.
 *
 * Available state properties:
 * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
@@ -45,21 +55,21 @@ import { Debouncer } from "@tanstack/pacer/debouncer";
 *   { wait: 500 }
 * );
 *
-* // Opt-in to re-render when isPending changes (optimized for loading states)
+* // Opt-in to track isPending changes (optimized for loading states)
 * const debouncer = createDebouncer(
 *   (query: string) => fetchSearchResults(query),
 *   { wait: 500 },
 *   (state) => ({ isPending: state.isPending })
 * );
 *
-* // Opt-in to re-render when executionCount changes (optimized for tracking execution)
+* // Opt-in to track executionCount changes (optimized for tracking execution)
 * const debouncer = createDebouncer(
 *   (query: string) => fetchSearchResults(query),
 *   { wait: 500 },
 *   (state) => ({ executionCount: state.executionCount })
 * );
 *
-* // Multiple state properties - re-render when any of these change
+* // Multiple state properties - track when any of these change
 * const debouncer = createDebouncer(
 *   (query: string) => fetchSearchResults(query),
 *   { wait: 500 },
@@ -84,6 +94,10 @@ function createDebouncer(fn, options, selector = () => ({})) {
 		...useDefaultPacerOptions().debouncer,
 		...options
 	});
+	asyncDebouncer.Subscribe = function Subscribe(props) {
+		const selected = useStore(asyncDebouncer.store, props.selector);
+		return typeof props.children === "function" ? props.children(selected) : props.children;
+	};
 	const state = useStore(asyncDebouncer.store, selector);
 	createEffect(() => {
 		onCleanup(() => {

package/dist/debouncer/createDebouncer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createDebouncer.js","names":[],"sources":["../../src/debouncer/createDebouncer.ts"],"sourcesContent":["import { Debouncer } from '@tanstack/pacer/debouncer'\nimport { createEffect, onCleanup } from 'solid-js'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\nexport interface SolidDebouncer<\n  TFn extends AnyFunction,\n  TSelected = {},\n> extends Omit<Debouncer<TFn>, 'store'> {\n  /**\n   * Reactive state that will be updated when the debouncer state changes\n   *\n   * Use this instead of `debouncer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `debouncer.state` instead of `debouncer.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.\n   * Although, you can make the state reactive by using the `useStore` in your own usage.\n   */\n  readonly store: Store<Readonly<DebouncerState<TFn>>>\n}\n\n/**\n * A Solid hook that creates and manages a Debouncer instance.\n *\n * This is a lower-level hook that provides direct access to the Debouncer's functionality without\n * any built-in state management. This allows you to integrate it with any state management solution\n * you prefer (createSignal, Redux, Zustand, etc.).\n *\n * This hook provides debouncing functionality to limit how often a function can be called,\n * waiting for a specified delay before executing the latest call. This is useful for handling\n * frequent events like window resizing, scroll events, or real-time search inputs.\n *\n * The debouncer will only execute the function after the specified wait time has elapsed\n * since the last call. If the function is called again before the wait time expires, the\n * timer resets and starts waiting again.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management. The `selector` parameter allows you\n * to specify which state changes will trigger a re-render, optimizing performance by preventing\n * unnecessary re-renders when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n *\n * Available state properties:\n * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 }\n * );\n *\n * // Opt-in to re-render when isPending changes (optimized for loading states)\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({ isPending: state.isPending })\n * );\n *\n * // Opt-in to re-render when executionCount changes (optimized for tracking execution)\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({ executionCount: state.executionCount })\n * );\n *\n * // Multiple state properties - re-render when any of these change\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({\n *     isPending: state.isPending,\n *     executionCount: state.executionCount,\n *     status: state.status\n *   })\n * );\n *\n * // In an event handler\n * const handleChange = (e) => {\n *   debouncer.maybeExecute(e.target.value);\n * };\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { isPending } = debouncer.state();\n * ```\n */\nexport function createDebouncer<TFn extends AnyFunction, TSelected = {}>(\n  fn: TFn,\n  options: DebouncerOptions<TFn>,\n  selector: (state: DebouncerState<TFn>) => TSelected = () => ({}) as TSelected,\n): SolidDebouncer<TFn, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().debouncer,\n    ...options,\n  } as DebouncerOptions<TFn>\n\n  const asyncDebouncer = new Debouncer<TFn>(fn, mergedOptions)\n\n  const state = useStore(asyncDebouncer.store, selector)\n\n  createEffect(() => {\n    onCleanup(() => {\n      asyncDebouncer.cancel()\n    })\n  })\n\n  return {\n    ...asyncDebouncer,\n    state,\n  } as SolidDebouncer<TFn, TSelected> // omit `store` in favor of `state`\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyGA,SAAgB,gBACd,IACA,SACA,kBAA6D,EAAE,GAC/B;CAMhC,MAAM,iBAAiB,IAAI,UAAe,IALpB;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ,CAE2D;CAE5D,MAAM,QAAQ,SAAS,eAAe,OAAO,SAAS;AAEtD,oBAAmB;AACjB,kBAAgB;AACd,kBAAe,QAAQ;IACvB;GACF;AAEF,QAAO;EACL,GAAG;EACH;EACD"}
+{"version":3,"file":"createDebouncer.js","names":[],"sources":["../../src/debouncer/createDebouncer.ts"],"sourcesContent":["import { Debouncer } from '@tanstack/pacer/debouncer'\nimport { createEffect, onCleanup } from 'solid-js'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor, JSX } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\nexport interface SolidDebouncer<\n  TFn extends AnyFunction,\n  TSelected = {},\n> extends Omit<Debouncer<TFn>, 'store'> {\n  /**\n   * A Solid component that allows you to subscribe to the debouncer state.\n   *\n   * This is useful for tracking specific parts of the debouncer state\n   * deep in your component tree without needing to pass a selector to the hook.\n   *\n   * @example\n   * <debouncer.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n   *   {(state) => (\n   *     <div>{state().isPending ? 'Waiting...' : 'Ready'}</div>\n   *   )}\n   * </debouncer.Subscribe>\n   */\n  Subscribe: <TSelected>(props: {\n    selector: (state: DebouncerState<TFn>) => TSelected\n    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element\n  }) => JSX.Element\n  /**\n   * Reactive state that will be updated when the debouncer state changes\n   *\n   * Use this instead of `debouncer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `debouncer.state` instead of `debouncer.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.\n   * Although, you can make the state reactive by using the `useStore` in your own usage.\n   */\n  readonly store: Store<Readonly<DebouncerState<TFn>>>\n}\n\n/**\n * A Solid hook that creates and manages a Debouncer instance.\n *\n * This is a lower-level hook that provides direct access to the Debouncer's functionality without\n * any built-in state management. This allows you to integrate it with any state management solution\n * you prefer (createSignal, Redux, Zustand, etc.).\n *\n * This hook provides debouncing functionality to limit how often a function can be called,\n * waiting for a specified delay before executing the latest call. This is useful for handling\n * frequent events like window resizing, scroll events, or real-time search inputs.\n *\n * The debouncer will only execute the function after the specified wait time has elapsed\n * since the last call. If the function is called again before the wait time expires, the\n * timer resets and starts waiting again.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management. You can subscribe to state changes\n * in two ways:\n *\n * **1. Using `debouncer.Subscribe` component (Recommended for component tree subscriptions)**\n *\n * Use the `Subscribe` component to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n *\n * **2. Using the `selector` parameter (For hook-level subscriptions)**\n *\n * The `selector` parameter allows you to specify which state changes will trigger reactive updates\n * at the hook level, optimizing performance by preventing unnecessary updates when irrelevant\n * state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary\n * updates and gives you full control over when your component tracks state changes.\n *\n * Available state properties:\n * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 }\n * );\n *\n * // Opt-in to track isPending changes (optimized for loading states)\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({ isPending: state.isPending })\n * );\n *\n * // Opt-in to track executionCount changes (optimized for tracking execution)\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({ executionCount: state.executionCount })\n * );\n *\n * // Multiple state properties - track when any of these change\n * const debouncer = createDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({\n *     isPending: state.isPending,\n *     executionCount: state.executionCount,\n *     status: state.status\n *   })\n * );\n *\n * // In an event handler\n * const handleChange = (e) => {\n *   debouncer.maybeExecute(e.target.value);\n * };\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { isPending } = debouncer.state();\n * ```\n */\nexport function createDebouncer<TFn extends AnyFunction, TSelected = {}>(\n  fn: TFn,\n  options: DebouncerOptions<TFn>,\n  selector: (state: DebouncerState<TFn>) => TSelected = () => ({}) as TSelected,\n): SolidDebouncer<TFn, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().debouncer,\n    ...options,\n  } as DebouncerOptions<TFn>\n\n  const asyncDebouncer = new Debouncer<TFn>(\n    fn,\n    mergedOptions,\n  ) as unknown as SolidDebouncer<TFn, TSelected>\n\n  asyncDebouncer.Subscribe = function Subscribe<TSelected>(props: {\n    selector: (state: DebouncerState<TFn>) => TSelected\n    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element\n  }) {\n    const selected = useStore(asyncDebouncer.store, props.selector)\n\n    return typeof props.children === 'function'\n      ? props.children(selected)\n      : props.children\n  }\n\n  const state = useStore(asyncDebouncer.store, selector)\n\n  createEffect(() => {\n    onCleanup(() => {\n      asyncDebouncer.cancel()\n    })\n  })\n\n  return {\n    ...asyncDebouncer,\n    state,\n  } as SolidDebouncer<TFn, TSelected> // omit `store` in favor of `state`\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoIA,SAAgB,gBACd,IACA,SACA,kBAA6D,EAAE,GAC/B;CAMhC,MAAM,iBAAiB,IAAI,UACzB,IANoB;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ,CAKA;AAED,gBAAe,YAAY,SAAS,UAAqB,OAGtD;EACD,MAAM,WAAW,SAAS,eAAe,OAAO,MAAM,SAAS;AAE/D,SAAO,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;CAGZ,MAAM,QAAQ,SAAS,eAAe,OAAO,SAAS;AAEtD,oBAAmB;AACjB,kBAAgB;AACd,kBAAe,QAAQ;IACvB;GACF;AAEF,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/debouncer/index.cjs

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

package/dist/index.cjs

@@ -37,10 +37,10 @@ exports.createThrottledValue = require_createThrottledValue.createThrottledValue
 exports.createThrottler = require_createThrottler.createThrottler;
 exports.useDefaultPacerOptions = require_PacerProvider.useDefaultPacerOptions;
 exports.usePacerContext = require_PacerProvider.usePacerContext;
-var __tanstack_pacer = require("@tanstack/pacer");
-Object.keys(__tanstack_pacer).forEach(function (k) {
+var _tanstack_pacer = require("@tanstack/pacer");
+Object.keys(_tanstack_pacer).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
-    get: function () { return __tanstack_pacer[k]; }
+    get: function () { return _tanstack_pacer[k]; }
   });
 });

package/dist/queuer/createQueuedSignal.cjs

@@ -19,13 +19,13 @@ const require_createQueuer = require('./createQueuer.cjs');
 * ## State Management and Selector
 *
 * The primitive uses Solid's reactive state management via the underlying queuer instance.
-* The `selector` parameter allows you to specify which queuer state changes will trigger a re-render,
-* optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.
+* The `selector` parameter allows you to specify which queuer state changes will trigger reactive updates,
+* optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
 *
 * **By default, there will be no reactive state subscriptions** and you must opt-in to state
-* tracking by providing a selector function. This prevents unnecessary re-renders and gives you
-* full control over when your component updates. Only when you provide a selector will the
-* component re-render when the selected state values change.
+* tracking by providing a selector function. This prevents unnecessary updates and gives you
+* full control over when your component tracks state changes. Only when you provide a selector will the
+* component track changes to the selected state values.
 *
 * Available queuer state properties:
 * - `executionCount`: Number of items that have been processed by the queuer
@@ -54,7 +54,7 @@ const require_createQueuer = require('./createQueuer.cjs');
 *   }
 * );
 *
-* // Opt-in to re-render when queue contents change (optimized for displaying queue items)
+* // Opt-in to track queue contents changes (optimized for displaying queue items)
 * const [items, addItem, queue] = createQueuedSignal(
 *   (item) => console.log('Processing:', item),
 *   { started: true, wait: 1000 },
@@ -65,7 +65,7 @@ const require_createQueuer = require('./createQueuer.cjs');
 *   })
 * );
 *
-* // Opt-in to re-render when processing state changes (optimized for loading indicators)
+* // Opt-in to track processing state changes (optimized for loading indicators)
 * const [items, addItem, queue] = createQueuedSignal(
 *   (item) => console.log('Processing:', item),
 *   { started: true, wait: 1000 },
@@ -77,7 +77,7 @@ const require_createQueuer = require('./createQueuer.cjs');
 *   })
 * );
 *
-* // Opt-in to re-render when execution metrics change (optimized for stats display)
+* // Opt-in to track execution metrics changes (optimized for stats display)
 * const [items, addItem, queue] = createQueuedSignal(
 *   (item) => console.log('Processing:', item),
 *   { started: true, wait: 1000 },

package/dist/queuer/createQueuedSignal.cjs.map

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

package/dist/queuer/createQueuedSignal.d.cts

@@ -21,13 +21,13 @@ import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
  * ## State Management and Selector
  *
  * The primitive uses Solid's reactive state management via the underlying queuer instance.
- * The `selector` parameter allows you to specify which queuer state changes will trigger a re-render,
- * optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.
+ * The `selector` parameter allows you to specify which queuer state changes will trigger reactive updates,
+ * optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
  *
  * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function. This prevents unnecessary re-renders and gives you
- * full control over when your component updates. Only when you provide a selector will the
- * component re-render when the selected state values change.
+ * tracking by providing a selector function. This prevents unnecessary updates and gives you
+ * full control over when your component tracks state changes. Only when you provide a selector will the
+ * component track changes to the selected state values.
  *
  * Available queuer state properties:
  * - `executionCount`: Number of items that have been processed by the queuer
@@ -56,7 +56,7 @@ import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
  *   }
  * );
  *
- * // Opt-in to re-render when queue contents change (optimized for displaying queue items)
+ * // Opt-in to track queue contents changes (optimized for displaying queue items)
  * const [items, addItem, queue] = createQueuedSignal(
  *   (item) => console.log('Processing:', item),
  *   { started: true, wait: 1000 },
@@ -67,7 +67,7 @@ import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
  *   })
  * );
  *
- * // Opt-in to re-render when processing state changes (optimized for loading indicators)
+ * // Opt-in to track processing state changes (optimized for loading indicators)
  * const [items, addItem, queue] = createQueuedSignal(
  *   (item) => console.log('Processing:', item),
  *   { started: true, wait: 1000 },
@@ -79,7 +79,7 @@ import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
  *   })
  * );
  *
- * // Opt-in to re-render when execution metrics change (optimized for stats display)
+ * // Opt-in to track execution metrics changes (optimized for stats display)
  * const [items, addItem, queue] = createQueuedSignal(
  *   (item) => console.log('Processing:', item),
  *   { started: true, wait: 1000 },

package/dist/queuer/createQueuedSignal.d.ts

@@ -21,13 +21,13 @@ import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
  * ## State Management and Selector
  *
  * The primitive uses Solid's reactive state management via the underlying queuer instance.
- * The `selector` parameter allows you to specify which queuer state changes will trigger a re-render,
- * optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.
+ * The `selector` parameter allows you to specify which queuer state changes will trigger reactive updates,
+ * optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
  *
  * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function. This prevents unnecessary re-renders and gives you
- * full control over when your component updates. Only when you provide a selector will the
- * component re-render when the selected state values change.
+ * tracking by providing a selector function. This prevents unnecessary updates and gives you
+ * full control over when your component tracks state changes. Only when you provide a selector will the
+ * component track changes to the selected state values.
  *
  * Available queuer state properties:
  * - `executionCount`: Number of items that have been processed by the queuer
@@ -56,7 +56,7 @@ import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
  *   }
  * );
  *
- * // Opt-in to re-render when queue contents change (optimized for displaying queue items)
+ * // Opt-in to track queue contents changes (optimized for displaying queue items)
  * const [items, addItem, queue] = createQueuedSignal(
  *   (item) => console.log('Processing:', item),
  *   { started: true, wait: 1000 },
@@ -67,7 +67,7 @@ import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
  *   })
  * );
  *
- * // Opt-in to re-render when processing state changes (optimized for loading indicators)
+ * // Opt-in to track processing state changes (optimized for loading indicators)
  * const [items, addItem, queue] = createQueuedSignal(
  *   (item) => console.log('Processing:', item),
  *   { started: true, wait: 1000 },
@@ -79,7 +79,7 @@ import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
  *   })
  * );
  *
- * // Opt-in to re-render when execution metrics change (optimized for stats display)
+ * // Opt-in to track execution metrics changes (optimized for stats display)
  * const [items, addItem, queue] = createQueuedSignal(
  *   (item) => console.log('Processing:', item),
  *   { started: true, wait: 1000 },

package/dist/queuer/createQueuedSignal.js

@@ -19,13 +19,13 @@ import { createQueuer } from "./createQueuer.js";
 * ## State Management and Selector
 *
 * The primitive uses Solid's reactive state management via the underlying queuer instance.
-* The `selector` parameter allows you to specify which queuer state changes will trigger a re-render,
-* optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.
+* The `selector` parameter allows you to specify which queuer state changes will trigger reactive updates,
+* optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
 *
 * **By default, there will be no reactive state subscriptions** and you must opt-in to state
-* tracking by providing a selector function. This prevents unnecessary re-renders and gives you
-* full control over when your component updates. Only when you provide a selector will the
-* component re-render when the selected state values change.
+* tracking by providing a selector function. This prevents unnecessary updates and gives you
+* full control over when your component tracks state changes. Only when you provide a selector will the
+* component track changes to the selected state values.
 *
 * Available queuer state properties:
 * - `executionCount`: Number of items that have been processed by the queuer
@@ -54,7 +54,7 @@ import { createQueuer } from "./createQueuer.js";
 *   }
 * );
 *
-* // Opt-in to re-render when queue contents change (optimized for displaying queue items)
+* // Opt-in to track queue contents changes (optimized for displaying queue items)
 * const [items, addItem, queue] = createQueuedSignal(
 *   (item) => console.log('Processing:', item),
 *   { started: true, wait: 1000 },
@@ -65,7 +65,7 @@ import { createQueuer } from "./createQueuer.js";
 *   })
 * );
 *
-* // Opt-in to re-render when processing state changes (optimized for loading indicators)
+* // Opt-in to track processing state changes (optimized for loading indicators)
 * const [items, addItem, queue] = createQueuedSignal(
 *   (item) => console.log('Processing:', item),
 *   { started: true, wait: 1000 },
@@ -77,7 +77,7 @@ import { createQueuer } from "./createQueuer.js";
 *   })
 * );
 *
-* // Opt-in to re-render when execution metrics change (optimized for stats display)
+* // Opt-in to track execution metrics changes (optimized for stats display)
 * const [items, addItem, queue] = createQueuedSignal(
 *   (item) => console.log('Processing:', item),
 *   { started: true, wait: 1000 },

package/dist/queuer/createQueuedSignal.js.map

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

package/dist/queuer/createQueuer.cjs

@@ -1,6 +1,6 @@
 const require_PacerProvider = require('../provider/PacerProvider.cjs');
-let __tanstack_solid_store = require("@tanstack/solid-store");
-let __tanstack_pacer_queuer = require("@tanstack/pacer/queuer");
+let _tanstack_solid_store = require("@tanstack/solid-store");
+let _tanstack_pacer_queuer = require("@tanstack/pacer/queuer");
 
 //#region src/queuer/createQueuer.ts
 /**
@@ -22,14 +22,24 @@ let __tanstack_pacer_queuer = require("@tanstack/pacer/queuer");
 *
 * ## State Management and Selector
 *
-* The hook uses TanStack Store for reactive state management. The `selector` parameter allows you
-* to specify which state changes will trigger a re-render, optimizing performance by preventing
-* unnecessary re-renders when irrelevant state changes occur.
+* The hook uses TanStack Store for reactive state management. You can subscribe to state changes
+* in two ways:
+*
+* **1. Using `queuer.Subscribe` component (Recommended for component tree subscriptions)**
+*
+* Use the `Subscribe` component to subscribe to state changes deep in your component tree without
+* needing to pass a selector to the hook. This is ideal when you want to subscribe to state
+* in child components.
+*
+* **2. Using the `selector` parameter (For hook-level subscriptions)**
+*
+* The `selector` parameter allows you to specify which state changes will trigger reactive updates
+* at the hook level, optimizing performance by preventing unnecessary updates when irrelevant
+* state changes occur.
 *
 * **By default, there will be no reactive state subscriptions** and you must opt-in to state
-* tracking by providing a selector function. This prevents unnecessary re-renders and gives you
-* full control over when your component updates. Only when you provide a selector will the
-* component re-render when the selected state values change.
+* tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary
+* updates and gives you full control over when your component tracks state changes.
 *
 * Available state properties:
 * - `executionCount`: Number of items that have been processed
@@ -52,14 +62,14 @@ let __tanstack_pacer_queuer = require("@tanstack/pacer/queuer");
 *   }
 * );
 *
-* // Opt-in to re-render when items or isRunning changes (optimized for UI updates)
+* // Opt-in to track items or isRunning changes (optimized for UI updates)
 * const queue = createQueuer(
 *   (item) => console.log('Processing', item),
 *   { started: true, wait: 1000 },
 *   (state) => ({ items: state.items, isRunning: state.isRunning })
 * );
 *
-* // Opt-in to re-render when execution metrics change (optimized for tracking progress)
+* // Opt-in to track execution metrics changes (optimized for tracking progress)
 * const queue = createQueuer(
 *   (item) => console.log('Processing', item),
 *   { started: true, wait: 1000 },
@@ -82,11 +92,15 @@ let __tanstack_pacer_queuer = require("@tanstack/pacer/queuer");
 * ```
 */
 function createQueuer(fn, options = {}, selector = () => ({})) {
-	const queuer = new __tanstack_pacer_queuer.Queuer(fn, {
+	const queuer = new _tanstack_pacer_queuer.Queuer(fn, {
 		...require_PacerProvider.useDefaultPacerOptions().queuer,
 		...options
 	});
-	const state = (0, __tanstack_solid_store.useStore)(queuer.store, selector);
+	queuer.Subscribe = function Subscribe(props) {
+		const selected = (0, _tanstack_solid_store.useStore)(queuer.store, props.selector);
+		return typeof props.children === "function" ? props.children(selected) : props.children;
+	};
+	const state = (0, _tanstack_solid_store.useStore)(queuer.store, selector);
 	return {
 		...queuer,
 		state

package/dist/queuer/createQueuer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createQueuer.cjs","names":["Queuer","useDefaultPacerOptions"],"sources":["../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer'\n\nexport interface SolidQueuer<TValue, TSelected = {}> extends Omit<\n  Queuer<TValue>,\n  'store'\n> {\n  /**\n   * Reactive state that will be updated when the queuer state changes\n   *\n   * Use this instead of `queuer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `queuer.state` instead of `queuer.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.\n   * Although, you can make the state reactive by using the `useStore` in your own usage.\n   */\n  readonly store: Store<Readonly<QueuerState<TValue>>>\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 * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management. The `selector` parameter allows you\n * to specify which state changes will trigger a re-render, optimizing performance by preventing\n * unnecessary re-renders when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n *\n * Available state properties:\n * - `executionCount`: Number of items that have been processed\n * - `isRunning`: Whether the queuer is currently running (not stopped)\n * - `items`: Array of items currently queued for processing\n * - `rejectionCount`: Number of items that were rejected (expired or failed validation)\n *\n * Example usage:\n * ```tsx\n * // Default behavior - no reactive state subscriptions\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 *     getPriority: (item) => item.priority // Process higher priority items first\n *   }\n * );\n *\n * // Opt-in to re-render when items or isRunning changes (optimized for UI updates)\n * const queue = createQueuer(\n *   (item) => console.log('Processing', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({ items: state.items, isRunning: state.isRunning })\n * );\n *\n * // Opt-in to re-render when execution metrics change (optimized for tracking progress)\n * const queue = createQueuer(\n *   (item) => console.log('Processing', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({\n *     executionCount: state.executionCount,\n *     rejectionCount: state.rejectionCount\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 the selected state (will be empty object {} unless selector provided)\n * const { items, isRunning } = queue.state();\n * ```\n */\nexport function createQueuer<TValue, TSelected = {}>(\n  fn: (item: TValue) => void,\n  options: QueuerOptions<TValue> = {},\n  selector: (state: QueuerState<TValue>) => TSelected = () => ({}) as TSelected,\n): SolidQueuer<TValue, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().queuer,\n    ...options,\n  } as QueuerOptions<TValue>\n\n  const queuer = new Queuer(fn, mergedOptions)\n\n  const state = useStore(queuer.store, selector)\n\n  return {\n    ...queuer,\n    state,\n  } as SolidQueuer<TValue, TSelected> // omit `store` in favor of `state`\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuGA,SAAgB,aACd,IACA,UAAiC,EAAE,EACnC,kBAA6D,EAAE,GAC/B;CAMhC,MAAM,SAAS,IAAIA,+BAAO,IALJ;EACpB,GAAGC,8CAAwB,CAAC;EAC5B,GAAG;EACJ,CAE2C;CAE5C,MAAM,6CAAiB,OAAO,OAAO,SAAS;AAE9C,QAAO;EACL,GAAG;EACH;EACD"}
+{"version":3,"file":"createQueuer.cjs","names":["Queuer","useDefaultPacerOptions"],"sources":["../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor, JSX } from 'solid-js'\nimport type { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer'\n\nexport interface SolidQueuer<TValue, TSelected = {}> extends Omit<\n  Queuer<TValue>,\n  'store'\n> {\n  /**\n   * A Solid component that allows you to subscribe to the queuer state.\n   *\n   * This is useful for tracking specific parts of the queuer state\n   * deep in your component tree without needing to pass a selector to the hook.\n   *\n   * @example\n   * <queuer.Subscribe selector={(state) => ({ size: state.size, isRunning: state.isRunning })}>\n   *   {(state) => (\n   *     <div>Queue: {state().size} items, {state().isRunning ? 'Processing' : 'Idle'}</div>\n   *   )}\n   * </queuer.Subscribe>\n   */\n  Subscribe: <TSelected>(props: {\n    selector: (state: QueuerState<TValue>) => TSelected\n    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element\n  }) => JSX.Element\n  /**\n   * Reactive state that will be updated when the queuer state changes\n   *\n   * Use this instead of `queuer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `queuer.state` instead of `queuer.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.\n   * Although, you can make the state reactive by using the `useStore` in your own usage.\n   */\n  readonly store: Store<Readonly<QueuerState<TValue>>>\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 * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management. You can subscribe to state changes\n * in two ways:\n *\n * **1. Using `queuer.Subscribe` component (Recommended for component tree subscriptions)**\n *\n * Use the `Subscribe` component to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n *\n * **2. Using the `selector` parameter (For hook-level subscriptions)**\n *\n * The `selector` parameter allows you to specify which state changes will trigger reactive updates\n * at the hook level, optimizing performance by preventing unnecessary updates when irrelevant\n * state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary\n * updates and gives you full control over when your component tracks state changes.\n *\n * Available state properties:\n * - `executionCount`: Number of items that have been processed\n * - `isRunning`: Whether the queuer is currently running (not stopped)\n * - `items`: Array of items currently queued for processing\n * - `rejectionCount`: Number of items that were rejected (expired or failed validation)\n *\n * Example usage:\n * ```tsx\n * // Default behavior - no reactive state subscriptions\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 *     getPriority: (item) => item.priority // Process higher priority items first\n *   }\n * );\n *\n * // Opt-in to track items or isRunning changes (optimized for UI updates)\n * const queue = createQueuer(\n *   (item) => console.log('Processing', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({ items: state.items, isRunning: state.isRunning })\n * );\n *\n * // Opt-in to track execution metrics changes (optimized for tracking progress)\n * const queue = createQueuer(\n *   (item) => console.log('Processing', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({\n *     executionCount: state.executionCount,\n *     rejectionCount: state.rejectionCount\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 the selected state (will be empty object {} unless selector provided)\n * const { items, isRunning } = queue.state();\n * ```\n */\nexport function createQueuer<TValue, TSelected = {}>(\n  fn: (item: TValue) => void,\n  options: QueuerOptions<TValue> = {},\n  selector: (state: QueuerState<TValue>) => TSelected = () => ({}) as TSelected,\n): SolidQueuer<TValue, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().queuer,\n    ...options,\n  } as QueuerOptions<TValue>\n\n  const queuer = new Queuer(fn, mergedOptions) as unknown as SolidQueuer<\n    TValue,\n    TSelected\n  >\n\n  queuer.Subscribe = function Subscribe<TSelected>(props: {\n    selector: (state: QueuerState<TValue>) => TSelected\n    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element\n  }) {\n    const selected = useStore(queuer.store, props.selector)\n\n    return typeof props.children === 'function'\n      ? props.children(selected)\n      : props.children\n  }\n\n  const state = useStore(queuer.store, selector)\n\n  return {\n    ...queuer,\n    state,\n  } as SolidQueuer<TValue, TSelected> // omit `store` in favor of `state`\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkIA,SAAgB,aACd,IACA,UAAiC,EAAE,EACnC,kBAA6D,EAAE,GAC/B;CAMhC,MAAM,SAAS,IAAIA,8BAAO,IALJ;EACpB,GAAGC,8CAAwB,CAAC;EAC5B,GAAG;EACJ,CAE2C;AAK5C,QAAO,YAAY,SAAS,UAAqB,OAG9C;EACD,MAAM,+CAAoB,OAAO,OAAO,MAAM,SAAS;AAEvD,SAAO,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;CAGZ,MAAM,4CAAiB,OAAO,OAAO,SAAS;AAE9C,QAAO;EACL,GAAG;EACH;EACD"}