Function: useQueuer()

function useQueuer<TValue, TSelected>(
   fn, 
   options, 
selector): ReactQueuer<TValue, TSelected>;

function useQueuer<TValue, TSelected>(
   fn, 
   options, 
selector): ReactQueuer<TValue, TSelected>;

Defined in: react-pacer/src/queuer/useQueuer.ts:170

A React hook that creates and manages a Queuer instance.

This is a lower-level hook that provides direct access to the Queuer's functionality without any built-in state management. This allows you to integrate it with any state management solution you prefer (useState, Redux, Zustand, etc.) by utilizing the onItemsChange callback.

For a hook with built-in state management, see useQueuedState.

The Queuer extends the base Queue to add processing capabilities. Items are processed synchronously in order, with optional delays between processing each item. The queuer includes an internal tick mechanism that can be started and stopped, making it useful as a scheduler. When started, it will process one item per tick, with an optional wait time between ticks.

By default uses FIFO (First In First Out) behavior, but can be configured for LIFO (Last In First Out) by specifying 'front' position when adding items.

State Management and Selector

The hook uses TanStack Store for reactive state management. You can subscribe to state changes in two ways:

1. Using queuer.Subscribe HOC (Recommended for component tree subscriptions)

Use the Subscribe HOC to subscribe to state changes deep in your component tree without needing to pass a selector to the hook. This is ideal when you want to subscribe to state in child components.

2. Using the selector parameter (For hook-level subscriptions)

The selector parameter allows you to specify which state changes will trigger a re-render at the hook level, 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 or using the Subscribe HOC. This prevents unnecessary re-renders and gives you full control over when your component updates.

Available 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')

// Default behavior - no reactive state subscriptions
const queue = useQueuer(
  (item) => console.log('Processing:', item),
  { started: true, wait: 1000 }
);

// Subscribe to state changes deep in component tree using Subscribe HOC
<queue.Subscribe selector={(state) => ({ size: state.size, isRunning: state.isRunning })}>
  {({ size, isRunning }) => (
    <div>Queue: {size} items, {isRunning ? 'Processing' : 'Idle'}</div>
  )}
</queue.Subscribe>

// Opt-in to re-render when queue size changes at hook level (optimized for displaying queue length)
const queue = useQueuer(
  (item) => console.log('Processing:', item),
  { started: true, wait: 1000 },
  (state) => ({
    size: state.size,
    isEmpty: state.isEmpty,
    isFull: state.isFull
  })
);

// Opt-in to re-render when processing state changes (optimized for loading indicators)
const queue = useQueuer(
  (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 queue = useQueuer(
  (item) => console.log('Processing:', item),
  { started: true, wait: 1000 },
  (state) => ({
    executionCount: state.executionCount,
    expirationCount: state.expirationCount,
    rejectionCount: state.rejectionCount
  })
);

// Example with custom state management and scheduling
const [items, setItems] = useState([]);

const queue = useQueuer(
  (item) => console.log('Processing:', item),
  {
    started: true, // Start processing immediately
    wait: 1000,    // Process one item every second
    onItemsChange: (queue) => setItems(queue.peekAllItems()),
    getPriority: (item) => item.priority // Process higher priority items first
  }
);

// Add items to process - they'll be handled automatically
queue.addItem('task1');
queue.addItem('task2');

// Control the scheduler
queue.stop();  // Pause processing
queue.start(); // Resume processing

// Access the selected state (will be empty object {} unless selector provided)
const { size, isRunning, executionCount } = queue.state;

// Default behavior - no reactive state subscriptions
const queue = useQueuer(
  (item) => console.log('Processing:', item),
  { started: true, wait: 1000 }
);

// Subscribe to state changes deep in component tree using Subscribe HOC
<queue.Subscribe selector={(state) => ({ size: state.size, isRunning: state.isRunning })}>
  {({ size, isRunning }) => (
    <div>Queue: {size} items, {isRunning ? 'Processing' : 'Idle'}</div>
  )}
</queue.Subscribe>

// Opt-in to re-render when queue size changes at hook level (optimized for displaying queue length)
const queue = useQueuer(
  (item) => console.log('Processing:', item),
  { started: true, wait: 1000 },
  (state) => ({
    size: state.size,
    isEmpty: state.isEmpty,
    isFull: state.isFull
  })
);

// Opt-in to re-render when processing state changes (optimized for loading indicators)
const queue = useQueuer(
  (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 queue = useQueuer(
  (item) => console.log('Processing:', item),
  { started: true, wait: 1000 },
  (state) => ({
    executionCount: state.executionCount,
    expirationCount: state.expirationCount,
    rejectionCount: state.rejectionCount
  })
);

// Example with custom state management and scheduling
const [items, setItems] = useState([]);

const queue = useQueuer(
  (item) => console.log('Processing:', item),
  {
    started: true, // Start processing immediately
    wait: 1000,    // Process one item every second
    onItemsChange: (queue) => setItems(queue.peekAllItems()),
    getPriority: (item) => item.priority // Process higher priority items first
  }
);

// Add items to process - they'll be handled automatically
queue.addItem('task1');
queue.addItem('task2');

// Control the scheduler
queue.stop();  // Pause processing
queue.start(); // Resume processing

// Access the selected state (will be empty object {} unless selector provided)
const { size, isRunning, executionCount } = queue.state;

useQueuer

Function: useQueuer()

State Management and Selector

Type Parameters

TValue

TSelected

Parameters

fn

options

selector

Returns

Example