rezo 1.0.5 → 1.0.6

package/dist/platform/node.d.ts

@@ -6,9 +6,6 @@ import { Agent as HttpsAgent } from 'node:https';
 import { Socket } from 'node:net';
 import { Readable, Writable, WritableOptions } from 'node:stream';
 import { SecureContext, TLSSocket } from 'node:tls';
-import PQueue from 'p-queue';
-import { Options as Options$1, QueueAddOptions } from 'p-queue';
-import PriorityQueue from 'p-queue/dist/priority-queue';
 import { Cookie as TouchCookie, CookieJar as TouchCookieJar, CreateCookieOptions } from 'tough-cookie';
 
 export interface RezoHttpHeaders {
@@ -972,8 +969,17 @@ export interface ProxyCooldownConfig {
  * Complete configuration for proxy rotation, filtering, and failure handling
  */
 export interface ProxyManagerBaseConfig {
-	/** Array of proxies to manage */
-	proxies: ProxyInfo[];
+	/**
+	 * Array of proxies to manage
+	 * Accepts ProxyInfo objects or proxy URL strings (parsed via parseProxyString)
+	 * @example
+	 * proxies: [
+	 *   { protocol: 'http', host: '127.0.0.1', port: 8080 },
+	 *   'socks5://user:pass@proxy.example.com:1080',
+	 *   'http://proxy.example.com:3128'
+	 * ]
+	 */
+	proxies: (ProxyInfo | string)[];
 	/**
 	 * Whitelist patterns for URLs that should use proxy
 	 * - String: exact domain match (e.g., 'api.example.com') or subdomain match (e.g., 'example.com' matches '*.example.com')
@@ -1983,6 +1989,275 @@ export declare class RezoError<T = any> extends Error {
 	toString(): string;
 	getFullDetails(): string;
 }
+/**
+ * Queue configuration options
+ */
+export interface QueueConfig {
+	/** Maximum concurrent tasks (default: Infinity) */
+	concurrency?: number;
+	/** Auto-start processing when tasks are added (default: true) */
+	autoStart?: boolean;
+	/** Timeout per task in milliseconds (default: none) */
+	timeout?: number;
+	/** Throw on timeout vs silently fail (default: true) */
+	throwOnTimeout?: boolean;
+	/** Interval between task starts in ms for rate limiting */
+	interval?: number;
+	/** Max tasks to start per interval (default: Infinity) */
+	intervalCap?: number;
+	/** Carry over unused interval capacity to next interval */
+	carryoverConcurrencyCount?: boolean;
+}
+/**
+ * Task options when adding to queue
+ */
+export interface TaskOptions {
+	/** Task priority (higher runs first, default: 0) */
+	priority?: number;
+	/** Task-specific timeout (overrides queue default) */
+	timeout?: number;
+	/** Unique ID for tracking/cancellation */
+	id?: string;
+	/** Signal for external cancellation */
+	signal?: AbortSignal;
+}
+/**
+ * Current queue state
+ */
+export interface QueueState {
+	/** Number of tasks currently running */
+	pending: number;
+	/** Number of tasks waiting in queue */
+	size: number;
+	/** Total tasks (pending + size) */
+	total: number;
+	/** Is queue paused */
+	isPaused: boolean;
+	/** Is queue idle (no tasks) */
+	isIdle: boolean;
+}
+/**
+ * Queue statistics
+ */
+export interface QueueStats {
+	/** Total tasks added since creation */
+	added: number;
+	/** Total tasks processed (started) */
+	processed: number;
+	/** Total successful completions */
+	completed: number;
+	/** Total failures */
+	failed: number;
+	/** Total timeouts */
+	timedOut: number;
+	/** Total cancellations */
+	cancelled: number;
+	/** Average task duration (ms) */
+	averageDuration: number;
+	/** Tasks per second (rolling average) */
+	throughput: number;
+}
+/**
+ * Queue event types
+ */
+export interface QueueEvents {
+	/** Task added to queue */
+	add: {
+		id: string;
+		priority: number;
+	};
+	/** Task started executing */
+	start: {
+		id: string;
+	};
+	/** Task completed successfully */
+	completed: {
+		id: string;
+		result: any;
+		duration: number;
+	};
+	/** Task failed with error */
+	error: {
+		id: string;
+		error: Error;
+	};
+	/** Task timed out */
+	timeout: {
+		id: string;
+	};
+	/** Task cancelled */
+	cancelled: {
+		id: string;
+	};
+	/** Queue became active (was idle, now processing) */
+	active: undefined;
+	/** Queue became idle (all tasks done) */
+	idle: undefined;
+	/** Queue was paused */
+	paused: undefined;
+	/** Queue was resumed */
+	resumed: undefined;
+	/** Next task about to run */
+	next: undefined;
+	/** Queue was emptied (no pending tasks) */
+	empty: undefined;
+}
+/**
+ * Event handler type
+ */
+export type EventHandler<T> = (data: T) => void;
+/**
+ * Task function type
+ */
+export type TaskFunction<T> = () => Promise<T>;
+declare class RezoQueue<T = any> {
+	private queue;
+	private pendingCount;
+	private isPausedFlag;
+	private intervalId?;
+	private intervalCount;
+	private intervalStart;
+	private eventHandlers;
+	private statsData;
+	private totalDuration;
+	private throughputWindow;
+	private readonly throughputWindowSize;
+	private idlePromise?;
+	private emptyPromise?;
+	readonly config: Required<QueueConfig>;
+	/**
+	 * Create a new RezoQueue
+	 * @param config - Queue configuration options
+	 */
+	constructor(config?: QueueConfig);
+	/**
+	 * Get current queue state
+	 */
+	get state(): QueueState;
+	/**
+	 * Get queue statistics
+	 */
+	get stats(): QueueStats;
+	/**
+	 * Get/set concurrency limit
+	 */
+	get concurrency(): number;
+	set concurrency(value: number);
+	/**
+	 * Number of pending (running) tasks
+	 */
+	get pending(): number;
+	/**
+	 * Number of tasks waiting in queue
+	 */
+	get size(): number;
+	/**
+	 * Check if queue is paused
+	 */
+	get isPaused(): boolean;
+	/**
+	 * Add a task to the queue
+	 * @param fn - Async function to execute
+	 * @param options - Task options
+	 * @returns Promise resolving to task result
+	 */
+	add<R = T>(fn: TaskFunction<R>, options?: TaskOptions): Promise<R>;
+	/**
+	 * Add multiple tasks to the queue
+	 * @param fns - Array of async functions
+	 * @param options - Task options (applied to all)
+	 * @returns Promise resolving to array of results
+	 */
+	addAll<R = T>(fns: TaskFunction<R>[], options?: TaskOptions): Promise<R[]>;
+	/**
+	 * Pause queue processing (running tasks continue)
+	 */
+	pause(): void;
+	/**
+	 * Resume queue processing
+	 */
+	start(): void;
+	/**
+	 * Clear all pending tasks from queue
+	 */
+	clear(): void;
+	/**
+	 * Cancel a specific task by ID
+	 * @param id - Task ID to cancel
+	 * @returns true if task was found and cancelled
+	 */
+	cancel(id: string): boolean;
+	/**
+	 * Cancel all tasks matching a predicate
+	 * @param predicate - Function to test each task
+	 * @returns Number of tasks cancelled
+	 */
+	cancelBy(predicate: (task: {
+		id: string;
+		priority: number;
+	}) => boolean): number;
+	/**
+	 * Wait for queue to become idle (no running or pending tasks)
+	 */
+	onIdle(): Promise<void>;
+	/**
+	 * Wait for queue to be empty (no pending tasks, but may have running)
+	 */
+	onEmpty(): Promise<void>;
+	/**
+	 * Wait for queue size to be less than limit
+	 * @param limit - Size threshold
+	 */
+	onSizeLessThan(limit: number): Promise<void>;
+	/**
+	 * Register an event handler
+	 * @param event - Event name
+	 * @param handler - Handler function
+	 */
+	on<E extends keyof QueueEvents>(event: E, handler: EventHandler<QueueEvents[E]>): void;
+	/**
+	 * Remove an event handler
+	 * @param event - Event name
+	 * @param handler - Handler function to remove
+	 */
+	off<E extends keyof QueueEvents>(event: E, handler: EventHandler<QueueEvents[E]>): void;
+	/**
+	 * Destroy the queue and cleanup resources
+	 */
+	destroy(): void;
+	/**
+	 * Insert task into queue maintaining priority order (highest first)
+	 */
+	private insertByPriority;
+	/**
+	 * Try to run next task if capacity available
+	 */
+	private tryRunNext;
+	/**
+	 * Execute a task
+	 */
+	private runTask;
+	/**
+	 * Record task duration for statistics
+	 */
+	private recordDuration;
+	/**
+	 * Start interval-based rate limiting
+	 */
+	private startInterval;
+	/**
+	 * Emit an event
+	 */
+	protected emit<E extends keyof QueueEvents>(event: E, data: QueueEvents[E]): void;
+	/**
+	 * Check if queue became empty
+	 */
+	private checkEmpty;
+	/**
+	 * Check if queue became idle
+	 */
+	private checkIdle;
+}
 type ProxyProtocol$1 = "http" | "https" | "socks4" | "socks5";
 /**
  * Configuration options for proxy connections
@@ -2104,7 +2379,7 @@ export interface RezoRequestConfig<D = any> {
 	/**
 	 * Queue to use for request execution
 	 */
-	queue?: PQueue | null;
+	queue?: RezoQueue | null;
 	/**
 	 * Controls how the response body is parsed and returned in `response.data`.
 	 *
@@ -2194,10 +2469,6 @@ export interface RezoRequestConfig<D = any> {
 	autoSetOrigin?: boolean;
 	treat302As303?: boolean;
 	startNewRequest?: boolean;
-	/** Whether to use HTTP/2 protocol */
-	http2?: boolean;
-	/** Whether to use cURL adapter */
-	curl?: boolean;
 	/**
 	 * DNS cache configuration for faster repeated requests.
 	 *
@@ -2301,6 +2572,12 @@ export interface RezoRequestConfig<D = any> {
 	withCredentials?: boolean;
 	/** Proxy configuration (URL string or detailed options) */
 	proxy?: string | ProxyOptions;
+	/**
+	 * Whether to use ProxyManager for this request
+	 * Set to false to bypass ProxyManager even when one is configured
+	 * @default true (uses ProxyManager if configured)
+	 */
+	useProxyManager?: boolean;
 	/** Whether to enable automatic cookie handling */
 	useCookies?: boolean;
 	/** Custom cookie jar for managing cookies */
@@ -2322,8 +2599,6 @@ export interface RezoRequestConfig<D = any> {
 	transformRequest?: Array<(data: any, headers: RezoHeaders) => any>;
 	/** Array of functions to transform response data */
 	transformResponse?: Array<(data: any) => any>;
-	/** Adapter to use for the request (name or custom function) */
-	adapter?: string | ((config: RezoRequestConfig) => Promise<any>);
 	/** AbortSignal to cancel the request */
 	signal?: AbortSignal;
 	/** File path to save the response to (for downloads) */
@@ -2688,7 +2963,7 @@ declare class ProxyManager {
 	private runAfterProxyDisableHooks;
 	private runAfterProxyEnableHooks;
 }
-export type queueOptions = Options$1<PriorityQueue, QueueAddOptions>;
+export type queueOptions = QueueConfig;
 export interface CacheConfig {
 	/** Response cache configuration */
 	response?: boolean | ResponseCacheConfig;
@@ -2747,10 +3022,6 @@ export interface RezoDefaultOptions {
 	keepAlive?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
-	/** Whether to use HTTP/2 protocol */
-	http2?: boolean;
-	/** Whether to use cURL adapter */
-	curl?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
 	withCredentials?: boolean;
 	/** Proxy configuration (URL string or detailed options) */
@@ -2789,8 +3060,6 @@ export interface RezoDefaultOptions {
 	transformRequest?: RezoHttpRequest["transformRequest"];
 	/** Array of functions to transform response data */
 	transformResponse?: RezoHttpRequest["transformResponse"];
-	/** Adapter to use for the request (name or custom function) */
-	adapter?: RezoHttpRequest["adapter"];
 	/** Browser simulation configuration for user agent spoofing */
 	browser?: RezoHttpRequest["browser"];
 	/** Enable debug logging for the request */
@@ -3693,7 +3962,7 @@ export type AdapterFunction<T = any> = (options: RezoRequestConfig, defaultOptio
  * Main Rezo class - Enterprise-grade HTTP client with advanced features
  */
 export declare class Rezo {
-	protected queue: PQueue | null;
+	protected queue: RezoQueue | null;
 	protected isQueueEnabled: boolean;
 	defaults: RezoDefaultOptions;
 	hooks: RezoHooks;