@tanstack/pacer-lite 0.1.0

package/dist/cjs/lite-debouncer.d.cts

@@ -0,0 +1,121 @@
+import { AnyFunction } from '@tanstack/pacer/types';
+/**
+ * Options for configuring a lite debounced function
+ */
+export interface LiteDebouncerOptions<TFn extends AnyFunction = AnyFunction> {
+    /**
+     * Whether to execute on the leading edge of the timeout.
+     * The first call will execute immediately and the rest will wait the delay.
+     * Defaults to false.
+     */
+    leading?: boolean;
+    /**
+     * Callback function that is called after the function is executed
+     */
+    onExecute?: (args: Parameters<TFn>, debouncer: LiteDebouncer<TFn>) => void;
+    /**
+     * Whether to execute on the trailing edge of the timeout.
+     * Defaults to true.
+     */
+    trailing?: boolean;
+    /**
+     * Delay in milliseconds before executing the function.
+     */
+    wait: number;
+}
+/**
+ * A lightweight class that creates a debounced function.
+ *
+ * This is an alternative to the Debouncer in the core @tanstack/pacer package, but is more
+ * suitable for libraries and npm packages that need minimal overhead. Unlike the core Debouncer,
+ * this version does not use TanStack Store for state management, has no devtools integration,
+ * and provides only essential debouncing functionality.
+ *
+ * Debouncing ensures that a function is only executed after a certain amount of time has passed
+ * since its last invocation. This is useful for handling frequent events like window resizing,
+ * scroll events, or input changes where you want to limit the rate of execution.
+ *
+ * The debounced function can be configured to execute either at the start of the delay period
+ * (leading edge) or at the end (trailing edge, default). Each new call during the wait period
+ * will reset the timer.
+ *
+ * Features:
+ * - Zero dependencies - no external libraries required
+ * - Minimal API surface - only essential methods (maybeExecute, flush, cancel)
+ * - Simple state management - uses basic private properties instead of reactive stores
+ * - Callback support for monitoring execution events
+ * - Lightweight - designed for use in npm packages where bundle size matters
+ *
+ * @example
+ * ```ts
+ * const debouncer = new LiteDebouncer((value: string) => {
+ *   saveToDatabase(value);
+ * }, {
+ *   wait: 500,
+ *   onExecute: (args, debouncer) => {
+ *     console.log('Saved value:', args[0]);
+ *   }
+ * });
+ *
+ * // Will only save after 500ms of no new input
+ * inputElement.addEventListener('input', () => {
+ *   debouncer.maybeExecute(inputElement.value);
+ * });
+ * ```
+ */
+export declare class LiteDebouncer<TFn extends AnyFunction> {
+    fn: TFn;
+    options: LiteDebouncerOptions<TFn>;
+    private timeoutId;
+    private lastArgs;
+    private canLeadingExecute;
+    constructor(fn: TFn, options: LiteDebouncerOptions<TFn>);
+    /**
+     * Attempts to execute the debounced function.
+     * If leading is true and this is the first call, executes immediately.
+     * Otherwise, queues the execution for after the wait time.
+     * Each new call resets the timer.
+     */
+    maybeExecute: (...args: Parameters<TFn>) => void;
+    /**
+     * Processes the current pending execution immediately.
+     * If there's a pending execution, it will be executed right away
+     * and the timeout will be cleared.
+     */
+    flush: () => void;
+    /**
+     * Cancels any pending execution.
+     * Clears the timeout and resets the internal state.
+     */
+    cancel: () => void;
+}
+/**
+ * Creates a lightweight debounced function that delays invoking the provided function until after a specified wait time.
+ * Multiple calls during the wait period will cancel previous pending invocations and reset the timer.
+ *
+ * This is an alternative to the debounce 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 debouncer with no external dependencies, devtools integration, or reactive state.
+ *
+ * If leading option is true, the function will execute immediately on the first call, then wait the delay
+ * before allowing another execution.
+ *
+ * @example
+ * ```ts
+ * const debouncedSave = liteDebounce(() => {
+ *   saveChanges();
+ * }, { wait: 1000 });
+ *
+ * // Called repeatedly but executes at most once per second
+ * inputElement.addEventListener('input', debouncedSave);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Leading edge execution - fires immediately then waits
+ * const debouncedSearch = liteDebounce((query: string) => {
+ *   performSearch(query);
+ * }, { wait: 300, leading: true });
+ * ```
+ */
+export declare function liteDebounce<TFn extends AnyFunction>(fn: TFn, options: LiteDebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;

package/dist/cjs/lite-queuer.cjs

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class LiteQueuer {
+  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) => {
+            const existingPriority = this.options.getPriority(existing);
+            const effectivePriority = existingPriority ?? -Infinity;
+            return effectivePriority < 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 void 0;
+      }
+      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) {
+        const item = this.execute(this.options.getItemsFrom);
+        if (item === 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 void 0;
+      }
+      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;
+  }
+}
+function liteQueue(fn, options = {}) {
+  const queuer = new LiteQueuer(fn, options);
+  return (item) => queuer.addItem(item);
+}
+exports.LiteQueuer = LiteQueuer;
+exports.liteQueue = liteQueue;
+//# sourceMappingURL=lite-queuer.cjs.map

package/dist/cjs/lite-queuer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lite-queuer.cjs","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"],"names":[],"mappings":"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"}

package/dist/cjs/lite-queuer.d.cts

@@ -0,0 +1,239 @@
+/**
+ * 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)
+ */
+export type QueuePosition = 'front' | 'back';
+/**
+ * Options for configuring a lite queuer instance
+ */
+export 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
+ * ```
+ */
+export 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
+ * ```
+ */
+export declare function liteQueue<TValue>(fn: (item: TValue) => void, options?: LiteQueuerOptions<TValue>): (item: TValue) => boolean;

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class LiteRateLimiter {
+  constructor(fn, options) {
+    this.fn = fn;
+    this.options = options;
+    this.executionTimes = [];
+    this.timeoutIds = /* @__PURE__ */ new Set();
+    this.maybeExecute = (...args) => {
+      this.cleanupOldExecutions();
+      const relevantExecutionTimes = this.getExecutionTimesInWindow();
+      if (relevantExecutionTimes.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 oldestExecution = Math.min(...this.executionTimes);
+        const windowStart = oldestExecution;
+        const windowEnd = windowStart + this.options.window;
+        const now = Date.now();
+        if (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 now = Date.now();
+        const timeUntilExpiration = executionTime - 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;
+      }
+      const oldestExecution = this.executionTimes[0] ?? Infinity;
+      return oldestExecution + this.options.window - Date.now();
+    };
+    this.reset = () => {
+      this.executionTimes = [];
+      this.clearTimeouts();
+    };
+    if (this.options.windowType === void 0) {
+      this.options.windowType = "fixed";
+    }
+  }
+}
+function liteRateLimit(fn, options) {
+  const rateLimiter = new LiteRateLimiter(fn, options);
+  return rateLimiter.maybeExecute;
+}
+exports.LiteRateLimiter = LiteRateLimiter;
+exports.liteRateLimit = liteRateLimit;
+//# sourceMappingURL=lite-rate-limiter.cjs.map