@tanstack/pacer-lite 0.1.0 → 0.1.1

package/dist/lite-queuer.d.ts

@@ -0,0 +1,243 @@
+//#region src/lite-queuer.d.ts
+/**
+ * Position type for addItem and getNextItem operations.
+ *
+ * - 'front': Operate on the front of the queue (FIFO for getNextItem)
+ * - 'back': Operate on the back of the queue (LIFO for getNextItem)
+ */
+type QueuePosition = 'front' | 'back';
+/**
+ * Options for configuring a lite queuer instance
+ */
+interface LiteQueuerOptions<TValue> {
+  /**
+   * Default position to add items to the queue
+   * @default 'back'
+   */
+  addItemsTo?: QueuePosition;
+  /**
+   * Default position to get items from during processing
+   * @default 'front'
+   */
+  getItemsFrom?: QueuePosition;
+  /**
+   * Function to determine priority of items in the queue
+   * Higher priority items will be processed first
+   * Return undefined for items that should use positional ordering
+   */
+  getPriority?: (item: TValue) => number | undefined;
+  /**
+   * Initial items to populate the queue with
+   */
+  initialItems?: Array<TValue>;
+  /**
+   * Maximum number of items allowed in the queue
+   */
+  maxSize?: number;
+  /**
+   * Whether the queuer should start processing items immediately
+   * @default true
+   */
+  started?: boolean;
+  /**
+   * Time in milliseconds to wait between processing items
+   * @default 0
+   */
+  wait?: number;
+}
+/**
+ * A lightweight class that creates a queue for processing items.
+ *
+ * This is an alternative to the Queuer in the core @tanstack/pacer package, but is more
+ * suitable for libraries and npm packages that need minimal overhead. Unlike the core Queuer,
+ * this version does not use TanStack Store for state management, has no devtools integration,
+ * no callbacks, and provides only essential queueing functionality.
+ *
+ * The queuer supports FIFO (First In First Out), LIFO (Last In First Out), and priority-based
+ * processing of items. Items can be processed automatically with configurable wait times
+ * between executions, or processed manually using the execute methods.
+ *
+ * Features included:
+ * - Automatic or manual processing of items
+ * - FIFO, LIFO, and priority-based ordering
+ * - Queue size limits with item rejection
+ * - Configurable wait times between processing
+ * - Batch processing capabilities
+ * - Start/stop processing control
+ * - Callback support for monitoring execution, rejection, and state change events
+ *
+ * Features NOT included (compared to core Queuer):
+ * - No TanStack Store state management
+ * - No devtools integration
+ * - No item expiration functionality (no onExpire callback)
+ * - No dynamic options updates (setOptions)
+ * - No detailed state tracking (execution counts, etc.)
+ *
+ * Queue behavior:
+ * - Default: FIFO (add to back, process from front)
+ * - LIFO: Configure addItemsTo: 'back', getItemsFrom: 'back'
+ * - Priority: Provide getPriority function; higher values processed first
+ *
+ * @example
+ * ```ts
+ * // Basic FIFO queue
+ * const queue = new LiteQueuer((item: string) => {
+ *   console.log('Processing:', item);
+ * }, { wait: 100 });
+ *
+ * queue.addItem('task1');
+ * queue.addItem('task2');
+ * // Processes: task1, then task2 after 100ms delay
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Priority queue
+ * const priorityQueue = new LiteQueuer((item: Task) => {
+ *   processTask(item);
+ * }, {
+ *   getPriority: task => task.priority,
+ *   wait: 500
+ * });
+ *
+ * priorityQueue.addItem({ name: 'low', priority: 1 });
+ * priorityQueue.addItem({ name: 'high', priority: 10 });
+ * // Processes high priority task first
+ * ```
+ */
+declare class LiteQueuer<TValue> {
+  fn: (item: TValue) => void;
+  options: LiteQueuerOptions<TValue>;
+  private items;
+  private timeoutId;
+  private isRunning;
+  private pendingTick;
+  constructor(fn: (item: TValue) => void, options?: LiteQueuerOptions<TValue>);
+  /**
+   * Number of items currently in the queue
+   */
+  get size(): number;
+  /**
+   * Whether the queue is empty
+   */
+  get isEmpty(): boolean;
+  /**
+   * Whether the queue is currently running (auto-processing items)
+   */
+  get isQueueRunning(): boolean;
+  /**
+   * Adds an item to the queue. If the queue is full, the item is rejected.
+   * Items can be inserted at the front or back, and priority ordering is applied if getPriority is configured.
+   *
+   * Returns true if the item was added, false if the queue is full.
+   *
+   * @example
+   * ```ts
+   * queue.addItem('task1');           // Add to default position (back)
+   * queue.addItem('task2', 'front');  // Add to front
+   * ```
+   */
+  addItem: (item: TValue, position?: QueuePosition, startProcessing?: boolean) => boolean;
+  private insertAtPosition;
+  /**
+   * Removes and returns the next item from the queue without executing the function.
+   * Use for manual queue management. Normally, use execute() to process items.
+   *
+   * @example
+   * ```ts
+   * const nextItem = queue.getNextItem();        // Get from default position (front)
+   * const lastItem = queue.getNextItem('back');  // Get from back (LIFO)
+   * ```
+   */
+  getNextItem: (position?: QueuePosition) => TValue | undefined;
+  /**
+   * Removes and returns the next item from the queue and processes it using the provided function.
+   *
+   * @example
+   * ```ts
+   * queue.execute();        // Execute from default position
+   * queue.execute('back');  // Execute from back (LIFO)
+   * ```
+   */
+  execute: (position?: QueuePosition) => TValue | undefined;
+  /**
+   * Internal method that processes items in the queue with wait intervals
+   */
+  private tick;
+  /**
+   * Starts processing items in the queue. If already running, does nothing.
+   */
+  start: () => void;
+  /**
+   * Stops processing items in the queue. Does not clear the queue.
+   */
+  stop: () => void;
+  /**
+   * Clears any pending timeout
+   */
+  private clearTimeout;
+  /**
+   * Returns the next item in the queue without removing it.
+   *
+   * @example
+   * ```ts
+   * const next = queue.peekNextItem();        // Peek at front
+   * const last = queue.peekNextItem('back');  // Peek at back
+   * ```
+   */
+  peekNextItem: (position?: QueuePosition) => TValue | undefined;
+  /**
+   * Returns a copy of all items in the queue.
+   */
+  peekAllItems: () => Array<TValue>;
+  /**
+   * Processes a specified number of items immediately with no wait time.
+   * If no numberOfItems is provided, all items will be processed.
+   *
+   * @example
+   * ```ts
+   * queue.flush();     // Process all items immediately
+   * queue.flush(3);    // Process next 3 items immediately
+   * ```
+   */
+  flush: (numberOfItems?: number, position?: QueuePosition) => void;
+  /**
+   * Processes all items in the queue as a batch using the provided function.
+   * The queue is cleared after processing.
+   *
+   * @example
+   * ```ts
+   * queue.flushAsBatch((items) => {
+   *   console.log('Processing batch:', items);
+   *   // Process all items together
+   * });
+   * ```
+   */
+  flushAsBatch: (batchFunction: (items: Array<TValue>) => void) => void;
+  /**
+   * Removes all items from the queue. Does not affect items being processed.
+   */
+  clear: () => void;
+}
+/**
+ * Creates a lightweight queue that processes items using the provided function.
+ *
+ * This is an alternative to the queue function in the core @tanstack/pacer package, but is more
+ * suitable for libraries and npm packages that need minimal overhead. Unlike the core version,
+ * this function creates a queuer with no external dependencies, devtools integration, or reactive state.
+ *
+ * @example
+ * ```ts
+ * const processItem = liteQueue((item: string) => {
+ *   console.log('Processing:', item);
+ * }, { wait: 1000 });
+ *
+ * processItem('task1');
+ * processItem('task2');
+ * // Processes each item with 1 second delay between them
+ * ```
+ */
+declare function liteQueue<TValue>(fn: (item: TValue) => void, options?: LiteQueuerOptions<TValue>): (item: TValue) => boolean;
+//#endregion
+export { LiteQueuer, LiteQueuerOptions, QueuePosition, liteQueue };
+//# sourceMappingURL=lite-queuer.d.ts.map

package/dist/lite-queuer.js

@@ -0,0 +1,206 @@
+//#region src/lite-queuer.ts
+/**
+* A lightweight class that creates a queue for processing items.
+*
+* This is an alternative to the Queuer in the core @tanstack/pacer package, but is more
+* suitable for libraries and npm packages that need minimal overhead. Unlike the core Queuer,
+* this version does not use TanStack Store for state management, has no devtools integration,
+* no callbacks, and provides only essential queueing functionality.
+*
+* The queuer supports FIFO (First In First Out), LIFO (Last In First Out), and priority-based
+* processing of items. Items can be processed automatically with configurable wait times
+* between executions, or processed manually using the execute methods.
+*
+* Features included:
+* - Automatic or manual processing of items
+* - FIFO, LIFO, and priority-based ordering
+* - Queue size limits with item rejection
+* - Configurable wait times between processing
+* - Batch processing capabilities
+* - Start/stop processing control
+* - Callback support for monitoring execution, rejection, and state change events
+*
+* Features NOT included (compared to core Queuer):
+* - No TanStack Store state management
+* - No devtools integration
+* - No item expiration functionality (no onExpire callback)
+* - No dynamic options updates (setOptions)
+* - No detailed state tracking (execution counts, etc.)
+*
+* Queue behavior:
+* - Default: FIFO (add to back, process from front)
+* - LIFO: Configure addItemsTo: 'back', getItemsFrom: 'back'
+* - Priority: Provide getPriority function; higher values processed first
+*
+* @example
+* ```ts
+* // Basic FIFO queue
+* const queue = new LiteQueuer((item: string) => {
+*   console.log('Processing:', item);
+* }, { wait: 100 });
+*
+* queue.addItem('task1');
+* queue.addItem('task2');
+* // Processes: task1, then task2 after 100ms delay
+* ```
+*
+* @example
+* ```ts
+* // Priority queue
+* const priorityQueue = new LiteQueuer((item: Task) => {
+*   processTask(item);
+* }, {
+*   getPriority: task => task.priority,
+*   wait: 500
+* });
+*
+* priorityQueue.addItem({ name: 'low', priority: 1 });
+* priorityQueue.addItem({ name: 'high', priority: 10 });
+* // Processes high priority task first
+* ```
+*/
+var LiteQueuer = class {
+	constructor(fn, options = {}) {
+		this.fn = fn;
+		this.options = options;
+		this.items = [];
+		this.timeoutId = null;
+		this.isRunning = true;
+		this.pendingTick = false;
+		this.addItem = (item, position = this.options.addItemsTo, startProcessing = true) => {
+			if (this.items.length >= this.options.maxSize) return false;
+			if (this.options.getPriority) {
+				const priority = this.options.getPriority(item);
+				if (priority !== void 0) {
+					const insertIndex = this.items.findIndex((existing) => {
+						return (this.options.getPriority(existing) ?? -Infinity) < priority;
+					});
+					if (insertIndex === -1) this.items.push(item);
+					else this.items.splice(insertIndex, 0, item);
+				} else this.insertAtPosition(item, position);
+			} else this.insertAtPosition(item, position);
+			if (startProcessing && this.isRunning && !this.pendingTick) this.tick();
+			return true;
+		};
+		this.insertAtPosition = (item, position) => {
+			if (position === "front") this.items.unshift(item);
+			else this.items.push(item);
+		};
+		this.getNextItem = (position = this.options.getItemsFrom) => {
+			if (this.items.length === 0) return;
+			let item;
+			if (this.options.getPriority || position === "front") item = this.items.shift();
+			else item = this.items.pop();
+			return item;
+		};
+		this.execute = (position) => {
+			const item = this.getNextItem(position);
+			if (item !== void 0) this.fn(item);
+			return item;
+		};
+		this.tick = () => {
+			if (!this.isRunning) {
+				this.pendingTick = false;
+				return;
+			}
+			this.pendingTick = true;
+			while (this.items.length > 0) {
+				if (this.execute(this.options.getItemsFrom) === void 0) break;
+				const wait = this.options.wait;
+				if (wait > 0) {
+					this.timeoutId = setTimeout(() => this.tick(), wait);
+					return;
+				}
+			}
+			this.pendingTick = false;
+		};
+		this.start = () => {
+			this.isRunning = true;
+			if (!this.pendingTick && this.items.length > 0) this.tick();
+		};
+		this.stop = () => {
+			this.clearTimeout();
+			this.isRunning = false;
+			this.pendingTick = false;
+		};
+		this.clearTimeout = () => {
+			if (this.timeoutId) {
+				clearTimeout(this.timeoutId);
+				this.timeoutId = null;
+			}
+		};
+		this.peekNextItem = (position = "front") => {
+			if (this.items.length === 0) return;
+			if (this.options.getPriority || position === "front") return this.items[0];
+			else return this.items[this.items.length - 1];
+		};
+		this.peekAllItems = () => {
+			return [...this.items];
+		};
+		this.flush = (numberOfItems = this.items.length, position) => {
+			this.clearTimeout();
+			for (let i = 0; i < numberOfItems && this.items.length > 0; i++) this.execute(position);
+			if (this.isRunning && this.items.length > 0 && !this.pendingTick) this.tick();
+		};
+		this.flushAsBatch = (batchFunction) => {
+			const items = this.peekAllItems();
+			this.clear();
+			batchFunction(items);
+		};
+		this.clear = () => {
+			this.items = [];
+		};
+		this.options.addItemsTo = this.options.addItemsTo ?? "back";
+		this.options.getItemsFrom = this.options.getItemsFrom ?? "front";
+		this.options.maxSize = this.options.maxSize ?? Infinity;
+		this.options.started = this.options.started ?? true;
+		this.options.wait = this.options.wait ?? 0;
+		this.isRunning = this.options.started;
+		if (this.options.initialItems) for (const item of this.options.initialItems) this.addItem(item, this.options.addItemsTo, false);
+		if (this.isRunning && this.items.length > 0) this.tick();
+	}
+	/**
+	* Number of items currently in the queue
+	*/
+	get size() {
+		return this.items.length;
+	}
+	/**
+	* Whether the queue is empty
+	*/
+	get isEmpty() {
+		return this.items.length === 0;
+	}
+	/**
+	* Whether the queue is currently running (auto-processing items)
+	*/
+	get isQueueRunning() {
+		return this.isRunning;
+	}
+};
+/**
+* Creates a lightweight queue that processes items using the provided function.
+*
+* This is an alternative to the queue function in the core @tanstack/pacer package, but is more
+* suitable for libraries and npm packages that need minimal overhead. Unlike the core version,
+* this function creates a queuer with no external dependencies, devtools integration, or reactive state.
+*
+* @example
+* ```ts
+* const processItem = liteQueue((item: string) => {
+*   console.log('Processing:', item);
+* }, { wait: 1000 });
+*
+* processItem('task1');
+* processItem('task2');
+* // Processes each item with 1 second delay between them
+* ```
+*/
+function liteQueue(fn, options = {}) {
+	const queuer = new LiteQueuer(fn, options);
+	return (item) => queuer.addItem(item);
+}
+
+//#endregion
+export { LiteQueuer, liteQueue };
+//# sourceMappingURL=lite-queuer.js.map

package/dist/lite-queuer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lite-queuer.js","names":["fn: (item: TValue) => void","options: LiteQueuerOptions<TValue>","item: TValue | undefined"],"sources":["../src/lite-queuer.ts"],"sourcesContent":["/**\n * Position type for addItem and getNextItem operations.\n *\n * - 'front': Operate on the front of the queue (FIFO for getNextItem)\n * - 'back': Operate on the back of the queue (LIFO for getNextItem)\n */\nexport type QueuePosition = 'front' | 'back'\n\n/**\n * Options for configuring a lite queuer instance\n */\nexport interface LiteQueuerOptions<TValue> {\n  /**\n   * Default position to add items to the queue\n   * @default 'back'\n   */\n  addItemsTo?: QueuePosition\n  /**\n   * Default position to get items from during processing\n   * @default 'front'\n   */\n  getItemsFrom?: QueuePosition\n  /**\n   * Function to determine priority of items in the queue\n   * Higher priority items will be processed first\n   * Return undefined for items that should use positional ordering\n   */\n  getPriority?: (item: TValue) => number | undefined\n  /**\n   * Initial items to populate the queue with\n   */\n  initialItems?: Array<TValue>\n  /**\n   * Maximum number of items allowed in the queue\n   */\n  maxSize?: number\n  /**\n   * Whether the queuer should start processing items immediately\n   * @default true\n   */\n  started?: boolean\n  /**\n   * Time in milliseconds to wait between processing items\n   * @default 0\n   */\n  wait?: number\n}\n\n/**\n * A lightweight class that creates a queue for processing items.\n *\n * This is an alternative to the Queuer in the core @tanstack/pacer package, but is more\n * suitable for libraries and npm packages that need minimal overhead. Unlike the core Queuer,\n * this version does not use TanStack Store for state management, has no devtools integration,\n * no callbacks, and provides only essential queueing functionality.\n *\n * The queuer supports FIFO (First In First Out), LIFO (Last In First Out), and priority-based\n * processing of items. Items can be processed automatically with configurable wait times\n * between executions, or processed manually using the execute methods.\n *\n * Features included:\n * - Automatic or manual processing of items\n * - FIFO, LIFO, and priority-based ordering\n * - Queue size limits with item rejection\n * - Configurable wait times between processing\n * - Batch processing capabilities\n * - Start/stop processing control\n * - Callback support for monitoring execution, rejection, and state change events\n *\n * Features NOT included (compared to core Queuer):\n * - No TanStack Store state management\n * - No devtools integration\n * - No item expiration functionality (no onExpire callback)\n * - No dynamic options updates (setOptions)\n * - No detailed state tracking (execution counts, etc.)\n *\n * Queue behavior:\n * - Default: FIFO (add to back, process from front)\n * - LIFO: Configure addItemsTo: 'back', getItemsFrom: 'back'\n * - Priority: Provide getPriority function; higher values processed first\n *\n * @example\n * ```ts\n * // Basic FIFO queue\n * const queue = new LiteQueuer((item: string) => {\n *   console.log('Processing:', item);\n * }, { wait: 100 });\n *\n * queue.addItem('task1');\n * queue.addItem('task2');\n * // Processes: task1, then task2 after 100ms delay\n * ```\n *\n * @example\n * ```ts\n * // Priority queue\n * const priorityQueue = new LiteQueuer((item: Task) => {\n *   processTask(item);\n * }, {\n *   getPriority: task => task.priority,\n *   wait: 500\n * });\n *\n * priorityQueue.addItem({ name: 'low', priority: 1 });\n * priorityQueue.addItem({ name: 'high', priority: 10 });\n * // Processes high priority task first\n * ```\n */\nexport class LiteQueuer<TValue> {\n  private items: Array<TValue> = []\n  private timeoutId: NodeJS.Timeout | null = null\n  private isRunning = true\n  private pendingTick = false\n\n  constructor(\n    public fn: (item: TValue) => void,\n    public options: LiteQueuerOptions<TValue> = {},\n  ) {\n    // Set defaults\n    this.options.addItemsTo = this.options.addItemsTo ?? 'back'\n    this.options.getItemsFrom = this.options.getItemsFrom ?? 'front'\n    this.options.maxSize = this.options.maxSize ?? Infinity\n    this.options.started = this.options.started ?? true\n    this.options.wait = this.options.wait ?? 0\n\n    this.isRunning = this.options.started\n\n    // Add initial items if provided\n    if (this.options.initialItems) {\n      for (const item of this.options.initialItems) {\n        this.addItem(item, this.options.addItemsTo, false)\n      }\n    }\n\n    // Start processing if enabled and has items\n    if (this.isRunning && this.items.length > 0) {\n      this.tick()\n    }\n  }\n\n  /**\n   * Number of items currently in the queue\n   */\n  get size(): number {\n    return this.items.length\n  }\n\n  /**\n   * Whether the queue is empty\n   */\n  get isEmpty(): boolean {\n    return this.items.length === 0\n  }\n\n  /**\n   * Whether the queue is currently running (auto-processing items)\n   */\n  get isQueueRunning(): boolean {\n    return this.isRunning\n  }\n\n  /**\n   * Adds an item to the queue. If the queue is full, the item is rejected.\n   * Items can be inserted at the front or back, and priority ordering is applied if getPriority is configured.\n   *\n   * Returns true if the item was added, false if the queue is full.\n   *\n   * @example\n   * ```ts\n   * queue.addItem('task1');           // Add to default position (back)\n   * queue.addItem('task2', 'front');  // Add to front\n   * ```\n   */\n  addItem = (\n    item: TValue,\n    position: QueuePosition = this.options.addItemsTo!,\n    startProcessing: boolean = true,\n  ): boolean => {\n    // Check size limit\n    if (this.items.length >= this.options.maxSize!) {\n      return false\n    }\n\n    // Handle priority insertion\n    if (this.options.getPriority) {\n      const priority = this.options.getPriority(item)\n      if (priority !== undefined) {\n        // Find insertion point for priority\n        const insertIndex = this.items.findIndex((existing) => {\n          const existingPriority = this.options.getPriority!(existing)\n          // Treat undefined priority as negative infinity for comparison\n          const effectivePriority = existingPriority ?? -Infinity\n          return effectivePriority < priority\n        })\n\n        if (insertIndex === -1) {\n          this.items.push(item)\n        } else {\n          this.items.splice(insertIndex, 0, item)\n        }\n      } else {\n        // No priority, use position\n        this.insertAtPosition(item, position)\n      }\n    } else {\n      // No priority function, use position\n      this.insertAtPosition(item, position)\n    }\n\n    // Start processing if running and not already processing\n    if (startProcessing && this.isRunning && !this.pendingTick) {\n      this.tick()\n    }\n\n    return true\n  }\n\n  private insertAtPosition = (item: TValue, position: QueuePosition): void => {\n    if (position === 'front') {\n      this.items.unshift(item)\n    } else {\n      this.items.push(item)\n    }\n  }\n\n  /**\n   * Removes and returns the next item from the queue without executing the function.\n   * Use for manual queue management. Normally, use execute() to process items.\n   *\n   * @example\n   * ```ts\n   * const nextItem = queue.getNextItem();        // Get from default position (front)\n   * const lastItem = queue.getNextItem('back');  // Get from back (LIFO)\n   * ```\n   */\n  getNextItem = (\n    position: QueuePosition = this.options.getItemsFrom!,\n  ): TValue | undefined => {\n    if (this.items.length === 0) {\n      return undefined\n    }\n\n    let item: TValue | undefined\n\n    // When priority function is provided, always get from front (highest priority)\n    if (this.options.getPriority || position === 'front') {\n      item = this.items.shift()\n    } else {\n      item = this.items.pop()\n    }\n\n    return item\n  }\n\n  /**\n   * Removes and returns the next item from the queue and processes it using the provided function.\n   *\n   * @example\n   * ```ts\n   * queue.execute();        // Execute from default position\n   * queue.execute('back');  // Execute from back (LIFO)\n   * ```\n   */\n  execute = (position?: QueuePosition): TValue | undefined => {\n    const item = this.getNextItem(position)\n    if (item !== undefined) {\n      this.fn(item)\n    }\n    return item\n  }\n\n  /**\n   * Internal method that processes items in the queue with wait intervals\n   */\n  private tick = (): void => {\n    if (!this.isRunning) {\n      this.pendingTick = false\n      return\n    }\n\n    this.pendingTick = true\n\n    // Process items while queue is not empty\n    while (this.items.length > 0) {\n      const item = this.execute(this.options.getItemsFrom)\n      if (item === undefined) {\n        break\n      }\n\n      const wait = this.options.wait!\n      if (wait > 0) {\n        // Schedule next processing after wait time\n        this.timeoutId = setTimeout(() => this.tick(), wait)\n        return\n      }\n\n      // No wait time, continue processing immediately\n    }\n\n    this.pendingTick = false\n  }\n\n  /**\n   * Starts processing items in the queue. If already running, does nothing.\n   */\n  start = (): void => {\n    this.isRunning = true\n    if (!this.pendingTick && this.items.length > 0) {\n      this.tick()\n    }\n  }\n\n  /**\n   * Stops processing items in the queue. Does not clear the queue.\n   */\n  stop = (): void => {\n    this.clearTimeout()\n    this.isRunning = false\n    this.pendingTick = false\n  }\n\n  /**\n   * Clears any pending timeout\n   */\n  private clearTimeout = (): void => {\n    if (this.timeoutId) {\n      clearTimeout(this.timeoutId)\n      this.timeoutId = null\n    }\n  }\n\n  /**\n   * Returns the next item in the queue without removing it.\n   *\n   * @example\n   * ```ts\n   * const next = queue.peekNextItem();        // Peek at front\n   * const last = queue.peekNextItem('back');  // Peek at back\n   * ```\n   */\n  peekNextItem = (position: QueuePosition = 'front'): TValue | undefined => {\n    if (this.items.length === 0) {\n      return undefined\n    }\n\n    if (this.options.getPriority || position === 'front') {\n      return this.items[0]\n    } else {\n      return this.items[this.items.length - 1]\n    }\n  }\n\n  /**\n   * Returns a copy of all items in the queue.\n   */\n  peekAllItems = (): Array<TValue> => {\n    return [...this.items]\n  }\n\n  /**\n   * Processes a specified number of items immediately with no wait time.\n   * If no numberOfItems is provided, all items will be processed.\n   *\n   * @example\n   * ```ts\n   * queue.flush();     // Process all items immediately\n   * queue.flush(3);    // Process next 3 items immediately\n   * ```\n   */\n  flush = (\n    numberOfItems: number = this.items.length,\n    position?: QueuePosition,\n  ): void => {\n    this.clearTimeout() // Clear any pending timeout\n    for (let i = 0; i < numberOfItems && this.items.length > 0; i++) {\n      this.execute(position)\n    }\n    // Restart normal processing if still running and has items\n    if (this.isRunning && this.items.length > 0 && !this.pendingTick) {\n      this.tick()\n    }\n  }\n\n  /**\n   * Processes all items in the queue as a batch using the provided function.\n   * The queue is cleared after processing.\n   *\n   * @example\n   * ```ts\n   * queue.flushAsBatch((items) => {\n   *   console.log('Processing batch:', items);\n   *   // Process all items together\n   * });\n   * ```\n   */\n  flushAsBatch = (batchFunction: (items: Array<TValue>) => void): void => {\n    const items = this.peekAllItems()\n    this.clear()\n    batchFunction(items)\n  }\n\n  /**\n   * Removes all items from the queue. Does not affect items being processed.\n   */\n  clear = (): void => {\n    this.items = []\n  }\n}\n\n/**\n * Creates a lightweight queue that processes items using the provided function.\n *\n * This is an alternative to the queue function in the core @tanstack/pacer package, but is more\n * suitable for libraries and npm packages that need minimal overhead. Unlike the core version,\n * this function creates a queuer with no external dependencies, devtools integration, or reactive state.\n *\n * @example\n * ```ts\n * const processItem = liteQueue((item: string) => {\n *   console.log('Processing:', item);\n * }, { wait: 1000 });\n *\n * processItem('task1');\n * processItem('task2');\n * // Processes each item with 1 second delay between them\n * ```\n */\nexport function liteQueue<TValue>(\n  fn: (item: TValue) => void,\n  options: LiteQueuerOptions<TValue> = {},\n): (item: TValue) => boolean {\n  const queuer = new LiteQueuer(fn, options)\n  return (item: TValue) => queuer.addItem(item)\n}\n"],"mappings":"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"}

package/dist/lite-rate-limiter.cjs

@@ -0,0 +1,149 @@
+
+//#region src/lite-rate-limiter.ts
+/**
+* A lightweight class that creates a rate-limited function.
+*
+* This is an alternative to the RateLimiter in the core @tanstack/pacer package, but is more
+* suitable for libraries and npm packages that need minimal overhead. Unlike the core RateLimiter,
+* this version does not use TanStack Store for state management, has no devtools integration,
+* and provides only essential rate limiting functionality.
+*
+* Rate limiting allows a function to execute up to a limit within a time window,
+* then blocks all subsequent calls until the window passes. This can lead to "bursty" behavior where
+* all executions happen immediately, followed by a complete block.
+*
+* The rate limiter supports two types of windows:
+* - 'fixed': A strict window that resets after the window period. All executions within the window count
+*   towards the limit, and the window resets completely after the period.
+* - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
+*   consistent rate of execution over time.
+*
+* Features:
+* - Zero dependencies - no external libraries required
+* - Minimal API surface - only essential methods (maybeExecute, getRemainingInWindow, getMsUntilNextWindow, reset)
+* - Simple state management - uses basic private properties instead of reactive stores
+* - Lightweight - designed for use in npm packages where bundle size matters
+*
+* @example
+* ```ts
+* const rateLimiter = new LiteRateLimiter((id: string) => {
+*   api.getData(id);
+* }, { limit: 5, window: 1000 });
+*
+* // First 5 calls will execute, then block until window resets
+* if (rateLimiter.maybeExecute('123')) {
+*   console.log('API call made');
+* } else {
+*   console.log('Rate limited - try again in', rateLimiter.getMsUntilNextWindow(), 'ms');
+* }
+* ```
+*/
+var LiteRateLimiter = class {
+	constructor(fn, options) {
+		this.fn = fn;
+		this.options = options;
+		this.executionTimes = [];
+		this.timeoutIds = /* @__PURE__ */ new Set();
+		this.maybeExecute = (...args) => {
+			this.cleanupOldExecutions();
+			if (this.getExecutionTimesInWindow().length < this.options.limit) {
+				this.execute(...args);
+				return true;
+			}
+			this.options.onReject?.(this);
+			return false;
+		};
+		this.execute = (...args) => {
+			const now = Date.now();
+			this.fn(...args);
+			this.options.onExecute?.(args, this);
+			this.executionTimes.push(now);
+			this.setCleanupTimeout(now);
+		};
+		this.getExecutionTimesInWindow = () => {
+			if (this.options.windowType === "sliding") return this.executionTimes.filter((time) => time > Date.now() - this.options.window);
+			else {
+				if (this.executionTimes.length === 0) return [];
+				const windowStart = Math.min(...this.executionTimes);
+				const windowEnd = windowStart + this.options.window;
+				if (Date.now() > windowEnd) return [];
+				return this.executionTimes.filter((time) => time >= windowStart && time <= windowEnd);
+			}
+		};
+		this.setCleanupTimeout = (executionTime) => {
+			if (this.options.windowType === "sliding" || this.timeoutIds.size === 0) {
+				const timeUntilExpiration = executionTime - Date.now() + this.options.window + 1;
+				const timeoutId = setTimeout(() => {
+					this.cleanupOldExecutions();
+					this.clearTimeout(timeoutId);
+				}, timeUntilExpiration);
+				this.timeoutIds.add(timeoutId);
+			}
+		};
+		this.clearTimeout = (timeoutId) => {
+			clearTimeout(timeoutId);
+			this.timeoutIds.delete(timeoutId);
+		};
+		this.clearTimeouts = () => {
+			this.timeoutIds.forEach((timeoutId) => clearTimeout(timeoutId));
+			this.timeoutIds.clear();
+		};
+		this.cleanupOldExecutions = () => {
+			this.executionTimes = this.getExecutionTimesInWindow();
+		};
+		this.getRemainingInWindow = () => {
+			const relevantExecutionTimes = this.getExecutionTimesInWindow();
+			return Math.max(0, this.options.limit - relevantExecutionTimes.length);
+		};
+		this.getMsUntilNextWindow = () => {
+			if (this.getRemainingInWindow() > 0) return 0;
+			return (this.executionTimes[0] ?? Infinity) + this.options.window - Date.now();
+		};
+		this.reset = () => {
+			this.executionTimes = [];
+			this.clearTimeouts();
+		};
+		if (this.options.windowType === void 0) this.options.windowType = "fixed";
+	}
+};
+/**
+* Creates a lightweight rate-limited function that will execute the provided function up to a maximum number of times within a time window.
+*
+* This is an alternative to the rateLimit function in the core @tanstack/pacer package, but is more
+* suitable for libraries and npm packages that need minimal overhead. Unlike the core version,
+* this function creates a rate limiter with no external dependencies, devtools integration, or reactive state.
+*
+* Rate limiting allows all executions until the limit is reached, then blocks all subsequent calls until the window resets.
+* This differs from throttling (which ensures even spacing) and debouncing (which waits for pauses).
+*
+* @example
+* ```ts
+* const rateLimitedApi = liteRateLimit(makeApiCall, {
+*   limit: 5,
+*   window: 60000, // 1 minute
+*   windowType: 'sliding'
+* });
+*
+* // First 5 calls execute immediately
+* // Additional calls are rejected until window allows
+* rateLimitedApi();
+* ```
+*
+* @example
+* ```ts
+* // Fixed window - all 10 calls happen in first second, then 10 second wait
+* const rateLimitedFixed = liteRateLimit(logEvent, {
+*   limit: 10,
+*   window: 10000,
+*   windowType: 'fixed'
+* });
+* ```
+*/
+function liteRateLimit(fn, options) {
+	return new LiteRateLimiter(fn, options).maybeExecute;
+}
+
+//#endregion
+exports.LiteRateLimiter = LiteRateLimiter;
+exports.liteRateLimit = liteRateLimit;
+//# sourceMappingURL=lite-rate-limiter.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lite-rate-limiter.cjs","names":["fn: TFn","options: LiteRateLimiterOptions<TFn>"],"sources":["../src/lite-rate-limiter.ts"],"sourcesContent":["import type { AnyFunction } from '@tanstack/pacer/types'\n\n/**\n * Options for configuring a lite rate-limited function\n */\nexport interface LiteRateLimiterOptions<TFn extends AnyFunction = AnyFunction> {\n  /**\n   * Maximum number of executions allowed within the time window.\n   */\n  limit: number\n  /**\n   * Callback function that is called after the function is executed\n   */\n  onExecute?: (args: Parameters<TFn>, rateLimiter: LiteRateLimiter<TFn>) => void\n  /**\n   * Optional callback function that is called when an execution is rejected due to rate limiting\n   */\n  onReject?: (rateLimiter: LiteRateLimiter<TFn>) => void\n  /**\n   * Time window in milliseconds within which the limit applies.\n   */\n  window: number\n  /**\n   * Type of window to use for rate limiting\n   * - 'fixed': Uses a fixed window that resets after the window period\n   * - 'sliding': Uses a sliding window that allows executions as old ones expire\n   * Defaults to 'fixed'\n   */\n  windowType?: 'fixed' | 'sliding'\n}\n\n/**\n * A lightweight class that creates a rate-limited function.\n *\n * This is an alternative to the RateLimiter in the core @tanstack/pacer package, but is more\n * suitable for libraries and npm packages that need minimal overhead. Unlike the core RateLimiter,\n * this version does not use TanStack Store for state management, has no devtools integration,\n * and provides only essential rate limiting functionality.\n *\n * Rate limiting allows a function to execute up to a limit within a time window,\n * then blocks all subsequent calls until the window passes. This can lead to \"bursty\" behavior where\n * all executions happen immediately, followed by a complete block.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n *   consistent rate of execution over time.\n *\n * Features:\n * - Zero dependencies - no external libraries required\n * - Minimal API surface - only essential methods (maybeExecute, getRemainingInWindow, getMsUntilNextWindow, reset)\n * - Simple state management - uses basic private properties instead of reactive stores\n * - Lightweight - designed for use in npm packages where bundle size matters\n *\n * @example\n * ```ts\n * const rateLimiter = new LiteRateLimiter((id: string) => {\n *   api.getData(id);\n * }, { limit: 5, window: 1000 });\n *\n * // First 5 calls will execute, then block until window resets\n * if (rateLimiter.maybeExecute('123')) {\n *   console.log('API call made');\n * } else {\n *   console.log('Rate limited - try again in', rateLimiter.getMsUntilNextWindow(), 'ms');\n * }\n * ```\n */\nexport class LiteRateLimiter<TFn extends AnyFunction> {\n  private executionTimes: Array<number> = []\n  private timeoutIds: Set<NodeJS.Timeout> = new Set()\n\n  constructor(\n    public fn: TFn,\n    public options: LiteRateLimiterOptions<TFn>,\n  ) {\n    // Default windowType to 'fixed' if not specified\n    if (this.options.windowType === undefined) {\n      this.options.windowType = 'fixed'\n    }\n  }\n\n  /**\n   * Attempts to execute the rate-limited function if within the configured limits.\n   * Returns true if executed, false if rejected due to rate limiting.\n   *\n   * @example\n   * ```ts\n   * const rateLimiter = new LiteRateLimiter(fn, { limit: 5, window: 1000 });\n   *\n   * // First 5 calls return true\n   * rateLimiter.maybeExecute('arg1', 'arg2'); // true\n   *\n   * // Additional calls within the window return false\n   * rateLimiter.maybeExecute('arg1', 'arg2'); // false\n   * ```\n   */\n  maybeExecute = (...args: Parameters<TFn>): boolean => {\n    this.cleanupOldExecutions()\n\n    const relevantExecutionTimes = this.getExecutionTimesInWindow()\n\n    if (relevantExecutionTimes.length < this.options.limit) {\n      this.execute(...args)\n      return true\n    }\n\n    this.options.onReject?.(this)\n    return false\n  }\n\n  private execute = (...args: Parameters<TFn>): void => {\n    const now = Date.now()\n    this.fn(...args)\n    this.options.onExecute?.(args, this)\n    this.executionTimes.push(now)\n    this.setCleanupTimeout(now)\n  }\n\n  private getExecutionTimesInWindow = (): Array<number> => {\n    if (this.options.windowType === 'sliding') {\n      // For sliding window, return all executions within the current window\n      return this.executionTimes.filter(\n        (time) => time > Date.now() - this.options.window,\n      )\n    } else {\n      // For fixed window, return all executions in the current window\n      if (this.executionTimes.length === 0) {\n        return []\n      }\n      const oldestExecution = Math.min(...this.executionTimes)\n      const windowStart = oldestExecution\n      const windowEnd = windowStart + this.options.window\n      const now = Date.now()\n\n      // If the window has expired, return empty array\n      if (now > windowEnd) {\n        return []\n      }\n\n      // Otherwise, return all executions in the current window\n      return this.executionTimes.filter(\n        (time) => time >= windowStart && time <= windowEnd,\n      )\n    }\n  }\n\n  private setCleanupTimeout = (executionTime: number): void => {\n    if (\n      this.options.windowType === 'sliding' ||\n      this.timeoutIds.size === 0 // new fixed window\n    ) {\n      const now = Date.now()\n      const timeUntilExpiration = executionTime - now + this.options.window + 1\n      const timeoutId = setTimeout(() => {\n        this.cleanupOldExecutions()\n        this.clearTimeout(timeoutId)\n      }, timeUntilExpiration)\n      this.timeoutIds.add(timeoutId)\n    }\n  }\n\n  private clearTimeout = (timeoutId: NodeJS.Timeout): void => {\n    clearTimeout(timeoutId)\n    this.timeoutIds.delete(timeoutId)\n  }\n\n  private clearTimeouts = (): void => {\n    this.timeoutIds.forEach((timeoutId) => clearTimeout(timeoutId))\n    this.timeoutIds.clear()\n  }\n\n  private cleanupOldExecutions = (): void => {\n    this.executionTimes = this.getExecutionTimesInWindow()\n  }\n\n  /**\n   * Returns the number of remaining executions allowed in the current window.\n   */\n  getRemainingInWindow = (): number => {\n    const relevantExecutionTimes = this.getExecutionTimesInWindow()\n    return Math.max(0, this.options.limit - relevantExecutionTimes.length)\n  }\n\n  /**\n   * Returns the number of milliseconds until the next execution will be possible.\n   * Returns 0 if executions are currently allowed.\n   */\n  getMsUntilNextWindow = (): number => {\n    if (this.getRemainingInWindow() > 0) {\n      return 0\n    }\n    const oldestExecution = this.executionTimes[0] ?? Infinity\n    return oldestExecution + this.options.window - Date.now()\n  }\n\n  /**\n   * Resets the rate limiter state, clearing all execution history.\n   */\n  reset = (): void => {\n    this.executionTimes = []\n    this.clearTimeouts()\n  }\n}\n\n/**\n * Creates a lightweight rate-limited function that will execute the provided function up to a maximum number of times within a time window.\n *\n * This is an alternative to the rateLimit function in the core @tanstack/pacer package, but is more\n * suitable for libraries and npm packages that need minimal overhead. Unlike the core version,\n * this function creates a rate limiter with no external dependencies, devtools integration, or reactive state.\n *\n * Rate limiting allows all executions until the limit is reached, then blocks all subsequent calls until the window resets.\n * This differs from throttling (which ensures even spacing) and debouncing (which waits for pauses).\n *\n * @example\n * ```ts\n * const rateLimitedApi = liteRateLimit(makeApiCall, {\n *   limit: 5,\n *   window: 60000, // 1 minute\n *   windowType: 'sliding'\n * });\n *\n * // First 5 calls execute immediately\n * // Additional calls are rejected until window allows\n * rateLimitedApi();\n * ```\n *\n * @example\n * ```ts\n * // Fixed window - all 10 calls happen in first second, then 10 second wait\n * const rateLimitedFixed = liteRateLimit(logEvent, {\n *   limit: 10,\n *   window: 10000,\n *   windowType: 'fixed'\n * });\n * ```\n */\nexport function liteRateLimit<TFn extends AnyFunction>(\n  fn: TFn,\n  options: LiteRateLimiterOptions<TFn>,\n): (...args: Parameters<TFn>) => boolean {\n  const rateLimiter = new LiteRateLimiter(fn, options)\n  return rateLimiter.maybeExecute\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqEA,IAAa,kBAAb,MAAsD;CAIpD,YACE,AAAOA,IACP,AAAOC,SACP;EAFO;EACA;wBAL+B,EAAE;oCACA,IAAI,KAAK;uBA2BnC,GAAG,SAAmC;AACpD,QAAK,sBAAsB;AAI3B,OAF+B,KAAK,2BAA2B,CAEpC,SAAS,KAAK,QAAQ,OAAO;AACtD,SAAK,QAAQ,GAAG,KAAK;AACrB,WAAO;;AAGT,QAAK,QAAQ,WAAW,KAAK;AAC7B,UAAO;;kBAGU,GAAG,SAAgC;GACpD,MAAM,MAAM,KAAK,KAAK;AACtB,QAAK,GAAG,GAAG,KAAK;AAChB,QAAK,QAAQ,YAAY,MAAM,KAAK;AACpC,QAAK,eAAe,KAAK,IAAI;AAC7B,QAAK,kBAAkB,IAAI;;yCAG4B;AACvD,OAAI,KAAK,QAAQ,eAAe,UAE9B,QAAO,KAAK,eAAe,QACxB,SAAS,OAAO,KAAK,KAAK,GAAG,KAAK,QAAQ,OAC5C;QACI;AAEL,QAAI,KAAK,eAAe,WAAW,EACjC,QAAO,EAAE;IAGX,MAAM,cADkB,KAAK,IAAI,GAAG,KAAK,eAAe;IAExD,MAAM,YAAY,cAAc,KAAK,QAAQ;AAI7C,QAHY,KAAK,KAAK,GAGZ,UACR,QAAO,EAAE;AAIX,WAAO,KAAK,eAAe,QACxB,SAAS,QAAQ,eAAe,QAAQ,UAC1C;;;4BAIwB,kBAAgC;AAC3D,OACE,KAAK,QAAQ,eAAe,aAC5B,KAAK,WAAW,SAAS,GACzB;IAEA,MAAM,sBAAsB,gBADhB,KAAK,KAAK,GAC4B,KAAK,QAAQ,SAAS;IACxE,MAAM,YAAY,iBAAiB;AACjC,UAAK,sBAAsB;AAC3B,UAAK,aAAa,UAAU;OAC3B,oBAAoB;AACvB,SAAK,WAAW,IAAI,UAAU;;;uBAIV,cAAoC;AAC1D,gBAAa,UAAU;AACvB,QAAK,WAAW,OAAO,UAAU;;6BAGC;AAClC,QAAK,WAAW,SAAS,cAAc,aAAa,UAAU,CAAC;AAC/D,QAAK,WAAW,OAAO;;oCAGkB;AACzC,QAAK,iBAAiB,KAAK,2BAA2B;;oCAMnB;GACnC,MAAM,yBAAyB,KAAK,2BAA2B;AAC/D,UAAO,KAAK,IAAI,GAAG,KAAK,QAAQ,QAAQ,uBAAuB,OAAO;;oCAOnC;AACnC,OAAI,KAAK,sBAAsB,GAAG,EAChC,QAAO;AAGT,WADwB,KAAK,eAAe,MAAM,YACzB,KAAK,QAAQ,SAAS,KAAK,KAAK;;qBAMvC;AAClB,QAAK,iBAAiB,EAAE;AACxB,QAAK,eAAe;;AA5HpB,MAAI,KAAK,QAAQ,eAAe,OAC9B,MAAK,QAAQ,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgKhC,SAAgB,cACd,IACA,SACuC;AAEvC,QADoB,IAAI,gBAAgB,IAAI,QAAQ,CACjC"}