@scalar/api-client 2.38.3 → 2.39.0

package/dist/v2/blocks/operation-block/helpers/apply-allow-reserved-to-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-allow-reserved-to-url.js","names":[],"sources":["../../../../../src/v2/blocks/operation-block/helpers/apply-allow-reserved-to-url.ts"],"sourcesContent":["/**\n * Reserved characters we can safely decode in query values when OpenAPI\n * `allowReserved` is enabled.\n *\n * We intentionally keep percent-encodings for characters that can break query\n * parsing (`#`, `&`, `=`, `?`, `[`, `]`) or change x-www-form-urlencoded\n * semantics (`+`).\n *\n * @see https://spec.openapis.org/oas/v3.1.0.html#fixed-fields-10\n */\nconst DECODABLE_RESERVED_CHARACTERS_BY_PERCENT_ENCODING: Record<string, string> = {\n  '21': '!',\n  '24': '$',\n  '27': \"'\",\n  '28': '(',\n  '29': ')',\n  '2A': '*',\n  '2C': ',',\n  '2F': '/',\n  '3A': ':',\n  '3B': ';',\n  '40': '@',\n}\n\nconst decodeReservedCharacters = (value: string): string =>\n  value.replace(\n    /%([0-9A-Fa-f]{2})/g,\n    (match, code: string) => DECODABLE_RESERVED_CHARACTERS_BY_PERCENT_ENCODING[code.toUpperCase()] ?? match,\n  )\n\nconst decodeQueryKey = (key: string): string => {\n  try {\n    return decodeURIComponent(key.replaceAll('+', '%20'))\n  } catch {\n    return key\n  }\n}\n\n/**\n * Decodes reserved character percent-encodings only for query keys marked with\n * OpenAPI's `allowReserved: true`.\n */\nexport const applyAllowReservedToUrl = (url: string, allowReservedQueryParameters: Set<string>): string => {\n  if (allowReservedQueryParameters.size === 0) {\n    return url\n  }\n\n  const queryStart = url.indexOf('?')\n  if (queryStart === -1) {\n    return url\n  }\n\n  const hashStart = url.indexOf('#', queryStart)\n  const urlPrefix = url.slice(0, queryStart + 1)\n  const query = hashStart === -1 ? url.slice(queryStart + 1) : url.slice(queryStart + 1, hashStart)\n  const hash = hashStart === -1 ? '' : url.slice(hashStart)\n\n  if (!query) {\n    return url\n  }\n\n  const decodedQuery = query\n    .split('&')\n    .map((segment) => {\n      if (!segment) {\n        return segment\n      }\n\n      const equalsIndex = segment.indexOf('=')\n      const rawKey = equalsIndex === -1 ? segment : segment.slice(0, equalsIndex)\n      const key = decodeQueryKey(rawKey)\n\n      if (!allowReservedQueryParameters.has(key) || equalsIndex === -1) {\n        return segment\n      }\n\n      const rawValue = segment.slice(equalsIndex + 1)\n      return `${rawKey}=${decodeReservedCharacters(rawValue)}`\n    })\n    .join('&')\n\n  return `${urlPrefix}${decodedQuery}${hash}`\n}\n"],"mappings":";;;;;;;;;;;AAUA,IAAM,oDAA4E;CAChF,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACP;AAED,IAAM,4BAA4B,UAChC,MAAM,QACJ,uBACC,OAAO,SAAiB,kDAAkD,KAAK,aAAa,KAAK,MACnG;AAEH,IAAM,kBAAkB,QAAwB;AAC9C,KAAI;AACF,SAAO,mBAAmB,IAAI,WAAW,KAAK,MAAM,CAAC;SAC/C;AACN,SAAO;;;;;;;AAQX,IAAa,2BAA2B,KAAa,iCAAsD;AACzG,KAAI,6BAA6B,SAAS,EACxC,QAAO;CAGT,MAAM,aAAa,IAAI,QAAQ,IAAI;AACnC,KAAI,eAAe,GACjB,QAAO;CAGT,MAAM,YAAY,IAAI,QAAQ,KAAK,WAAW;CAC9C,MAAM,YAAY,IAAI,MAAM,GAAG,aAAa,EAAE;CAC9C,MAAM,QAAQ,cAAc,KAAK,IAAI,MAAM,aAAa,EAAE,GAAG,IAAI,MAAM,aAAa,GAAG,UAAU;CACjG,MAAM,OAAO,cAAc,KAAK,KAAK,IAAI,MAAM,UAAU;AAEzD,KAAI,CAAC,MACH,QAAO;AAuBT,QAAO,GAAG,YApBW,MAClB,MAAM,IAAI,CACV,KAAK,YAAY;AAChB,MAAI,CAAC,QACH,QAAO;EAGT,MAAM,cAAc,QAAQ,QAAQ,IAAI;EACxC,MAAM,SAAS,gBAAgB,KAAK,UAAU,QAAQ,MAAM,GAAG,YAAY;EAC3E,MAAM,MAAM,eAAe,OAAO;AAElC,MAAI,CAAC,6BAA6B,IAAI,IAAI,IAAI,gBAAgB,GAC5D,QAAO;AAIT,SAAO,GAAG,OAAO,GAAG,yBADH,QAAQ,MAAM,cAAc,EAAE,CACO;GACtD,CACD,KAAK,IAAI,GAEyB"}

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

@@ -0,0 +1,65 @@
+import { getSelectedBodyContentType } from "./get-selected-body-content-type.js";
+import { getExampleFromBody } from "../../request-block/helpers/get-request-body-example.js";
+import { replaceEnvVariables } from "@scalar/helpers/regex/replace-variables";
+import { unpackProxyObject } from "@scalar/workspace-store/helpers/unpack-proxy";
+//#region src/v2/blocks/operation-block/helpers/build-request-body.ts
+var getMultipartEncodingContentType = (requestBody, bodyContentType, fieldName, replacedFieldName) => requestBody.content[bodyContentType]?.encoding?.[fieldName]?.contentType ?? requestBody.content[bodyContentType]?.encoding?.[replacedFieldName]?.contentType;
+var serializeMultipartValue = (value, env) => {
+	if (typeof value === "string") return replaceEnvVariables(value, env);
+	return replaceEnvVariables(typeof value === "object" && value !== null ? JSON.stringify(unpackProxyObject(value)) : String(value), env);
+};
+/**
+* Create the fetch request body
+*/
+var buildRequestBody = (requestBody, env = {}, exampleKey = "default") => {
+	if (!requestBody) return null;
+	/** Selected content type for the body from the dropdown, stored as x-scalar-selected-content-type */
+	const bodyContentType = getSelectedBodyContentType(requestBody, exampleKey);
+	if (!bodyContentType) return null;
+	/** An example value or generated example from the schema */
+	const example = getExampleFromBody(requestBody, bodyContentType, exampleKey);
+	if (!example) return null;
+	if ((bodyContentType === "multipart/form-data" || bodyContentType === "application/x-www-form-urlencoded") && Array.isArray(example.value)) {
+		const exampleValue = example.value.filter((item) => !item.isDisabled);
+		const form = bodyContentType === "multipart/form-data" ? new FormData() : new URLSearchParams();
+		exampleValue.forEach(({ name, value }) => {
+			if (!name) return;
+			const replacedName = replaceEnvVariables(name, env);
+			const partContentType = form instanceof FormData ? getMultipartEncodingContentType(requestBody, bodyContentType, name, replacedName) : void 0;
+			if (value instanceof File && form instanceof FormData) {
+				/**
+				* We need to unwrap the proxies to get the file name due to the
+				* "this" context in the proxy causing an illegal invocation error
+				*/
+				const unwrappedValue = unpackProxyObject(value);
+				const encodedValue = partContentType && partContentType !== unwrappedValue.type ? new File([unwrappedValue], unwrappedValue.name, {
+					type: partContentType,
+					lastModified: unwrappedValue.lastModified
+				}) : unwrappedValue;
+				form.append(replacedName, encodedValue, encodedValue.name);
+			} else if (value !== void 0 && value !== null) {
+				const serializedValue = serializeMultipartValue(value, env);
+				if (form instanceof FormData && partContentType) form.append(replacedName, new Blob([serializedValue], { type: partContentType }));
+				else form.append(replacedName, serializedValue);
+			}
+		});
+		return form;
+	}
+	if (bodyContentType === "application/x-www-form-urlencoded" && example.value !== null && typeof example.value === "object" && !Array.isArray(example.value)) {
+		const form = new URLSearchParams();
+		for (const [key, value] of Object.entries(example.value)) if (key && value !== void 0 && value !== null) {
+			const replacedKey = replaceEnvVariables(key, env);
+			const stringValue = typeof value === "string" ? value : String(value);
+			form.append(replacedKey, replaceEnvVariables(stringValue, env));
+		}
+		return form;
+	}
+	const exampleValue = example.value !== null && typeof example.value === "object" ? unpackProxyObject(example.value) : example.value;
+	if (exampleValue instanceof File) return exampleValue;
+	if (typeof exampleValue === "object") return replaceEnvVariables(JSON.stringify(exampleValue), env);
+	return typeof exampleValue === "string" ? replaceEnvVariables(exampleValue, env) : exampleValue;
+};
+//#endregion
+export { buildRequestBody };
+
+//# sourceMappingURL=build-request-body.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-request-body.js","names":[],"sources":["../../../../../src/v2/blocks/operation-block/helpers/build-request-body.ts"],"sourcesContent":["import { replaceEnvVariables } from '@scalar/helpers/regex/replace-variables'\nimport { unpackProxyObject } from '@scalar/workspace-store/helpers/unpack-proxy'\nimport type { RequestBodyObject } from '@scalar/workspace-store/schemas/v3.1/strict/request-body'\n\nimport { getSelectedBodyContentType } from '@/v2/blocks/operation-block/helpers/get-selected-body-content-type'\nimport { getExampleFromBody } from '@/v2/blocks/request-block/helpers/get-request-body-example'\n\nconst getMultipartEncodingContentType = (\n  requestBody: RequestBodyObject,\n  bodyContentType: string,\n  fieldName: string,\n  replacedFieldName: string,\n) =>\n  requestBody.content[bodyContentType]?.encoding?.[fieldName]?.contentType ??\n  requestBody.content[bodyContentType]?.encoding?.[replacedFieldName]?.contentType\n\nconst serializeMultipartValue = (value: unknown, env: Record<string, string>) => {\n  if (typeof value === 'string') {\n    return replaceEnvVariables(value, env)\n  }\n\n  const serializedValue =\n    typeof value === 'object' && value !== null ? JSON.stringify(unpackProxyObject(value)) : String(value)\n\n  return replaceEnvVariables(serializedValue, env)\n}\n\n/**\n * Create the fetch request body\n */\nexport const buildRequestBody = (\n  requestBody: RequestBodyObject | undefined,\n  /** Environment variables flattened into a key-value object */\n  env: Record<string, string> = {},\n  /** The key of the current example */\n  exampleKey = 'default',\n): BodyInit | null => {\n  if (!requestBody) {\n    return null\n  }\n\n  /** Selected content type for the body from the dropdown, stored as x-scalar-selected-content-type */\n  const bodyContentType = getSelectedBodyContentType(requestBody, exampleKey)\n  if (!bodyContentType) {\n    return null\n  }\n\n  /** An example value or generated example from the schema */\n  const example = getExampleFromBody(requestBody, bodyContentType, exampleKey)\n  if (!example) {\n    return null\n  }\n\n  // Form data - array format (from UI editor)\n  if (\n    (bodyContentType === 'multipart/form-data' || bodyContentType === 'application/x-www-form-urlencoded') &&\n    Array.isArray(example.value)\n  ) {\n    const exampleValue = example.value.filter((item) => !item.isDisabled) as { name: string; value: unknown }[]\n    const form = bodyContentType === 'multipart/form-data' ? new FormData() : new URLSearchParams()\n\n    // Loop over all entries and add them to the form\n    exampleValue.forEach(({ name, value }) => {\n      if (!name) {\n        return\n      }\n      const replacedName = replaceEnvVariables(name, env)\n      const partContentType =\n        form instanceof FormData\n          ? getMultipartEncodingContentType(requestBody, bodyContentType, name, replacedName)\n          : undefined\n\n      // Handle file uploads\n      if (value instanceof File && form instanceof FormData) {\n        /**\n         * We need to unwrap the proxies to get the file name due to the\n         * \"this\" context in the proxy causing an illegal invocation error\n         */\n        const unwrappedValue = unpackProxyObject(value)\n        const encodedValue =\n          partContentType && partContentType !== unwrappedValue.type\n            ? new File([unwrappedValue], unwrappedValue.name, {\n                type: partContentType,\n                lastModified: unwrappedValue.lastModified,\n              })\n            : unwrappedValue\n\n        form.append(replacedName, encodedValue, encodedValue.name)\n      }\n      // Text and structured inputs\n      else if (value !== undefined && value !== null) {\n        const serializedValue = serializeMultipartValue(value, env)\n\n        if (form instanceof FormData && partContentType) {\n          form.append(replacedName, new Blob([serializedValue], { type: partContentType }))\n        } else {\n          form.append(replacedName, serializedValue)\n        }\n      }\n    })\n\n    return form\n  }\n\n  // Form data - object format (from schema examples)\n  // When the example value is a plain object and content type is form-urlencoded,\n  // convert to URLSearchParams instead of JSON stringifying\n  if (\n    bodyContentType === 'application/x-www-form-urlencoded' &&\n    example.value !== null &&\n    typeof example.value === 'object' &&\n    !Array.isArray(example.value)\n  ) {\n    const form = new URLSearchParams()\n\n    // Convert object properties to form fields\n    for (const [key, value] of Object.entries(example.value)) {\n      if (key && value !== undefined && value !== null) {\n        const replacedKey = replaceEnvVariables(key, env)\n        const stringValue = typeof value === 'string' ? value : String(value)\n        form.append(replacedKey, replaceEnvVariables(stringValue, env))\n      }\n    }\n\n    return form\n  }\n\n  const exampleValue =\n    example.value !== null && typeof example.value === 'object' ? unpackProxyObject(example.value) : example.value\n\n  if (exampleValue instanceof File) {\n    return exampleValue\n  }\n\n  // Ensure we stringify the example value if it is an object\n  if (typeof exampleValue === 'object') {\n    return replaceEnvVariables(JSON.stringify(exampleValue), env)\n  }\n\n  // Return binary or string values\n  return typeof exampleValue === 'string' ? replaceEnvVariables(exampleValue, env) : exampleValue\n}\n"],"mappings":";;;;;AAOA,IAAM,mCACJ,aACA,iBACA,WACA,sBAEA,YAAY,QAAQ,kBAAkB,WAAW,YAAY,eAC7D,YAAY,QAAQ,kBAAkB,WAAW,oBAAoB;AAEvE,IAAM,2BAA2B,OAAgB,QAAgC;AAC/E,KAAI,OAAO,UAAU,SACnB,QAAO,oBAAoB,OAAO,IAAI;AAMxC,QAAO,oBAFL,OAAO,UAAU,YAAY,UAAU,OAAO,KAAK,UAAU,kBAAkB,MAAM,CAAC,GAAG,OAAO,MAAM,EAE5D,IAAI;;;;;AAMlD,IAAa,oBACX,aAEA,MAA8B,EAAE,EAEhC,aAAa,cACO;AACpB,KAAI,CAAC,YACH,QAAO;;CAIT,MAAM,kBAAkB,2BAA2B,aAAa,WAAW;AAC3E,KAAI,CAAC,gBACH,QAAO;;CAIT,MAAM,UAAU,mBAAmB,aAAa,iBAAiB,WAAW;AAC5E,KAAI,CAAC,QACH,QAAO;AAIT,MACG,oBAAoB,yBAAyB,oBAAoB,wCAClE,MAAM,QAAQ,QAAQ,MAAM,EAC5B;EACA,MAAM,eAAe,QAAQ,MAAM,QAAQ,SAAS,CAAC,KAAK,WAAW;EACrE,MAAM,OAAO,oBAAoB,wBAAwB,IAAI,UAAU,GAAG,IAAI,iBAAiB;AAG/F,eAAa,SAAS,EAAE,MAAM,YAAY;AACxC,OAAI,CAAC,KACH;GAEF,MAAM,eAAe,oBAAoB,MAAM,IAAI;GACnD,MAAM,kBACJ,gBAAgB,WACZ,gCAAgC,aAAa,iBAAiB,MAAM,aAAa,GACjF,KAAA;AAGN,OAAI,iBAAiB,QAAQ,gBAAgB,UAAU;;;;;IAKrD,MAAM,iBAAiB,kBAAkB,MAAM;IAC/C,MAAM,eACJ,mBAAmB,oBAAoB,eAAe,OAClD,IAAI,KAAK,CAAC,eAAe,EAAE,eAAe,MAAM;KAC9C,MAAM;KACN,cAAc,eAAe;KAC9B,CAAC,GACF;AAEN,SAAK,OAAO,cAAc,cAAc,aAAa,KAAK;cAGnD,UAAU,KAAA,KAAa,UAAU,MAAM;IAC9C,MAAM,kBAAkB,wBAAwB,OAAO,IAAI;AAE3D,QAAI,gBAAgB,YAAY,gBAC9B,MAAK,OAAO,cAAc,IAAI,KAAK,CAAC,gBAAgB,EAAE,EAAE,MAAM,iBAAiB,CAAC,CAAC;QAEjF,MAAK,OAAO,cAAc,gBAAgB;;IAG9C;AAEF,SAAO;;AAMT,KACE,oBAAoB,uCACpB,QAAQ,UAAU,QAClB,OAAO,QAAQ,UAAU,YACzB,CAAC,MAAM,QAAQ,QAAQ,MAAM,EAC7B;EACA,MAAM,OAAO,IAAI,iBAAiB;AAGlC,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,MAAM,CACtD,KAAI,OAAO,UAAU,KAAA,KAAa,UAAU,MAAM;GAChD,MAAM,cAAc,oBAAoB,KAAK,IAAI;GACjD,MAAM,cAAc,OAAO,UAAU,WAAW,QAAQ,OAAO,MAAM;AACrE,QAAK,OAAO,aAAa,oBAAoB,aAAa,IAAI,CAAC;;AAInE,SAAO;;CAGT,MAAM,eACJ,QAAQ,UAAU,QAAQ,OAAO,QAAQ,UAAU,WAAW,kBAAkB,QAAQ,MAAM,GAAG,QAAQ;AAE3G,KAAI,wBAAwB,KAC1B,QAAO;AAIT,KAAI,OAAO,iBAAiB,SAC1B,QAAO,oBAAoB,KAAK,UAAU,aAAa,EAAE,IAAI;AAI/D,QAAO,OAAO,iBAAiB,WAAW,oBAAoB,cAAc,IAAI,GAAG"}

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

@@ -0,0 +1,55 @@
+import { filterGlobalCookie } from "./filter-global-cookies.js";
+import { replaceEnvVariables } from "@scalar/helpers/regex/replace-variables";
+import { xScalarCookieSchema } from "@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies";
+import { coerceValue } from "@scalar/workspace-store/schemas/typebox-coerce";
+//#region src/v2/blocks/operation-block/helpers/build-request-cookie-header.ts
+var CUSTOM_COOKIE_HEADER_WARNING = "We're using a `X-Scalar-Cookie` custom header to the request. The proxy will forward this as a `Cookie` header. We do this to avoid the browser omitting the `Cookie` header for cross-origin requests for security reasons.";
+var COOKIE_HEADER_WARNING = `We're trying to add a Cookie header, but browsers often omit them for cross-origin requests for various security reasons. If it's not working, that's probably why. Here are the requirements for it to work:
+
+        - The browser URL must be on the same domain as the server URL.
+        - The connection must be made over HTTPS.
+        `;
+/**
+* Generate a cookie header from the cookie params
+*/
+var getCookieHeader = (cookieParams, originalCookieHeader) => {
+	const cookieHeader = cookieParams.map((c) => `${c.name}=${c.value}`).join("; ");
+	if (originalCookieHeader && cookieHeader) return `${originalCookieHeader}; ${cookieHeader}`;
+	return originalCookieHeader || cookieHeader || "";
+};
+/**
+* Build out the cookies header taking in global, param and security scheme cookies
+*/
+var buildRequestCookieHeader = ({ paramCookies, globalCookies, env, originalCookieHeader, url, useCustomCookieHeader, disabledGlobalCookies }) => {
+	/** Generate the cookie header */
+	const cookieHeader = getCookieHeader([...globalCookies.filter((cookie) => filterGlobalCookie({
+		cookie,
+		url,
+		disabledGlobalCookies
+	})).map((cookie) => {
+		return coerceValue(xScalarCookieSchema, {
+			...cookie,
+			name: replaceEnvVariables(cookie.name, env),
+			value: replaceEnvVariables(cookie.value, env)
+		});
+	}), ...paramCookies], originalCookieHeader ?? void 0);
+	if (cookieHeader) {
+		if (useCustomCookieHeader) {
+			console.warn(CUSTOM_COOKIE_HEADER_WARNING);
+			return {
+				name: "X-Scalar-Cookie",
+				value: cookieHeader
+			};
+		}
+		console.warn(COOKIE_HEADER_WARNING);
+		return {
+			name: "Cookie",
+			value: cookieHeader
+		};
+	}
+	return null;
+};
+//#endregion
+export { buildRequestCookieHeader };
+
+//# sourceMappingURL=build-request-cookie-header.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-request-cookie-header.js","names":[],"sources":["../../../../../src/v2/blocks/operation-block/helpers/build-request-cookie-header.ts"],"sourcesContent":["import { replaceEnvVariables } from '@scalar/helpers/regex/replace-variables'\nimport {\n  type XScalarCookie,\n  xScalarCookieSchema,\n} from '@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies'\nimport { coerceValue } from '@scalar/workspace-store/schemas/typebox-coerce'\n\nimport { filterGlobalCookie } from '@/v2/blocks/operation-block/helpers/filter-global-cookies'\n\nconst CUSTOM_COOKIE_HEADER_WARNING =\n  \"We're using a `X-Scalar-Cookie` custom header to the request. The proxy will forward this as a `Cookie` header. We do this to avoid the browser omitting the `Cookie` header for cross-origin requests for security reasons.\"\nconst COOKIE_HEADER_WARNING = `We're trying to add a Cookie header, but browsers often omit them for cross-origin requests for various security reasons. If it's not working, that's probably why. Here are the requirements for it to work:\n\n        - The browser URL must be on the same domain as the server URL.\n        - The connection must be made over HTTPS.\n        `\n\n/**\n * Generate a cookie header from the cookie params\n */\nexport const getCookieHeader = (cookieParams: XScalarCookie[], originalCookieHeader: string | undefined): string => {\n  // Generate the cookie header from the cookie params\n  const cookieHeader = cookieParams.map((c) => `${c.name}=${c.value}`).join('; ')\n\n  // Merge with the original cookie header\n  if (originalCookieHeader && cookieHeader) {\n    return `${originalCookieHeader}; ${cookieHeader}`\n  }\n\n  // Return whichever one exists, or empty string if both are empty\n  return originalCookieHeader || cookieHeader || ''\n}\n\n/**\n * Build out the cookies header taking in global, param and security scheme cookies\n */\nexport const buildRequestCookieHeader = ({\n  paramCookies,\n  globalCookies,\n  env,\n  originalCookieHeader,\n  url,\n  useCustomCookieHeader,\n  disabledGlobalCookies,\n}: {\n  /** Parsed/replaced cookies from the parameters and security schemes */\n  paramCookies: XScalarCookie[]\n  /** Raw global cookies from the workspace/document */\n  globalCookies: XScalarCookie[]\n  /** Environment variables flattened into a key-value object */\n  env: Record<string, string>\n  /** Cookie header that previously exists from the spec OR from the user */\n  originalCookieHeader: string | undefined | null\n  /** The url of the request used to filter global cookies by domain */\n  url: string\n  /**\n   * If we are running in Electron or using the proxy, we need to add a custom header\n   * that's then forwarded as a `Cookie` header.\n   */\n  useCustomCookieHeader: boolean\n  /** The disabled global cookies for the current example */\n  disabledGlobalCookies: Record<string, boolean>\n}): null | { name: string; value: string } => {\n  /** Filter the global cookies by domain + parse */\n  const filteredGlobalCookies = globalCookies\n    .filter((cookie) => filterGlobalCookie({ cookie, url, disabledGlobalCookies }))\n    .map((cookie) => {\n      return coerceValue(xScalarCookieSchema, {\n        ...cookie,\n        name: replaceEnvVariables(cookie.name, env),\n        value: replaceEnvVariables(cookie.value, env),\n      })\n    })\n\n  /** Generate the cookie header */\n  const cookieHeader = getCookieHeader([...filteredGlobalCookies, ...paramCookies], originalCookieHeader ?? undefined)\n\n  if (cookieHeader) {\n    // Add a custom header for the proxy (that's then forwarded as `Cookie`)\n    if (useCustomCookieHeader) {\n      console.warn(CUSTOM_COOKIE_HEADER_WARNING)\n      return { name: 'X-Scalar-Cookie', value: cookieHeader }\n    }\n\n    // or stick to the original header (which might be removed by the browser)\n    console.warn(COOKIE_HEADER_WARNING)\n    return { name: 'Cookie', value: cookieHeader }\n  }\n\n  return null\n}\n"],"mappings":";;;;;AASA,IAAM,+BACJ;AACF,IAAM,wBAAwB;;;;;;;;AAS9B,IAAa,mBAAmB,cAA+B,yBAAqD;CAElH,MAAM,eAAe,aAAa,KAAK,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,QAAQ,CAAC,KAAK,KAAK;AAG/E,KAAI,wBAAwB,aAC1B,QAAO,GAAG,qBAAqB,IAAI;AAIrC,QAAO,wBAAwB,gBAAgB;;;;;AAMjD,IAAa,4BAA4B,EACvC,cACA,eACA,KACA,sBACA,KACA,uBACA,4BAmB4C;;CAa5C,MAAM,eAAe,gBAAgB,CAAC,GAXR,cAC3B,QAAQ,WAAW,mBAAmB;EAAE;EAAQ;EAAK;EAAuB,CAAC,CAAC,CAC9E,KAAK,WAAW;AACf,SAAO,YAAY,qBAAqB;GACtC,GAAG;GACH,MAAM,oBAAoB,OAAO,MAAM,IAAI;GAC3C,OAAO,oBAAoB,OAAO,OAAO,IAAI;GAC9C,CAAC;GACF,EAG4D,GAAG,aAAa,EAAE,wBAAwB,KAAA,EAAU;AAEpH,KAAI,cAAc;AAEhB,MAAI,uBAAuB;AACzB,WAAQ,KAAK,6BAA6B;AAC1C,UAAO;IAAE,MAAM;IAAmB,OAAO;IAAc;;AAIzD,UAAQ,KAAK,sBAAsB;AACnC,SAAO;GAAE,MAAM;GAAU,OAAO;GAAc;;AAGhD,QAAO"}

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

@@ -0,0 +1,159 @@
+import { getExample } from "./get-example.js";
+import { deSerializeParameter } from "./de-serialize-parameter.js";
+import { isParamDisabled } from "../../request-block/helpers/is-param-disabled.js";
+import { serializeContentValue, serializeDeepObjectStyle, serializeFormStyle, serializeFormStyleForCookies, serializePipeDelimitedStyle, serializeSimpleStyle, serializeSpaceDelimitedStyle } from "./serialize-parameter.js";
+import { isDefined } from "@scalar/helpers/array/is-defined";
+import { replaceEnvVariables } from "@scalar/helpers/regex/replace-variables";
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { xScalarCookieSchema } from "@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies";
+import { coerceValue } from "@scalar/workspace-store/schemas/typebox-coerce";
+import { isObject } from "@scalar/helpers/object/is-object";
+//#region src/v2/blocks/operation-block/helpers/build-request-parameters.ts
+/** Helper to get explode value with default */
+var getExplode = (param, defaultValue) => "explode" in param && param.explode !== void 0 ? param.explode : defaultValue;
+/**
+* Converts the parameters into a set of headers, cookies and url params while
+* replacing environment variables and extracting example values. Also builds up a record of the path
+* parameters which can then be used to replace variables in the path.
+* Also handles both content based and schema based parameters.
+*
+* @param parameters - Unfiltered parameters
+* @param env - Environment variables flattened into a key-value object
+* @param exampleKey - The key of the current example
+* @returns A set of headers, cookies and url params
+*/
+var buildRequestParameters = (parameters = [], env = {}, exampleKey = "default") => {
+	const result = {
+		cookies: [],
+		headers: {},
+		pathVariables: {},
+		allowReservedQueryParameters: /* @__PURE__ */ new Set(),
+		urlParams: new URLSearchParams()
+	};
+	if (parameters.length === 0) return result;
+	for (const referencedParam of parameters) {
+		const param = getResolvedRef(referencedParam);
+		const example = getExample(param, exampleKey, void 0);
+		if (!example || isParamDisabled(param, example)) continue;
+		/** De-serialize the example value if it is a string and matches the schema type */
+		const deSerializedValue = deSerializeParameter(typeof example.value === "string" ? replaceEnvVariables(example.value, env) : example.value, param);
+		const paramName = replaceEnvVariables(param.name, env);
+		switch (param.in) {
+			case "header": {
+				if (paramName.toLowerCase() === "content-type" && deSerializedValue === "multipart/form-data") break;
+				/** Headers only support simple style according to OpenAPI 3.1.1 */
+				const serialized = serializeSimpleStyle(deSerializedValue, getExplode(param, false));
+				if (!isDefined(serialized)) break;
+				/** Headers can only be strings so we can cast numbers etc */
+				const serializedString = String(serialized);
+				if (result.headers[paramName]) result.headers[paramName] = `${result.headers[paramName]},${serializedString}`;
+				else result.headers[paramName] = serializedString;
+				break;
+			}
+			case "path": {
+				const serialized = serializeSimpleStyle(deSerializedValue, getExplode(param, false));
+				result.pathVariables[paramName] = encodeURIComponent(String(serialized));
+				break;
+			}
+			case "query":
+				processQueryParameter(param, paramName, deSerializedValue, result.urlParams, result.allowReservedQueryParameters);
+				break;
+			case "cookie":
+				processCookieParameter(paramName, deSerializedValue, getExplode(param, true), result.cookies);
+				break;
+		}
+	}
+	return result;
+};
+/** Ensure we only apply the correcet style to the correct types */
+var getStyle = (param, replacedValue) => {
+	if (!("style" in param) || !param.style) return "form";
+	if (param.style === "deepObject") {
+		if (isObject(replacedValue)) return "deepObject";
+		return "form";
+	}
+	return param.style;
+};
+/** Whether the parameter allows reserved characters (from param or schema). */
+var isAllowReserved = (param) => {
+	if ("allowReserved" in param && param.allowReserved !== void 0) return param.allowReserved;
+	if ("schema" in param && param.schema && typeof param.schema === "object" && "allowReserved" in param.schema) return param.schema.allowReserved === true;
+	return false;
+};
+/** When allowReserved is true, add keys to the set so reserved chars stay unescaped in the URL. */
+var trackReservedKeys = (allowReservedQueryParameters, allowReserved, ...keys) => {
+	if (allowReserved) for (const key of keys) allowReservedQueryParameters.add(key);
+};
+/**
+* Helper function to process query parameters.
+* Extracted to reduce complexity in main function.
+*/
+var processQueryParameter = (param, paramName, replacedValue, urlParams, allowReservedQueryParameters) => {
+	/** If the parameter should be exploded, defaults to true for form style */
+	const explodeParam = "explode" in param && param.explode !== void 0 ? param.explode : true;
+	const allowReserved = isAllowReserved(param);
+	/** Style of the parameter, defaults to form */
+	const style = getStyle(param, replacedValue);
+	if ("content" in param && param.content) {
+		const serializedValue = serializeContentValue(replacedValue, Object.keys(param.content)[0] ?? "application/json");
+		urlParams.set(paramName, serializedValue);
+		trackReservedKeys(allowReservedQueryParameters, allowReserved, paramName);
+		return;
+	}
+	if (style === "deepObject" && explodeParam) {
+		const entries = serializeDeepObjectStyle(paramName, replacedValue);
+		for (const entry of entries) {
+			urlParams.append(entry.key, entry.value);
+			trackReservedKeys(allowReservedQueryParameters, allowReserved, entry.key);
+		}
+		return;
+	}
+	if (style === "spaceDelimited") {
+		const serialized = serializeSpaceDelimitedStyle(replacedValue);
+		const existingValue = urlParams.get(paramName);
+		urlParams.set(paramName, existingValue ? `${existingValue} ${serialized}` : serialized);
+		trackReservedKeys(allowReservedQueryParameters, allowReserved, paramName);
+		return;
+	}
+	if (style === "pipeDelimited") {
+		const serialized = serializePipeDelimitedStyle(replacedValue);
+		const existingValue = urlParams.get(paramName);
+		urlParams.set(paramName, existingValue ? `${existingValue}|${serialized}` : serialized);
+		trackReservedKeys(allowReservedQueryParameters, allowReserved, paramName);
+		return;
+	}
+	const serialized = serializeFormStyle(replacedValue, explodeParam);
+	if (Array.isArray(serialized)) for (const entry of serialized) {
+		const key = entry.key || paramName;
+		urlParams.append(key, String(entry.value));
+		trackReservedKeys(allowReservedQueryParameters, allowReserved, key);
+	}
+	else {
+		urlParams.append(paramName, String(serialized));
+		trackReservedKeys(allowReservedQueryParameters, allowReserved, paramName);
+	}
+};
+/**
+* Helper function to process cookie parameters.
+* Extracted to reduce complexity in main function.
+*/
+var processCookieParameter = (paramName, replacedValue, explode, cookies) => {
+	const serialized = serializeFormStyleForCookies(replacedValue, explode);
+	if (Array.isArray(serialized)) for (const entry of serialized) {
+		const key = entry.key || paramName;
+		cookies.push(coerceValue(xScalarCookieSchema, {
+			name: key,
+			value: String(entry.value),
+			path: "/"
+		}));
+	}
+	else cookies.push(coerceValue(xScalarCookieSchema, {
+		name: paramName,
+		value: String(serialized),
+		path: "/"
+	}));
+};
+//#endregion
+export { buildRequestParameters };
+
+//# sourceMappingURL=build-request-parameters.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-request-parameters.js","names":[],"sources":["../../../../../src/v2/blocks/operation-block/helpers/build-request-parameters.ts"],"sourcesContent":["import { isDefined } from '@scalar/helpers/array/is-defined'\nimport { isObject } from '@scalar/helpers/object/is-object'\nimport { replaceEnvVariables } from '@scalar/helpers/regex/replace-variables'\nimport { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport {\n  type XScalarCookie,\n  xScalarCookieSchema,\n} from '@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies'\nimport { coerceValue } from '@scalar/workspace-store/schemas/typebox-coerce'\nimport type { ParameterObject, ReferenceType } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport { deSerializeParameter } from '@/v2/blocks/operation-block/helpers/de-serialize-parameter'\nimport { isParamDisabled } from '@/v2/blocks/request-block/helpers/is-param-disabled'\n\nimport { getExample } from './get-example'\nimport {\n  serializeContentValue,\n  serializeDeepObjectStyle,\n  serializeFormStyle,\n  serializeFormStyleForCookies,\n  serializePipeDelimitedStyle,\n  serializeSimpleStyle,\n  serializeSpaceDelimitedStyle,\n} from './serialize-parameter'\n\n/** Helper to get explode value with default */\nconst getExplode = (param: ParameterObject, defaultValue: boolean): boolean =>\n  'explode' in param && param.explode !== undefined ? param.explode : defaultValue\n\n/**\n * Converts the parameters into a set of headers, cookies and url params while\n * replacing environment variables and extracting example values. Also builds up a record of the path\n * parameters which can then be used to replace variables in the path.\n * Also handles both content based and schema based parameters.\n *\n * @param parameters - Unfiltered parameters\n * @param env - Environment variables flattened into a key-value object\n * @param exampleKey - The key of the current example\n * @returns A set of headers, cookies and url params\n */\nexport const buildRequestParameters = (\n  /** All parameters */\n  parameters: ReferenceType<ParameterObject>[] = [],\n  /** Environment variables flattened into a key-value object */\n  env: Record<string, string> = {},\n  /** The key of the current example */\n  exampleKey: string = 'default',\n): {\n  cookies: XScalarCookie[]\n  headers: Record<string, string>\n  pathVariables: Record<string, string>\n  allowReservedQueryParameters: Set<string>\n  urlParams: URLSearchParams\n} => {\n  const result = {\n    cookies: [] as XScalarCookie[],\n    headers: {} as Record<string, string>,\n    pathVariables: {} as Record<string, string>,\n    allowReservedQueryParameters: new Set<string>(),\n    urlParams: new URLSearchParams(),\n  }\n\n  // Early return for empty parameters\n  if (parameters.length === 0) {\n    return result\n  }\n\n  // Second pass: process all parameters\n  for (const referencedParam of parameters) {\n    const param = getResolvedRef(referencedParam)\n    const example = getExample(param, exampleKey, undefined)\n\n    // Skip disabled examples\n    if (!example || isParamDisabled(param, example)) {\n      continue\n    }\n\n    /** Replace environment variables in the key and value */\n    const replacedEnvValue = typeof example.value === 'string' ? replaceEnvVariables(example.value, env) : example.value\n\n    /** De-serialize the example value if it is a string and matches the schema type */\n    const deSerializedValue = deSerializeParameter(replacedEnvValue, param)\n    const paramName = replaceEnvVariables(param.name, env)\n\n    // Handle by parameter location\n    switch (param.in) {\n      case 'header': {\n        // Filter out Content-Type header when it is multipart/form-data\n        // The browser will automatically set this header with the proper boundary\n        const lowerParamName = paramName.toLowerCase()\n        if (lowerParamName === 'content-type' && deSerializedValue === 'multipart/form-data') {\n          break\n        }\n\n        /** Headers only support simple style according to OpenAPI 3.1.1 */\n        const serialized = serializeSimpleStyle(deSerializedValue, getExplode(param, false))\n\n        // Remove undefined/null headers\n        if (!isDefined(serialized)) {\n          break\n        }\n\n        /** Headers can only be strings so we can cast numbers etc */\n        const serializedString = String(serialized)\n\n        // If the header already exists, append with comma\n        if (result.headers[paramName]) {\n          result.headers[paramName] = `${result.headers[paramName]},${serializedString}`\n        } else {\n          result.headers[paramName] = serializedString\n        }\n        break\n      }\n\n      case 'path': {\n        // Path parameters use simple style by default\n        const serialized = serializeSimpleStyle(deSerializedValue, getExplode(param, false))\n        result.pathVariables[paramName] = encodeURIComponent(String(serialized))\n        break\n      }\n\n      case 'query': {\n        processQueryParameter(\n          param,\n          paramName,\n          deSerializedValue,\n          result.urlParams,\n          result.allowReservedQueryParameters,\n        )\n        break\n      }\n\n      case 'cookie': {\n        processCookieParameter(paramName, deSerializedValue, getExplode(param, true), result.cookies)\n        break\n      }\n    }\n  }\n\n  return result\n}\n\n/** Ensure we only apply the correcet style to the correct types */\nconst getStyle = (param: ParameterObject, replacedValue: unknown): string => {\n  if (!('style' in param) || !param.style) {\n    return 'form'\n  }\n\n  // DeepObject can only apply to objects\n  if (param.style === 'deepObject') {\n    if (isObject(replacedValue)) {\n      return 'deepObject'\n    }\n    return 'form'\n  }\n\n  return param.style\n}\n\n/** Whether the parameter allows reserved characters (from param or schema). */\nconst isAllowReserved = (param: ParameterObject): boolean => {\n  if ('allowReserved' in param && param.allowReserved !== undefined) {\n    return param.allowReserved\n  }\n  if ('schema' in param && param.schema && typeof param.schema === 'object' && 'allowReserved' in param.schema) {\n    return (param.schema as { allowReserved?: boolean }).allowReserved === true\n  }\n  return false\n}\n\n/** When allowReserved is true, add keys to the set so reserved chars stay unescaped in the URL. */\nconst trackReservedKeys = (\n  allowReservedQueryParameters: Set<string>,\n  allowReserved: boolean,\n  ...keys: string[]\n): void => {\n  if (allowReserved) {\n    for (const key of keys) {\n      allowReservedQueryParameters.add(key)\n    }\n  }\n}\n\n/**\n * Helper function to process query parameters.\n * Extracted to reduce complexity in main function.\n */\nconst processQueryParameter = (\n  param: ParameterObject,\n  paramName: string,\n  replacedValue: unknown,\n  urlParams: URLSearchParams,\n  allowReservedQueryParameters: Set<string>,\n): void => {\n  /** If the parameter should be exploded, defaults to true for form style */\n  const explodeParam = 'explode' in param && param.explode !== undefined ? param.explode : true\n  const allowReserved = isAllowReserved(param)\n\n  /** Style of the parameter, defaults to form */\n  const style = getStyle(param, replacedValue)\n\n  // Content type parameters should be serialized according to the parameter's own content type\n  if ('content' in param && param.content) {\n    // We grab the first for now but eventually we should support selecting the content type per parameter\n    const paramContentType = Object.keys(param.content)[0] ?? 'application/json'\n    const serializedValue = serializeContentValue(replacedValue, paramContentType)\n    urlParams.set(paramName, serializedValue)\n    trackReservedKeys(allowReservedQueryParameters, allowReserved, paramName)\n    return\n  }\n\n  // Handle deepObject style\n  if (style === 'deepObject' && explodeParam) {\n    const entries = serializeDeepObjectStyle(paramName, replacedValue)\n    for (const entry of entries) {\n      urlParams.append(entry.key, entry.value)\n      trackReservedKeys(allowReservedQueryParameters, allowReserved, entry.key)\n    }\n    return\n  }\n\n  // Handle spaceDelimited style\n  if (style === 'spaceDelimited') {\n    const serialized = serializeSpaceDelimitedStyle(replacedValue)\n    const existingValue = urlParams.get(paramName)\n    urlParams.set(paramName, existingValue ? `${existingValue} ${serialized}` : serialized)\n    trackReservedKeys(allowReservedQueryParameters, allowReserved, paramName)\n    return\n  }\n\n  // Handle pipeDelimited style\n  if (style === 'pipeDelimited') {\n    const serialized = serializePipeDelimitedStyle(replacedValue)\n    const existingValue = urlParams.get(paramName)\n    urlParams.set(paramName, existingValue ? `${existingValue}|${serialized}` : serialized)\n    trackReservedKeys(allowReservedQueryParameters, allowReserved, paramName)\n    return\n  }\n\n  // Handle form style (default)\n  const serialized = serializeFormStyle(replacedValue, explodeParam)\n\n  // If serialized is an array of key-value pairs (exploded object or array)\n  if (Array.isArray(serialized)) {\n    for (const entry of serialized) {\n      // If key is empty, use paramName (for arrays)\n      const key = entry.key || paramName\n      urlParams.append(key, String(entry.value))\n      trackReservedKeys(allowReservedQueryParameters, allowReserved, key)\n    }\n  } else {\n    // Otherwise, convert to string for URLSearchParams\n    urlParams.append(paramName, String(serialized))\n    trackReservedKeys(allowReservedQueryParameters, allowReserved, paramName)\n  }\n}\n\n/**\n * Helper function to process cookie parameters.\n * Extracted to reduce complexity in main function.\n */\nconst processCookieParameter = (\n  paramName: string,\n  replacedValue: unknown,\n  explode: boolean,\n  cookies: XScalarCookie[],\n): void => {\n  // Cookies only support form style according to OpenAPI 3.1.1\n  const serialized = serializeFormStyleForCookies(replacedValue, explode)\n\n  // If serialized is an array of key-value pairs (exploded object or array)\n  if (Array.isArray(serialized)) {\n    for (const entry of serialized) {\n      const key = entry.key || paramName\n      cookies.push(\n        coerceValue(xScalarCookieSchema, {\n          name: key,\n          value: String(entry.value),\n          path: '/',\n        }),\n      )\n    }\n  } else {\n    // Otherwise, convert to string for cookie value\n    cookies.push(\n      coerceValue(xScalarCookieSchema, {\n        name: paramName,\n        value: String(serialized),\n        path: '/',\n      }),\n    )\n  }\n}\n"],"mappings":";;;;;;;;;;;;AA0BA,IAAM,cAAc,OAAwB,iBAC1C,aAAa,SAAS,MAAM,YAAY,KAAA,IAAY,MAAM,UAAU;;;;;;;;;;;;AAatE,IAAa,0BAEX,aAA+C,EAAE,EAEjD,MAA8B,EAAE,EAEhC,aAAqB,cAOlB;CACH,MAAM,SAAS;EACb,SAAS,EAAE;EACX,SAAS,EAAE;EACX,eAAe,EAAE;EACjB,8CAA8B,IAAI,KAAa;EAC/C,WAAW,IAAI,iBAAiB;EACjC;AAGD,KAAI,WAAW,WAAW,EACxB,QAAO;AAIT,MAAK,MAAM,mBAAmB,YAAY;EACxC,MAAM,QAAQ,eAAe,gBAAgB;EAC7C,MAAM,UAAU,WAAW,OAAO,YAAY,KAAA,EAAU;AAGxD,MAAI,CAAC,WAAW,gBAAgB,OAAO,QAAQ,CAC7C;;EAOF,MAAM,oBAAoB,qBAHD,OAAO,QAAQ,UAAU,WAAW,oBAAoB,QAAQ,OAAO,IAAI,GAAG,QAAQ,OAG9C,MAAM;EACvE,MAAM,YAAY,oBAAoB,MAAM,MAAM,IAAI;AAGtD,UAAQ,MAAM,IAAd;GACE,KAAK,UAAU;AAIb,QADuB,UAAU,aAAa,KACvB,kBAAkB,sBAAsB,sBAC7D;;IAIF,MAAM,aAAa,qBAAqB,mBAAmB,WAAW,OAAO,MAAM,CAAC;AAGpF,QAAI,CAAC,UAAU,WAAW,CACxB;;IAIF,MAAM,mBAAmB,OAAO,WAAW;AAG3C,QAAI,OAAO,QAAQ,WACjB,QAAO,QAAQ,aAAa,GAAG,OAAO,QAAQ,WAAW,GAAG;QAE5D,QAAO,QAAQ,aAAa;AAE9B;;GAGF,KAAK,QAAQ;IAEX,MAAM,aAAa,qBAAqB,mBAAmB,WAAW,OAAO,MAAM,CAAC;AACpF,WAAO,cAAc,aAAa,mBAAmB,OAAO,WAAW,CAAC;AACxE;;GAGF,KAAK;AACH,0BACE,OACA,WACA,mBACA,OAAO,WACP,OAAO,6BACR;AACD;GAGF,KAAK;AACH,2BAAuB,WAAW,mBAAmB,WAAW,OAAO,KAAK,EAAE,OAAO,QAAQ;AAC7F;;;AAKN,QAAO;;;AAIT,IAAM,YAAY,OAAwB,kBAAmC;AAC3E,KAAI,EAAE,WAAW,UAAU,CAAC,MAAM,MAChC,QAAO;AAIT,KAAI,MAAM,UAAU,cAAc;AAChC,MAAI,SAAS,cAAc,CACzB,QAAO;AAET,SAAO;;AAGT,QAAO,MAAM;;;AAIf,IAAM,mBAAmB,UAAoC;AAC3D,KAAI,mBAAmB,SAAS,MAAM,kBAAkB,KAAA,EACtD,QAAO,MAAM;AAEf,KAAI,YAAY,SAAS,MAAM,UAAU,OAAO,MAAM,WAAW,YAAY,mBAAmB,MAAM,OACpG,QAAQ,MAAM,OAAuC,kBAAkB;AAEzE,QAAO;;;AAIT,IAAM,qBACJ,8BACA,eACA,GAAG,SACM;AACT,KAAI,cACF,MAAK,MAAM,OAAO,KAChB,8BAA6B,IAAI,IAAI;;;;;;AAS3C,IAAM,yBACJ,OACA,WACA,eACA,WACA,iCACS;;CAET,MAAM,eAAe,aAAa,SAAS,MAAM,YAAY,KAAA,IAAY,MAAM,UAAU;CACzF,MAAM,gBAAgB,gBAAgB,MAAM;;CAG5C,MAAM,QAAQ,SAAS,OAAO,cAAc;AAG5C,KAAI,aAAa,SAAS,MAAM,SAAS;EAGvC,MAAM,kBAAkB,sBAAsB,eADrB,OAAO,KAAK,MAAM,QAAQ,CAAC,MAAM,mBACoB;AAC9E,YAAU,IAAI,WAAW,gBAAgB;AACzC,oBAAkB,8BAA8B,eAAe,UAAU;AACzE;;AAIF,KAAI,UAAU,gBAAgB,cAAc;EAC1C,MAAM,UAAU,yBAAyB,WAAW,cAAc;AAClE,OAAK,MAAM,SAAS,SAAS;AAC3B,aAAU,OAAO,MAAM,KAAK,MAAM,MAAM;AACxC,qBAAkB,8BAA8B,eAAe,MAAM,IAAI;;AAE3E;;AAIF,KAAI,UAAU,kBAAkB;EAC9B,MAAM,aAAa,6BAA6B,cAAc;EAC9D,MAAM,gBAAgB,UAAU,IAAI,UAAU;AAC9C,YAAU,IAAI,WAAW,gBAAgB,GAAG,cAAc,GAAG,eAAe,WAAW;AACvF,oBAAkB,8BAA8B,eAAe,UAAU;AACzE;;AAIF,KAAI,UAAU,iBAAiB;EAC7B,MAAM,aAAa,4BAA4B,cAAc;EAC7D,MAAM,gBAAgB,UAAU,IAAI,UAAU;AAC9C,YAAU,IAAI,WAAW,gBAAgB,GAAG,cAAc,GAAG,eAAe,WAAW;AACvF,oBAAkB,8BAA8B,eAAe,UAAU;AACzE;;CAIF,MAAM,aAAa,mBAAmB,eAAe,aAAa;AAGlE,KAAI,MAAM,QAAQ,WAAW,CAC3B,MAAK,MAAM,SAAS,YAAY;EAE9B,MAAM,MAAM,MAAM,OAAO;AACzB,YAAU,OAAO,KAAK,OAAO,MAAM,MAAM,CAAC;AAC1C,oBAAkB,8BAA8B,eAAe,IAAI;;MAEhE;AAEL,YAAU,OAAO,WAAW,OAAO,WAAW,CAAC;AAC/C,oBAAkB,8BAA8B,eAAe,UAAU;;;;;;;AAQ7E,IAAM,0BACJ,WACA,eACA,SACA,YACS;CAET,MAAM,aAAa,6BAA6B,eAAe,QAAQ;AAGvE,KAAI,MAAM,QAAQ,WAAW,CAC3B,MAAK,MAAM,SAAS,YAAY;EAC9B,MAAM,MAAM,MAAM,OAAO;AACzB,UAAQ,KACN,YAAY,qBAAqB;GAC/B,MAAM;GACN,OAAO,OAAO,MAAM,MAAM;GAC1B,MAAM;GACP,CAAC,CACH;;KAIH,SAAQ,KACN,YAAY,qBAAqB;EAC/B,MAAM;EACN,OAAO,OAAO,WAAW;EACzB,MAAM;EACP,CAAC,CACH"}

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

@@ -1,7 +1,7 @@
 import { type XScalarCookie } from '@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies';
 import type { SecurityRequirementObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
-import type { MergedSecuritySchemes } from '@/v2/blocks/scalar-auth-selector-block/helpers/merge-security';
-import type { SecuritySchemeObjectSecret } from '@/v2/blocks/scalar-auth-selector-block/helpers/secret-types';
+import type { MergedSecuritySchemes } from '../../../../v2/blocks/scalar-auth-selector-block/helpers/merge-security.js';
+import type { SecuritySchemeObjectSecret } from '../../../../v2/blocks/scalar-auth-selector-block/helpers/secret-types';
 /**
  * Get the selected security schemes from security requirements.
  * Takes security requirement objects and resolves them to actual security scheme objects.

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

@@ -0,0 +1,53 @@
+import { encode } from "js-base64";
+import { isDefined } from "@scalar/helpers/array/is-defined";
+import { objectKeys } from "@scalar/helpers/object/object-keys";
+import { replaceEnvVariables } from "@scalar/helpers/regex/replace-variables";
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { xScalarCookieSchema } from "@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies";
+import { coerceValue } from "@scalar/workspace-store/schemas/typebox-coerce";
+//#region src/v2/blocks/operation-block/helpers/build-request-security.ts
+/**
+* Get the selected security schemes from security requirements.
+* Takes security requirement objects and resolves them to actual security scheme objects.
+*/
+var getSecuritySchemes = (securitySchemes, selectedSecurity) => selectedSecurity.flatMap((scheme) => objectKeys(scheme).flatMap((key) => {
+	const scheme = getResolvedRef(securitySchemes?.[key]);
+	if (scheme) return scheme;
+	return [];
+})) ?? [];
+/**
+* Generates the headers, cookies and query params for selected security schemes
+* In the future we can add customization for where the security is applied
+*/
+var buildRequestSecurity = (selectedSecuritySchemes, env = {}, emptyTokenPlaceholder = "") => {
+	const headers = {};
+	const cookies = [];
+	const urlParams = new URLSearchParams();
+	selectedSecuritySchemes.forEach((scheme) => {
+		if (scheme.type === "apiKey") {
+			const name = replaceEnvVariables(scheme.name, env);
+			const value = replaceEnvVariables(scheme["x-scalar-secret-token"], env) || emptyTokenPlaceholder;
+			if (scheme.in === "header") headers[name] = value;
+			if (scheme.in === "query") urlParams.append(name, value);
+			if (scheme.in === "cookie") cookies.push(coerceValue(xScalarCookieSchema, {
+				name,
+				value,
+				path: "/"
+			}));
+		}
+		if (scheme.type === "http") if (scheme.scheme === "basic") {
+			const value = `${replaceEnvVariables(scheme["x-scalar-secret-username"], env)}:${replaceEnvVariables(scheme["x-scalar-secret-password"], env)}`;
+			headers["Authorization"] = `Basic ${value === ":" ? "username:password" : encode(value)}`;
+		} else headers["Authorization"] = `Bearer ${replaceEnvVariables(scheme["x-scalar-secret-token"], env) || emptyTokenPlaceholder}`;
+		if (scheme.type === "oauth2") headers["Authorization"] = `Bearer ${replaceEnvVariables(Object.values(scheme?.flows ?? {}).filter(isDefined).find((f) => f["x-scalar-secret-token"])?.["x-scalar-secret-token"] ?? "", env) || emptyTokenPlaceholder}`;
+	});
+	return {
+		headers,
+		cookies,
+		urlParams
+	};
+};
+//#endregion
+export { buildRequestSecurity, getSecuritySchemes };
+
+//# sourceMappingURL=build-request-security.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-request-security.js","names":[],"sources":["../../../../../src/v2/blocks/operation-block/helpers/build-request-security.ts"],"sourcesContent":["import { isDefined } from '@scalar/helpers/array/is-defined'\nimport { objectKeys } from '@scalar/helpers/object/object-keys'\nimport { replaceEnvVariables } from '@scalar/helpers/regex/replace-variables'\nimport { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport {\n  type XScalarCookie,\n  xScalarCookieSchema,\n} from '@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies'\nimport { coerceValue } from '@scalar/workspace-store/schemas/typebox-coerce'\nimport type { SecurityRequirementObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\nimport { encode } from 'js-base64'\n\nimport type { MergedSecuritySchemes } from '@/v2/blocks/scalar-auth-selector-block/helpers/merge-security'\nimport type { SecuritySchemeObjectSecret } from '@/v2/blocks/scalar-auth-selector-block/helpers/secret-types'\n\n/**\n * Get the selected security schemes from security requirements.\n * Takes security requirement objects and resolves them to actual security scheme objects.\n */\nexport const getSecuritySchemes = (\n  securitySchemes: MergedSecuritySchemes,\n  selectedSecurity: SecurityRequirementObject[],\n): SecuritySchemeObjectSecret[] =>\n  selectedSecurity.flatMap((scheme) =>\n    objectKeys(scheme).flatMap((key) => {\n      const scheme = getResolvedRef(securitySchemes?.[key])\n      if (scheme) {\n        return scheme\n      }\n\n      return []\n    }),\n  ) ?? []\n\n/**\n * Generates the headers, cookies and query params for selected security schemes\n * In the future we can add customization for where the security is applied\n */\nexport const buildRequestSecurity = (\n  /** Currently selected security for the current operation */\n  selectedSecuritySchemes: SecuritySchemeObjectSecret[],\n  /** Environment variables flattened into a key-value object */\n  env: Record<string, string> = {},\n  /** Include this parameter to set the placeholder for empty tokens */\n  emptyTokenPlaceholder = '',\n): { headers: Record<string, string>; cookies: XScalarCookie[]; urlParams: URLSearchParams } => {\n  const headers: Record<string, string> = {}\n  const cookies: XScalarCookie[] = []\n  const urlParams = new URLSearchParams()\n\n  selectedSecuritySchemes.forEach((scheme) => {\n    // Api key\n    if (scheme.type === 'apiKey') {\n      const name = replaceEnvVariables(scheme.name, env)\n      const value = replaceEnvVariables(scheme['x-scalar-secret-token'], env) || emptyTokenPlaceholder\n\n      if (scheme.in === 'header') {\n        headers[name] = value\n      }\n      if (scheme.in === 'query') {\n        urlParams.append(name, value)\n      }\n      if (scheme.in === 'cookie') {\n        cookies.push(\n          coerceValue(xScalarCookieSchema, {\n            name,\n            value,\n            path: '/',\n          }),\n        )\n      }\n    }\n\n    // HTTP\n    if (scheme.type === 'http') {\n      if (scheme.scheme === 'basic') {\n        const username = replaceEnvVariables(scheme['x-scalar-secret-username'], env)\n        const password = replaceEnvVariables(scheme['x-scalar-secret-password'], env)\n        const value = `${username}:${password}`\n\n        headers['Authorization'] = `Basic ${value === ':' ? 'username:password' : encode(value)}`\n      } else {\n        const value = replaceEnvVariables(scheme['x-scalar-secret-token'], env)\n        headers['Authorization'] = `Bearer ${value || emptyTokenPlaceholder}`\n      }\n    }\n\n    // OAuth2\n    if (scheme.type === 'oauth2') {\n      const flows = Object.values(scheme?.flows ?? {})\n      const token = replaceEnvVariables(\n        flows.filter(isDefined).find((f) => f['x-scalar-secret-token'])?.['x-scalar-secret-token'] ?? '',\n        env,\n      )\n\n      headers['Authorization'] = `Bearer ${token || emptyTokenPlaceholder}`\n    }\n  })\n\n  return { headers, cookies, urlParams }\n}\n"],"mappings":";;;;;;;;;;;;AAmBA,IAAa,sBACX,iBACA,qBAEA,iBAAiB,SAAS,WACxB,WAAW,OAAO,CAAC,SAAS,QAAQ;CAClC,MAAM,SAAS,eAAe,kBAAkB,KAAK;AACrD,KAAI,OACF,QAAO;AAGT,QAAO,EAAE;EACT,CACH,IAAI,EAAE;;;;;AAMT,IAAa,wBAEX,yBAEA,MAA8B,EAAE,EAEhC,wBAAwB,OACsE;CAC9F,MAAM,UAAkC,EAAE;CAC1C,MAAM,UAA2B,EAAE;CACnC,MAAM,YAAY,IAAI,iBAAiB;AAEvC,yBAAwB,SAAS,WAAW;AAE1C,MAAI,OAAO,SAAS,UAAU;GAC5B,MAAM,OAAO,oBAAoB,OAAO,MAAM,IAAI;GAClD,MAAM,QAAQ,oBAAoB,OAAO,0BAA0B,IAAI,IAAI;AAE3E,OAAI,OAAO,OAAO,SAChB,SAAQ,QAAQ;AAElB,OAAI,OAAO,OAAO,QAChB,WAAU,OAAO,MAAM,MAAM;AAE/B,OAAI,OAAO,OAAO,SAChB,SAAQ,KACN,YAAY,qBAAqB;IAC/B;IACA;IACA,MAAM;IACP,CAAC,CACH;;AAKL,MAAI,OAAO,SAAS,OAClB,KAAI,OAAO,WAAW,SAAS;GAG7B,MAAM,QAAQ,GAFG,oBAAoB,OAAO,6BAA6B,IAAI,CAEnD,GADT,oBAAoB,OAAO,6BAA6B,IAAI;AAG7E,WAAQ,mBAAmB,SAAS,UAAU,MAAM,sBAAsB,OAAO,MAAM;QAGvF,SAAQ,mBAAmB,UADb,oBAAoB,OAAO,0BAA0B,IAAI,IACzB;AAKlD,MAAI,OAAO,SAAS,SAOlB,SAAQ,mBAAmB,UALb,oBADA,OAAO,OAAO,QAAQ,SAAS,EAAE,CAAC,CAExC,OAAO,UAAU,CAAC,MAAM,MAAM,EAAE,yBAAyB,GAAG,4BAA4B,IAC9F,IACD,IAE6C;GAEhD;AAEF,QAAO;EAAE;EAAS;EAAS;EAAW"}

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

@@ -3,8 +3,8 @@ import type { XScalarEnvironment } from '@scalar/workspace-store/schemas/extensi
 import type { XScalarCookie } from '@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies';
 import type { ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
 import type { OperationObject } from '@scalar/workspace-store/schemas/v3.1/strict/operation';
-import { type ErrorResponse } from '@/libs/errors';
-import type { SecuritySchemeObjectSecret } from '@/v2/blocks/scalar-auth-selector-block/helpers/secret-types';
+import { type ErrorResponse } from '../../../../libs/errors.js';
+import type { SecuritySchemeObjectSecret } from '../../../../v2/blocks/scalar-auth-selector-block/helpers/secret-types';
 /**
  * Builds a fully configured Request object ready for execution.
  *

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

@@ -0,0 +1,102 @@
+import { ERRORS, normalizeError } from "../../../../libs/errors.js";
+import { isElectron } from "../../../../libs/electron.js";
+import { buildRequestSecurity } from "./build-request-security.js";
+import { getEnvironmentVariables } from "./get-environment-variables.js";
+import { getResolvedUrl } from "./get-resolved-url.js";
+import { getDefaultHeaders } from "../../request-block/helpers/get-default-headers.js";
+import { buildRequestBody } from "./build-request-body.js";
+import { buildRequestCookieHeader } from "./build-request-cookie-header.js";
+import { buildRequestParameters } from "./build-request-parameters.js";
+import { redirectToProxy, shouldUseProxy } from "@scalar/helpers/url/redirect-to-proxy";
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { canMethodHaveBody } from "@scalar/helpers/http/can-method-have-body";
+//#region src/v2/blocks/operation-block/helpers/build-request.ts
+/**
+* Builds a fully configured Request object ready for execution.
+*
+* This function processes an OpenAPI operation and constructs a fetch-compatible
+* Request by resolving environment variables, applying security schemes, building
+* headers and cookies, handling proxy redirection, and preparing the request body.
+*
+* The function handles special cases like Electron environments and proxy usage
+* where custom cookie headers are required.
+*
+* @returns A tuple containing either an error or the request object with an abort controller
+*/
+var buildRequest = ({ environment, exampleKey = "default", globalCookies, method, operation, path, proxyUrl, server, selectedSecuritySchemes }) => {
+	try {
+		const requestBody = getResolvedRef(operation.requestBody);
+		/** Flatten the environment variables array into a key-value object */
+		const env = getEnvironmentVariables(environment);
+		/** Build out the request parameters */
+		const params = buildRequestParameters(operation.parameters ?? [], env, exampleKey);
+		const security = buildRequestSecurity(selectedSecuritySchemes, env);
+		const defaultHeaders = getDefaultHeaders({
+			method,
+			operation,
+			exampleKey,
+			hideDisabledHeaders: true
+		}).filter((header) => !header.isOverridden).reduce((acc, header) => {
+			acc[header.name] = header.defaultValue;
+			return acc;
+		}, {});
+		const headers = new Headers({
+			...defaultHeaders,
+			...params.headers,
+			...security.headers
+		});
+		const urlParams = new URLSearchParams([...params.urlParams, ...security.urlParams]);
+		const body = canMethodHaveBody(method) ? buildRequestBody(requestBody, env, exampleKey) : null;
+		if (body && (body instanceof FormData || body instanceof URLSearchParams)) headers.delete("Content-Type");
+		/** Combine the server url, path and url params into a single url */
+		const url = getResolvedUrl({
+			environment,
+			server,
+			path,
+			pathVariables: params.pathVariables,
+			allowReservedQueryParameters: params.allowReservedQueryParameters,
+			urlParams
+		});
+		if (!url) throw ERRORS.URL_EMPTY;
+		const isUsingProxy = shouldUseProxy(proxyUrl, url);
+		const proxiedUrl = redirectToProxy(proxyUrl, url);
+		const userAgentHeader = headers.get("User-Agent");
+		if (isElectron() && userAgentHeader) headers.set("X-Scalar-User-Agent", userAgentHeader);
+		/** Build out the cookies header */
+		const cookiesHeader = buildRequestCookieHeader({
+			paramCookies: [...params.cookies, ...security.cookies],
+			globalCookies,
+			env,
+			originalCookieHeader: headers.get("Cookie"),
+			url,
+			useCustomCookieHeader: isElectron() || isUsingProxy,
+			disabledGlobalCookies: operation["x-scalar-disable-parameters"]?.["global-cookies"]?.[exampleKey] ?? {}
+		});
+		if (cookiesHeader) headers.set(cookiesHeader.name, cookiesHeader.value);
+		/** Controller to allow aborting the request */
+		const controller = new AbortController();
+		const isSseAcceptHeader = headers.get("Accept")?.toLowerCase().includes("text/event-stream") ?? false;
+		const requestCacheMode = isSseAcceptHeader ? "no-store" : "default";
+		if (isSseAcceptHeader) {
+			headers.set("Cache-Control", "no-cache");
+			headers.set("Pragma", "no-cache");
+		}
+		return [null, {
+			controller,
+			isUsingProxy,
+			request: new Request(proxiedUrl, {
+				method: method.toUpperCase(),
+				headers,
+				signal: controller.signal,
+				body,
+				cache: requestCacheMode
+			})
+		}];
+	} catch (error) {
+		return [normalizeError(error, ERRORS.BUILDING_REQUEST_FAILED), null];
+	}
+};
+//#endregion
+export { buildRequest };
+
+//# sourceMappingURL=build-request.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-request.js","names":[],"sources":["../../../../../src/v2/blocks/operation-block/helpers/build-request.ts"],"sourcesContent":["import { canMethodHaveBody } from '@scalar/helpers/http/can-method-have-body'\nimport type { HttpMethod } from '@scalar/helpers/http/http-methods'\nimport { redirectToProxy, shouldUseProxy } from '@scalar/helpers/url/redirect-to-proxy'\nimport { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport type { XScalarEnvironment } from '@scalar/workspace-store/schemas/extensions/document/x-scalar-environments'\nimport type { XScalarCookie } from '@scalar/workspace-store/schemas/extensions/general/x-scalar-cookies'\nimport type { ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\nimport type { OperationObject } from '@scalar/workspace-store/schemas/v3.1/strict/operation'\n\nimport { isElectron } from '@/libs/electron'\nimport { ERRORS, type ErrorResponse, normalizeError } from '@/libs/errors'\nimport { getEnvironmentVariables } from '@/v2/blocks/operation-block/helpers/get-environment-variables'\nimport { getResolvedUrl } from '@/v2/blocks/operation-block/helpers/get-resolved-url'\nimport { getDefaultHeaders } from '@/v2/blocks/request-block/helpers/get-default-headers'\nimport type { SecuritySchemeObjectSecret } from '@/v2/blocks/scalar-auth-selector-block/helpers/secret-types'\n\nimport { buildRequestBody } from './build-request-body'\nimport { buildRequestCookieHeader } from './build-request-cookie-header'\nimport { buildRequestParameters } from './build-request-parameters'\nimport { buildRequestSecurity } from './build-request-security'\n\n/**\n * Builds a fully configured Request object ready for execution.\n *\n * This function processes an OpenAPI operation and constructs a fetch-compatible\n * Request by resolving environment variables, applying security schemes, building\n * headers and cookies, handling proxy redirection, and preparing the request body.\n *\n * The function handles special cases like Electron environments and proxy usage\n * where custom cookie headers are required.\n *\n * @returns A tuple containing either an error or the request object with an abort controller\n */\nexport const buildRequest = ({\n  environment,\n  exampleKey = 'default',\n  globalCookies,\n  method,\n  operation,\n  path,\n  proxyUrl,\n  server,\n  selectedSecuritySchemes,\n}: {\n  /** For environment variables in the inputs */\n  environment: XScalarEnvironment\n  /** The key of the current example */\n  exampleKey: string\n  /** Workspace + document cookies */\n  globalCookies: XScalarCookie[]\n  /** The HTTP method of the operation */\n  method: HttpMethod\n  /** The operation object */\n  operation: OperationObject\n  /** The path of the operation */\n  path: string\n  /** The proxy URL for cookie domain determination */\n  proxyUrl: string\n  /** The server object */\n  server: ServerObject | null\n  /** The selected security schemes for the current operation */\n  selectedSecuritySchemes: SecuritySchemeObjectSecret[]\n}): ErrorResponse<{\n  controller: AbortController\n  request: Request\n  isUsingProxy: boolean\n}> => {\n  try {\n    const requestBody = getResolvedRef(operation.requestBody)\n\n    /** Flatten the environment variables array into a key-value object */\n    const env = getEnvironmentVariables(environment)\n    /** Build out the request parameters */\n    const params = buildRequestParameters(operation.parameters ?? [], env, exampleKey)\n    const security = buildRequestSecurity(selectedSecuritySchemes, env)\n\n    // Combine the headers, cookies and url params\n    const defaultHeaders = getDefaultHeaders({ method, operation, exampleKey, hideDisabledHeaders: true })\n      .filter((header) => !header.isOverridden)\n      .reduce(\n        (acc, header) => {\n          acc[header.name] = header.defaultValue\n          return acc\n        },\n        {} as Record<string, string>,\n      )\n    const headers = new Headers({ ...defaultHeaders, ...params.headers, ...security.headers })\n    const urlParams = new URLSearchParams([...params.urlParams, ...security.urlParams])\n\n    // If the method can have a body, build the request body, otherwise set it to null\n    const body = canMethodHaveBody(method) ? buildRequestBody(requestBody, env, exampleKey) : null\n\n    if (body && (body instanceof FormData || body instanceof URLSearchParams)) {\n      // Delete the Content-Type header so the browser will set it automatically based on the request body\n      headers.delete('Content-Type')\n    }\n\n    /** Combine the server url, path and url params into a single url */\n    const url = getResolvedUrl({\n      environment,\n      server,\n      path,\n      pathVariables: params.pathVariables,\n      allowReservedQueryParameters: params.allowReservedQueryParameters,\n      urlParams,\n    })\n\n    // Throw for no server or path\n    if (!url) {\n      throw ERRORS.URL_EMPTY\n    }\n\n    const isUsingProxy = shouldUseProxy(proxyUrl, url)\n    const proxiedUrl = redirectToProxy(proxyUrl, url)\n\n    // If we are running in Electron, we need to add a custom header\n    // that's then forwarded as a `User-Agent` header.\n    const userAgentHeader = headers.get('User-Agent')\n    if (isElectron() && userAgentHeader) {\n      headers.set('X-Scalar-User-Agent', userAgentHeader)\n    }\n\n    /** Build out the cookies header */\n    const cookiesHeader = buildRequestCookieHeader({\n      paramCookies: [...params.cookies, ...security.cookies],\n      globalCookies,\n      env,\n      originalCookieHeader: headers.get('Cookie'),\n      url,\n      useCustomCookieHeader: isElectron() || isUsingProxy,\n      disabledGlobalCookies: operation['x-scalar-disable-parameters']?.['global-cookies']?.[exampleKey] ?? {},\n    })\n\n    if (cookiesHeader) {\n      headers.set(cookiesHeader.name, cookiesHeader.value)\n    }\n\n    /** Controller to allow aborting the request */\n    const controller = new AbortController()\n    const acceptHeader = headers.get('Accept')\n    const isSseAcceptHeader = acceptHeader?.toLowerCase().includes('text/event-stream') ?? false\n    const requestCacheMode: RequestCache = isSseAcceptHeader ? 'no-store' : 'default'\n\n    if (isSseAcceptHeader) {\n      headers.set('Cache-Control', 'no-cache')\n      headers.set('Pragma', 'no-cache')\n    }\n\n    /** Build the js request object */\n    const request = new Request(proxiedUrl, {\n      /**\n       * Ensure that all methods are uppercased (though only needed for patch)\n       *\n       * @see https://github.com/whatwg/fetch/issues/50\n       */\n      method: method.toUpperCase(),\n      headers,\n      signal: controller.signal,\n      body,\n      cache: requestCacheMode,\n    })\n\n    return [\n      null,\n      {\n        controller,\n        isUsingProxy,\n        request,\n      },\n    ]\n  } catch (error) {\n    return [normalizeError(error, ERRORS.BUILDING_REQUEST_FAILED), null]\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAa,gBAAgB,EAC3B,aACA,aAAa,WACb,eACA,QACA,WACA,MACA,UACA,QACA,8BAwBI;AACJ,KAAI;EACF,MAAM,cAAc,eAAe,UAAU,YAAY;;EAGzD,MAAM,MAAM,wBAAwB,YAAY;;EAEhD,MAAM,SAAS,uBAAuB,UAAU,cAAc,EAAE,EAAE,KAAK,WAAW;EAClF,MAAM,WAAW,qBAAqB,yBAAyB,IAAI;EAGnE,MAAM,iBAAiB,kBAAkB;GAAE;GAAQ;GAAW;GAAY,qBAAqB;GAAM,CAAC,CACnG,QAAQ,WAAW,CAAC,OAAO,aAAa,CACxC,QACE,KAAK,WAAW;AACf,OAAI,OAAO,QAAQ,OAAO;AAC1B,UAAO;KAET,EAAE,CACH;EACH,MAAM,UAAU,IAAI,QAAQ;GAAE,GAAG;GAAgB,GAAG,OAAO;GAAS,GAAG,SAAS;GAAS,CAAC;EAC1F,MAAM,YAAY,IAAI,gBAAgB,CAAC,GAAG,OAAO,WAAW,GAAG,SAAS,UAAU,CAAC;EAGnF,MAAM,OAAO,kBAAkB,OAAO,GAAG,iBAAiB,aAAa,KAAK,WAAW,GAAG;AAE1F,MAAI,SAAS,gBAAgB,YAAY,gBAAgB,iBAEvD,SAAQ,OAAO,eAAe;;EAIhC,MAAM,MAAM,eAAe;GACzB;GACA;GACA;GACA,eAAe,OAAO;GACtB,8BAA8B,OAAO;GACrC;GACD,CAAC;AAGF,MAAI,CAAC,IACH,OAAM,OAAO;EAGf,MAAM,eAAe,eAAe,UAAU,IAAI;EAClD,MAAM,aAAa,gBAAgB,UAAU,IAAI;EAIjD,MAAM,kBAAkB,QAAQ,IAAI,aAAa;AACjD,MAAI,YAAY,IAAI,gBAClB,SAAQ,IAAI,uBAAuB,gBAAgB;;EAIrD,MAAM,gBAAgB,yBAAyB;GAC7C,cAAc,CAAC,GAAG,OAAO,SAAS,GAAG,SAAS,QAAQ;GACtD;GACA;GACA,sBAAsB,QAAQ,IAAI,SAAS;GAC3C;GACA,uBAAuB,YAAY,IAAI;GACvC,uBAAuB,UAAU,iCAAiC,oBAAoB,eAAe,EAAE;GACxG,CAAC;AAEF,MAAI,cACF,SAAQ,IAAI,cAAc,MAAM,cAAc,MAAM;;EAItD,MAAM,aAAa,IAAI,iBAAiB;EAExC,MAAM,oBADe,QAAQ,IAAI,SAAS,EACF,aAAa,CAAC,SAAS,oBAAoB,IAAI;EACvF,MAAM,mBAAiC,oBAAoB,aAAa;AAExE,MAAI,mBAAmB;AACrB,WAAQ,IAAI,iBAAiB,WAAW;AACxC,WAAQ,IAAI,UAAU,WAAW;;AAiBnC,SAAO,CACL,MACA;GACE;GACA;GACA,SAlBY,IAAI,QAAQ,YAAY;IAMtC,QAAQ,OAAO,aAAa;IAC5B;IACA,QAAQ,WAAW;IACnB;IACA,OAAO;IACR,CAAC;GAQC,CACF;UACM,OAAO;AACd,SAAO,CAAC,eAAe,OAAO,OAAO,wBAAwB,EAAE,KAAK"}

package/dist/v2/blocks/operation-block/helpers/de-serialize-parameter.js

@@ -0,0 +1,41 @@
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+//#region src/v2/blocks/operation-block/helpers/de-serialize-parameter.ts
+/** Helper that de-serializes the example value based on the parameter type */
+var deSerializeParameter = (example, param) => {
+	if ("content" in param) return deSerializeContentExample(example, Object.keys(param.content ?? {})[0] ?? "");
+	if ("schema" in param) return deSerializeSchemaExample(example, param.schema);
+	return example;
+};
+/** De-serialize the example value based on the content type */
+var deSerializeContentExample = (example, contentType) => {
+	if (typeof example === "string" && contentType.includes("json")) try {
+		return JSON.parse(example);
+	} catch {}
+	return example;
+};
+/** Create a set of all the types we wish to parse as JSON */
+var parseableTypesSet = new Set([
+	"array",
+	"object",
+	"boolean",
+	"number",
+	"integer",
+	"null"
+]);
+/** De-serialize the example value based on the schema type */
+var deSerializeSchemaExample = (example, schema) => {
+	const resolvedSchema = getResolvedRef(schema);
+	if (typeof example === "string" && resolvedSchema && "type" in resolvedSchema) {
+		const type = Array.isArray(resolvedSchema.type) ? resolvedSchema.type[0] : resolvedSchema.type;
+		if (type && parseableTypesSet.has(type)) try {
+			return JSON.parse(example);
+		} catch {
+			if (type === "array") return example.split(/,\s?/).filter((v) => v !== "");
+		}
+	}
+	return example;
+};
+//#endregion
+export { deSerializeParameter };
+
+//# sourceMappingURL=de-serialize-parameter.js.map

package/dist/v2/blocks/operation-block/helpers/de-serialize-parameter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"de-serialize-parameter.js","names":[],"sources":["../../../../../src/v2/blocks/operation-block/helpers/de-serialize-parameter.ts"],"sourcesContent":["import { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport type {\n  ParameterObject,\n  ParameterWithSchemaObject,\n} from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\n/** Helper that de-serializes the example value based on the parameter type */\nexport const deSerializeParameter = (example: unknown, param: ParameterObject) => {\n  if ('content' in param) {\n    return deSerializeContentExample(example, Object.keys(param.content ?? {})[0] ?? '')\n  }\n  if ('schema' in param) {\n    return deSerializeSchemaExample(example, param.schema)\n  }\n\n  return example\n}\n\n/** De-serialize the example value based on the content type */\nconst deSerializeContentExample = (example: unknown, contentType: string) => {\n  if (typeof example === 'string' && contentType.includes('json')) {\n    try {\n      return JSON.parse(example)\n    } catch {\n      // Ignore the error and return the original example\n    }\n  }\n  return example\n}\n\n/** Create a set of all the types we wish to parse as JSON */\nconst parseableTypesSet = new Set(['array', 'object', 'boolean', 'number', 'integer', 'null'])\n\n/** De-serialize the example value based on the schema type */\nconst deSerializeSchemaExample = (example: unknown, schema: ParameterWithSchemaObject['schema']) => {\n  const resolvedSchema = getResolvedRef(schema)\n\n  if (typeof example === 'string' && resolvedSchema && 'type' in resolvedSchema) {\n    const type = Array.isArray(resolvedSchema.type) ? resolvedSchema.type[0] : resolvedSchema.type\n\n    if (type && parseableTypesSet.has(type)) {\n      try {\n        return JSON.parse(example)\n      } catch {\n        // For array types, fall back to splitting comma-separated values.\n        // Users commonly enter array values as \"foo,bar\" or \"foo, bar\" in the UI\n        // text field, which is not valid JSON. Per the OpenAPI spec, the default\n        // serialization for query array parameters is style=form + explode=true,\n        // meaning each value should be sent as a separate query parameter.\n        if (type === 'array') {\n          return example.split(/,\\s?/).filter((v) => v !== '')\n        }\n        // Ignore the error and return the original example for other types\n      }\n    }\n  }\n\n  return example\n}\n"],"mappings":";;;AAOA,IAAa,wBAAwB,SAAkB,UAA2B;AAChF,KAAI,aAAa,MACf,QAAO,0BAA0B,SAAS,OAAO,KAAK,MAAM,WAAW,EAAE,CAAC,CAAC,MAAM,GAAG;AAEtF,KAAI,YAAY,MACd,QAAO,yBAAyB,SAAS,MAAM,OAAO;AAGxD,QAAO;;;AAIT,IAAM,6BAA6B,SAAkB,gBAAwB;AAC3E,KAAI,OAAO,YAAY,YAAY,YAAY,SAAS,OAAO,CAC7D,KAAI;AACF,SAAO,KAAK,MAAM,QAAQ;SACpB;AAIV,QAAO;;;AAIT,IAAM,oBAAoB,IAAI,IAAI;CAAC;CAAS;CAAU;CAAW;CAAU;CAAW;CAAO,CAAC;;AAG9F,IAAM,4BAA4B,SAAkB,WAAgD;CAClG,MAAM,iBAAiB,eAAe,OAAO;AAE7C,KAAI,OAAO,YAAY,YAAY,kBAAkB,UAAU,gBAAgB;EAC7E,MAAM,OAAO,MAAM,QAAQ,eAAe,KAAK,GAAG,eAAe,KAAK,KAAK,eAAe;AAE1F,MAAI,QAAQ,kBAAkB,IAAI,KAAK,CACrC,KAAI;AACF,UAAO,KAAK,MAAM,QAAQ;UACpB;AAMN,OAAI,SAAS,QACX,QAAO,QAAQ,MAAM,OAAO,CAAC,QAAQ,MAAM,MAAM,GAAG;;;AAO5D,QAAO"}