@scalar/api-client 2.19.2 → 2.20.0

package/dist/v2/blocks/operation-block/helpers/build-request-parameters.js

@@ -1,56 +1,104 @@
-import { replaceEnvVariables as f } from "@scalar/helpers/regex/replace-variables";
-import { getResolvedRef as u } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import { xScalarCookieSchema as P } from "@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies";
-import { coerceValue as y } from "@scalar/workspace-store/schemas/typebox-coerce";
-import { isParamDisabled as c } from "../../request-block/helpers/is-param-disabled.js";
-import { getDelimiter as v } from "./get-delimiter.js";
-import { getExample as R } from "./get-example.js";
-const L = (d = [], n = {}, l = "default") => {
-  const a = [];
-  let i = "application/json";
-  for (const t of d) {
-    const e = u(t);
-    a.push(e), e.in === "header" && e.name.toLowerCase() === "content-type" && "examples" in e && (i = u(e?.examples?.[l])?.value ?? i);
-  }
-  return a.reduce(
-    (t, e) => {
-      const s = R(e, l, i);
-      if (!s || c(e, s))
-        return t;
-      const r = typeof s.value == "string" ? f(s.value, n) : s.value, o = f(e.name, n);
-      if (e.in === "header") {
-        if (o.toLowerCase() === "content-type" && r === "multipart/form-data")
-          return t;
-        t.headers[o] ? t.headers[o] += `,${r}` : t.headers[o] = r;
+import { isDefined as k } from "@scalar/helpers/array/is-defined";
+import { replaceEnvVariables as y } from "@scalar/helpers/regex/replace-variables";
+import { getResolvedRef as g } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { xScalarCookieSchema as u } from "@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies";
+import { coerceValue as S } from "@scalar/workspace-store/schemas/typebox-coerce";
+import { isParamDisabled as m } from "../../request-block/helpers/is-param-disabled.js";
+import { getExample as z } from "./get-example.js";
+import { serializeSimpleStyle as h, serializeFormStyleForCookies as b, serializeContentValue as x, serializeDeepObjectStyle as v, serializeSpaceDelimitedStyle as C, serializePipeDelimitedStyle as D, serializeFormStyle as $ } from "./serialize-parameter.js";
+const a = (o, s) => "explode" in o && o.explode !== void 0 ? o.explode : s, L = (o = [], s = {}, l = "default") => {
+  const e = {
+    cookies: [],
+    headers: {},
+    pathVariables: {},
+    urlParams: new URLSearchParams()
+  };
+  if (o.length === 0)
+    return e;
+  for (const c of o) {
+    const r = g(c), n = z(r, l, void 0);
+    if (!n || m(r, n))
+      continue;
+    const i = typeof n.value == "string" ? y(n.value, s) : n.value, t = y(r.name, s);
+    switch (r.in) {
+      case "header": {
+        if (t.toLowerCase() === "content-type" && i === "multipart/form-data")
+          break;
+        const f = h(i, a(r, !1));
+        if (!k(f))
+          break;
+        const p = String(f);
+        e.headers[t] ? e.headers[t] = `${e.headers[t]},${p}` : e.headers[t] = p;
+        break;
+      }
+      case "path": {
+        const d = h(i, a(r, !1));
+        e.pathVariables[t] = encodeURIComponent(String(d));
+        break;
+      }
+      case "query": {
+        w(r, t, i, e.urlParams);
+        break;
       }
-      if (e.in === "path" && (t.pathVariables[o] = encodeURIComponent(r)), e.in === "query") {
-        const p = "explode" in e && e.explode !== void 0 ? e.explode : !0, h = "style" in e && e.style ? e.style : "form";
-        if (p)
-          t.urlParams.append(o, r);
-        else {
-          const m = t.urlParams.get(o);
-          if (m) {
-            const x = v(h);
-            t.urlParams.set(o, `${m}${x}${r}`);
-          } else
-            t.urlParams.set(o, r);
-        }
+      case "cookie": {
+        P(t, i, a(r, !0), e.cookies);
+        break;
       }
-      return e.in === "cookie" && t.cookies.push(
-        y(P, {
-          name: o,
-          value: r,
+    }
+  }
+  return e;
+}, w = (o, s, l, e) => {
+  const c = "explode" in o && o.explode !== void 0 ? o.explode : !0, r = "style" in o && o.style ? o.style : "form";
+  if ("content" in o && o.content) {
+    const i = Object.keys(o.content)[0] ?? "application/json", t = x(l, i);
+    e.set(s, t);
+    return;
+  }
+  if (r === "deepObject" && c) {
+    const i = v(s, l);
+    for (const t of i)
+      e.append(t.key, t.value);
+    return;
+  }
+  if (r === "spaceDelimited") {
+    const i = C(l), t = e.get(s);
+    e.set(s, t ? `${t} ${i}` : i);
+    return;
+  }
+  if (r === "pipeDelimited") {
+    const i = D(l), t = e.get(s);
+    e.set(s, t ? `${t}|${i}` : i);
+    return;
+  }
+  const n = $(l, c);
+  if (Array.isArray(n))
+    for (const i of n) {
+      const t = i.key || s;
+      e.append(t, String(i.value));
+    }
+  else
+    e.append(s, String(n));
+}, P = (o, s, l, e) => {
+  const c = b(s, l);
+  if (Array.isArray(c))
+    for (const r of c) {
+      const n = r.key || o;
+      e.push(
+        S(u, {
+          name: n,
+          value: String(r.value),
           path: "/"
         })
-      ), t;
-    },
-    {
-      cookies: [],
-      headers: {},
-      pathVariables: {},
-      urlParams: new URLSearchParams()
+      );
     }
-  );
+  else
+    e.push(
+      S(u, {
+        name: o,
+        value: String(c),
+        path: "/"
+      })
+    );
 };
 export {
   L as buildRequestParameters

package/dist/v2/blocks/operation-block/helpers/build-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-request.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/operation-block/helpers/build-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAGnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2EAA2E,CAAA;AACnH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qEAAqE,CAAA;AACxG,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AACtH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uDAAuD,CAAA;AAG5F,OAAO,EAAU,KAAK,aAAa,EAAkB,MAAM,eAAe,CAAA;AAU1E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,iHAU1B;IACD,8CAA8C;IAC9C,WAAW,EAAE,kBAAkB,CAAA;IAC/B,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,mCAAmC;IACnC,aAAa,EAAE,aAAa,EAAE,CAAA;IAC9B,uCAAuC;IACvC,MAAM,EAAE,UAAU,CAAA;IAClB,2BAA2B;IAC3B,SAAS,EAAE,eAAe,CAAA;IAC1B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAA;IAChB,wBAAwB;IACxB,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA;IAC3B,8DAA8D;IAC9D,uBAAuB,EAAE,oBAAoB,EAAE,CAAA;CAChD,KAAG,aAAa,CAAC;IAChB,UAAU,EAAE,eAAe,CAAA;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB,YAAY,EAAE,OAAO,CAAA;CACtB,CAoFA,CAAA"}
+{"version":3,"file":"build-request.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/operation-block/helpers/build-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAGnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2EAA2E,CAAA;AACnH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qEAAqE,CAAA;AACxG,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AACtH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uDAAuD,CAAA;AAG5F,OAAO,EAAU,KAAK,aAAa,EAAkB,MAAM,eAAe,CAAA;AAU1E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,iHAU1B;IACD,8CAA8C;IAC9C,WAAW,EAAE,kBAAkB,CAAA;IAC/B,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,mCAAmC;IACnC,aAAa,EAAE,aAAa,EAAE,CAAA;IAC9B,uCAAuC;IACvC,MAAM,EAAE,UAAU,CAAA;IAClB,2BAA2B;IAC3B,SAAS,EAAE,eAAe,CAAA;IAC1B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAA;IAChB,wBAAwB;IACxB,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA;IAC3B,8DAA8D;IAC9D,uBAAuB,EAAE,oBAAoB,EAAE,CAAA;CAChD,KAAG,aAAa,CAAC;IAChB,UAAU,EAAE,eAAe,CAAA;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB,YAAY,EAAE,OAAO,CAAA;CACtB,CA0FA,CAAA"}

package/dist/v2/blocks/operation-block/helpers/build-request.js

@@ -1,65 +1,67 @@
-import { shouldUseProxy as v, redirectToProxy as A } from "@scalar/oas-utils/helpers";
-import { getResolvedRef as S } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import { isElectron as p } from "../../../../libs/electron.js";
-import { ERRORS as g, normalizeError as w } from "../../../../libs/errors.js";
-import { getEnvironmentVariables as B } from "./get-environment-variables.js";
-import { getResolvedUrl as D } from "./get-resolved-url.js";
-import { getDefaultHeaders as L } from "../../request-block/helpers/get-default-headers.js";
+import { shouldUseProxy as v, redirectToProxy as w } from "@scalar/oas-utils/helpers";
+import { getResolvedRef as A } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { isElectron as U } from "../../../../libs/electron.js";
+import { ERRORS as h, normalizeError as D } from "../../../../libs/errors.js";
+import { getEnvironmentVariables as L } from "./get-environment-variables.js";
+import { getResolvedUrl as B } from "./get-resolved-url.js";
+import { getDefaultHeaders as T } from "../../request-block/helpers/get-default-headers.js";
 import { buildRequestBody as V } from "./build-request-body.js";
 import { buildRequestCookieHeader as I } from "./build-request-cookie-header.js";
-import { buildRequestParameters as T } from "./build-request-parameters.js";
-import { buildRequestSecurity as _ } from "./build-request-security.js";
+import { buildRequestParameters as _ } from "./build-request-parameters.js";
+import { buildRequestSecurity as x } from "./build-request-security.js";
 const W = ({
-  environment: d,
-  exampleKey: o = "default",
+  environment: m,
+  exampleKey: r = "default",
   globalCookies: k,
-  method: n,
-  operation: s,
-  path: U,
-  proxyUrl: m,
-  server: h,
+  method: c,
+  operation: o,
+  path: C,
+  proxyUrl: f,
+  server: P,
   selectedSecuritySchemes: q
 }) => {
   try {
-    const r = B(d), C = S(s.requestBody), t = T(s.parameters ?? [], r, o), H = V(C, r, o), l = _(q, r), e = { ...L({ method: n, operation: s, exampleKey: o, hideDisabledHeaders: !0 }).filter((i) => !i.isOverridden).reduce(
-      (i, R) => (i[R.name] = R.defaultValue, i),
+    const n = A(o.requestBody), t = L(m), s = _(o.parameters ?? [], t, r), d = x(q, t), H = T({ method: c, operation: o, exampleKey: r, hideDisabledHeaders: !0 }).filter((l) => !l.isOverridden).reduce(
+      (l, g) => (l[g.name] = g.defaultValue, l),
       {}
-    ), ...t.headers, ...l.headers }, P = new URLSearchParams([...t.urlParams, ...l.urlParams]), a = D({ environment: d, server: h, path: U, pathVariables: t.pathVariables, urlParams: P });
-    if (!a)
-      throw g.URL_EMPTY;
-    const c = v(m, a), E = A(m, a), f = e["User-Agent"] || e["user-agent"];
-    p() && f && (e["X-Scalar-User-Agent"] = f);
+    ), e = new Headers({ ...H, ...s.headers, ...d.headers }), E = new URLSearchParams([...s.urlParams, ...d.urlParams]), a = V(n, t, r);
+    a && (a instanceof FormData || a instanceof URLSearchParams) && e.delete("Content-Type");
+    const i = B({ environment: m, server: P, path: C, pathVariables: s.pathVariables, urlParams: E });
+    if (!i)
+      throw h.URL_EMPTY;
+    const R = v(f, i), y = w(f, i), b = e.get("User-Agent");
+    U() && b && e.set("X-Scalar-User-Agent", b);
     const u = I({
-      paramCookies: [...t.cookies, ...l.cookies],
+      paramCookies: [...s.cookies, ...d.cookies],
       globalCookies: k,
-      env: r,
-      originalCookieHeader: e.Cookie || e.cookie,
-      url: a,
-      useCustomCookieHeader: p() || c,
-      disabledGlobalCookies: s["x-scalar-disable-parameters"]?.["global-cookies"]?.[o] ?? {}
+      env: t,
+      originalCookieHeader: e.get("Cookie"),
+      url: i,
+      useCustomCookieHeader: U() || R,
+      disabledGlobalCookies: o["x-scalar-disable-parameters"]?.["global-cookies"]?.[r] ?? {}
     });
-    u && (e[u.name] = u.value);
-    const b = new AbortController(), y = new Request(E, {
+    u && e.set(u.name, u.value);
+    const p = new AbortController(), S = new Request(y, {
       /**
        * Ensure that all methods are uppercased (though only needed for patch)
        *
        * @see https://github.com/whatwg/fetch/issues/50
        */
-      method: n.toUpperCase(),
+      method: c.toUpperCase(),
       headers: e,
-      signal: b.signal,
-      body: H
+      signal: p.signal,
+      body: a
     });
     return [
       null,
       {
-        controller: b,
-        isUsingProxy: c,
-        request: y
+        controller: p,
+        isUsingProxy: R,
+        request: S
       }
     ];
-  } catch (r) {
-    return [w(r, g.BUILDING_REQUEST_FAILED), null];
+  } catch (n) {
+    return [D(n, h.BUILDING_REQUEST_FAILED), null];
   }
 };
 export {

package/dist/v2/blocks/operation-block/helpers/har-to-fetch-request.d.ts

@@ -0,0 +1,42 @@
+import type { HarRequest } from '@scalar/snippetz';
+type HarToFetchRequestProps = {
+    /** The HAR Request object to convert */
+    harRequest: HarRequest;
+};
+/**
+ * Converts a HAR (HTTP Archive) Request to a Fetch API Request object.
+ *
+ * This function is the reverse of fetchRequestToHar - it takes a HAR request
+ * and converts it into a standard JavaScript Fetch API Request object.
+ *
+ * The conversion handles:
+ * - Request method and URL reconstruction
+ * - Headers reconstruction from HAR headers array
+ * - Cookies conversion to Cookie header
+ * - Form data (params) conversion to FormData or URLSearchParams
+ * - Body decoding
+ * - Content-Type and other header restoration
+ * - Query parameters (already embedded in the URL)
+ *
+ * Use cases:
+ * - Replaying recorded HTTP requests
+ * - Creating mock requests from HAR files
+ * - Testing with fixtures
+ * - Request caching and restoration
+ * - Re-executing historical API calls
+ *
+ * Note: The Fetch API Request object does not support setting the HTTP version,
+ * so that information from the HAR is not preserved in the returned Request.
+ * Query parameters are expected to be already part of the URL in the HAR.
+ *
+ * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Request
+ *
+ * @example
+ * const harRequest = { method: 'POST', url: 'https://api.example.com', ... }
+ * const request = harToFetchRequest({ harRequest })
+ * const response = await fetch(request)
+ */
+export declare const harToFetchRequest: ({ harRequest }: HarToFetchRequestProps) => Request;
+export {};
+//# sourceMappingURL=har-to-fetch-request.d.ts.map

package/dist/v2/blocks/operation-block/helpers/har-to-fetch-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"har-to-fetch-request.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/operation-block/helpers/har-to-fetch-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,KAAK,sBAAsB,GAAG;IAC5B,wCAAwC;IACxC,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,iBAAiB,GAAI,gBAAgB,sBAAsB,KAAG,OAS1E,CAAA"}

package/dist/v2/blocks/operation-block/helpers/har-to-fetch-request.js

@@ -0,0 +1,31 @@
+const l = ({ harRequest: e }) => {
+  const n = s(e), o = d(e.postData);
+  return new Request(e.url, {
+    method: e.method,
+    headers: n,
+    body: o
+  });
+}, s = (e) => {
+  const n = new Headers();
+  if (e.headers.forEach(({ name: o, value: t }) => {
+    n.append(o, t);
+  }), e.cookies?.length) {
+    const o = e.cookies.map(({ name: t, value: r }) => `${t}=${r}`).join("; ");
+    n.append("Cookie", o);
+  }
+  return n;
+}, d = (e) => {
+  if (!e)
+    return null;
+  const { params: n, text: o, mimeType: t } = e;
+  if (n?.length) {
+    const c = t?.includes("multipart/form-data") ? new FormData() : new URLSearchParams();
+    return n.forEach(({ name: a, value: i }) => {
+      c.append(a, i || "");
+    }), c;
+  }
+  return o ? new TextEncoder().encode(o) : null;
+};
+export {
+  l as harToFetchRequest
+};

package/dist/v2/blocks/operation-block/helpers/har-to-fetch-response.d.ts

@@ -0,0 +1,66 @@
+import type { HttpMethod } from '@scalar/helpers/http/http-methods';
+import type { HarResponse } from '@scalar/snippetz';
+import type { ResponseInstance } from '../../../../v2/blocks/operation-block/helpers/send-request.js';
+type HarToFetchResponseProps = {
+    /** The HAR Response object to convert */
+    harResponse: HarResponse;
+    /** Optional URL to set on the Response object */
+    url?: string;
+    /** The HTTP method used for the request */
+    method: HttpMethod;
+    /** The request path */
+    path: string;
+    /** Time in ms the request took */
+    duration?: number;
+};
+/**
+ * Converts a HAR (HTTP Archive) Response back to a ResponseInstance object.
+ *
+ * This function is the reverse of fetchResponseToHar - it takes a HAR response
+ * and converts it back into a ResponseInstance object that includes both the
+ * standard Fetch API Response properties and additional metadata.
+ *
+ * The conversion handles:
+ * - Status code and status text restoration
+ * - Headers reconstruction from HAR headers array
+ * - Body decoding
+ * - Content-Type and other header restoration
+ * - URL property setting (if provided)
+ * - Cookie header detection
+ * - Duration tracking
+ * - Response size calculation in bytes
+ *
+ * Body Handling:
+ * - Plain text (no encoding): Text-based responses under 1MB from fetchResponseToHar
+ * - Base64 encoded: Binary or legacy data (note: new HAR files won't contain binary data)
+ * - Empty: Streaming responses, large responses (>1MB), or responses without bodies
+ *
+ * Use cases:
+ * - Replaying recorded HTTP responses
+ * - Creating mock responses from HAR files
+ * - Testing with fixtures
+ * - Response caching and restoration
+ *
+ * Note: The Fetch API Response object does not support setting the HTTP version,
+ * so that information from the HAR is not preserved in the returned Response.
+ * The URL property is set using Object.defineProperty since it is read-only
+ * in the standard Response constructor.
+ *
+ * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Response
+ *
+ * @example
+ * const harResponse = { status: 200, statusText: 'OK', ... }
+ * const response = harToFetchResponse({
+ *   harResponse,
+ *   url: 'https://api.example.com',
+ *   method: 'GET',
+ *   path: '/users',
+ *   duration: 250
+ * })
+ * console.log(response.url) // 'https://api.example.com'
+ * console.log(response.duration) // 250
+ */
+export declare const harToFetchResponse: ({ harResponse, url, method, path, duration, }: HarToFetchResponseProps) => ResponseInstance;
+export {};
+//# sourceMappingURL=har-to-fetch-response.d.ts.map

package/dist/v2/blocks/operation-block/helpers/har-to-fetch-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"har-to-fetch-response.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/operation-block/helpers/har-to-fetch-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAA;AAExF,KAAK,uBAAuB,GAAG;IAC7B,yCAAyC;IACzC,WAAW,EAAE,WAAW,CAAA;IACxB,iDAAiD;IACjD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,2CAA2C;IAC3C,MAAM,EAAE,UAAU,CAAA;IAClB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,kCAAkC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,kBAAkB,GAAI,+CAMhC,uBAAuB,KAAG,gBAwB5B,CAAA"}

package/dist/v2/blocks/operation-block/helpers/har-to-fetch-response.js

@@ -0,0 +1,43 @@
+import { getCookieHeaderKeys as i } from "./get-cookie-header-keys.js";
+const l = ({
+  harResponse: t,
+  url: e = "",
+  method: n,
+  path: s,
+  duration: r = 0
+}) => {
+  const o = b(t), { body: d, data: a, size: c } = x(t), u = i(o);
+  return {
+    ...new Response(d, {
+      status: t.status,
+      statusText: t.statusText,
+      headers: o
+    }),
+    headers: Object.fromEntries(o.entries()),
+    cookieHeaderKeys: u,
+    duration: r,
+    status: t.status,
+    statusText: t.statusText,
+    method: n,
+    path: s,
+    data: a,
+    size: c,
+    url: e
+  };
+}, b = (t) => {
+  const e = new Headers();
+  return t.headers.forEach(({ name: n, value: s }) => {
+    e.append(n, s);
+  }), e;
+}, x = (t) => {
+  if (!t.content.text)
+    return { body: null, data: "", size: 0 };
+  const { text: e, encoding: n } = t.content;
+  if (n)
+    return { body: null, data: e, size: e.length };
+  const s = new TextEncoder().encode(e).buffer;
+  return { body: s, data: e, size: s.byteLength };
+};
+export {
+  l as harToFetchResponse
+};

package/dist/v2/blocks/operation-block/helpers/send-request.d.ts

@@ -49,5 +49,6 @@ export declare const sendRequest: ({ isUsingProxy, operation, request, plugins,
     response: ResponseInstance;
     request: Request;
     timestamp: number;
+    originalResponse: Response;
 }>>;
 //# sourceMappingURL=send-request.d.ts.map

package/dist/v2/blocks/operation-block/helpers/send-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"send-request.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/operation-block/helpers/send-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAEnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AAEnG,OAAO,EAAU,KAAK,aAAa,EAAkB,MAAM,eAAe,CAAA;AAE1E,OAAO,EAAE,KAAK,YAAY,EAAe,MAAM,sBAAsB,CAAA;AAKrE,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG;IACzD,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,wCAAwC;IACxC,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,0BAA0B;IAC1B,MAAM,EAAE,UAAU,CAAA;IAClB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAA;CACb,GAAG,CACE;IACE,wBAAwB;IACxB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,qDAAqD;IACrD,MAAM,EAAE,2BAA2B,CAAC,UAAU,CAAC,CAAA;CAChD,CACJ,CAAA;AAKH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAU,gDAK/B;IACD,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,eAAe,CAAA;IAC1B,OAAO,EAAE,YAAY,EAAE,CAAA;IACvB,OAAO,EAAE,OAAO,CAAA;CACjB,KAAG,OAAO,CACT,aAAa,CAAC;IACZ,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAC,CA0DH,CAAA"}
+{"version":3,"file":"send-request.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/operation-block/helpers/send-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAEnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AAEnG,OAAO,EAAU,KAAK,aAAa,EAAkB,MAAM,eAAe,CAAA;AAE1E,OAAO,EAAE,KAAK,YAAY,EAAe,MAAM,sBAAsB,CAAA;AAKrE,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG;IACzD,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,wCAAwC;IACxC,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,0BAA0B;IAC1B,MAAM,EAAE,UAAU,CAAA;IAClB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAA;CACb,GAAG,CACE;IACE,wBAAwB;IACxB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,qDAAqD;IACrD,MAAM,EAAE,2BAA2B,CAAC,UAAU,CAAC,CAAA;CAChD,CACJ,CAAA;AAKH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAU,gDAK/B;IACD,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,eAAe,CAAA;IAC1B,OAAO,EAAE,YAAY,EAAE,CAAA;IACvB,OAAO,EAAE,OAAO,CAAA;CACjB,KAAG,OAAO,CACT,aAAa,CAAC;IACZ,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,gBAAgB,EAAE,QAAQ,CAAA;CAC3B,CAAC,CA0DH,CAAA"}

package/dist/v2/blocks/operation-block/helpers/send-request.js

@@ -6,47 +6,47 @@ import { decodeBuffer as D } from "./decode-buffer.js";
 import { getCookieHeaderKeys as T } from "./get-cookie-header-keys.js";
 const E = [204, 205, 304], v = async ({
   isUsingProxy: t,
-  operation: r,
-  request: i,
-  plugins: n
+  operation: n,
+  request: p,
+  plugins: r
 }) => {
   try {
-    const { request: s } = await f({ request: i }, "beforeRequest", n), m = Date.now(), e = await fetch(s), a = Date.now(), c = a - m, d = e.headers.get("content-type"), o = x(e.headers, t), u = new URL(e.url), h = u.pathname + u.search, p = e.statusText || S[e.status]?.name || "", l = s.method, y = E.includes(e.status);
+    const { request: s } = await f({ request: p }, "beforeRequest", r), l = Date.now(), e = await fetch(s.clone()), a = Date.now(), c = a - l, d = e.headers.get("content-type"), o = x(e.headers, t), u = new URL(e.url), m = u.pathname + u.search, i = e.statusText || S[e.status]?.name || "", h = s.method, R = E.includes(e.status);
     return d?.startsWith("text/event-stream") && e.body ? H({
       response: e,
       modifiedRequest: s,
-      operation: r,
-      plugins: n,
+      operation: n,
+      plugins: r,
       endTime: a,
       duration: c,
       responseHeaders: o,
-      statusText: p,
-      method: l,
-      fullPath: h
-    }) : k({
+      statusText: i,
+      method: h,
+      fullPath: m
+    }) : g({
       response: e,
       modifiedRequest: s,
-      operation: r,
-      plugins: n,
+      operation: n,
+      plugins: r,
       endTime: a,
       duration: c,
       responseHeaders: o,
-      statusText: p,
-      method: l,
-      fullPath: h,
+      statusText: i,
+      method: h,
+      fullPath: m,
       contentType: d,
-      shouldSkipBody: y
+      shouldSkipBody: R
     });
   } catch (s) {
     return [b(s, q.REQUEST_FAILED), null];
   }
 }, H = async ({
   response: t,
-  modifiedRequest: r,
-  operation: i,
-  plugins: n,
+  modifiedRequest: n,
+  operation: p,
+  plugins: r,
   endTime: s,
-  duration: m,
+  duration: l,
   responseHeaders: e,
   statusText: a,
   method: c,
@@ -57,31 +57,32 @@ const E = [204, 205, 304], v = async ({
     statusText: a,
     headers: t.headers
   });
-  await f({ response: o, request: r, operation: i }, "responseReceived", n);
+  await f({ response: o, request: n, operation: p }, "responseReceived", r);
   const u = T(o.headers);
   return [
     null,
     {
       timestamp: s,
-      request: r,
+      request: n,
       response: {
         ...o,
         headers: e,
         cookieHeaderKeys: u,
         reader: t.body.getReader(),
-        duration: m,
+        duration: l,
         method: c,
         path: d
-      }
+      },
+      originalResponse: o.clone()
     }
   ];
-}, k = async ({
+}, g = async ({
   response: t,
-  modifiedRequest: r,
-  operation: i,
-  plugins: n,
+  modifiedRequest: n,
+  operation: p,
+  plugins: r,
   endTime: s,
-  duration: m,
+  duration: l,
   responseHeaders: e,
   statusText: a,
   method: c,
@@ -89,29 +90,30 @@ const E = [204, 205, 304], v = async ({
   contentType: o,
   shouldSkipBody: u
 }) => {
-  const p = await t.clone().arrayBuffer(), y = D(p, o ?? "text/plain;charset=UTF-8"), R = new Response(u ? null : p, {
+  const i = await t.clone().arrayBuffer(), R = D(i, o ?? "text/plain;charset=UTF-8"), y = new Response(u ? null : i, {
     status: t.status,
     statusText: a,
     headers: t.headers
   });
-  await f({ response: R, request: r, operation: i }, "responseReceived", n);
-  const w = T(R.headers);
+  await f({ response: y, request: n, operation: p }, "responseReceived", r);
+  const w = T(y.headers);
   return [
     null,
     {
       timestamp: s,
-      request: r,
+      request: n,
       response: {
-        ...R,
+        ...y,
         headers: e,
         cookieHeaderKeys: w,
-        data: y,
-        size: p.byteLength,
-        duration: m,
+        data: R,
+        size: i.byteLength,
+        duration: l,
         method: c,
         status: t.status,
         path: d
-      }
+      },
+      originalResponse: t.clone()
     }
   ];
 };