@seayoo-web/request 3.5.2 → 4.0.0

package/dist/node.js

@@ -1,83 +1,83 @@
-import { h as b, r as q, c as w, n as g, a as d, f as E, N as f, X as x } from "./retry-Cxkf8ke1.js";
-import { g as z } from "./retry-Cxkf8ke1.js";
-import { f as C } from "./request.fetch-Jj3A4PnG.js";
+import { h as w, r as R, c as y, d as b, f as q, R as s, N as h, X as g } from "./retry-DRbCcUt8.js";
+import { g as S } from "./retry-DRbCcUt8.js";
+import { f as x } from "./request.fetch-BNCxK4Wq.js";
 import N from "node:http";
-import T from "node:https";
-const j = async function(o, a, u) {
-  return b(await q(L, o, a, u), o, a, u);
-}, L = async function(o, a, u) {
-  const t = await w(o, a, u);
-  if (!g(t.url))
-    return {
-      url: t.url,
-      method: t.method,
-      status: -1,
-      statusText: d.URLFormatError,
-      headers: {},
-      body: ""
-    };
-  const R = /^https:\/\//i.test(t.url) ? T : N, n = new URL(t.url), i = t.params;
-  i instanceof Object && Object.keys(i).forEach((r) => n.searchParams.set(r, i[r]));
-  const l = t.method === "HEAD";
-  return new Promise((r) => {
-    const c = R.request(
-      n,
+import C from "node:https";
+const E = async function(o, n, a) {
+  return w(await R(T, o, n, a), o, n, a);
+}, T = async function(o, n, a) {
+  const t = await y(o, n, a), p = /^https:\/\//i.test(t.url) ? C : N;
+  return new Promise((d) => {
+    const u = p.request(
+      t.url,
       {
         headers: t.headers,
         method: t.method,
         timeout: t.timeout > 0 ? t.timeout : void 0
       },
       function(e) {
-        const p = [];
-        e.on("data", (m) => p.push(m)), e.on("end", () => {
-          const m = E(
-            Object.entries(e.headers).map(([y, h]) => [y.toLowerCase(), Array.isArray(h) ? h.join(",") : h])
+        const f = [];
+        e.on("data", (c) => f.push(c)), e.on("end", async () => {
+          const c = b(
+            Object.entries(e.headers).map(([l, i]) => [l.toLowerCase(), Array.isArray(i) ? i.join(",") : i])
+          ), m = Buffer.concat(f);
+          d(
+            await q(
+              {
+                url: t.url,
+                method: t.method,
+                status: e.statusCode || -1,
+                error: e.statusCode ? void 0 : s.Unknown,
+                statusText: e.statusMessage || s.Unknown,
+                headers: c,
+                body: null
+              },
+              {
+                asBuffer: t.asBuffer,
+                text: () => m.toString("utf-8"),
+                buffer: () => m.buffer
+              }
+            )
           );
-          r({
-            url: n.toString(),
-            method: t.method,
-            status: e.statusCode || -1,
-            statusText: e.statusMessage || d.Unknown,
-            headers: m,
-            body: l || e.statusCode === 204 ? "" : Buffer.concat(p).toString("utf-8")
-          });
         });
       }
     );
-    c.on("error", (e) => {
-      r({
-        url: n.toString(),
+    u.on("error", (e) => {
+      d({
+        url: t.url,
         method: t.method,
         status: -1,
-        statusText: d.NetworkError,
-        body: "",
+        error: s.NetworkError,
+        statusText: s.NetworkError,
+        body: null,
         rawError: e
       });
-    }), c.on("timeout", () => {
-      r({
-        url: n.toString(),
+    }), u.on("timeout", () => {
+      d({
+        url: t.url,
         method: t.method,
         status: -1,
-        statusText: d.Timeout,
-        body: ""
+        error: s.Timeout,
+        statusText: s.Timeout,
+        body: null
       });
-    }), t.body && c.write(t.body), c.end();
+    }), t.body && u.write(t.body), u.end();
   });
 };
 // @__NO_SIDE_EFFECTS__
-function O(o) {
-  return x() ? new f(C, o) : new f(j, o);
+function k(o) {
+  return g() ? new h(x, o) : new h(E, o);
 }
-const s = /* @__PURE__ */ O(), k = s.setConfig, B = s.head, D = s.get, P = s.post, X = s.del, F = s.put, G = s.patch;
+const r = /* @__PURE__ */ k(), U = r.setConfig, X = r.head, D = r.get, G = r.post, H = r.del, I = r.put, L = r.patch;
 export {
-  O as NetRequest,
-  d as RequestInternalError,
-  X as del,
+  k as NetRequest,
+  s as RequestInternalError,
+  H as del,
   D as get,
-  z as getResponseRulesDescription,
-  B as head,
-  G as patch,
-  P as post,
-  F as put,
-  k as setGlobalConfig
+  S as getResponseRulesDescription,
+  X as head,
+  L as patch,
+  G as post,
+  I as put,
+  U as setGlobalConfig
 };

package/dist/request.fetch-BNCxK4Wq.js

@@ -0,0 +1,54 @@
+import { h as f, r as h, c as m, e as b, f as y, d as T, R as u } from "./retry-DRbCcUt8.js";
+const x = async function(o, a, s) {
+  return f(await h(w, o, a, s), o, a, s);
+}, w = async function(o, a, s) {
+  const t = await m(o, a, s), r = b() ? new AbortController() : null;
+  function n(e) {
+    r && !r.signal.aborted && r.abort(e);
+  }
+  t.abort?.addEventListener("abort", n);
+  let i = !1;
+  const l = t.timeout > 0 ? setTimeout(function() {
+    i = !0, n("TimeoutTriggered");
+  }, t.timeout) : null;
+  return await fetch(t.url, {
+    method: t.method,
+    headers: Object.keys(t.headers).length > 0 ? new Headers(t.headers) : void 0,
+    body: t.body,
+    credentials: t.credentials,
+    signal: r?.signal,
+    redirect: "follow"
+  }).then(
+    async (e) => y(
+      {
+        url: t.url,
+        method: t.method,
+        status: e.status,
+        statusText: e.statusText,
+        headers: T([...e.headers.entries()]),
+        body: null
+      },
+      {
+        asBuffer: t.asBuffer,
+        text: () => e.text(),
+        buffer: () => e.arrayBuffer()
+      }
+    )
+  ).catch((e) => {
+    const c = r?.signal.aborted, d = i ? u.Timeout : c ? u.Aborted : u.NetworkError;
+    return {
+      url: t.url,
+      method: t.method,
+      status: -1,
+      error: d,
+      statusText: d,
+      body: null,
+      rawError: e
+    };
+  }).finally(() => {
+    l !== null && clearTimeout(l), t.abort && t.abort.removeEventListener("abort", n);
+  });
+};
+export {
+  x as f
+};