@scalar/workspace-store 0.25.3 → 0.26.0

package/dist/mutators/fetch-request-to-har.d.ts

@@ -0,0 +1,62 @@
+import type { HarRequest } from '@scalar/snippetz';
+type FetchRequestToHarProps = {
+    /** The Fetch API Request object to convert */
+    request: Request;
+    /**
+     * Whether to include the request body in the HAR postData.
+     * Note: Reading the body consumes it, so the request will be cloned automatically.
+     * @default true
+     */
+    includeBody?: boolean;
+    /**
+     * HTTP version string to use (since Fetch API does not expose this)
+     * @default 'HTTP/1.1'
+     */
+    httpVersion?: string;
+    /**
+     * The maximum size of the request body to include in the HAR postData.
+     * @default 1MB
+     */
+    bodySizeLimit?: number;
+};
+/**
+ * Converts a Fetch API Request object to HAR (HTTP Archive) Request format.
+ *
+ * This function transforms a standard JavaScript Fetch API Request into the
+ * HAR format, which is useful for:
+ * - Recording HTTP requests for replay or analysis
+ * - Creating request fixtures from real API calls
+ * - Debugging and monitoring HTTP traffic
+ * - Storing request history in a standard format
+ * - Generating API documentation from real requests
+ *
+ * The conversion handles:
+ * - Request method and URL
+ * - Headers extraction (excluding sensitive headers if needed)
+ * - Query parameters extraction from URL
+ * - Cookie extraction from headers
+ * - Request body reading (with automatic cloning to preserve the original)
+ * - Content-Type detection and MIME type extraction
+ * - Size calculations for headers and body
+ * - Form data bodies are converted to params array
+ * - Other body types are read as text
+ *
+ * Note: The Fetch API does not expose the HTTP version, so it defaults to HTTP/1.1
+ * unless specified otherwise.
+ *
+ * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Request
+ *
+ * @example
+ * const request = new Request('https://api.example.com/users', {
+ *   method: 'POST',
+ *   headers: { 'Content-Type': 'application/json' },
+ *   body: JSON.stringify({ name: 'John' })
+ * })
+ * const harRequest = await fetchRequestToHar({ request })
+ * console.log(harRequest.method) // 'POST'
+ * console.log(harRequest.postData?.text) // '{"name":"John"}'
+ */
+export declare const fetchRequestToHar: ({ request, includeBody, httpVersion, bodySizeLimit, }: FetchRequestToHarProps) => Promise<HarRequest>;
+export {};
+//# sourceMappingURL=fetch-request-to-har.d.ts.map

package/dist/mutators/fetch-request-to-har.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-request-to-har.d.ts","sourceRoot":"","sources":["../../src/mutators/fetch-request-to-har.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,KAAK,sBAAsB,GAAG;IAC5B,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAA;IAChB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAAU,uDAMrC,sBAAsB,KAAG,OAAO,CAAC,UAAU,CA+C7C,CAAA"}

package/dist/mutators/fetch-request-to-har.js

@@ -0,0 +1,117 @@
+const fetchRequestToHar = async ({
+  request,
+  includeBody = true,
+  httpVersion = "HTTP/1.1",
+  // Default to 1MB
+  bodySizeLimit = 1048576
+}) => {
+  const url = new URL(request.url);
+  const queryString = Array.from(url.searchParams.entries()).map(([name, value]) => ({ name, value }));
+  const { headers, headersSize, cookies } = processRequestHeaders(request);
+  const mimeType = request.headers.get("content-type")?.split(";")[0]?.trim() ?? "text/plain";
+  const bodyDetails = await (async () => {
+    if (includeBody && request.body) {
+      const details = await processRequestBody(request.clone());
+      if (details.size <= bodySizeLimit) {
+        return details;
+      }
+    }
+    return { text: "", size: -1 };
+  })();
+  const harRequest = {
+    method: request.method,
+    url: request.url,
+    httpVersion,
+    headers,
+    cookies,
+    queryString,
+    headersSize,
+    bodySize: bodyDetails.size,
+    postData: "params" in bodyDetails ? {
+      mimeType,
+      params: bodyDetails.params
+    } : {
+      mimeType,
+      text: bodyDetails.text
+    }
+  };
+  return harRequest;
+};
+const processRequestBody = async (request) => {
+  const formData = await tryGetRequestFormData(request.clone());
+  if (formData) {
+    return Array.from(formData.entries()).reduce(
+      (acc, [name, value]) => {
+        if (value instanceof File) {
+          const fileName = `@${value.name}`;
+          acc.params.push({ name, value: fileName });
+          acc.size += fileName.length;
+          return acc;
+        }
+        acc.params.push({ name, value });
+        acc.size += value.length;
+        return acc;
+      },
+      { params: [], size: 0 }
+    );
+  }
+  if (request.headers.get("content-type")?.includes("application/octet-stream")) {
+    return { text: "", size: -1 };
+  }
+  const arrayBuffer = await request.arrayBuffer();
+  const size = arrayBuffer.byteLength;
+  return { size, text: new TextDecoder().decode(arrayBuffer) };
+};
+async function tryGetRequestFormData(request) {
+  if (typeof request.formData !== "function") {
+    return null;
+  }
+  if (request.bodyUsed) {
+    return null;
+  }
+  const contentType = request.headers.get("content-type") ?? "";
+  if (!contentType.includes("multipart/form-data") && !contentType.includes("application/x-www-form-urlencoded")) {
+    return null;
+  }
+  try {
+    return await request.formData();
+  } catch {
+    return null;
+  }
+}
+const processRequestHeaders = (request) => {
+  return Array.from(request.headers.entries()).reduce(
+    (acc, [name, value]) => {
+      if (name.toLowerCase() === "cookie") {
+        const parsedCookies = parseCookieHeader(value);
+        acc.cookies.push(...parsedCookies.cookies);
+      } else {
+        acc.headers.push({ name, value });
+        acc.headersSize += name.length + 2 + value.length + 2;
+      }
+      return acc;
+    },
+    { headers: [], headersSize: 0, cookies: [] }
+  );
+};
+const parseCookieHeader = (cookieValue) => {
+  return cookieValue.split(";").reduce(
+    (acc, part) => {
+      const trimmedPart = part.trim();
+      const equalIndex = trimmedPart.indexOf("=");
+      if (equalIndex === -1) {
+        return acc;
+      }
+      const name = trimmedPart.substring(0, equalIndex).trim();
+      const value = trimmedPart.substring(equalIndex + 1).trim();
+      acc.cookies.push({ name, value });
+      acc.size += name.length + 2 + value.length + 2;
+      return acc;
+    },
+    { cookies: [], size: 0 }
+  );
+};
+export {
+  fetchRequestToHar
+};
+//# sourceMappingURL=fetch-request-to-har.js.map

package/dist/mutators/fetch-request-to-har.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mutators/fetch-request-to-har.ts"],
+  "sourcesContent": ["import type { HarRequest } from '@scalar/snippetz'\n\ntype FetchRequestToHarProps = {\n  /** The Fetch API Request object to convert */\n  request: Request\n  /**\n   * Whether to include the request body in the HAR postData.\n   * Note: Reading the body consumes it, so the request will be cloned automatically.\n   * @default true\n   */\n  includeBody?: boolean\n  /**\n   * HTTP version string to use (since Fetch API does not expose this)\n   * @default 'HTTP/1.1'\n   */\n  httpVersion?: string\n  /**\n   * The maximum size of the request body to include in the HAR postData.\n   * @default 1MB\n   */\n  bodySizeLimit?: number\n}\n\n/**\n * Converts a Fetch API Request object to HAR (HTTP Archive) Request format.\n *\n * This function transforms a standard JavaScript Fetch API Request into the\n * HAR format, which is useful for:\n * - Recording HTTP requests for replay or analysis\n * - Creating request fixtures from real API calls\n * - Debugging and monitoring HTTP traffic\n * - Storing request history in a standard format\n * - Generating API documentation from real requests\n *\n * The conversion handles:\n * - Request method and URL\n * - Headers extraction (excluding sensitive headers if needed)\n * - Query parameters extraction from URL\n * - Cookie extraction from headers\n * - Request body reading (with automatic cloning to preserve the original)\n * - Content-Type detection and MIME type extraction\n * - Size calculations for headers and body\n * - Form data bodies are converted to params array\n * - Other body types are read as text\n *\n * Note: The Fetch API does not expose the HTTP version, so it defaults to HTTP/1.1\n * unless specified otherwise.\n *\n * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Request\n *\n * @example\n * const request = new Request('https://api.example.com/users', {\n *   method: 'POST',\n *   headers: { 'Content-Type': 'application/json' },\n *   body: JSON.stringify({ name: 'John' })\n * })\n * const harRequest = await fetchRequestToHar({ request })\n * console.log(harRequest.method) // 'POST'\n * console.log(harRequest.postData?.text) // '{\"name\":\"John\"}'\n */\nexport const fetchRequestToHar = async ({\n  request,\n  includeBody = true,\n  httpVersion = 'HTTP/1.1',\n  // Default to 1MB\n  bodySizeLimit = 1048576,\n}: FetchRequestToHarProps): Promise<HarRequest> => {\n  // Extract query string from URL\n  const url = new URL(request.url)\n\n  // Extract the query strings from the URL\n  const queryString = Array.from(url.searchParams.entries()).map(([name, value]) => ({ name, value }))\n\n  // Extract the headers from the request\n  const { headers, headersSize, cookies } = processRequestHeaders(request)\n\n  // Extract the MIME type from the request headers\n  const mimeType = request.headers.get('content-type')?.split(';')[0]?.trim() ?? 'text/plain'\n\n  // Read the request body if requested\n  const bodyDetails = await (async () => {\n    if (includeBody && request.body) {\n      const details = await processRequestBody(request.clone())\n      if (details.size <= bodySizeLimit) {\n        return details\n      }\n    }\n    return { text: '', size: -1 }\n  })()\n\n  // Create the HAR request object\n  const harRequest: HarRequest = {\n    method: request.method,\n    url: request.url,\n    httpVersion,\n    headers,\n    cookies,\n    queryString,\n    headersSize,\n    bodySize: bodyDetails.size,\n    postData:\n      'params' in bodyDetails\n        ? {\n            mimeType,\n            params: bodyDetails.params,\n          }\n        : {\n            mimeType,\n            text: bodyDetails.text,\n          },\n  }\n\n  return harRequest\n}\n\nconst processRequestBody = async (request: Request) => {\n  const formData = await tryGetRequestFormData(request.clone())\n  if (formData) {\n    return Array.from(formData.entries()).reduce<{ params: { name: string; value: string }[]; size: number }>(\n      (acc, [name, value]) => {\n        if (value instanceof File) {\n          const fileName = `@${value.name}`\n          acc.params.push({ name, value: fileName })\n          acc.size += fileName.length\n          return acc\n        }\n\n        acc.params.push({ name, value })\n        acc.size += value.length\n        return acc\n      },\n      { params: [], size: 0 },\n    )\n  }\n  // Skip binary bodies\n  if (request.headers.get('content-type')?.includes('application/octet-stream')) {\n    return { text: '', size: -1 }\n  }\n\n  // Read the request body as text\n  const arrayBuffer = await request.arrayBuffer()\n  const size = arrayBuffer.byteLength\n  return { size, text: new TextDecoder().decode(arrayBuffer) }\n}\n\nasync function tryGetRequestFormData(request: Request): Promise<FormData | null> {\n  if (typeof request.formData !== 'function') {\n    return null\n  }\n\n  if (request.bodyUsed) {\n    return null\n  }\n\n  const contentType = request.headers.get('content-type') ?? ''\n  if (!contentType.includes('multipart/form-data') && !contentType.includes('application/x-www-form-urlencoded')) {\n    return null\n  }\n\n  try {\n    return await request.formData()\n  } catch {\n    return null\n  }\n}\n\nconst processRequestHeaders = (request: Request) => {\n  return Array.from(request.headers.entries()).reduce<{\n    headers: { name: string; value: string }[]\n    headersSize: number\n    cookies: { name: string; value: string }[]\n  }>(\n    (acc, [name, value]) => {\n      if (name.toLowerCase() === 'cookie') {\n        const parsedCookies = parseCookieHeader(value)\n        acc.cookies.push(...parsedCookies.cookies)\n      } else {\n        acc.headers.push({ name, value })\n        acc.headersSize += name.length + 2 + value.length + 2\n      }\n      return acc\n    },\n    { headers: [], headersSize: 0, cookies: [] },\n  )\n}\n\n/**\n * Parses a Cookie header value into an array of cookie objects.\n * Cookie format: name1=value1; name2=value2\n */\nconst parseCookieHeader = (cookieValue: string) => {\n  return cookieValue.split(';').reduce<{ cookies: { name: string; value: string }[]; size: number }>(\n    (acc, part) => {\n      const trimmedPart = part.trim()\n      const equalIndex = trimmedPart.indexOf('=')\n\n      if (equalIndex === -1) {\n        return acc\n      }\n\n      const name = trimmedPart.substring(0, equalIndex).trim()\n      const value = trimmedPart.substring(equalIndex + 1).trim()\n\n      acc.cookies.push({ name, value })\n      acc.size += name.length + 2 + value.length + 2\n      return acc\n    },\n    { cookies: [], size: 0 },\n  )\n}\n"],
+  "mappings": "AA6DO,MAAM,oBAAoB,OAAO;AAAA,EACtC;AAAA,EACA,cAAc;AAAA,EACd,cAAc;AAAA;AAAA,EAEd,gBAAgB;AAClB,MAAmD;AAEjD,QAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;AAG/B,QAAM,cAAc,MAAM,KAAK,IAAI,aAAa,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC,MAAM,KAAK,OAAO,EAAE,MAAM,MAAM,EAAE;AAGnG,QAAM,EAAE,SAAS,aAAa,QAAQ,IAAI,sBAAsB,OAAO;AAGvE,QAAM,WAAW,QAAQ,QAAQ,IAAI,cAAc,GAAG,MAAM,GAAG,EAAE,CAAC,GAAG,KAAK,KAAK;AAG/E,QAAM,cAAc,OAAO,YAAY;AACrC,QAAI,eAAe,QAAQ,MAAM;AAC/B,YAAM,UAAU,MAAM,mBAAmB,QAAQ,MAAM,CAAC;AACxD,UAAI,QAAQ,QAAQ,eAAe;AACjC,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO,EAAE,MAAM,IAAI,MAAM,GAAG;AAAA,EAC9B,GAAG;AAGH,QAAM,aAAyB;AAAA,IAC7B,QAAQ,QAAQ;AAAA,IAChB,KAAK,QAAQ;AAAA,IACb;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU,YAAY;AAAA,IACtB,UACE,YAAY,cACR;AAAA,MACE;AAAA,MACA,QAAQ,YAAY;AAAA,IACtB,IACA;AAAA,MACE;AAAA,MACA,MAAM,YAAY;AAAA,IACpB;AAAA,EACR;AAEA,SAAO;AACT;AAEA,MAAM,qBAAqB,OAAO,YAAqB;AACrD,QAAM,WAAW,MAAM,sBAAsB,QAAQ,MAAM,CAAC;AAC5D,MAAI,UAAU;AACZ,WAAO,MAAM,KAAK,SAAS,QAAQ,CAAC,EAAE;AAAA,MACpC,CAAC,KAAK,CAAC,MAAM,KAAK,MAAM;AACtB,YAAI,iBAAiB,MAAM;AACzB,gBAAM,WAAW,IAAI,MAAM,IAAI;AAC/B,cAAI,OAAO,KAAK,EAAE,MAAM,OAAO,SAAS,CAAC;AACzC,cAAI,QAAQ,SAAS;AACrB,iBAAO;AAAA,QACT;AAEA,YAAI,OAAO,KAAK,EAAE,MAAM,MAAM,CAAC;AAC/B,YAAI,QAAQ,MAAM;AAClB,eAAO;AAAA,MACT;AAAA,MACA,EAAE,QAAQ,CAAC,GAAG,MAAM,EAAE;AAAA,IACxB;AAAA,EACF;AAEA,MAAI,QAAQ,QAAQ,IAAI,cAAc,GAAG,SAAS,0BAA0B,GAAG;AAC7E,WAAO,EAAE,MAAM,IAAI,MAAM,GAAG;AAAA,EAC9B;AAGA,QAAM,cAAc,MAAM,QAAQ,YAAY;AAC9C,QAAM,OAAO,YAAY;AACzB,SAAO,EAAE,MAAM,MAAM,IAAI,YAAY,EAAE,OAAO,WAAW,EAAE;AAC7D;AAEA,eAAe,sBAAsB,SAA4C;AAC/E,MAAI,OAAO,QAAQ,aAAa,YAAY;AAC1C,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,UAAU;AACpB,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,QAAQ,QAAQ,IAAI,cAAc,KAAK;AAC3D,MAAI,CAAC,YAAY,SAAS,qBAAqB,KAAK,CAAC,YAAY,SAAS,mCAAmC,GAAG;AAC9G,WAAO;AAAA,EACT;AAEA,MAAI;AACF,WAAO,MAAM,QAAQ,SAAS;AAAA,EAChC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,MAAM,wBAAwB,CAAC,YAAqB;AAClD,SAAO,MAAM,KAAK,QAAQ,QAAQ,QAAQ,CAAC,EAAE;AAAA,IAK3C,CAAC,KAAK,CAAC,MAAM,KAAK,MAAM;AACtB,UAAI,KAAK,YAAY,MAAM,UAAU;AACnC,cAAM,gBAAgB,kBAAkB,KAAK;AAC7C,YAAI,QAAQ,KAAK,GAAG,cAAc,OAAO;AAAA,MAC3C,OAAO;AACL,YAAI,QAAQ,KAAK,EAAE,MAAM,MAAM,CAAC;AAChC,YAAI,eAAe,KAAK,SAAS,IAAI,MAAM,SAAS;AAAA,MACtD;AACA,aAAO;AAAA,IACT;AAAA,IACA,EAAE,SAAS,CAAC,GAAG,aAAa,GAAG,SAAS,CAAC,EAAE;AAAA,EAC7C;AACF;AAMA,MAAM,oBAAoB,CAAC,gBAAwB;AACjD,SAAO,YAAY,MAAM,GAAG,EAAE;AAAA,IAC5B,CAAC,KAAK,SAAS;AACb,YAAM,cAAc,KAAK,KAAK;AAC9B,YAAM,aAAa,YAAY,QAAQ,GAAG;AAE1C,UAAI,eAAe,IAAI;AACrB,eAAO;AAAA,MACT;AAEA,YAAM,OAAO,YAAY,UAAU,GAAG,UAAU,EAAE,KAAK;AACvD,YAAM,QAAQ,YAAY,UAAU,aAAa,CAAC,EAAE,KAAK;AAEzD,UAAI,QAAQ,KAAK,EAAE,MAAM,MAAM,CAAC;AAChC,UAAI,QAAQ,KAAK,SAAS,IAAI,MAAM,SAAS;AAC7C,aAAO;AAAA,IACT;AAAA,IACA,EAAE,SAAS,CAAC,GAAG,MAAM,EAAE;AAAA,EACzB;AACF;",
+  "names": []
+}

package/dist/mutators/fetch-response-to-har.d.ts

@@ -0,0 +1,67 @@
+import type { HarResponse } from '@scalar/snippetz';
+type FetchResponseToHarProps = {
+    /** The Fetch API Response object to convert */
+    response: Response;
+    /**
+     * Whether to include the response body in the HAR content.
+     * Note: Reading the body consumes it, so the response will be cloned automatically.
+     * Bodies will only be included if they meet the following criteria:
+     * - Not a streaming response (text/event-stream)
+     * - Text-based content (not binary)
+     * - Under 1MB in size
+     * @default true
+     */
+    includeBody?: boolean;
+    /**
+     * HTTP version string to use (since Fetch API does not expose this)
+     * @default 'HTTP/1.1'
+     */
+    httpVersion?: string;
+    /**
+     * The maximum size of the response body to include in the HAR content.
+     * @default 1MB
+     */
+    bodySizeLimit?: number;
+};
+/**
+ * Converts a Fetch API Response object to HAR (HTTP Archive) Response format.
+ *
+ * This function transforms a standard JavaScript Fetch API Response into the
+ * HAR format, which is useful for:
+ * - Recording HTTP responses for replay or analysis
+ * - Creating test fixtures from real API responses
+ * - Debugging and monitoring HTTP traffic
+ * - Generating API documentation from real responses
+ *
+ * The conversion handles:
+ * - Response status and status text
+ * - Headers extraction (including Set-Cookie headers converted to cookies)
+ * - Response body reading (with automatic cloning to preserve the original)
+ * - Content-Type detection and MIME type extraction
+ * - Size calculations for headers and body
+ * - Redirect URL extraction from Location header
+ *
+ * Note: The Fetch API does not expose the HTTP version, so it defaults to HTTP/1.1
+ * unless specified otherwise.
+ *
+ * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Response
+ *
+ * @example
+ * const response = await fetch('https://api.example.com/users')
+ * const harResponse = await fetchResponseToHar({ response })
+ * console.log(harResponse.status) // 200
+ */
+export declare const fetchResponseToHar: ({ response, includeBody, httpVersion, bodySizeLimit, }: FetchResponseToHarProps) => Promise<HarResponse>;
+/**
+ * Checks if the content type is text-based and should be included in HAR.
+ * Text-based content types include:
+ * - text/* (text/plain, text/html, text/css, etc.)
+ * - application/json
+ * - application/xml and text/xml
+ * - application/javascript
+ * - application/*+json and application/*+xml variants
+ */
+export declare const isTextBasedContent: (contentType: string) => boolean;
+export {};
+//# sourceMappingURL=fetch-response-to-har.d.ts.map

package/dist/mutators/fetch-response-to-har.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-response-to-har.d.ts","sourceRoot":"","sources":["../../src/mutators/fetch-response-to-har.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,KAAK,uBAAuB,GAAG;IAC7B,+CAA+C;IAC/C,QAAQ,EAAE,QAAQ,CAAA;IAClB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB,GAAU,wDAKtC,uBAAuB,KAAG,OAAO,CAAC,WAAW,CAwC/C,CAAA;AA4CD;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,aAAa,MAAM,KAAG,OAoCxD,CAAA"}

package/dist/mutators/fetch-response-to-har.js

@@ -0,0 +1,104 @@
+const fetchResponseToHar = async ({
+  response,
+  includeBody = true,
+  httpVersion = "HTTP/1.1",
+  bodySizeLimit = 1048576
+}) => {
+  const { headers, headersSize, cookies } = processResponseHeaders(response);
+  const redirectURL = response.headers.get("location") || "";
+  const contentType = response.headers.get("content-type") ?? "text/plain";
+  const bodyDetails = await (async () => {
+    if (includeBody && response.body) {
+      const details = await processResponseBody(response.clone());
+      if (details.size <= bodySizeLimit) {
+        return details;
+      }
+    }
+    return { text: "", size: -1, encoding: void 0 };
+  })();
+  const harResponse = {
+    status: response.status,
+    statusText: response.statusText,
+    httpVersion,
+    headers,
+    cookies,
+    content: {
+      size: bodyDetails.size,
+      mimeType: contentType,
+      text: bodyDetails.text,
+      encoding: bodyDetails.encoding
+    },
+    redirectURL,
+    headersSize,
+    bodySize: bodyDetails.size
+  };
+  return harResponse;
+};
+const processResponseHeaders = (response) => {
+  return Array.from(response.headers.entries()).reduce(
+    (acc, [name, value]) => {
+      acc.headers.push({ name, value });
+      acc.headersSize += name.length + 2 + value.length + 2;
+      if (name.toLowerCase() === "set-cookie") {
+        const cookie = parseSetCookieHeader(value);
+        if (cookie) {
+          acc.cookies.push(cookie);
+        }
+      }
+      return acc;
+    },
+    { headers: [], headersSize: 0, cookies: [] }
+  );
+};
+const processResponseBody = async (response) => {
+  const contentType = response.headers.get("content-type");
+  if (!contentType || !isTextBasedContent(contentType)) {
+    return { text: "", size: -1, encoding: void 0 };
+  }
+  try {
+    const arrayBuffer = await response.arrayBuffer();
+    const bodySize = arrayBuffer.byteLength;
+    const text = new TextDecoder("utf-8").decode(arrayBuffer);
+    return { text, size: bodySize, encoding: void 0 };
+  } catch {
+    return { text: "", size: -1, encoding: void 0 };
+  }
+};
+const isTextBasedContent = (contentType) => {
+  const lowerContentType = contentType.toLowerCase();
+  if (lowerContentType.startsWith("text/")) {
+    return true;
+  }
+  if (lowerContentType.includes("application/json") || lowerContentType.includes("+json")) {
+    return true;
+  }
+  if (lowerContentType.includes("application/xml") || lowerContentType.includes("text/xml") || lowerContentType.includes("+xml")) {
+    return true;
+  }
+  if (lowerContentType.includes("application/javascript") || lowerContentType.includes("application/x-javascript")) {
+    return true;
+  }
+  if (lowerContentType.includes("application/x-www-form-urlencoded") || lowerContentType.includes("application/graphql")) {
+    return true;
+  }
+  return false;
+};
+const parseSetCookieHeader = (setCookieValue) => {
+  const parts = setCookieValue.split(";");
+  if (parts.length === 0 || !parts[0]) {
+    return null;
+  }
+  const cookiePart = parts[0].trim();
+  const equalIndex = cookiePart.indexOf("=");
+  if (equalIndex === -1) {
+    return null;
+  }
+  const name = cookiePart.substring(0, equalIndex).trim();
+  const value = cookiePart.substring(equalIndex + 1).trim();
+  return { name, value };
+};
+export {
+  fetchResponseToHar,
+  isTextBasedContent
+};
+//# sourceMappingURL=fetch-response-to-har.js.map

package/dist/mutators/fetch-response-to-har.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mutators/fetch-response-to-har.ts"],
+  "sourcesContent": ["import type { HarResponse } from '@scalar/snippetz'\n\ntype FetchResponseToHarProps = {\n  /** The Fetch API Response object to convert */\n  response: Response\n  /**\n   * Whether to include the response body in the HAR content.\n   * Note: Reading the body consumes it, so the response will be cloned automatically.\n   * Bodies will only be included if they meet the following criteria:\n   * - Not a streaming response (text/event-stream)\n   * - Text-based content (not binary)\n   * - Under 1MB in size\n   * @default true\n   */\n  includeBody?: boolean\n  /**\n   * HTTP version string to use (since Fetch API does not expose this)\n   * @default 'HTTP/1.1'\n   */\n  httpVersion?: string\n  /**\n   * The maximum size of the response body to include in the HAR content.\n   * @default 1MB\n   */\n  bodySizeLimit?: number\n}\n\n/**\n * Converts a Fetch API Response object to HAR (HTTP Archive) Response format.\n *\n * This function transforms a standard JavaScript Fetch API Response into the\n * HAR format, which is useful for:\n * - Recording HTTP responses for replay or analysis\n * - Creating test fixtures from real API responses\n * - Debugging and monitoring HTTP traffic\n * - Generating API documentation from real responses\n *\n * The conversion handles:\n * - Response status and status text\n * - Headers extraction (including Set-Cookie headers converted to cookies)\n * - Response body reading (with automatic cloning to preserve the original)\n * - Content-Type detection and MIME type extraction\n * - Size calculations for headers and body\n * - Redirect URL extraction from Location header\n *\n * Note: The Fetch API does not expose the HTTP version, so it defaults to HTTP/1.1\n * unless specified otherwise.\n *\n * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Response\n *\n * @example\n * const response = await fetch('https://api.example.com/users')\n * const harResponse = await fetchResponseToHar({ response })\n * console.log(harResponse.status) // 200\n */\nexport const fetchResponseToHar = async ({\n  response,\n  includeBody = true,\n  httpVersion = 'HTTP/1.1',\n  bodySizeLimit = 1048576,\n}: FetchResponseToHarProps): Promise<HarResponse> => {\n  // Extract the headers from the response\n  const { headers, headersSize, cookies } = processResponseHeaders(response)\n\n  // Extract redirect URL from Location header\n  const redirectURL = response.headers.get('location') || ''\n\n  // Get content type\n  const contentType = response.headers.get('content-type') ?? 'text/plain'\n\n  // Read the response body if requested\n  const bodyDetails = await (async () => {\n    if (includeBody && response.body) {\n      const details = await processResponseBody(response.clone())\n      if (details.size <= bodySizeLimit) {\n        return details\n      }\n    }\n    return { text: '', size: -1, encoding: undefined }\n  })()\n\n  // Create the HAR response object\n  const harResponse: HarResponse = {\n    status: response.status,\n    statusText: response.statusText,\n    httpVersion,\n    headers,\n    cookies,\n    content: {\n      size: bodyDetails.size,\n      mimeType: contentType,\n      text: bodyDetails.text,\n      encoding: bodyDetails.encoding,\n    },\n    redirectURL,\n    headersSize,\n    bodySize: bodyDetails.size,\n  }\n\n  return harResponse\n}\n\nconst processResponseHeaders = (response: Response) => {\n  return Array.from(response.headers.entries()).reduce<{\n    headers: { name: string; value: string }[]\n    headersSize: number\n    cookies: { name: string; value: string }[]\n  }>(\n    (acc, [name, value]) => {\n      acc.headers.push({ name, value })\n      acc.headersSize += name.length + 2 + value.length + 2\n\n      // Parse Set-Cookie headers into cookies array\n      if (name.toLowerCase() === 'set-cookie') {\n        const cookie = parseSetCookieHeader(value)\n        if (cookie) {\n          acc.cookies.push(cookie)\n        }\n      }\n\n      return acc\n    },\n    { headers: [], headersSize: 0, cookies: [] },\n  )\n}\n\nconst processResponseBody = async (response: Response) => {\n  const contentType = response.headers.get('content-type')\n  if (!contentType || !isTextBasedContent(contentType)) {\n    return { text: '', size: -1, encoding: undefined }\n  }\n\n  try {\n    // Read as ArrayBuffer to get the size\n    const arrayBuffer = await response.arrayBuffer()\n    const bodySize = arrayBuffer.byteLength\n    const text = new TextDecoder('utf-8').decode(arrayBuffer)\n    return { text, size: bodySize, encoding: undefined }\n  } catch {\n    // If body cannot be read, leave it empty\n    return { text: '', size: -1, encoding: undefined }\n  }\n}\n\n/**\n * Checks if the content type is text-based and should be included in HAR.\n * Text-based content types include:\n * - text/* (text/plain, text/html, text/css, etc.)\n * - application/json\n * - application/xml and text/xml\n * - application/javascript\n * - application/*+json and application/*+xml variants\n */\nexport const isTextBasedContent = (contentType: string): boolean => {\n  const lowerContentType = contentType.toLowerCase()\n\n  // Check for text/* types\n  if (lowerContentType.startsWith('text/')) {\n    return true\n  }\n\n  // Check for JSON types\n  if (lowerContentType.includes('application/json') || lowerContentType.includes('+json')) {\n    return true\n  }\n\n  // Check for XML types\n  if (\n    lowerContentType.includes('application/xml') ||\n    lowerContentType.includes('text/xml') ||\n    lowerContentType.includes('+xml')\n  ) {\n    return true\n  }\n\n  // Check for JavaScript\n  if (lowerContentType.includes('application/javascript') || lowerContentType.includes('application/x-javascript')) {\n    return true\n  }\n\n  // Check for common text-based formats\n  if (\n    lowerContentType.includes('application/x-www-form-urlencoded') ||\n    lowerContentType.includes('application/graphql')\n  ) {\n    return true\n  }\n\n  return false\n}\n\n/**\n * Parses a Set-Cookie header value into a cookie object.\n * This is a simplified parser that extracts the name and value.\n * For full cookie parsing with attributes, a more robust parser would be needed.\n */\nconst parseSetCookieHeader = (setCookieValue: string): { name: string; value: string } | null => {\n  // Set-Cookie format: name=value; attribute1=value1; attribute2=value2\n  const parts = setCookieValue.split(';')\n  if (parts.length === 0 || !parts[0]) {\n    return null\n  }\n\n  const cookiePart = parts[0].trim()\n  const equalIndex = cookiePart.indexOf('=')\n\n  if (equalIndex === -1) {\n    return null\n  }\n\n  const name = cookiePart.substring(0, equalIndex).trim()\n  const value = cookiePart.substring(equalIndex + 1).trim()\n\n  return { name, value }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mutators/har-to-operation.d.ts

@@ -0,0 +1,37 @@
+import type { HarRequest } from '@scalar/snippetz';
+import type { OperationObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+type HarToOperationProps = {
+    /** HAR request to convert */
+    harRequest: HarRequest;
+    /** Name of the example to populate (e.g., 'default', 'example1') */
+    exampleKey: string;
+    /** Optional base operation to merge with */
+    baseOperation?: OperationObject;
+    /** Optional path variables to merge with */
+    pathVariables?: Record<string, string>;
+};
+/**
+ * Converts a HAR request back to an OpenAPI Operation object with populated examples.
+ *
+ * This function is the reverse of operationToHar - it takes a HAR request and
+ * converts it back into an OpenAPI operation structure, populating the example
+ * values based on the HAR request data.
+ *
+ * The conversion handles:
+ * - URL parsing to extract path and query parameters
+ * - Header extraction and mapping to operation parameters
+ * - Query string parsing and mapping to parameters
+ * - Cookie extraction and mapping to cookie parameters
+ * - Request body extraction and mapping to requestBody with examples
+ * - Content-Type detection and media type assignment
+ *
+ * Note: This function focuses on populating examples and does not reconstruct
+ * schema definitions. If you need full schema generation, consider combining
+ * this with a schema inference tool.
+ *
+ * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html
+ * @see https://spec.openapis.org/oas/v3.1.0#operation-object
+ */
+export declare const harToOperation: ({ harRequest, exampleKey, baseOperation, pathVariables, }: HarToOperationProps) => OperationObject;
+export {};
+//# sourceMappingURL=har-to-operation.d.ts.map

package/dist/mutators/har-to-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"har-to-operation.d.ts","sourceRoot":"","sources":["../../src/mutators/har-to-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,8DAA8D,CAAA;AAKpH,KAAK,mBAAmB,GAAG;IACzB,6BAA6B;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,eAAe,CAAA;IAC/B,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvC,CAAA;AAyBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GAAI,2DAK5B,mBAAmB,KAAG,eAyHxB,CAAA"}

package/dist/mutators/har-to-operation.js

@@ -0,0 +1,146 @@
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { isContentTypeParameterObject } from "../schemas/v3.1/strict/type-guards.js";
+const preprocessParameters = (parameters, pathVariables, exampleKey) => {
+  parameters.forEach((param) => {
+    const resolvedParam = getResolvedRef(param);
+    if (isContentTypeParameterObject(resolvedParam)) {
+      return;
+    }
+    setParameterDisabled(getResolvedRef(param), exampleKey, true);
+    if (resolvedParam.in === "path") {
+      resolvedParam.examples ||= {};
+      resolvedParam.examples[exampleKey] = {
+        value: pathVariables[resolvedParam.name] ?? "",
+        "x-disabled": false
+      };
+    }
+  });
+};
+const harToOperation = ({
+  harRequest,
+  exampleKey,
+  baseOperation = {},
+  pathVariables = {}
+}) => {
+  if (!baseOperation.parameters) {
+    baseOperation.parameters = [];
+  }
+  preprocessParameters(baseOperation.parameters, pathVariables, exampleKey);
+  if (harRequest.queryString && harRequest.queryString.length > 0) {
+    for (const queryParam of harRequest.queryString) {
+      const param = findOrCreateParameter(baseOperation.parameters, queryParam.name, "query");
+      if (!param || isContentTypeParameterObject(param)) {
+        continue;
+      }
+      param.examples ||= {};
+      param.examples[exampleKey] = {
+        value: queryParam.value,
+        "x-disabled": false
+      };
+    }
+  }
+  if (harRequest.headers && harRequest.headers.length > 0) {
+    for (const header of harRequest.headers) {
+      const param = findOrCreateParameter(baseOperation.parameters, header.name, "header");
+      if (!param || isContentTypeParameterObject(param)) {
+        continue;
+      }
+      param.examples ||= {};
+      param.examples[exampleKey] = {
+        value: header.value,
+        "x-disabled": false
+      };
+    }
+  }
+  if (harRequest.cookies && harRequest.cookies.length > 0) {
+    for (const cookie of harRequest.cookies) {
+      const param = findOrCreateParameter(baseOperation.parameters, cookie.name, "cookie");
+      if (!param || isContentTypeParameterObject(param)) {
+        continue;
+      }
+      param.examples ||= {};
+      param.examples[exampleKey] = {
+        value: cookie.value,
+        "x-disabled": false
+      };
+    }
+  }
+  if (harRequest.postData) {
+    const { mimeType, text, params } = harRequest.postData;
+    if (!baseOperation.requestBody) {
+      baseOperation.requestBody = {
+        content: {}
+      };
+    }
+    const requestBody = getResolvedRef(baseOperation.requestBody);
+    if (!requestBody.content[mimeType]) {
+      requestBody.content[mimeType] = {
+        schema: {
+          type: "object"
+        }
+      };
+    }
+    const mediaType = requestBody.content[mimeType];
+    if (!mediaType) {
+      return baseOperation;
+    }
+    mediaType.examples ||= {};
+    let exampleValue;
+    if (params && params.length > 0) {
+      exampleValue = [];
+      for (const param of params) {
+        exampleValue.push({
+          name: param.name,
+          value: param.value,
+          "x-disabled": false
+        });
+      }
+    } else {
+      exampleValue = text;
+    }
+    mediaType.examples[exampleKey] = {
+      value: exampleValue,
+      "x-disabled": false
+    };
+    requestBody["x-scalar-selected-content-type"] ||= {};
+    requestBody["x-scalar-selected-content-type"][exampleKey] = mimeType;
+  }
+  return baseOperation;
+};
+const setParameterDisabled = (param, exampleKey, disabled) => {
+  if (isContentTypeParameterObject(param)) {
+    return;
+  }
+  if (!param.examples?.[exampleKey]) {
+    return;
+  }
+  getResolvedRef(param.examples[exampleKey])["x-disabled"] = disabled;
+};
+const findOrCreateParameter = (parameters, name, inValue) => {
+  for (const param of parameters) {
+    const resolved = getResolvedRef(param);
+    if (isContentTypeParameterObject(resolved)) {
+      continue;
+    }
+    if (resolved.in !== inValue) {
+      continue;
+    }
+    const namesMatch = inValue === "header" ? resolved.name.toLowerCase() === name.toLowerCase() : resolved.name === name;
+    if (namesMatch) {
+      return resolved;
+    }
+  }
+  const newParam = {
+    name,
+    in: inValue,
+    schema: {
+      type: "string"
+    }
+  };
+  parameters.push(newParam);
+  return newParam;
+};
+export {
+  harToOperation
+};
+//# sourceMappingURL=har-to-operation.js.map

package/dist/mutators/har-to-operation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mutators/har-to-operation.ts"],
+  "sourcesContent": ["import type { HarRequest } from '@scalar/snippetz'\nimport { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport type { OperationObject, ParameterObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\nimport type { ReferenceType } from '@scalar/workspace-store/schemas/v3.1/strict/reference'\n\nimport { isContentTypeParameterObject } from '@/schemas/v3.1/strict/type-guards'\n\ntype HarToOperationProps = {\n  /** HAR request to convert */\n  harRequest: HarRequest\n  /** Name of the example to populate (e.g., 'default', 'example1') */\n  exampleKey: string\n  /** Optional base operation to merge with */\n  baseOperation?: OperationObject\n  /** Optional path variables to merge with */\n  pathVariables?: Record<string, string>\n}\n\nconst preprocessParameters = (\n  parameters: ReferenceType<ParameterObject>[],\n  pathVariables: Record<string, string>,\n  exampleKey: string,\n) => {\n  parameters.forEach((param) => {\n    const resolvedParam = getResolvedRef(param)\n    if (isContentTypeParameterObject(resolvedParam)) {\n      return\n    }\n\n    setParameterDisabled(getResolvedRef(param), exampleKey, true)\n\n    if (resolvedParam.in === 'path') {\n      resolvedParam.examples ||= {}\n      resolvedParam.examples[exampleKey] = {\n        value: pathVariables[resolvedParam.name] ?? '',\n        'x-disabled': false,\n      }\n    }\n  })\n}\n\n/**\n * Converts a HAR request back to an OpenAPI Operation object with populated examples.\n *\n * This function is the reverse of operationToHar - it takes a HAR request and\n * converts it back into an OpenAPI operation structure, populating the example\n * values based on the HAR request data.\n *\n * The conversion handles:\n * - URL parsing to extract path and query parameters\n * - Header extraction and mapping to operation parameters\n * - Query string parsing and mapping to parameters\n * - Cookie extraction and mapping to cookie parameters\n * - Request body extraction and mapping to requestBody with examples\n * - Content-Type detection and media type assignment\n *\n * Note: This function focuses on populating examples and does not reconstruct\n * schema definitions. If you need full schema generation, consider combining\n * this with a schema inference tool.\n *\n * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html\n * @see https://spec.openapis.org/oas/v3.1.0#operation-object\n */\nexport const harToOperation = ({\n  harRequest,\n  exampleKey,\n  baseOperation = {},\n  pathVariables = {},\n}: HarToOperationProps): OperationObject => {\n  // Ensure parameters array exists on the base operation\n  if (!baseOperation.parameters) {\n    baseOperation.parameters = []\n  }\n\n  // Set any other parameters as disabled and set the path variables\n  preprocessParameters(baseOperation.parameters, pathVariables, exampleKey)\n\n  // Process query string parameters from the HAR request\n  if (harRequest.queryString && harRequest.queryString.length > 0) {\n    for (const queryParam of harRequest.queryString) {\n      const param = findOrCreateParameter(baseOperation.parameters, queryParam.name, 'query')\n\n      if (!param || isContentTypeParameterObject(param)) {\n        continue\n      }\n\n      param.examples ||= {}\n      param.examples[exampleKey] = {\n        value: queryParam.value,\n        'x-disabled': false,\n      }\n    }\n  }\n\n  // Process headers from the HAR request\n  if (harRequest.headers && harRequest.headers.length > 0) {\n    for (const header of harRequest.headers) {\n      const param = findOrCreateParameter(baseOperation.parameters, header.name, 'header')\n\n      if (!param || isContentTypeParameterObject(param)) {\n        continue\n      }\n\n      param.examples ||= {}\n      param.examples[exampleKey] = {\n        value: header.value,\n        'x-disabled': false,\n      }\n    }\n  }\n\n  // Process cookies from the HAR request\n  if (harRequest.cookies && harRequest.cookies.length > 0) {\n    for (const cookie of harRequest.cookies) {\n      const param = findOrCreateParameter(baseOperation.parameters, cookie.name, 'cookie')\n\n      if (!param || isContentTypeParameterObject(param)) {\n        continue\n      }\n\n      param.examples ||= {}\n      param.examples[exampleKey] = {\n        value: cookie.value,\n        'x-disabled': false,\n      }\n    }\n  }\n\n  // Process request body from the HAR request\n  if (harRequest.postData) {\n    const { mimeType, text, params } = harRequest.postData\n\n    // Ensure requestBody exists on the base operation\n    if (!baseOperation.requestBody) {\n      baseOperation.requestBody = {\n        content: {},\n      }\n    }\n\n    // Resolve the request body in case it is a reference\n    const requestBody = getResolvedRef(baseOperation.requestBody)\n\n    // Ensure the content type exists in the requestBody\n    if (!requestBody.content[mimeType]) {\n      requestBody.content[mimeType] = {\n        schema: {\n          type: 'object',\n        },\n      }\n    }\n\n    // Get the media type object\n    const mediaType = requestBody.content[mimeType]\n    if (!mediaType) {\n      return baseOperation\n    }\n\n    // Ensure examples object exists\n    mediaType.examples ||= {}\n\n    // Convert the HAR postData to an example value\n    let exampleValue: any\n\n    // If params exist (form data), convert to array\n    if (params && params.length > 0) {\n      exampleValue = []\n      for (const param of params) {\n        exampleValue.push({\n          name: param.name,\n          value: param.value,\n          'x-disabled': false,\n        })\n      }\n    } else {\n      exampleValue = text\n    }\n\n    // Add the example to the media type\n    mediaType.examples[exampleKey] = {\n      value: exampleValue,\n      'x-disabled': false,\n    }\n\n    // Update the selected media type\n    requestBody['x-scalar-selected-content-type'] ||= {}\n    requestBody['x-scalar-selected-content-type'][exampleKey] = mimeType\n  }\n\n  return baseOperation\n}\n\nconst setParameterDisabled = (param: ParameterObject, exampleKey: string, disabled: boolean): void => {\n  if (isContentTypeParameterObject(param)) {\n    return\n  }\n\n  if (!param.examples?.[exampleKey]) {\n    return\n  }\n\n  getResolvedRef(param.examples[exampleKey])['x-disabled'] = disabled\n}\n\n/**\n * Finds an existing parameter in the parameters array or creates a new one.\n * This ensures we do not create duplicate parameters.\n */\nconst findOrCreateParameter = (\n  parameters: ReferenceType<ParameterObject>[],\n  name: string,\n  inValue: 'query' | 'header' | 'path' | 'cookie',\n): ParameterObject => {\n  // Try to find existing parameter using getResolvedRef to handle references\n  for (const param of parameters) {\n    const resolved = getResolvedRef(param)\n    if (isContentTypeParameterObject(resolved)) {\n      continue\n    }\n\n    // Check if parameter location matches\n    if (resolved.in !== inValue) {\n      continue\n    }\n\n    // For headers, use case-insensitive comparison; otherwise use exact match\n    const namesMatch =\n      inValue === 'header' ? resolved.name.toLowerCase() === name.toLowerCase() : resolved.name === name\n\n    if (namesMatch) {\n      return resolved\n    }\n  }\n\n  // Create new parameter with schema\n  const newParam: ParameterObject = {\n    name,\n    in: inValue,\n    schema: {\n      type: 'string',\n    },\n  }\n\n  parameters.push(newParam)\n  return newParam\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mutators/index.d.ts

@@ -104,6 +104,8 @@ export declare function generateClientMutators(store: WorkspaceStore | null): {
             updateOperationRequestBodyContentType: (payload: import("../events/definitions/operation.js").OperationEvents["operation:update:requestBody:contentType"]) => void;
             updateOperationRequestBodyExample: (payload: import("../events/definitions/operation.js").OperationEvents["operation:update:requestBody:value"]) => void;
             updateOperationRequestBodyFormValue: (payload: import("../events/definitions/operation.js").OperationEvents["operation:update:requestBody:formValue"]) => void;
+            addResponseToHistory: (payload: import("../events/definitions/hooks.js").HooksEvents["hooks:on:request:complete"]) => Promise<void>;
+            reloadOperationHistory: (payload: import("../events/definitions/operation.js").OperationEvents["operation:reload:history"]) => void;
         };
         server: {
             addServer: () => import("../schemas/v3.1/strict/server.js").ServerObject | undefined;
@@ -185,6 +187,8 @@ export declare function generateClientMutators(store: WorkspaceStore | null): {
             updateOperationRequestBodyContentType: (payload: import("../events/definitions/operation.js").OperationEvents["operation:update:requestBody:contentType"]) => void;
             updateOperationRequestBodyExample: (payload: import("../events/definitions/operation.js").OperationEvents["operation:update:requestBody:value"]) => void;
             updateOperationRequestBodyFormValue: (payload: import("../events/definitions/operation.js").OperationEvents["operation:update:requestBody:formValue"]) => void;
+            addResponseToHistory: (payload: import("../events/definitions/hooks.js").HooksEvents["hooks:on:request:complete"]) => Promise<void>;
+            reloadOperationHistory: (payload: import("../events/definitions/operation.js").OperationEvents["operation:reload:history"]) => void;
         };
         server: {
             addServer: () => import("../schemas/v3.1/strict/server.js").ServerObject | undefined;

package/dist/mutators/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mutators/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAa9C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAqC/D;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;gBACS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAErB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mutators/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAa9C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAqC/D;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;gBACS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAErB"}