rezo 1.0.4 → 1.0.6

package/dist/crawler.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';
 
 /**
@@ -1195,8 +1192,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')
@@ -2146,6 +2152,275 @@ 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
@@ -2222,7 +2497,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`.
 	 *
@@ -2312,10 +2587,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.
 	 *
@@ -2419,6 +2690,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 */
@@ -2440,8 +2717,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) */
@@ -2806,7 +3081,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;
@@ -2865,10 +3140,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) */
@@ -2907,8 +3178,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 */
@@ -3808,7 +4077,7 @@ export interface httpAdapterPutOverloads {
  */
 export type AdapterFunction<T = any> = (options: RezoRequestConfig, defaultOptions: RezoDefaultOptions, jar: RezoCookieJar) => Promise<RezoResponse<T> | RezoStreamResponse | RezoDownloadResponse | RezoUploadResponse>;
 declare class Rezo {
-	protected queue: PQueue | null;
+	protected queue: RezoQueue | null;
 	protected isQueueEnabled: boolean;
 	defaults: RezoDefaultOptions;
 	hooks: RezoHooks;
@@ -6041,7 +6310,7 @@ export declare class CrawlerOptions {
 	/**
 	 * Internal method to process and add rate limiter configurations
 	 * @param options - Limiter configuration object with enable flag and queue options
-	 * @description Validates and stores rate limiter configurations, creating PQueue instances
+	 * @description Validates and stores rate limiter configurations, creating RezoQueue instances
 	 * for each valid configuration. Supports domain-specific or global rate limiting.
 	 * @private
 	 */
@@ -6205,7 +6474,7 @@ export declare class CrawlerOptions {
 	 * ```
 	 */
 	getAdapter(url: string, type: "proxies", useGlobal?: boolean, random?: boolean): IProxy | null;
-	getAdapter(url: string, type: "limiters", useGlobal?: boolean, random?: boolean): PQueue | null;
+	getAdapter(url: string, type: "limiters", useGlobal?: boolean, random?: boolean): RezoQueue | null;
 	getAdapter(url: string, type: "oxylabs", useGlobal?: boolean, random?: boolean): Oxylabs | null;
 	getAdapter(url: string, type: "decodo", useGlobal?: boolean, random?: boolean): Decodo | null;
 	getAdapter(url: string, type: "headers", useGlobal?: boolean, random?: boolean): OutgoingHttpHeaders | null;

package/dist/entries/crawler.cjs

@@ -1,5 +1,5 @@
-const _mod_9syr2y = require('../plugin/crawler.cjs');
-exports.Crawler = _mod_9syr2y.Crawler;;
-const _mod_xywryj = require('../plugin/crawler-options.cjs');
-exports.CrawlerOptions = _mod_xywryj.CrawlerOptions;
-exports.Domain = _mod_xywryj.Domain;;
+const _mod_8o6t31 = require('../plugin/crawler.cjs');
+exports.Crawler = _mod_8o6t31.Crawler;;
+const _mod_a2uxv0 = require('../plugin/crawler-options.cjs');
+exports.CrawlerOptions = _mod_a2uxv0.CrawlerOptions;
+exports.Domain = _mod_a2uxv0.Domain;;

package/dist/index.cjs

@@ -1,21 +1,26 @@
-const _mod_li4oo6 = require('./core/rezo.cjs');
-exports.Rezo = _mod_li4oo6.Rezo;
-exports.createRezoInstance = _mod_li4oo6.createRezoInstance;
-exports.createDefaultInstance = _mod_li4oo6.createDefaultInstance;;
-const _mod_g7vumm = require('./errors/rezo-error.cjs');
-exports.RezoError = _mod_g7vumm.RezoError;
-exports.RezoErrorCode = _mod_g7vumm.RezoErrorCode;;
-const _mod_lcvlqo = require('./utils/headers.cjs');
-exports.RezoHeaders = _mod_lcvlqo.RezoHeaders;;
-const _mod_vdm8pb = require('./utils/form-data.cjs');
-exports.RezoFormData = _mod_vdm8pb.RezoFormData;;
-const _mod_zocq9d = require('./utils/cookies.cjs');
-exports.RezoCookieJar = _mod_zocq9d.RezoCookieJar;;
-const _mod_uxqfdf = require('./core/hooks.cjs');
-exports.createDefaultHooks = _mod_uxqfdf.createDefaultHooks;
-exports.mergeHooks = _mod_uxqfdf.mergeHooks;;
-const _mod_ztg1xc = require('./proxy/manager.cjs');
-exports.ProxyManager = _mod_ztg1xc.ProxyManager;;
+const _mod_b7ju2q = require('./core/rezo.cjs');
+exports.Rezo = _mod_b7ju2q.Rezo;
+exports.createRezoInstance = _mod_b7ju2q.createRezoInstance;
+exports.createDefaultInstance = _mod_b7ju2q.createDefaultInstance;;
+const _mod_cnsb78 = require('./errors/rezo-error.cjs');
+exports.RezoError = _mod_cnsb78.RezoError;
+exports.RezoErrorCode = _mod_cnsb78.RezoErrorCode;;
+const _mod_skuirr = require('./utils/headers.cjs');
+exports.RezoHeaders = _mod_skuirr.RezoHeaders;;
+const _mod_57nl1j = require('./utils/form-data.cjs');
+exports.RezoFormData = _mod_57nl1j.RezoFormData;;
+const _mod_ue7zge = require('./utils/cookies.cjs');
+exports.RezoCookieJar = _mod_ue7zge.RezoCookieJar;;
+const _mod_lm33u8 = require('./core/hooks.cjs');
+exports.createDefaultHooks = _mod_lm33u8.createDefaultHooks;
+exports.mergeHooks = _mod_lm33u8.mergeHooks;;
+const _mod_biuxmx = require('./proxy/manager.cjs');
+exports.ProxyManager = _mod_biuxmx.ProxyManager;;
+const _mod_aekrq7 = require('./queue/index.cjs');
+exports.RezoQueue = _mod_aekrq7.RezoQueue;
+exports.HttpQueue = _mod_aekrq7.HttpQueue;
+exports.Priority = _mod_aekrq7.Priority;
+exports.HttpMethodPriority = _mod_aekrq7.HttpMethodPriority;;
 const { RezoError } = require('./errors/rezo-error.cjs');
 const isRezoError = exports.isRezoError = RezoError.isRezoError;
 const Cancel = exports.Cancel = RezoError;