Queue Management

/**
 * Creates a new Queue instance
 * @param options - Configuration options for the queue
 */
constructor(options?: Options): Queue;

interface Options {
  /** Maximum number of jobs to process concurrently (default: Infinity) */
  concurrency?: number;
  /** Default timeout in milliseconds for jobs (default: 0 - no timeout) */
  timeout?: number;
  /** Automatically start processing when jobs are added (default: false) */
  autostart?: boolean;
  /** Array to collect job results (default: null) */
  results?: any[];
}

import Queue from "queue";

// Basic queue with unlimited concurrency
const basicQueue = new Queue();

// Queue with concurrency control
const limitedQueue = new Queue({
  concurrency: 3,
  timeout: 5000,
  results: []
});

// Auto-starting queue
const autoQueue = new Queue({
  autostart: true,
  concurrency: 2
});

/**
 * Start processing jobs in the queue
 * @param callback - Optional callback executed when queue empties or errors
 * @returns Promise resolving to results array if no callback provided
 */
start(): Promise<any[] | null>;
start(callback: (error?: Error, results?: any[] | null) => void): void;

// With callback
q.start((err, results) => {
  if (err) throw err;
  console.log('Queue finished:', results);
});

// With Promise
try {
  const results = await q.start();
  console.log('Queue finished:', results);
} catch (error) {
  console.error('Queue failed:', error);
}

/**
 * Stops queue processing (can be resumed)
 */
stop(): void;

// Stop processing temporarily
q.stop();

// Resume later
q.start();

/**
 * Stop and empty the queue immediately
 * @param error - Optional error to pass to the end event
 */
end(error?: Error): void;

// Emergency stop with error
q.end(new Error('Critical failure'));

// Clean shutdown
q.end();

/**
 * Total jobs pending execution and queued (readonly)
 */
readonly length: number;

console.log(`Queue has ${q.length} jobs total`);

/**
 * Maximum number of jobs to process concurrently
 */
concurrency: number;

/**
 * Default timeout in milliseconds for jobs
 */
timeout: number;

/**
 * Automatically start processing when jobs are added
 */
autostart: boolean;

/**
 * Array to collect job results (null if disabled)
 */
results: any[] | null;

/**
 * Number of jobs currently being processed (readonly)
 */
readonly pending: number;

/**
 * Internal session counter for queue operations (readonly)
 */
readonly session: number;

/**
 * Whether the queue is currently running (readonly)
 */
readonly running: boolean;

/**
 * Internal array of queued jobs waiting to be processed (readonly)
 */
readonly jobs: QueueWorker[];

/**
 * Array of active timeout IDs for job timeouts (readonly)
 */
readonly timers: number[];

// Adjust concurrency at runtime
q.concurrency = 5;

// Change default timeout
q.timeout = 10000;

// Enable result collection
q.results = [];

// Enable auto-start mode
q.autostart = true;

// Check queue status (readonly properties)
console.log(`Pending jobs: ${q.pending}`);
console.log(`Queue running: ${q.running}`);
console.log(`Jobs in queue: ${q.jobs.length}`);
console.log(`Active timeouts: ${q.timers.length}`);

/**
 * Clear all active timeout timers
 */
clearTimers(): void;

// Cancel all timeouts but keep jobs running
q.clearTimers();