@tanstack/solid-pacer 0.15.3 → 0.16.1

package/dist/provider/PacerProvider.js

@@ -0,0 +1,25 @@
+import { createComponent } from "solid-js/web";
+import { createContext, useContext } from "solid-js";
+
+//#region src/provider/PacerProvider.tsx
+const PacerContext = createContext(null);
+const DEFAULT_OPTIONS = {};
+function PacerProvider(props) {
+	const contextValue = { defaultOptions: props.defaultOptions ?? DEFAULT_OPTIONS };
+	return createComponent(PacerContext.Provider, {
+		value: contextValue,
+		get children() {
+			return props.children;
+		}
+	});
+}
+function usePacerContext() {
+	return useContext(PacerContext);
+}
+function useDefaultPacerOptions() {
+	return useContext(PacerContext)?.defaultOptions ?? {};
+}
+
+//#endregion
+export { PacerProvider, useDefaultPacerOptions, usePacerContext };
+//# sourceMappingURL=PacerProvider.js.map

package/dist/provider/PacerProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PacerProvider.js","names":["createContext","useContext","JSX","AnyAsyncFunction","AnyFunction","AsyncBatcherOptions","AsyncDebouncerOptions","AsyncQueuerOptions","AsyncRateLimiterOptions","AsyncThrottlerOptions","BatcherOptions","DebouncerOptions","QueuerOptions","RateLimiterOptions","ThrottlerOptions","PacerProviderOptions","asyncBatcher","Partial","asyncDebouncer","asyncQueuer","asyncRateLimiter","asyncThrottler","batcher","debouncer","queuer","rateLimiter","throttler","PacerContextValue","defaultOptions","PacerContext","PacerProviderProps","children","Element","DEFAULT_OPTIONS","PacerProvider","props","contextValue","_$createComponent","Provider","value","usePacerContext","useDefaultPacerOptions","context"],"sources":["../../src/provider/PacerProvider.tsx"],"sourcesContent":["import { createContext, useContext } from 'solid-js'\nimport type { JSX } from 'solid-js'\nimport type {\n  AnyAsyncFunction,\n  AnyFunction,\n  AsyncBatcherOptions,\n  AsyncDebouncerOptions,\n  AsyncQueuerOptions,\n  AsyncRateLimiterOptions,\n  AsyncThrottlerOptions,\n  BatcherOptions,\n  DebouncerOptions,\n  QueuerOptions,\n  RateLimiterOptions,\n  ThrottlerOptions,\n} from '@tanstack/pacer'\n\nexport interface PacerProviderOptions {\n  asyncBatcher?: Partial<AsyncBatcherOptions<any>>\n  asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>\n  asyncQueuer?: Partial<AsyncQueuerOptions<any>>\n  asyncRateLimiter?: Partial<AsyncRateLimiterOptions<AnyAsyncFunction>>\n  asyncThrottler?: Partial<AsyncThrottlerOptions<AnyAsyncFunction>>\n  batcher?: Partial<BatcherOptions<any>>\n  debouncer?: Partial<DebouncerOptions<AnyFunction>>\n  queuer?: Partial<QueuerOptions<any>>\n  rateLimiter?: Partial<RateLimiterOptions<AnyFunction>>\n  throttler?: Partial<ThrottlerOptions<AnyFunction>>\n}\n\ninterface PacerContextValue {\n  defaultOptions: PacerProviderOptions\n}\n\nconst PacerContext = createContext<PacerContextValue | null>(null)\n\nexport interface PacerProviderProps {\n  children: JSX.Element\n  defaultOptions?: PacerProviderOptions\n}\n\nconst DEFAULT_OPTIONS: PacerProviderOptions = {}\n\nexport function PacerProvider(props: PacerProviderProps) {\n  const contextValue: PacerContextValue = {\n    defaultOptions: props.defaultOptions ?? DEFAULT_OPTIONS,\n  }\n\n  return (\n    <PacerContext.Provider value={contextValue}>\n      {props.children}\n    </PacerContext.Provider>\n  )\n}\n\nexport function usePacerContext() {\n  return useContext(PacerContext)\n}\n\nexport function useDefaultPacerOptions() {\n  const context = useContext(PacerContext)\n  return context?.defaultOptions ?? {}\n}\n"],"mappings":";;;;AAkCA,MAAM6B,eAAe7B,cAAwC,KAAK;AAOlE,MAAMiC,kBAAwC,EAAE;AAEhD,SAAgBC,cAAcC,OAA2B;CACvD,MAAMC,eAAkC,EACtCR,gBAAgBO,MAAMP,kBAAkBK,iBACzC;AAED,QAAAI,gBACGR,aAAaS,UAAQ;EAACC,OAAOH;EAAY,IAAAL,WAAA;AAAA,UACvCI,MAAMJ;;EAAQ,CAAA;;AAKrB,SAAgBS,kBAAkB;AAChC,QAAOvC,WAAW4B,aAAa;;AAGjC,SAAgBY,yBAAyB;AAEvC,QADgBxC,WAAW4B,aAAa,EACxBD,kBAAkB,EAAE"}

package/dist/provider/index.cjs

@@ -0,0 +1,5 @@
+const require_PacerProvider = require('./PacerProvider.cjs');
+
+exports.PacerProvider = require_PacerProvider.PacerProvider;
+exports.useDefaultPacerOptions = require_PacerProvider.useDefaultPacerOptions;
+exports.usePacerContext = require_PacerProvider.usePacerContext;

package/dist/provider/index.d.cts

@@ -0,0 +1,2 @@
+import { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext } from "./PacerProvider.cjs";
+export { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext };

package/dist/provider/index.d.ts

@@ -0,0 +1,2 @@
+import { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext } from "./PacerProvider.js";
+export { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext };

package/dist/provider/index.js

@@ -0,0 +1,3 @@
+import { PacerProvider, useDefaultPacerOptions, usePacerContext } from "./PacerProvider.js";
+
+export { PacerProvider, useDefaultPacerOptions, usePacerContext };

package/dist/queuer/createQueuedSignal.cjs

@@ -0,0 +1,129 @@
+const require_createQueuer = require('./createQueuer.cjs');
+
+//#region src/queuer/createQueuedSignal.ts
+/**
+* A Solid primitive that creates a queuer with managed state, combining Solid's signals with queuing functionality.
+* This primitive provides both the current queue state and queue control methods.
+*
+* The queue state is automatically updated whenever items are added, removed, or reordered in the queue.
+* All queue operations are reflected in the state array returned by the primitive.
+*
+* The queue can be started and stopped to automatically process items at a specified interval,
+* making it useful as a scheduler. When started, it will process one item per tick, with an
+* optional wait time between ticks.
+*
+* The primitive returns a tuple containing:
+* - The current queue state as an array
+* - The queue instance with methods for queue manipulation
+*
+* ## 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.
+*
+* **By default, there will be no reactive state subscriptions** and you must opt-in to state
+* tracking by providing a selector function. This prevents unnecessary re-renders and gives you
+* full control over when your component updates. Only when you provide a selector will the
+* component re-render when the selected state values change.
+*
+* Available queuer state properties:
+* - `executionCount`: Number of items that have been processed by the queuer
+* - `expirationCount`: Number of items that have been removed due to expiration
+* - `isEmpty`: Whether the queuer has no items to process
+* - `isFull`: Whether the queuer has reached its maximum capacity
+* - `isIdle`: Whether the queuer is not currently processing any items
+* - `isRunning`: Whether the queuer is active and will process items automatically
+* - `items`: Array of items currently waiting to be processed
+* - `itemTimestamps`: Timestamps when items were added for expiration tracking
+* - `pendingTick`: Whether the queuer has a pending timeout for processing the next item
+* - `rejectionCount`: Number of items that have been rejected from being added
+* - `size`: Number of items currently in the queue
+* - `status`: Current processing status ('idle' | 'running' | 'stopped')
+*
+* @example
+* ```tsx
+* // Default behavior - no reactive state subscriptions
+* const [items, addItem, queue] = createQueuedSignal(
+*   (item) => console.log('Processing:', item),
+*   {
+*     initialItems: ['item1', 'item2'],
+*     started: true,
+*     wait: 1000,
+*     getPriority: (item) => item.priority
+*   }
+* );
+*
+* // Opt-in to re-render when queue contents change (optimized for displaying queue items)
+* const [items, addItem, queue] = createQueuedSignal(
+*   (item) => console.log('Processing:', item),
+*   { started: true, wait: 1000 },
+*   (state) => ({
+*     items: state.items,
+*     size: state.size,
+*     isEmpty: state.isEmpty
+*   })
+* );
+*
+* // Opt-in to re-render when processing state changes (optimized for loading indicators)
+* const [items, addItem, queue] = createQueuedSignal(
+*   (item) => console.log('Processing:', item),
+*   { started: true, wait: 1000 },
+*   (state) => ({
+*     isRunning: state.isRunning,
+*     isIdle: state.isIdle,
+*     status: state.status,
+*     pendingTick: state.pendingTick
+*   })
+* );
+*
+* // Opt-in to re-render when execution metrics change (optimized for stats display)
+* const [items, addItem, queue] = createQueuedSignal(
+*   (item) => console.log('Processing:', item),
+*   { started: true, wait: 1000 },
+*   (state) => ({
+*     executionCount: state.executionCount,
+*     expirationCount: state.expirationCount,
+*     rejectionCount: state.rejectionCount
+*   })
+* );
+*
+* // Add items to queue
+* const handleAdd = (item) => {
+*   addItem(item);
+* };
+*
+* // Start automatic processing
+* const startProcessing = () => {
+*   queue.start();
+* };
+*
+* // Stop automatic processing
+* const stopProcessing = () => {
+*   queue.stop();
+* };
+*
+* // Manual processing still available
+* const handleProcess = () => {
+*   const nextItem = queue.getNextItem();
+*   if (nextItem) {
+*     processItem(nextItem);
+*   }
+* };
+*
+* // Access the selected queuer state (will be empty object {} unless selector provided)
+* const { size, isRunning, executionCount } = queue.state;
+* ```
+*/
+function createQueuedSignal(fn, options = {}, selector = (state) => ({ items: state.items })) {
+	const queue = require_createQueuer.createQueuer(fn, options, selector);
+	return [
+		() => queue.state().items,
+		queue.addItem,
+		queue
+	];
+}
+
+//#endregion
+exports.createQueuedSignal = createQueuedSignal;
+//# sourceMappingURL=createQueuedSignal.cjs.map

package/dist/queuer/createQueuedSignal.cjs.map

@@ -0,0 +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"}

package/dist/queuer/createQueuedSignal.d.cts

@@ -0,0 +1,123 @@
+import { SolidQueuer } from "./createQueuer.cjs";
+import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
+
+//#region src/queuer/createQueuedSignal.d.ts
+
+/**
+ * A Solid primitive that creates a queuer with managed state, combining Solid's signals with queuing functionality.
+ * This primitive provides both the current queue state and queue control methods.
+ *
+ * The queue state is automatically updated whenever items are added, removed, or reordered in the queue.
+ * All queue operations are reflected in the state array returned by the primitive.
+ *
+ * The queue can be started and stopped to automatically process items at a specified interval,
+ * making it useful as a scheduler. When started, it will process one item per tick, with an
+ * optional wait time between ticks.
+ *
+ * The primitive returns a tuple containing:
+ * - The current queue state as an array
+ * - The queue instance with methods for queue manipulation
+ *
+ * ## 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.
+ *
+ * **By default, there will be no reactive state subscriptions** and you must opt-in to state
+ * tracking by providing a selector function. This prevents unnecessary re-renders and gives you
+ * full control over when your component updates. Only when you provide a selector will the
+ * component re-render when the selected state values change.
+ *
+ * Available queuer state properties:
+ * - `executionCount`: Number of items that have been processed by the queuer
+ * - `expirationCount`: Number of items that have been removed due to expiration
+ * - `isEmpty`: Whether the queuer has no items to process
+ * - `isFull`: Whether the queuer has reached its maximum capacity
+ * - `isIdle`: Whether the queuer is not currently processing any items
+ * - `isRunning`: Whether the queuer is active and will process items automatically
+ * - `items`: Array of items currently waiting to be processed
+ * - `itemTimestamps`: Timestamps when items were added for expiration tracking
+ * - `pendingTick`: Whether the queuer has a pending timeout for processing the next item
+ * - `rejectionCount`: Number of items that have been rejected from being added
+ * - `size`: Number of items currently in the queue
+ * - `status`: Current processing status ('idle' | 'running' | 'stopped')
+ *
+ * @example
+ * ```tsx
+ * // Default behavior - no reactive state subscriptions
+ * const [items, addItem, queue] = createQueuedSignal(
+ *   (item) => console.log('Processing:', item),
+ *   {
+ *     initialItems: ['item1', 'item2'],
+ *     started: true,
+ *     wait: 1000,
+ *     getPriority: (item) => item.priority
+ *   }
+ * );
+ *
+ * // Opt-in to re-render when queue contents change (optimized for displaying queue items)
+ * const [items, addItem, queue] = createQueuedSignal(
+ *   (item) => console.log('Processing:', item),
+ *   { started: true, wait: 1000 },
+ *   (state) => ({
+ *     items: state.items,
+ *     size: state.size,
+ *     isEmpty: state.isEmpty
+ *   })
+ * );
+ *
+ * // Opt-in to re-render when processing state changes (optimized for loading indicators)
+ * const [items, addItem, queue] = createQueuedSignal(
+ *   (item) => console.log('Processing:', item),
+ *   { started: true, wait: 1000 },
+ *   (state) => ({
+ *     isRunning: state.isRunning,
+ *     isIdle: state.isIdle,
+ *     status: state.status,
+ *     pendingTick: state.pendingTick
+ *   })
+ * );
+ *
+ * // Opt-in to re-render when execution metrics change (optimized for stats display)
+ * const [items, addItem, queue] = createQueuedSignal(
+ *   (item) => console.log('Processing:', item),
+ *   { started: true, wait: 1000 },
+ *   (state) => ({
+ *     executionCount: state.executionCount,
+ *     expirationCount: state.expirationCount,
+ *     rejectionCount: state.rejectionCount
+ *   })
+ * );
+ *
+ * // Add items to queue
+ * const handleAdd = (item) => {
+ *   addItem(item);
+ * };
+ *
+ * // Start automatic processing
+ * const startProcessing = () => {
+ *   queue.start();
+ * };
+ *
+ * // Stop automatic processing
+ * const stopProcessing = () => {
+ *   queue.stop();
+ * };
+ *
+ * // Manual processing still available
+ * const handleProcess = () => {
+ *   const nextItem = queue.getNextItem();
+ *   if (nextItem) {
+ *     processItem(nextItem);
+ *   }
+ * };
+ *
+ * // Access the selected queuer state (will be empty object {} unless selector provided)
+ * const { size, isRunning, executionCount } = queue.state;
+ * ```
+ */
+declare function createQueuedSignal<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(fn: (item: TValue) => void, options?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): [() => Array<TValue>, SolidQueuer<TValue, TSelected>['addItem'], SolidQueuer<TValue, TSelected>];
+//#endregion
+export { createQueuedSignal };
+//# sourceMappingURL=createQueuedSignal.d.cts.map

package/dist/queuer/createQueuedSignal.d.ts

@@ -0,0 +1,123 @@
+import { SolidQueuer } from "./createQueuer.js";
+import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
+
+//#region src/queuer/createQueuedSignal.d.ts
+
+/**
+ * A Solid primitive that creates a queuer with managed state, combining Solid's signals with queuing functionality.
+ * This primitive provides both the current queue state and queue control methods.
+ *
+ * The queue state is automatically updated whenever items are added, removed, or reordered in the queue.
+ * All queue operations are reflected in the state array returned by the primitive.
+ *
+ * The queue can be started and stopped to automatically process items at a specified interval,
+ * making it useful as a scheduler. When started, it will process one item per tick, with an
+ * optional wait time between ticks.
+ *
+ * The primitive returns a tuple containing:
+ * - The current queue state as an array
+ * - The queue instance with methods for queue manipulation
+ *
+ * ## 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.
+ *
+ * **By default, there will be no reactive state subscriptions** and you must opt-in to state
+ * tracking by providing a selector function. This prevents unnecessary re-renders and gives you
+ * full control over when your component updates. Only when you provide a selector will the
+ * component re-render when the selected state values change.
+ *
+ * Available queuer state properties:
+ * - `executionCount`: Number of items that have been processed by the queuer
+ * - `expirationCount`: Number of items that have been removed due to expiration
+ * - `isEmpty`: Whether the queuer has no items to process
+ * - `isFull`: Whether the queuer has reached its maximum capacity
+ * - `isIdle`: Whether the queuer is not currently processing any items
+ * - `isRunning`: Whether the queuer is active and will process items automatically
+ * - `items`: Array of items currently waiting to be processed
+ * - `itemTimestamps`: Timestamps when items were added for expiration tracking
+ * - `pendingTick`: Whether the queuer has a pending timeout for processing the next item
+ * - `rejectionCount`: Number of items that have been rejected from being added
+ * - `size`: Number of items currently in the queue
+ * - `status`: Current processing status ('idle' | 'running' | 'stopped')
+ *
+ * @example
+ * ```tsx
+ * // Default behavior - no reactive state subscriptions
+ * const [items, addItem, queue] = createQueuedSignal(
+ *   (item) => console.log('Processing:', item),
+ *   {
+ *     initialItems: ['item1', 'item2'],
+ *     started: true,
+ *     wait: 1000,
+ *     getPriority: (item) => item.priority
+ *   }
+ * );
+ *
+ * // Opt-in to re-render when queue contents change (optimized for displaying queue items)
+ * const [items, addItem, queue] = createQueuedSignal(
+ *   (item) => console.log('Processing:', item),
+ *   { started: true, wait: 1000 },
+ *   (state) => ({
+ *     items: state.items,
+ *     size: state.size,
+ *     isEmpty: state.isEmpty
+ *   })
+ * );
+ *
+ * // Opt-in to re-render when processing state changes (optimized for loading indicators)
+ * const [items, addItem, queue] = createQueuedSignal(
+ *   (item) => console.log('Processing:', item),
+ *   { started: true, wait: 1000 },
+ *   (state) => ({
+ *     isRunning: state.isRunning,
+ *     isIdle: state.isIdle,
+ *     status: state.status,
+ *     pendingTick: state.pendingTick
+ *   })
+ * );
+ *
+ * // Opt-in to re-render when execution metrics change (optimized for stats display)
+ * const [items, addItem, queue] = createQueuedSignal(
+ *   (item) => console.log('Processing:', item),
+ *   { started: true, wait: 1000 },
+ *   (state) => ({
+ *     executionCount: state.executionCount,
+ *     expirationCount: state.expirationCount,
+ *     rejectionCount: state.rejectionCount
+ *   })
+ * );
+ *
+ * // Add items to queue
+ * const handleAdd = (item) => {
+ *   addItem(item);
+ * };
+ *
+ * // Start automatic processing
+ * const startProcessing = () => {
+ *   queue.start();
+ * };
+ *
+ * // Stop automatic processing
+ * const stopProcessing = () => {
+ *   queue.stop();
+ * };
+ *
+ * // Manual processing still available
+ * const handleProcess = () => {
+ *   const nextItem = queue.getNextItem();
+ *   if (nextItem) {
+ *     processItem(nextItem);
+ *   }
+ * };
+ *
+ * // Access the selected queuer state (will be empty object {} unless selector provided)
+ * const { size, isRunning, executionCount } = queue.state;
+ * ```
+ */
+declare function createQueuedSignal<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(fn: (item: TValue) => void, options?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): [() => Array<TValue>, SolidQueuer<TValue, TSelected>['addItem'], SolidQueuer<TValue, TSelected>];
+//#endregion
+export { createQueuedSignal };
+//# sourceMappingURL=createQueuedSignal.d.ts.map

package/dist/queuer/createQueuedSignal.js

@@ -0,0 +1,129 @@
+import { createQueuer } from "./createQueuer.js";
+
+//#region src/queuer/createQueuedSignal.ts
+/**
+* A Solid primitive that creates a queuer with managed state, combining Solid's signals with queuing functionality.
+* This primitive provides both the current queue state and queue control methods.
+*
+* The queue state is automatically updated whenever items are added, removed, or reordered in the queue.
+* All queue operations are reflected in the state array returned by the primitive.
+*
+* The queue can be started and stopped to automatically process items at a specified interval,
+* making it useful as a scheduler. When started, it will process one item per tick, with an
+* optional wait time between ticks.
+*
+* The primitive returns a tuple containing:
+* - The current queue state as an array
+* - The queue instance with methods for queue manipulation
+*
+* ## 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.
+*
+* **By default, there will be no reactive state subscriptions** and you must opt-in to state
+* tracking by providing a selector function. This prevents unnecessary re-renders and gives you
+* full control over when your component updates. Only when you provide a selector will the
+* component re-render when the selected state values change.
+*
+* Available queuer state properties:
+* - `executionCount`: Number of items that have been processed by the queuer
+* - `expirationCount`: Number of items that have been removed due to expiration
+* - `isEmpty`: Whether the queuer has no items to process
+* - `isFull`: Whether the queuer has reached its maximum capacity
+* - `isIdle`: Whether the queuer is not currently processing any items
+* - `isRunning`: Whether the queuer is active and will process items automatically
+* - `items`: Array of items currently waiting to be processed
+* - `itemTimestamps`: Timestamps when items were added for expiration tracking
+* - `pendingTick`: Whether the queuer has a pending timeout for processing the next item
+* - `rejectionCount`: Number of items that have been rejected from being added
+* - `size`: Number of items currently in the queue
+* - `status`: Current processing status ('idle' | 'running' | 'stopped')
+*
+* @example
+* ```tsx
+* // Default behavior - no reactive state subscriptions
+* const [items, addItem, queue] = createQueuedSignal(
+*   (item) => console.log('Processing:', item),
+*   {
+*     initialItems: ['item1', 'item2'],
+*     started: true,
+*     wait: 1000,
+*     getPriority: (item) => item.priority
+*   }
+* );
+*
+* // Opt-in to re-render when queue contents change (optimized for displaying queue items)
+* const [items, addItem, queue] = createQueuedSignal(
+*   (item) => console.log('Processing:', item),
+*   { started: true, wait: 1000 },
+*   (state) => ({
+*     items: state.items,
+*     size: state.size,
+*     isEmpty: state.isEmpty
+*   })
+* );
+*
+* // Opt-in to re-render when processing state changes (optimized for loading indicators)
+* const [items, addItem, queue] = createQueuedSignal(
+*   (item) => console.log('Processing:', item),
+*   { started: true, wait: 1000 },
+*   (state) => ({
+*     isRunning: state.isRunning,
+*     isIdle: state.isIdle,
+*     status: state.status,
+*     pendingTick: state.pendingTick
+*   })
+* );
+*
+* // Opt-in to re-render when execution metrics change (optimized for stats display)
+* const [items, addItem, queue] = createQueuedSignal(
+*   (item) => console.log('Processing:', item),
+*   { started: true, wait: 1000 },
+*   (state) => ({
+*     executionCount: state.executionCount,
+*     expirationCount: state.expirationCount,
+*     rejectionCount: state.rejectionCount
+*   })
+* );
+*
+* // Add items to queue
+* const handleAdd = (item) => {
+*   addItem(item);
+* };
+*
+* // Start automatic processing
+* const startProcessing = () => {
+*   queue.start();
+* };
+*
+* // Stop automatic processing
+* const stopProcessing = () => {
+*   queue.stop();
+* };
+*
+* // Manual processing still available
+* const handleProcess = () => {
+*   const nextItem = queue.getNextItem();
+*   if (nextItem) {
+*     processItem(nextItem);
+*   }
+* };
+*
+* // Access the selected queuer state (will be empty object {} unless selector provided)
+* const { size, isRunning, executionCount } = queue.state;
+* ```
+*/
+function createQueuedSignal(fn, options = {}, selector = (state) => ({ items: state.items })) {
+	const queue = createQueuer(fn, options, selector);
+	return [
+		() => queue.state().items,
+		queue.addItem,
+		queue
+	];
+}
+
+//#endregion
+export { createQueuedSignal };
+//# sourceMappingURL=createQueuedSignal.js.map

package/dist/queuer/createQueuedSignal.js.map

@@ -0,0 +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"}