recker 1.0.85 → 1.0.86-next.a24fa13

package/dist/browser/index.mini.umd.js

@@ -10027,6 +10027,9 @@ var recker = (() => {
         case "total":
           values.total = parseCurlTimingValue(value);
           break;
+        case "pretransfer":
+          values.pretransfer = parseCurlTimingValue(value);
+          break;
         default:
           break;
       }
@@ -10138,7 +10141,7 @@ var recker = (() => {
               "--compressed",
               "--no-keepalive",
               "--write-out",
-              `\\n${TIMING_MARKER} dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} ttfb=%{time_starttransfer} total=%{time_total}`
+              `\\n${TIMING_MARKER} dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} pretransfer=%{time_pretransfer} ttfb=%{time_starttransfer} total=%{time_total}`
             ];
             const proxy = this.getNextProxy();
             if (proxy) {
@@ -10228,14 +10231,49 @@ var recker = (() => {
                 statusText,
                 headers
               });
-              const responseTimings = timings && Object.keys(timings).length > 0 ? {
-                dns: timings.dns,
-                tcp: timings.tcp,
-                tls: timings.tls ? timings.ttfb !== void 0 ? timings.tls : timings.tls : void 0,
-                firstByte: timings.ttfb,
-                content: timings.download,
-                total: timings.total
-              } : {};
+              const usedProxy = this.proxyList.length > 0;
+              let responseTimings = {};
+              if (timings && Object.keys(timings).length > 0) {
+                const dns = timings.dns;
+                const tcp = timings.tcp !== void 0 && timings.dns !== void 0 ? timings.tcp - timings.dns : void 0;
+                const hasTls = timings.tls !== void 0 && timings.tls > 0;
+                const tls = hasTls && timings.tcp !== void 0 ? timings.tls - timings.tcp : void 0;
+                const content = timings.download;
+                if (usedProxy && timings.pretransfer !== void 0) {
+                  const afterProxy = hasTls ? timings.tls : timings.tcp;
+                  const targetTls = afterProxy !== void 0 ? timings.pretransfer - afterProxy : void 0;
+                  const proxyTotal = (dns ?? 0) + (tcp ?? 0) + (tls ?? 0);
+                  const connectionTime = proxyTotal + (targetTls ?? 0);
+                  const serverTime = timings.ttfb !== void 0 ? timings.ttfb - connectionTime : void 0;
+                  responseTimings = {
+                    tls: targetTls,
+                    content,
+                    transferTime: content,
+                    proxyDns: dns,
+                    proxyTcp: tcp,
+                    proxyTls: tls,
+                    proxyTotal,
+                    firstByte: timings.ttfb,
+                    total: timings.total,
+                    connectionTime,
+                    serverTime
+                  };
+                } else {
+                  const connectionTime = (dns ?? 0) + (tcp ?? 0) + (tls ?? 0);
+                  const serverTime = timings.ttfb !== void 0 ? timings.ttfb - connectionTime : void 0;
+                  responseTimings = {
+                    dns,
+                    tcp,
+                    tls,
+                    content,
+                    transferTime: content,
+                    firstByte: timings.ttfb,
+                    total: timings.total,
+                    connectionTime,
+                    serverTime
+                  };
+                }
+              }
               resolve12(new HttpResponse(nativeResponse, {
                 timings: responseTimings,
                 connection: { protocol: "curl" }
@@ -11068,6 +11106,90 @@ var recker = (() => {
     }
   });
 
+  // dist/browser/utils/env-proxy.js
+  function getProxyForUrl(url, options2 = {}) {
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(url);
+    } catch {
+      return void 0;
+    }
+    const protocol = parsedUrl.protocol.replace(":", "").toLowerCase();
+    const noProxy = options2.noProxy ?? process.env.NO_PROXY ?? process.env.no_proxy ?? "";
+    if (shouldBypassProxy(parsedUrl.hostname, parsedUrl.port, noProxy)) {
+      return void 0;
+    }
+    let proxy;
+    if (protocol === "https") {
+      proxy = options2.httpsProxy ?? process.env.HTTPS_PROXY ?? process.env.https_proxy ?? process.env.ALL_PROXY ?? process.env.all_proxy;
+    } else {
+      proxy = options2.httpProxy ?? process.env.HTTP_PROXY ?? process.env.http_proxy ?? process.env.ALL_PROXY ?? process.env.all_proxy;
+    }
+    return proxy || void 0;
+  }
+  function shouldBypassProxy(hostname, port, noProxy) {
+    if (!noProxy || noProxy.trim() === "") {
+      return false;
+    }
+    hostname = hostname.toLowerCase();
+    const rules = noProxy.split(/[\s,]+/).filter(Boolean);
+    for (const rule of rules) {
+      const normalizedRule = rule.toLowerCase().trim();
+      if (normalizedRule === "*") {
+        return true;
+      }
+      if (normalizedRule.includes("/") && !normalizedRule.includes(":")) {
+        if (matchesCIDR(hostname, normalizedRule)) {
+          return true;
+        }
+        continue;
+      }
+      if (normalizedRule.includes(":") && !normalizedRule.startsWith("[")) {
+        const [ruleHost, rulePort] = normalizedRule.split(":");
+        if (hostname === ruleHost && (!rulePort || port === rulePort)) {
+          return true;
+        }
+        continue;
+      }
+      if (normalizedRule.startsWith(".")) {
+        if (hostname.endsWith(normalizedRule) || hostname === normalizedRule.slice(1)) {
+          return true;
+        }
+        continue;
+      }
+      if (hostname === normalizedRule) {
+        return true;
+      }
+      if (hostname.endsWith("." + normalizedRule)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function matchesCIDR(ip, cidr) {
+    const [range, bits] = cidr.split("/");
+    if (!bits)
+      return ip === range;
+    const mask = parseInt(bits, 10);
+    if (isNaN(mask))
+      return false;
+    const ipParts = ip.split(".").map(Number);
+    const rangeParts = range.split(".").map(Number);
+    if (ipParts.length !== 4 || rangeParts.length !== 4)
+      return false;
+    if (ipParts.some(isNaN) || rangeParts.some(isNaN))
+      return false;
+    const ipNum = ipParts[0] << 24 | ipParts[1] << 16 | ipParts[2] << 8 | ipParts[3];
+    const rangeNum = rangeParts[0] << 24 | rangeParts[1] << 16 | rangeParts[2] << 8 | rangeParts[3];
+    const maskNum = ~((1 << 32 - mask) - 1);
+    return (ipNum & maskNum) === (rangeNum & maskNum);
+  }
+  var init_env_proxy = __esm({
+    "dist/browser/utils/env-proxy.js"() {
+      "use strict";
+    }
+  });
+
   // node-stub:events
   var events_exports = {};
   __export(events_exports, {
@@ -16269,7 +16391,7 @@ var recker = (() => {
         return void 0;
     }
   }
-  function matchesCIDR(ip, cidr) {
+  function matchesCIDR2(ip, cidr) {
     const [range, bits] = cidr.split("/");
     if (!bits)
       return ip === range;
@@ -16287,7 +16409,7 @@ var recker = (() => {
     const maskNum = ~((1 << 32 - mask) - 1);
     return (ipNum & maskNum) === (rangeNum & maskNum);
   }
-  function shouldBypassProxy(url, bypass) {
+  function shouldBypassProxy2(url, bypass) {
     if (!bypass || bypass.length === 0)
       return false;
     let hostname = "";
@@ -16303,7 +16425,7 @@ var recker = (() => {
       if (rule === "*")
         return true;
       if (rule.includes("/")) {
-        if (matchesCIDR(hostname, rule))
+        if (matchesCIDR2(hostname, rule))
           return true;
         continue;
       }
@@ -16431,6 +16553,7 @@ var recker = (() => {
       init_node_diagnostics_channel();
       init_dns();
       init_agent_manager();
+      init_env_proxy();
       init_progress();
       init_streaming();
       init_protocol_cache();
@@ -16683,7 +16806,7 @@ var recker = (() => {
           if (this.proxySlots.length > 0) {
             const slot = this.proxySlots[this.proxyIndex % this.proxySlots.length];
             this.proxyIndex++;
-            if (!shouldBypassProxy(url, slot.bypass)) {
+            if (!shouldBypassProxy2(url, slot.bypass)) {
               if (slot.agent)
                 return slot.agent;
               if (!slot.socksAgentPromise) {
@@ -16693,6 +16816,9 @@ var recker = (() => {
               return slot.agent;
             }
           }
+          const envProxy = getProxyForUrl(url);
+          if (envProxy)
+            return new ProxyAgent5(envProxy);
           if (this.agentManager)
             return this.agentManager.getAgentForUrl(url);
           if (this.dnsAgent)
@@ -18994,6 +19120,7 @@ var recker = (() => {
     policyTags;
     policySource;
     traceId;
+    queue;
     constructor(url, options2 = {}) {
       this.url = url;
       this.method = options2.method || "GET";
@@ -19015,6 +19142,7 @@ var recker = (() => {
       this.policyTags = options2.policyTags ?? [];
       this.policySource = options2.policySource;
       this.traceId = options2.traceId;
+      this.queue = options2.queue;
     }
     withHeader(name, value) {
       const context = getRequestContext(this);
@@ -19039,7 +19167,8 @@ var recker = (() => {
         tenant: this.tenant,
         policyTags: this.policyTags,
         policySource: this.policySource,
-        traceId: this.traceId
+        traceId: this.traceId,
+        queue: this.queue
       });
       if (context) {
         return attachRequestContext(request11, context);
@@ -19067,7 +19196,8 @@ var recker = (() => {
         tenant: this.tenant,
         policyTags: this.policyTags,
         policySource: this.policySource,
-        traceId: this.traceId
+        traceId: this.traceId,
+        queue: this.queue
       });
       if (context) {
         return attachRequestContext(request11, context);
@@ -21073,6 +21203,166 @@ var recker = (() => {
     };
   }
 
+  // dist/browser/plugins/queue.js
+  var jobSeq = 0;
+  function generateJobId() {
+    jobSeq += 1;
+    return `qj-${Date.now().toString(36)}-${jobSeq.toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
+  }
+  function serializeRequest(req, jobId, metadata) {
+    var _a2;
+    const headers = {};
+    req.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    let body = null;
+    const bodyContentType = headers["content-type"];
+    if (req.body !== null && req.body !== void 0) {
+      if (typeof req.body === "string") {
+        body = req.body;
+      } else if (typeof req.body === "object") {
+        try {
+          body = JSON.stringify(req.body);
+        } catch {
+          body = String(req.body);
+        }
+      } else {
+        body = String(req.body);
+      }
+    }
+    return {
+      jobId,
+      url: req.url,
+      method: req.method,
+      headers,
+      body,
+      bodyContentType: bodyContentType || void 0,
+      correlationId: req.correlationId,
+      traceId: req.traceId,
+      tenant: req.tenant,
+      policyTags: ((_a2 = req.policyTags) == null ? void 0 : _a2.length) ? req.policyTags : void 0,
+      createdAt: Date.now(),
+      metadata: metadata && Object.keys(metadata).length > 0 ? metadata : void 0
+    };
+  }
+  function compileFilter(config) {
+    return (req) => {
+      if (config.methods && !config.methods.includes(req.method)) {
+        return false;
+      }
+      if (config.urlPatterns) {
+        const matched = config.urlPatterns.some((pattern) => {
+          if (typeof pattern === "string")
+            return req.url.includes(pattern);
+          return pattern.test(req.url);
+        });
+        if (!matched)
+          return false;
+      }
+      if (config.headerPresent && !req.headers.has(config.headerPresent)) {
+        return false;
+      }
+      return true;
+    };
+  }
+  var QueuedResponse = class _QueuedResponse {
+    jobId;
+    raw;
+    timings = void 0;
+    connection = void 0;
+    constructor(jobId) {
+      this.jobId = jobId;
+      const responseBody = JSON.stringify({
+        queued: true,
+        jobId,
+        status: "queued"
+      });
+      this.raw = new Response(responseBody, {
+        status: 202,
+        statusText: "Accepted",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Queue-Job-Id": jobId,
+          "X-Queue-Status": "queued"
+        }
+      });
+    }
+    get status() {
+      return 202;
+    }
+    get statusText() {
+      return "Accepted";
+    }
+    get headers() {
+      return this.raw.headers;
+    }
+    get ok() {
+      return true;
+    }
+    get url() {
+      return "";
+    }
+    json() {
+      return this.raw.json();
+    }
+    text() {
+      return this.raw.text();
+    }
+    async cleanText() {
+      return this.raw.text();
+    }
+    blob() {
+      return this.raw.blob();
+    }
+    read() {
+      return this.raw.body;
+    }
+    clone() {
+      return new _QueuedResponse(this.jobId);
+    }
+    async *sse() {
+    }
+    async *download() {
+    }
+    async *[Symbol.asyncIterator]() {
+      if (!this.raw.body)
+        return;
+      const reader = this.raw.body.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        yield value;
+      }
+    }
+  };
+  function queuePlugin(options2) {
+    const adapter = options2.adapter;
+    const filter2 = typeof options2.filter === "function" ? options2.filter : options2.filter ? compileFilter(options2.filter) : () => true;
+    const generateId = options2.jobIdGenerator || generateJobId;
+    const queueMiddleware = async (req, next) => {
+      const perReq = req.queue;
+      if (perReq === false) {
+        return next(req);
+      }
+      const shouldQueue = perReq === true || typeof perReq === "object" || filter2(req);
+      if (!shouldQueue) {
+        return next(req);
+      }
+      const metadata = {
+        ...options2.defaultMetadata,
+        ...typeof perReq === "object" && perReq !== null && "metadata" in perReq ? perReq.metadata : void 0
+      };
+      const jobId = generateId(req);
+      const job = serializeRequest(req, jobId, metadata);
+      const assignedId = await adapter.enqueue(job);
+      return new QueuedResponse(assignedId || jobId);
+    };
+    return (client) => {
+      client.use(queueMiddleware);
+    };
+  }
+
   // dist/browser/plugins/xsrf.js
   function parseCookies(cookieString) {
     const cookies = {};
@@ -23005,6 +23295,13 @@ var recker = (() => {
           scope: "request"
         });
       }
+      if (options2.queue) {
+        registerPlugin(queuePlugin(options2.queue), {
+          name: "recker:queue",
+          priority: 135,
+          scope: "request"
+        });
+      }
       if (options2.plugins) {
         options2.plugins.forEach((plugin, index) => {
           const existingManifest = getPluginManifest(plugin);