rezo 1.0.5 → 1.0.7

package/dist/queue/queue.js

@@ -0,0 +1,344 @@
+function generateId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`;
+}
+
+export class RezoQueue {
+  queue = [];
+  pendingCount = 0;
+  isPausedFlag = false;
+  intervalId;
+  intervalCount = 0;
+  intervalStart = 0;
+  eventHandlers = new Map;
+  statsData = {
+    added: 0,
+    processed: 0,
+    completed: 0,
+    failed: 0,
+    timedOut: 0,
+    cancelled: 0,
+    averageDuration: 0,
+    throughput: 0
+  };
+  totalDuration = 0;
+  throughputWindow = [];
+  throughputWindowSize = 60;
+  idlePromise;
+  emptyPromise;
+  config;
+  constructor(config = {}) {
+    this.config = {
+      concurrency: config.concurrency ?? 1 / 0,
+      autoStart: config.autoStart ?? true,
+      timeout: config.timeout ?? 0,
+      throwOnTimeout: config.throwOnTimeout ?? true,
+      interval: config.interval ?? 0,
+      intervalCap: config.intervalCap ?? 1 / 0,
+      carryoverConcurrencyCount: config.carryoverConcurrencyCount ?? false
+    };
+    if (!this.config.autoStart) {
+      this.isPausedFlag = true;
+    }
+    if (this.config.interval > 0) {
+      this.startInterval();
+    }
+  }
+  get state() {
+    return {
+      pending: this.pendingCount,
+      size: this.queue.length,
+      total: this.pendingCount + this.queue.length,
+      isPaused: this.isPausedFlag,
+      isIdle: this.pendingCount === 0 && this.queue.length === 0
+    };
+  }
+  get stats() {
+    return { ...this.statsData };
+  }
+  get concurrency() {
+    return this.config.concurrency;
+  }
+  set concurrency(value) {
+    this.config.concurrency = value;
+    this.tryRunNext();
+  }
+  get pending() {
+    return this.pendingCount;
+  }
+  get size() {
+    return this.queue.length;
+  }
+  get isPaused() {
+    return this.isPausedFlag;
+  }
+  add(fn, options = {}) {
+    return new Promise((resolve, reject) => {
+      const task = {
+        id: options.id ?? generateId(),
+        fn,
+        priority: options.priority ?? 0,
+        timeout: options.timeout ?? this.config.timeout,
+        signal: options.signal,
+        resolve,
+        reject,
+        addedAt: Date.now()
+      };
+      if (options.signal?.aborted) {
+        reject(new Error("Task was cancelled before starting"));
+        return;
+      }
+      options.signal?.addEventListener("abort", () => {
+        this.cancel(task.id);
+      });
+      this.insertByPriority(task);
+      this.statsData.added++;
+      this.emit("add", { id: task.id, priority: task.priority });
+      if (this.config.autoStart && !this.isPausedFlag) {
+        this.tryRunNext();
+      }
+    });
+  }
+  addAll(fns, options = {}) {
+    return Promise.all(fns.map((fn, i) => this.add(fn, { ...options, id: options.id ? `${options.id}-${i}` : undefined })));
+  }
+  pause() {
+    if (!this.isPausedFlag) {
+      this.isPausedFlag = true;
+      this.emit("paused", undefined);
+    }
+  }
+  start() {
+    if (this.isPausedFlag) {
+      this.isPausedFlag = false;
+      this.emit("resumed", undefined);
+      this.tryRunNext();
+    }
+  }
+  clear() {
+    const tasks = [...this.queue];
+    this.queue = [];
+    for (const task of tasks) {
+      task.reject(new Error("Queue was cleared"));
+      this.statsData.cancelled++;
+      this.emit("cancelled", { id: task.id });
+    }
+    this.checkEmpty();
+  }
+  cancel(id) {
+    const index = this.queue.findIndex((t) => t.id === id);
+    if (index !== -1) {
+      const [task] = this.queue.splice(index, 1);
+      task.reject(new Error("Task was cancelled"));
+      this.statsData.cancelled++;
+      this.emit("cancelled", { id });
+      this.checkEmpty();
+      return true;
+    }
+    return false;
+  }
+  cancelBy(predicate) {
+    let count = 0;
+    const remaining = [];
+    for (const task of this.queue) {
+      if (predicate({ id: task.id, priority: task.priority })) {
+        task.reject(new Error("Task was cancelled"));
+        this.statsData.cancelled++;
+        this.emit("cancelled", { id: task.id });
+        count++;
+      } else {
+        remaining.push(task);
+      }
+    }
+    this.queue = remaining;
+    if (count > 0) {
+      this.checkEmpty();
+    }
+    return count;
+  }
+  onIdle() {
+    if (this.state.isIdle) {
+      return Promise.resolve();
+    }
+    if (!this.idlePromise) {
+      let resolvePromise;
+      const promise = new Promise((resolve) => {
+        resolvePromise = resolve;
+      });
+      this.idlePromise = { promise, resolve: resolvePromise };
+    }
+    return this.idlePromise.promise;
+  }
+  onEmpty() {
+    if (this.queue.length === 0) {
+      return Promise.resolve();
+    }
+    if (!this.emptyPromise) {
+      let resolvePromise;
+      const promise = new Promise((resolve) => {
+        resolvePromise = resolve;
+      });
+      this.emptyPromise = { promise, resolve: resolvePromise };
+    }
+    return this.emptyPromise.promise;
+  }
+  onSizeLessThan(limit) {
+    if (this.queue.length < limit) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      const check = () => {
+        if (this.queue.length < limit) {
+          this.off("completed", check);
+          this.off("cancelled", check);
+          this.off("error", check);
+          resolve();
+        }
+      };
+      this.on("completed", check);
+      this.on("cancelled", check);
+      this.on("error", check);
+    });
+  }
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, new Set);
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  destroy() {
+    this.clear();
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = undefined;
+    }
+    this.eventHandlers.clear();
+  }
+  insertByPriority(task) {
+    let insertIndex = this.queue.length;
+    for (let i = 0;i < this.queue.length; i++) {
+      if (task.priority > this.queue[i].priority) {
+        insertIndex = i;
+        break;
+      }
+    }
+    this.queue.splice(insertIndex, 0, task);
+  }
+  tryRunNext() {
+    if (this.isPausedFlag)
+      return;
+    if (this.queue.length === 0)
+      return;
+    if (this.pendingCount >= this.config.concurrency)
+      return;
+    if (this.config.interval > 0) {
+      if (this.intervalCount >= this.config.intervalCap)
+        return;
+      this.intervalCount++;
+    }
+    const task = this.queue.shift();
+    this.runTask(task);
+    this.tryRunNext();
+  }
+  async runTask(task) {
+    this.pendingCount++;
+    this.statsData.processed++;
+    const wasIdle = this.pendingCount === 1 && this.queue.length === 0;
+    if (wasIdle) {
+      this.emit("active", undefined);
+    }
+    this.emit("start", { id: task.id });
+    this.emit("next", undefined);
+    const startTime = Date.now();
+    let timeoutId;
+    try {
+      let result;
+      if (task.timeout && task.timeout > 0) {
+        result = await Promise.race([
+          task.fn(),
+          new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+              this.statsData.timedOut++;
+              this.emit("timeout", { id: task.id });
+              if (this.config.throwOnTimeout) {
+                reject(new Error(`Task ${task.id} timed out after ${task.timeout}ms`));
+              }
+            }, task.timeout);
+          })
+        ]);
+      } else {
+        result = await task.fn();
+      }
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      const duration = Date.now() - startTime;
+      this.recordDuration(duration);
+      this.statsData.completed++;
+      this.emit("completed", { id: task.id, result, duration });
+      task.resolve(result);
+    } catch (error) {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      this.statsData.failed++;
+      this.emit("error", { id: task.id, error });
+      task.reject(error);
+    } finally {
+      this.pendingCount--;
+      this.checkEmpty();
+      this.checkIdle();
+      this.tryRunNext();
+    }
+  }
+  recordDuration(duration) {
+    this.totalDuration += duration;
+    this.statsData.averageDuration = this.totalDuration / this.statsData.completed;
+    const now = Date.now();
+    this.throughputWindow.push(now);
+    const windowStart = now - this.throughputWindowSize * 1000;
+    this.throughputWindow = this.throughputWindow.filter((t) => t > windowStart);
+    this.statsData.throughput = this.throughputWindow.length / this.throughputWindowSize;
+  }
+  startInterval() {
+    this.intervalStart = Date.now();
+    this.intervalCount = 0;
+    this.intervalId = setInterval(() => {
+      if (!this.config.carryoverConcurrencyCount) {
+        this.intervalCount = 0;
+      } else {
+        this.intervalCount = Math.max(0, this.intervalCount - this.config.intervalCap);
+      }
+      this.intervalStart = Date.now();
+      this.tryRunNext();
+    }, this.config.interval);
+  }
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch {}
+      }
+    }
+  }
+  checkEmpty() {
+    if (this.queue.length === 0) {
+      this.emit("empty", undefined);
+      if (this.emptyPromise) {
+        this.emptyPromise.resolve();
+        this.emptyPromise = undefined;
+      }
+    }
+  }
+  checkIdle() {
+    if (this.state.isIdle) {
+      this.emit("idle", undefined);
+      if (this.idlePromise) {
+        this.idlePromise.resolve();
+        this.idlePromise = undefined;
+      }
+    }
+  }
+}

package/dist/queue/types.cjs

@@ -0,0 +1,17 @@
+const Priority = exports.Priority = {
+  LOWEST: 0,
+  LOW: 25,
+  NORMAL: 50,
+  HIGH: 75,
+  HIGHEST: 100,
+  CRITICAL: 1000
+};
+const HttpMethodPriority = exports.HttpMethodPriority = {
+  HEAD: 100,
+  GET: 75,
+  OPTIONS: 50,
+  POST: 50,
+  PUT: 50,
+  PATCH: 50,
+  DELETE: 25
+};

package/dist/queue/types.js

@@ -0,0 +1,17 @@
+export const Priority = {
+  LOWEST: 0,
+  LOW: 25,
+  NORMAL: 50,
+  HIGH: 75,
+  HIGHEST: 100,
+  CRITICAL: 1000
+};
+export const HttpMethodPriority = {
+  HEAD: 100,
+  GET: 75,
+  OPTIONS: 50,
+  POST: 50,
+  PUT: 50,
+  PATCH: 50,
+  DELETE: 25
+};

package/dist/types/curl-options.cjs

@@ -0,0 +1,25 @@
+const CURL_OPTION_DEFAULTS = exports.CURL_OPTION_DEFAULTS = {
+  tcpFastOpen: false,
+  tcpNodelay: false,
+  noKeepalive: false,
+  pathAsIs: false,
+  globOff: false,
+  certStatus: false,
+  noAlpn: false,
+  sessionId: true,
+  locationTrusted: false,
+  junkSessionCookies: false,
+  fail: false,
+  verbose: false,
+  traceTime: false,
+  raw: false,
+  noCompressed: false,
+  noAltSvc: false,
+  negotiate: false,
+  saslIr: false,
+  compressedSsh: false,
+  insecure: false,
+  maxRedirs: 50,
+  happyEyeballsTimeout: 200
+};
+const CURL_OPTIONS_COUNT = exports.CURL_OPTIONS_COUNT = 120;

package/dist/types/curl-options.js

@@ -0,0 +1,25 @@
+export const CURL_OPTION_DEFAULTS = {
+  tcpFastOpen: false,
+  tcpNodelay: false,
+  noKeepalive: false,
+  pathAsIs: false,
+  globOff: false,
+  certStatus: false,
+  noAlpn: false,
+  sessionId: true,
+  locationTrusted: false,
+  junkSessionCookies: false,
+  fail: false,
+  verbose: false,
+  traceTime: false,
+  raw: false,
+  noCompressed: false,
+  noAltSvc: false,
+  negotiate: false,
+  saslIr: false,
+  compressedSsh: false,
+  insecure: false,
+  maxRedirs: 50,
+  happyEyeballsTimeout: 200
+};
+export const CURL_OPTIONS_COUNT = 120;

package/dist/utils/http-config.cjs

@@ -175,10 +175,7 @@ function setSignal() {
   }
 }
 async function getDefaultConfig(config = {}, proxyManager) {
-  const curl = await checkCurl();
   return {
-    useCurl: config.curl === true,
-    isCurl: curl.status || false,
     baseURL: config.baseURL,
     headers: config.headers,
     rejectUnauthorized: config.rejectUnauthorized,
@@ -192,7 +189,6 @@ async function getDefaultConfig(config = {}, proxyManager) {
     useCookies: config.enableCookieJar,
     fs: await getFS(),
     timeout: config.timeout ?? config.requestTimeout,
-    http2: config.http2 === true,
     hooks: config.hooks,
     cookieFile: config.cookieFile,
     encoding: config.encoding,
@@ -523,8 +519,6 @@ As a workaround, process.env.NODE_TLS_REJECT_UNAUTHORIZED is being set to '0'.
     headers: requestOptions.headers,
     maxRedirects,
     retryAttempts: 0,
-    http2: requestOptions.http2 === true,
-    curl: requestOptions.curl === true,
     timeout: typeof requestOptions.timeout === "number" ? requestOptions.timeout : null,
     enableCookieJar: typeof defaultOptions.enableCookieJar === "boolean" ? defaultOptions.enableCookieJar : true,
     useCookies: typeof requestOptions.useCookies === "boolean" ? requestOptions.useCookies : true,
@@ -583,15 +577,6 @@ As a workaround, process.env.NODE_TLS_REJECT_UNAUTHORIZED is being set to '0'.
     config.httpsAgent = options.httpsAgent;
   }
   const isSupportedRuntime = type === "node" || type === "bun" || type === "deno";
-  if (requestOptions.curl && !defaultOptions.isCurl && debug) {
-    const recommendations = isSupportedRuntime ? `Recommendations:
-` + `• Only enable 'curl' mode when absolutely necessary
-` + `• Verify curl is installed and up-to-date on your system
-` + `• For enhanced security, consider using native Rezo HTTP clients instead` : "";
-    console.warn(`⚠️ [WARNING]: ${isSupportedRuntime ? `Curl binary not detected in your environment while 'curl' mode is enabled` : `'curl' mode is not supported in '${type}' environment`}
-
-` + recommendations);
-  }
   if (saveTo) {
     if (!isSupportedRuntime) {
       throw new Error(`You can only use this feature in Node.js, Deno or Bun and not available in Edge or Browser.`);

package/dist/utils/http-config.js

@@ -175,10 +175,7 @@ function setSignal() {
   }
 }
 export async function getDefaultConfig(config = {}, proxyManager) {
-  const curl = await checkCurl();
   return {
-    useCurl: config.curl === true,
-    isCurl: curl.status || false,
     baseURL: config.baseURL,
     headers: config.headers,
     rejectUnauthorized: config.rejectUnauthorized,
@@ -192,7 +189,6 @@ export async function getDefaultConfig(config = {}, proxyManager) {
     useCookies: config.enableCookieJar,
     fs: await getFS(),
     timeout: config.timeout ?? config.requestTimeout,
-    http2: config.http2 === true,
     hooks: config.hooks,
     cookieFile: config.cookieFile,
     encoding: config.encoding,
@@ -523,8 +519,6 @@ As a workaround, process.env.NODE_TLS_REJECT_UNAUTHORIZED is being set to '0'.
     headers: requestOptions.headers,
     maxRedirects,
     retryAttempts: 0,
-    http2: requestOptions.http2 === true,
-    curl: requestOptions.curl === true,
     timeout: typeof requestOptions.timeout === "number" ? requestOptions.timeout : null,
     enableCookieJar: typeof defaultOptions.enableCookieJar === "boolean" ? defaultOptions.enableCookieJar : true,
     useCookies: typeof requestOptions.useCookies === "boolean" ? requestOptions.useCookies : true,
@@ -583,15 +577,6 @@ As a workaround, process.env.NODE_TLS_REJECT_UNAUTHORIZED is being set to '0'.
     config.httpsAgent = options.httpsAgent;
   }
   const isSupportedRuntime = type === "node" || type === "bun" || type === "deno";
-  if (requestOptions.curl && !defaultOptions.isCurl && debug) {
-    const recommendations = isSupportedRuntime ? `Recommendations:
-` + `• Only enable 'curl' mode when absolutely necessary
-` + `• Verify curl is installed and up-to-date on your system
-` + `• For enhanced security, consider using native Rezo HTTP clients instead` : "";
-    console.warn(`⚠️ [WARNING]: ${isSupportedRuntime ? `Curl binary not detected in your environment while 'curl' mode is enabled` : `'curl' mode is not supported in '${type}' environment`}
-
-` + recommendations);
-  }
   if (saveTo) {
     if (!isSupportedRuntime) {
       throw new Error(`You can only use this feature in Node.js, Deno or Bun and not available in Edge or Browser.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rezo",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Lightning-fast, enterprise-grade HTTP client for modern JavaScript. Full HTTP/2 support, intelligent cookie management, multiple adapters (HTTP, Fetch, cURL, XHR), streaming, proxy support (HTTP/HTTPS/SOCKS), and cross-environment compatibility.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -66,7 +66,6 @@
     "http-proxy-agent": "^7.0.2",
     "https-proxy-agent": "^7.0.6",
     "socks-proxy-agent": "^8.0.5",
-    "p-queue": "^8.1.0",
     "linkedom": "^0.18.11",
     "agent-base": "^7.1.4"
   },