@scalar/api-client 2.38.4 → 2.39.0

package/dist/v2/blocks/scalar-auth-selector-block/helpers/fetch-openid-connect-discovery.js

@@ -0,0 +1,45 @@
+import { redirectToProxy } from "@scalar/helpers/url/redirect-to-proxy";
+import { coerceValue } from "@scalar/workspace-store/schemas/typebox-coerce";
+import { Type } from "@scalar/typebox";
+//#region src/v2/blocks/scalar-auth-selector-block/helpers/fetch-openid-connect-discovery.ts
+/**
+* OpenID Connect Discovery Document (subset)
+* Represents the metadata fields consumed by the auth selector flow conversion.
+*
+* @see https://openid.net/specs/openid-connect-discovery-1_0.html
+*/
+var OpenIDConnectDiscoverySchema = Type.Object({
+	authorization_endpoint: Type.Optional(Type.String()),
+	token_endpoint: Type.Optional(Type.String()),
+	scopes_supported: Type.Optional(Type.Array(Type.String())),
+	grant_types_supported: Type.Optional(Type.Array(Type.String())),
+	code_challenge_methods_supported: Type.Optional(Type.Array(Type.String()))
+});
+/**
+* Fetches the OpenID Connect discovery document from the specified URL.
+* Supports both full discovery URLs and issuer URLs.
+*
+* @param url - The OpenID Connect discovery URL or issuer URL
+* @returns The discovery document or an error
+*/
+var fetchOpenIDConnectDiscovery = async (url, proxyUrl) => {
+	try {
+		let discoveryUrl = url.trim();
+		if (!discoveryUrl) return [/* @__PURE__ */ new Error("URL cannot be empty"), null];
+		if (discoveryUrl.endsWith("/")) discoveryUrl = discoveryUrl.slice(0, -1);
+		if (!discoveryUrl.includes("/.well-known/openid-configuration")) discoveryUrl = `${discoveryUrl}/.well-known/openid-configuration`;
+		const proxiedUrl = redirectToProxy(proxyUrl, discoveryUrl);
+		const response = await fetch(proxiedUrl);
+		if (!response.ok) return [/* @__PURE__ */ new Error(`Failed to fetch OpenID Connect discovery document: ${response.status} ${response.statusText}`), null];
+		const data = coerceValue(OpenIDConnectDiscoverySchema, await response.json());
+		if (!data.authorization_endpoint && !data.token_endpoint) return [/* @__PURE__ */ new Error("Invalid OpenID Connect discovery document: missing required endpoints"), null];
+		return [null, data];
+	} catch (error) {
+		if (error instanceof Error) return [error, null];
+		return [/* @__PURE__ */ new Error("Failed to fetch OpenID Connect discovery document"), null];
+	}
+};
+//#endregion
+export { fetchOpenIDConnectDiscovery };
+
+//# sourceMappingURL=fetch-openid-connect-discovery.js.map

package/dist/v2/blocks/scalar-auth-selector-block/helpers/fetch-openid-connect-discovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-openid-connect-discovery.js","names":[],"sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/helpers/fetch-openid-connect-discovery.ts"],"sourcesContent":["import { redirectToProxy } from '@scalar/helpers/url/redirect-to-proxy'\nimport { type Static, Type } from '@scalar/typebox'\nimport { coerceValue } from '@scalar/workspace-store/schemas/typebox-coerce'\n\nimport type { ErrorResponse } from '@/libs/errors'\n\n/**\n * OpenID Connect Discovery Document (subset)\n * Represents the metadata fields consumed by the auth selector flow conversion.\n *\n * @see https://openid.net/specs/openid-connect-discovery-1_0.html\n */\nconst OpenIDConnectDiscoverySchema = Type.Object({\n  /** URL of the OAuth 2.0 Authorization Endpoint */\n  authorization_endpoint: Type.Optional(Type.String()),\n  /** URL of the OAuth 2.0 Token Endpoint */\n  token_endpoint: Type.Optional(Type.String()),\n  /** List of OAuth 2.0 scope values that this server supports */\n  scopes_supported: Type.Optional(Type.Array(Type.String())),\n  /** List of OAuth 2.0 grant type values that this server supports */\n  grant_types_supported: Type.Optional(Type.Array(Type.String())),\n  /** Supported PKCE code challenge methods (RFC 7636) */\n  code_challenge_methods_supported: Type.Optional(Type.Array(Type.String())),\n})\n\nexport type OpenIDConnectDiscovery = Static<typeof OpenIDConnectDiscoverySchema>\n\n/**\n * The required scope for OpenID Connect requests.\n * If this scope is present, the request is an OIDC request; otherwise, it is a standard OAuth 2.0 request.\n */\nexport const OPENID_SCOPE = 'openid'\n\n/**\n * Fetches the OpenID Connect discovery document from the specified URL.\n * Supports both full discovery URLs and issuer URLs.\n *\n * @param url - The OpenID Connect discovery URL or issuer URL\n * @returns The discovery document or an error\n */\nexport const fetchOpenIDConnectDiscovery = async (\n  url: string,\n  proxyUrl: string,\n): Promise<ErrorResponse<OpenIDConnectDiscovery>> => {\n  try {\n    // If the URL does not end with the well-known path, append it\n    let discoveryUrl = url.trim()\n\n    if (!discoveryUrl) {\n      return [new Error('URL cannot be empty'), null]\n    }\n\n    // Remove trailing slash if present\n    if (discoveryUrl.endsWith('/')) {\n      discoveryUrl = discoveryUrl.slice(0, -1)\n    }\n\n    // If the URL does not already include the well-known path, append it\n    if (!discoveryUrl.includes('/.well-known/openid-configuration')) {\n      discoveryUrl = `${discoveryUrl}/.well-known/openid-configuration`\n    }\n\n    const proxiedUrl = redirectToProxy(proxyUrl, discoveryUrl)\n    const response = await fetch(proxiedUrl)\n\n    if (!response.ok) {\n      return [\n        new Error(`Failed to fetch OpenID Connect discovery document: ${response.status} ${response.statusText}`),\n        null,\n      ]\n    }\n\n    const data = coerceValue(OpenIDConnectDiscoverySchema, await response.json())\n\n    // Validate that we have the essential fields\n    if (!data.authorization_endpoint && !data.token_endpoint) {\n      return [new Error('Invalid OpenID Connect discovery document: missing required endpoints'), null]\n    }\n\n    return [null, data]\n  } catch (error) {\n    if (error instanceof Error) {\n      return [error, null]\n    }\n    return [new Error('Failed to fetch OpenID Connect discovery document'), null]\n  }\n}\n"],"mappings":";;;;;;;;;;AAYA,IAAM,+BAA+B,KAAK,OAAO;CAE/C,wBAAwB,KAAK,SAAS,KAAK,QAAQ,CAAC;CAEpD,gBAAgB,KAAK,SAAS,KAAK,QAAQ,CAAC;CAE5C,kBAAkB,KAAK,SAAS,KAAK,MAAM,KAAK,QAAQ,CAAC,CAAC;CAE1D,uBAAuB,KAAK,SAAS,KAAK,MAAM,KAAK,QAAQ,CAAC,CAAC;CAE/D,kCAAkC,KAAK,SAAS,KAAK,MAAM,KAAK,QAAQ,CAAC,CAAC;CAC3E,CAAC;;;;;;;;AAiBF,IAAa,8BAA8B,OACzC,KACA,aACmD;AACnD,KAAI;EAEF,IAAI,eAAe,IAAI,MAAM;AAE7B,MAAI,CAAC,aACH,QAAO,iBAAC,IAAI,MAAM,sBAAsB,EAAE,KAAK;AAIjD,MAAI,aAAa,SAAS,IAAI,CAC5B,gBAAe,aAAa,MAAM,GAAG,GAAG;AAI1C,MAAI,CAAC,aAAa,SAAS,oCAAoC,CAC7D,gBAAe,GAAG,aAAa;EAGjC,MAAM,aAAa,gBAAgB,UAAU,aAAa;EAC1D,MAAM,WAAW,MAAM,MAAM,WAAW;AAExC,MAAI,CAAC,SAAS,GACZ,QAAO,iBACL,IAAI,MAAM,sDAAsD,SAAS,OAAO,GAAG,SAAS,aAAa,EACzG,KACD;EAGH,MAAM,OAAO,YAAY,8BAA8B,MAAM,SAAS,MAAM,CAAC;AAG7E,MAAI,CAAC,KAAK,0BAA0B,CAAC,KAAK,eACxC,QAAO,iBAAC,IAAI,MAAM,wEAAwE,EAAE,KAAK;AAGnG,SAAO,CAAC,MAAM,KAAK;UACZ,OAAO;AACd,MAAI,iBAAiB,MACnB,QAAO,CAAC,OAAO,KAAK;AAEtB,SAAO,iBAAC,IAAI,MAAM,oDAAoD,EAAE,KAAK"}

package/dist/v2/blocks/scalar-auth-selector-block/helpers/is-auth-optional.js

@@ -0,0 +1,10 @@
+//#region src/v2/blocks/scalar-auth-selector-block/helpers/is-auth-optional.ts
+/** Determines if the authentication is optional */
+var isAuthOptional = (securityRequirements) => {
+	const hasComplexRequirement = securityRequirements.some((requirement) => Object.keys(requirement).length > 1);
+	return securityRequirements.some((requirement) => Object.keys(requirement).length === 0) && !hasComplexRequirement;
+};
+//#endregion
+export { isAuthOptional };
+
+//# sourceMappingURL=is-auth-optional.js.map

package/dist/v2/blocks/scalar-auth-selector-block/helpers/is-auth-optional.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-auth-optional.js","names":[],"sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/helpers/is-auth-optional.ts"],"sourcesContent":["import type { OpenApiDocument } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\n/** Determines if the authentication is optional */\nexport const isAuthOptional = (securityRequirements: NonNullable<OpenApiDocument['security']>): boolean => {\n  const hasComplexRequirement = securityRequirements.some((requirement) => Object.keys(requirement).length > 1)\n  const hasEmptyRequirement = securityRequirements.some((requirement) => Object.keys(requirement).length === 0)\n\n  return hasEmptyRequirement && !hasComplexRequirement\n}\n"],"mappings":";;AAGA,IAAa,kBAAkB,yBAA4E;CACzG,MAAM,wBAAwB,qBAAqB,MAAM,gBAAgB,OAAO,KAAK,YAAY,CAAC,SAAS,EAAE;AAG7G,QAF4B,qBAAqB,MAAM,gBAAgB,OAAO,KAAK,YAAY,CAAC,WAAW,EAAE,IAE/E,CAAC"}

package/dist/v2/blocks/scalar-auth-selector-block/helpers/merge-security.js

@@ -0,0 +1,27 @@
+import { extractSecuritySchemeSecrets } from "./extract-security-scheme-secrets.js";
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { coerceValue } from "@scalar/workspace-store/schemas/typebox-coerce";
+import { objectEntries } from "@scalar/helpers/object/object-entries";
+import { SecuritySchemeObjectSchema } from "@scalar/workspace-store/schemas/v3.1/strict/openapi-document";
+import { deepClone } from "@scalar/workspace-store/helpers/deep-clone";
+import { mergeObjects } from "@scalar/workspace-store/helpers/merge-object";
+//#region src/v2/blocks/scalar-auth-selector-block/helpers/merge-security.ts
+/** Merge the authentication config with the document security schemes + the auth store secrets */
+var mergeSecurity = (documentSecuritySchemes = {}, configSecuritySchemes = {}, authStore, documentSlug) => {
+	/** Convert the config secrets to the new secret extensions */
+	return objectEntries(mergeObjects(objectEntries(documentSecuritySchemes).reduce((acc, [key, value]) => {
+		const resolved = deepClone(getResolvedRef(value));
+		if (resolved) acc[key] = resolved;
+		return acc;
+	}, {}), configSecuritySchemes) ?? {}).reduce((acc, [name, value]) => {
+		acc[name] = extractSecuritySchemeSecrets({
+			...coerceValue(SecuritySchemeObjectSchema, value),
+			...value
+		}, authStore, name, documentSlug);
+		return acc;
+	}, {});
+};
+//#endregion
+export { mergeSecurity };
+
+//# sourceMappingURL=merge-security.js.map

package/dist/v2/blocks/scalar-auth-selector-block/helpers/merge-security.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-security.js","names":[],"sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/helpers/merge-security.ts"],"sourcesContent":["import { objectEntries } from '@scalar/helpers/object/object-entries'\nimport type { AuthenticationConfiguration } from '@scalar/types/api-reference'\nimport type { AuthStore } from '@scalar/workspace-store/entities/auth'\nimport { deepClone } from '@scalar/workspace-store/helpers/deep-clone'\nimport { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport { mergeObjects } from '@scalar/workspace-store/helpers/merge-object'\nimport { coerceValue } from '@scalar/workspace-store/schemas/typebox-coerce'\nimport {\n  type ComponentsObject,\n  type SecuritySchemeObject,\n  SecuritySchemeObjectSchema,\n} from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport { extractSecuritySchemeSecrets } from './extract-security-scheme-secrets'\nimport type { SecuritySchemeObjectSecret } from './secret-types'\n\n/** Document security merged with the config security schemes */\nexport type MergedSecuritySchemes = Record<string, SecuritySchemeObjectSecret>\n\n/** Merge the authentication config with the document security schemes + the auth store secrets */\nexport const mergeSecurity = (\n  documentSecuritySchemes: ComponentsObject['securitySchemes'] = {},\n  configSecuritySchemes: AuthenticationConfiguration['securitySchemes'] = {},\n  authStore: AuthStore,\n  documentSlug: string,\n): MergedSecuritySchemes => {\n  /** Resolve any refs in the document security schemes */\n  const resolvedDocumentSecuritySchemes = objectEntries(documentSecuritySchemes).reduce(\n    (acc, [key, value]) => {\n      const resolved = deepClone(getResolvedRef(value))\n      if (resolved) {\n        acc[key] = resolved\n      }\n      return acc\n    },\n    {} as Record<string, SecuritySchemeObject>,\n  )\n\n  /** Merge the config security schemes into the document security schemes */\n  const mergedSchemes =\n    mergeObjects<Record<string, SecuritySchemeObject>>(resolvedDocumentSecuritySchemes, configSecuritySchemes) ?? {}\n\n  /** Convert the config secrets to the new secret extensions */\n  return objectEntries(mergedSchemes).reduce((acc, [name, value]) => {\n    // We coerce in case the scheme is missing any key fields like type\n    const coerced = coerceValue(SecuritySchemeObjectSchema, value)\n    // We then overwrite it back with the original value to keep any other fields like description, etc.\n    const merged = { ...coerced, ...value }\n\n    acc[name] = extractSecuritySchemeSecrets(merged, authStore, name, documentSlug)\n    return acc\n  }, {} as MergedSecuritySchemes)\n}\n"],"mappings":";;;;;;;;;AAoBA,IAAa,iBACX,0BAA+D,EAAE,EACjE,wBAAwE,EAAE,EAC1E,WACA,iBAC0B;;AAkB1B,QAAO,cAHL,aAbsC,cAAc,wBAAwB,CAAC,QAC5E,KAAK,CAAC,KAAK,WAAW;EACrB,MAAM,WAAW,UAAU,eAAe,MAAM,CAAC;AACjD,MAAI,SACF,KAAI,OAAO;AAEb,SAAO;IAET,EAAE,CACH,EAIqF,sBAAsB,IAAI,EAAE,CAG/E,CAAC,QAAQ,KAAK,CAAC,MAAM,WAAW;AAMjE,MAAI,QAAQ,6BAFG;GAAE,GAFD,YAAY,4BAA4B,MAAM;GAEjC,GAAG;GAAO,EAEU,WAAW,MAAM,aAAa;AAC/E,SAAO;IACN,EAAE,CAA0B"}

package/dist/v2/blocks/scalar-auth-selector-block/helpers/oauth.d.ts

@@ -1,5 +1,5 @@
 import type { ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
-import type { ErrorResponse } from '../../../../libs/errors';
+import type { ErrorResponse } from '../../../../libs/errors.js';
 import type { OAuthFlowsObjectSecret } from '../../../../v2/blocks/scalar-auth-selector-block/helpers/secret-types';
 export type OAuth2Tokens = {
     accessToken: string;

package/dist/v2/blocks/scalar-auth-selector-block/helpers/oauth.js

@@ -0,0 +1,183 @@
+import { getServerUrl } from "../../operation-block/helpers/get-server-url.js";
+import { encode, fromUint8Array } from "js-base64";
+import { shouldUseProxy } from "@scalar/helpers/url/redirect-to-proxy";
+import { isRelativePath } from "@scalar/helpers/url/is-relative-path";
+import { makeUrlAbsolute } from "@scalar/helpers/url/make-url-absolute";
+//#region src/v2/blocks/scalar-auth-selector-block/helpers/oauth.ts
+var getActiveServerBase = (activeServer, environmentVariables = {}) => {
+	const serverUrl = getServerUrl(activeServer, environmentVariables);
+	if (!serverUrl) return {};
+	if (isRelativePath(serverUrl)) return typeof window === "undefined" ? {} : { basePath: serverUrl };
+	return { baseUrl: serverUrl };
+};
+/**
+* Generates a random string for PKCE code verifier
+*
+* @see https://www.rfc-editor.org/rfc/rfc7636#page-8
+*/
+var generateCodeVerifier = () => {
+	const buffer = new Uint8Array(32);
+	crypto.getRandomValues(buffer);
+	return fromUint8Array(buffer, true);
+};
+/**
+* Creates a code challenge from the code verifier
+*/
+var generateCodeChallenge = async (verifier, encoding) => {
+	if (encoding === "plain") return verifier;
+	if (typeof crypto?.subtle?.digest !== "function") {
+		console.warn("SHA-256 is only supported when using https, using a plain text code challenge instead.");
+		return verifier;
+	}
+	const data = new TextEncoder().encode(verifier);
+	const digest = await crypto.subtle.digest("SHA-256", data);
+	return fromUint8Array(new Uint8Array(digest), true);
+};
+/**
+* Authorize oauth2 flow
+*
+* @returns the resolved oauth2 tokens
+*/
+var authorizeOauth2 = async (flows, type, selectedScopes, activeServer, proxyUrl, environmentVariables = {}) => {
+	const flow = flows[type];
+	try {
+		if (!flow) return [/* @__PURE__ */ new Error("Flow not found"), null];
+		const scopes = selectedScopes.join(" ");
+		if (type === "clientCredentials" || type === "password") return authorizeServers(flows, type, scopes, { proxyUrl }, activeServer, environmentVariables);
+		const state = (Math.random() + 1).toString(36).substring(2, 10);
+		const authorizationUrl = makeUrlAbsolute(flows[type]["x-scalar-secret-auth-url"] ?? flows[type].authorizationUrl, getActiveServerBase(activeServer, environmentVariables));
+		const url = new URL(authorizationUrl);
+		/** Special PKCE state */
+		let pkce = null;
+		if (type === "implicit") url.searchParams.set("response_type", "token");
+		else if (type === "authorizationCode") {
+			const typedFlow = flows[type];
+			url.searchParams.set("response_type", "code");
+			if (typedFlow["x-usePkce"] !== "no") {
+				const codeVerifier = generateCodeVerifier();
+				const codeChallenge = await generateCodeChallenge(codeVerifier, typedFlow["x-usePkce"]);
+				pkce = {
+					codeVerifier,
+					codeChallenge,
+					codeChallengeMethod: typedFlow["x-usePkce"] === "SHA-256" ? "S256" : "plain"
+				};
+				url.searchParams.set("code_challenge", codeChallenge);
+				url.searchParams.set("code_challenge_method", pkce.codeChallengeMethod);
+			}
+		}
+		const typedFlow = flows[type];
+		if (typedFlow["x-scalar-secret-redirect-uri"].startsWith("/")) {
+			const baseUrl = getServerUrl(activeServer, environmentVariables) || window.location.origin + window.location.pathname;
+			const redirectUri = new URL(typedFlow["x-scalar-secret-redirect-uri"], baseUrl).toString();
+			url.searchParams.set("redirect_uri", redirectUri);
+		} else url.searchParams.set("redirect_uri", typedFlow["x-scalar-secret-redirect-uri"]);
+		if (flow["x-scalar-security-query"]) Object.keys(flow["x-scalar-security-query"]).forEach((key) => {
+			const value = flow["x-scalar-security-query"]?.[key];
+			if (!value) return;
+			url.searchParams.set(key, value);
+		});
+		url.searchParams.set("client_id", flow["x-scalar-secret-client-id"]);
+		url.searchParams.set("state", state);
+		if (scopes) url.searchParams.set("scope", scopes);
+		const authWindow = window.open(url, "openAuth2Window", "left=100,top=100,width=800,height=600");
+		if (authWindow) return new Promise((resolve) => {
+			const checkWindowClosed = setInterval(() => {
+				let accessToken = null;
+				let refreshToken = null;
+				let code = null;
+				let error = null;
+				let errorDescription = null;
+				try {
+					const urlParams = new URL(authWindow.location.href).searchParams;
+					const tokenName = flow["x-tokenName"] || "access_token";
+					accessToken = urlParams.get(tokenName);
+					refreshToken = urlParams.get("refresh_token");
+					code = urlParams.get("code");
+					error = urlParams.get("error");
+					errorDescription = urlParams.get("error_description");
+					const hashParams = new URLSearchParams(authWindow.location.href.split("#")[1]);
+					accessToken ||= hashParams.get(tokenName);
+					refreshToken ||= hashParams.get("refresh_token");
+					code ||= hashParams.get("code");
+					error ||= hashParams.get("error");
+					errorDescription ||= hashParams.get("error_description");
+				} catch (_e) {}
+				if (authWindow.closed || accessToken || code || error) {
+					clearInterval(checkWindowClosed);
+					authWindow.close();
+					if (error) resolve([/* @__PURE__ */ new Error(`OAuth error: ${error}${errorDescription ? ` (${errorDescription})` : ""}`), null]);
+					else if (accessToken) if (authWindow.location.href.match(/state=([^&]*)/)?.[1] === state) resolve([null, {
+						accessToken,
+						...refreshToken ? { refreshToken } : {}
+					}]);
+					else resolve([/* @__PURE__ */ new Error("State mismatch"), null]);
+					else if (code && type === "authorizationCode") if (new URL(authWindow.location.href).searchParams.get("state") === state) authorizeServers(flows, type, scopes, {
+						code,
+						pkce,
+						proxyUrl
+					}, activeServer, environmentVariables).then(resolve);
+					else resolve([/* @__PURE__ */ new Error("State mismatch"), null]);
+					else {
+						clearInterval(checkWindowClosed);
+						resolve([/* @__PURE__ */ new Error("Window was closed without granting authorization"), null]);
+					}
+				}
+			}, 200);
+		});
+		return [/* @__PURE__ */ new Error("Failed to open auth window"), null];
+	} catch (_) {
+		return [/* @__PURE__ */ new Error("Failed to authorize oauth2 flow"), null];
+	}
+};
+/**
+* Makes the BE authorization call to grab the token server to server
+* Used for clientCredentials and authorizationCode
+*/
+var authorizeServers = async (flows, type, scopes, { code, pkce, proxyUrl } = {}, activeServer, environmentVariables = {}) => {
+	const flow = flows[type];
+	if (!flow) return [/* @__PURE__ */ new Error("OAuth2 flow was not defined"), null];
+	const formData = new URLSearchParams();
+	if (scopes && (type === "clientCredentials" || type === "password")) formData.set("scope", scopes);
+	/** Where to add the credentials */
+	const addCredentialsToBody = flow["x-scalar-credentials-location"] === "body";
+	const hasClientSecret = Boolean(flow["x-scalar-secret-client-secret"]);
+	if (addCredentialsToBody || type === "authorizationCode" && !hasClientSecret) formData.set("client_id", flow["x-scalar-secret-client-id"]);
+	if (addCredentialsToBody && hasClientSecret) formData.set("client_secret", flow["x-scalar-secret-client-secret"]);
+	if ("x-scalar-secret-redirect-uri" in flow && flow["x-scalar-secret-redirect-uri"]) formData.set("redirect_uri", flow["x-scalar-secret-redirect-uri"]);
+	if (code) {
+		formData.set("code", code);
+		formData.set("grant_type", "authorization_code");
+		if (pkce) formData.set("code_verifier", pkce.codeVerifier);
+	} else if (type === "password") {
+		const typedFlow = flows[type];
+		formData.set("grant_type", "password");
+		formData.set("username", typedFlow["x-scalar-secret-username"]);
+		formData.set("password", typedFlow["x-scalar-secret-password"]);
+	} else formData.set("grant_type", "client_credentials");
+	if (flow["x-scalar-security-body"]) Object.entries(flow["x-scalar-security-body"]).forEach(([key, value]) => {
+		if (value) formData.set(key, String(value));
+	});
+	try {
+		const headers = { "Content-Type": "application/x-www-form-urlencoded" };
+		if (!addCredentialsToBody && hasClientSecret) headers.Authorization = `Basic ${encode(`${flow["x-scalar-secret-client-id"]}:${flow["x-scalar-secret-client-secret"]}`)}`;
+		const tokenUrl = makeUrlAbsolute(flow["x-scalar-secret-token-url"] ?? flow.tokenUrl, getActiveServerBase(activeServer, environmentVariables));
+		const url = shouldUseProxy(proxyUrl, tokenUrl) ? `${proxyUrl}?${new URLSearchParams([["scalar_url", tokenUrl]]).toString()}` : tokenUrl;
+		const responseData = await (await fetch(url, {
+			method: "POST",
+			headers,
+			body: formData
+		})).json();
+		const accessToken = responseData[flow["x-tokenName"] || "access_token"];
+		const refreshToken = responseData.refresh_token;
+		return [null, {
+			accessToken,
+			...typeof refreshToken === "string" ? { refreshToken } : {}
+		}];
+	} catch {
+		return [/* @__PURE__ */ new Error("Failed to get an access token. Please check your credentials."), null];
+	}
+};
+//#endregion
+export { authorizeOauth2 };
+
+//# sourceMappingURL=oauth.js.map

package/dist/v2/blocks/scalar-auth-selector-block/helpers/oauth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.js","names":[],"sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/helpers/oauth.ts"],"sourcesContent":["import { isRelativePath } from '@scalar/helpers/url/is-relative-path'\nimport { makeUrlAbsolute } from '@scalar/helpers/url/make-url-absolute'\nimport { shouldUseProxy } from '@scalar/helpers/url/redirect-to-proxy'\nimport type { ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\nimport { encode, fromUint8Array } from 'js-base64'\n\nimport type { ErrorResponse } from '@/libs/errors'\nimport { getServerUrl } from '@/v2/blocks/operation-block/helpers/get-server-url'\nimport type { OAuthFlowsObjectSecret } from '@/v2/blocks/scalar-auth-selector-block/helpers/secret-types'\n\n/** Oauth2 security schemes which are not implicit */\ntype NonImplicitFlows = Omit<OAuthFlowsObjectSecret, 'implicit'>\n\ntype PKCEState = {\n  codeVerifier: string\n  codeChallenge: string\n  codeChallengeMethod: string\n}\n\nexport type OAuth2Tokens = {\n  accessToken: string\n  refreshToken?: string\n}\n\nconst getActiveServerBase = (activeServer: ServerObject | null, environmentVariables: Record<string, string> = {}) => {\n  const serverUrl = getServerUrl(activeServer, environmentVariables)\n\n  if (!serverUrl) {\n    return {}\n  }\n\n  if (isRelativePath(serverUrl)) {\n    return typeof window === 'undefined' ? {} : { basePath: serverUrl }\n  }\n\n  return { baseUrl: serverUrl }\n}\n\n/**\n * Generates a random string for PKCE code verifier\n *\n * @see https://www.rfc-editor.org/rfc/rfc7636#page-8\n */\nconst generateCodeVerifier = (): string => {\n  // Generate 32 random bytes\n  const buffer = new Uint8Array(32)\n  crypto.getRandomValues(buffer)\n\n  // Base64URL encode the bytes\n  return fromUint8Array(buffer, true)\n}\n\n/**\n * Creates a code challenge from the code verifier\n */\nconst generateCodeChallenge = async (verifier: string, encoding: 'SHA-256' | 'plain'): Promise<string> => {\n  if (encoding === 'plain') {\n    return verifier\n  }\n\n  // If crypto.subtle.digest is not a function, we cannot use SHA-256\n  if (typeof crypto?.subtle?.digest !== 'function') {\n    console.warn('SHA-256 is only supported when using https, using a plain text code challenge instead.')\n    return verifier\n  }\n\n  // ASCII encoding is just taking the lower 8 bits of each character\n  const encoder = new TextEncoder()\n  const data = encoder.encode(verifier)\n  const digest = await crypto.subtle.digest('SHA-256', data)\n\n  // Base64URL encode the bytes\n  return fromUint8Array(new Uint8Array(digest), true)\n}\n\n/**\n * Authorize oauth2 flow\n *\n * @returns the resolved oauth2 tokens\n */\nexport const authorizeOauth2 = async (\n  flows: OAuthFlowsObjectSecret,\n  type: keyof OAuthFlowsObjectSecret,\n  selectedScopes: string[],\n  /** We use the active server to set a base for relative redirect uris */\n  activeServer: ServerObject | null,\n  /** If we want to use the proxy */\n  proxyUrl: string,\n  /** Flattened environment variables used to resolve server URL templates like `{protocol}` */\n  environmentVariables: Record<string, string> = {},\n): Promise<ErrorResponse<OAuth2Tokens>> => {\n  const flow = flows[type]\n\n  try {\n    if (!flow) {\n      return [new Error('Flow not found'), null]\n    }\n\n    const scopes = selectedScopes.join(' ')\n\n    // Client Credentials or Password Flow\n    if (type === 'clientCredentials' || type === 'password') {\n      return authorizeServers(\n        flows,\n        type,\n        scopes,\n        {\n          proxyUrl,\n        },\n        activeServer,\n        environmentVariables,\n      )\n    }\n\n    // Generate a random state string with the length of 8 characters\n    const state = (Math.random() + 1).toString(36).substring(2, 10)\n\n    const authorizationUrl = makeUrlAbsolute(\n      flows[type]!['x-scalar-secret-auth-url'] ?? flows[type]!.authorizationUrl,\n      getActiveServerBase(activeServer, environmentVariables),\n    )\n\n    const url = new URL(authorizationUrl)\n\n    /** Special PKCE state */\n    let pkce: PKCEState | null = null\n\n    // Params unique to the flows\n    if (type === 'implicit') {\n      url.searchParams.set('response_type', 'token')\n    } else if (type === 'authorizationCode') {\n      const typedFlow = flows[type]! // Safe to assert due to earlier check\n\n      url.searchParams.set('response_type', 'code')\n\n      // PKCE\n      if (typedFlow['x-usePkce'] !== 'no') {\n        const codeVerifier = generateCodeVerifier()\n        const codeChallenge = await generateCodeChallenge(codeVerifier, typedFlow['x-usePkce'])\n\n        // Set state for later verification\n        pkce = {\n          codeVerifier,\n          codeChallenge,\n          codeChallengeMethod: typedFlow['x-usePkce'] === 'SHA-256' ? 'S256' : 'plain',\n        }\n\n        // Set the code challenge and method on the url\n        url.searchParams.set('code_challenge', codeChallenge)\n        url.searchParams.set('code_challenge_method', pkce.codeChallengeMethod)\n      }\n    }\n\n    const typedFlow = flows[type]! // Safe to assert due to earlier check\n\n    // Handle relative redirect uris\n    if (typedFlow['x-scalar-secret-redirect-uri'].startsWith('/')) {\n      const baseUrl =\n        getServerUrl(activeServer, environmentVariables) || window.location.origin + window.location.pathname\n      const redirectUri = new URL(typedFlow['x-scalar-secret-redirect-uri'], baseUrl).toString()\n\n      url.searchParams.set('redirect_uri', redirectUri)\n    } else {\n      url.searchParams.set('redirect_uri', typedFlow['x-scalar-secret-redirect-uri'])\n    }\n\n    if (flow['x-scalar-security-query']) {\n      Object.keys(flow['x-scalar-security-query']).forEach((key: string): void => {\n        const value = flow['x-scalar-security-query']?.[key]\n        if (!value) {\n          return\n        }\n        url.searchParams.set(key, value)\n      })\n    }\n\n    // Common to all flows\n    url.searchParams.set('client_id', flow['x-scalar-secret-client-id'])\n    url.searchParams.set('state', state)\n    if (scopes) {\n      url.searchParams.set('scope', scopes)\n    }\n\n    const windowFeatures = 'left=100,top=100,width=800,height=600'\n    const authWindow = window.open(url, 'openAuth2Window', windowFeatures)\n\n    // Open up a window and poll until closed or we have the data we want\n    if (authWindow) {\n      // We need to return a promise here due to the setInterval\n      return new Promise<ErrorResponse<OAuth2Tokens>>((resolve) => {\n        const checkWindowClosed = setInterval(() => {\n          let accessToken: string | null = null\n          let refreshToken: string | null = null\n          let code: string | null = null\n          let error: string | null = null\n          let errorDescription: string | null = null\n\n          try {\n            const urlParams = new URL(authWindow.location.href).searchParams\n            const tokenName = flow['x-tokenName'] || 'access_token'\n            accessToken = urlParams.get(tokenName)\n            refreshToken = urlParams.get('refresh_token')\n            code = urlParams.get('code')\n\n            error = urlParams.get('error')\n            errorDescription = urlParams.get('error_description')\n\n            // We may get the properties in a hash\n            const hashParams = new URLSearchParams(authWindow.location.href.split('#')[1])\n            accessToken ||= hashParams.get(tokenName)\n            refreshToken ||= hashParams.get('refresh_token')\n            code ||= hashParams.get('code')\n            error ||= hashParams.get('error')\n            errorDescription ||= hashParams.get('error_description')\n          } catch (_e) {\n            // Ignore CORS error from popup\n          }\n\n          // The window has closed OR we have what we are looking for so we stop polling\n          if (authWindow.closed || accessToken || code || error) {\n            clearInterval(checkWindowClosed)\n            authWindow.close()\n\n            if (error) {\n              resolve([new Error(`OAuth error: ${error}${errorDescription ? ` (${errorDescription})` : ''}`), null])\n            }\n\n            // Implicit Flow\n            else if (accessToken) {\n              // State is a hash fragment and cannot be found through search params\n              const _state = authWindow.location.href.match(/state=([^&]*)/)?.[1]\n\n              if (_state === state) {\n                resolve([null, { accessToken, ...(refreshToken ? { refreshToken } : {}) }])\n              } else {\n                resolve([new Error('State mismatch'), null])\n              }\n            }\n\n            // Authorization Code Server Flow\n            else if (code && type === 'authorizationCode') {\n              const _state = new URL(authWindow.location.href).searchParams.get('state')\n\n              if (_state === state) {\n                // biome-ignore lint/nursery/noFloatingPromises: output of authorizeServers must be returned\n                authorizeServers(\n                  flows,\n                  type,\n                  scopes,\n                  {\n                    code,\n                    pkce,\n                    proxyUrl,\n                  },\n                  activeServer,\n                  environmentVariables,\n                ).then(resolve)\n              } else {\n                resolve([new Error('State mismatch'), null])\n              }\n            }\n            // User closed window without authorizing\n            else {\n              clearInterval(checkWindowClosed)\n              resolve([new Error('Window was closed without granting authorization'), null])\n            }\n          }\n        }, 200)\n      })\n    }\n    return [new Error('Failed to open auth window'), null]\n  } catch (_) {\n    return [new Error('Failed to authorize oauth2 flow'), null]\n  }\n}\n\n/**\n * Makes the BE authorization call to grab the token server to server\n * Used for clientCredentials and authorizationCode\n */\nconst authorizeServers = async (\n  flows: NonImplicitFlows,\n  type: keyof NonImplicitFlows,\n  scopes: string,\n  {\n    code,\n    pkce,\n    proxyUrl,\n  }: {\n    code?: string\n    pkce?: PKCEState | null\n    proxyUrl?: string\n  } = {},\n  activeServer: ServerObject | null,\n  environmentVariables: Record<string, string> = {},\n): Promise<ErrorResponse<OAuth2Tokens>> => {\n  const flow = flows[type]\n\n  if (!flow) {\n    return [new Error('OAuth2 flow was not defined'), null]\n  }\n\n  const formData = new URLSearchParams()\n\n  // Only client credentials and password flows support scopes in the token request\n  if (scopes && (type === 'clientCredentials' || type === 'password')) {\n    formData.set('scope', scopes)\n  }\n\n  /** Where to add the credentials */\n  const addCredentialsToBody = flow['x-scalar-credentials-location'] === 'body'\n  const hasClientSecret = Boolean(flow['x-scalar-secret-client-secret'])\n  /**\n   * Public authorization-code clients still need client_id in the token body.\n   * We only send it implicitly for that case to avoid conflicting with Basic auth.\n   */\n  const shouldSendClientIdInBody = addCredentialsToBody || (type === 'authorizationCode' && !hasClientSecret)\n\n  if (shouldSendClientIdInBody) {\n    formData.set('client_id', flow['x-scalar-secret-client-id'])\n  }\n  if (addCredentialsToBody && hasClientSecret) {\n    formData.set('client_secret', flow['x-scalar-secret-client-secret'])\n  }\n  if ('x-scalar-secret-redirect-uri' in flow && flow['x-scalar-secret-redirect-uri']) {\n    formData.set('redirect_uri', flow['x-scalar-secret-redirect-uri'])\n  }\n\n  // Authorization Code\n  if (code) {\n    formData.set('code', code)\n    formData.set('grant_type', 'authorization_code')\n\n    // PKCE\n    if (pkce) {\n      formData.set('code_verifier', pkce.codeVerifier)\n    }\n  }\n  // Password\n  else if (type === 'password') {\n    const typedFlow = flows[type]! // Safe to assert due to earlier check\n    formData.set('grant_type', 'password')\n    formData.set('username', typedFlow['x-scalar-secret-username'])\n    formData.set('password', typedFlow['x-scalar-secret-password'])\n  }\n  // Client Credentials\n  else {\n    formData.set('grant_type', 'client_credentials')\n  }\n\n  // Additional request body parameters\n  if (flow['x-scalar-security-body']) {\n    Object.entries(flow['x-scalar-security-body']).forEach(([key, value]) => {\n      if (value) {\n        formData.set(key, String(value))\n      }\n    })\n  }\n\n  try {\n    const headers: Record<string, string> = {\n      'Content-Type': 'application/x-www-form-urlencoded',\n    }\n\n    // Add client id + secret to headers for confidential clients.\n    if (!addCredentialsToBody && hasClientSecret) {\n      headers.Authorization = `Basic ${encode(`${flow['x-scalar-secret-client-id']}:${flow['x-scalar-secret-client-secret']}`)}`\n    }\n\n    // Check if we should use the proxy\n    const tokenUrl = makeUrlAbsolute(\n      flow['x-scalar-secret-token-url'] ?? flow.tokenUrl,\n      getActiveServerBase(activeServer, environmentVariables),\n    )\n    const url = shouldUseProxy(proxyUrl, tokenUrl)\n      ? `${proxyUrl}?${new URLSearchParams([['scalar_url', tokenUrl]]).toString()}`\n      : tokenUrl\n\n    // Make the call\n    const resp = await fetch(url, {\n      method: 'POST',\n      headers,\n      body: formData,\n    })\n    const responseData = await resp.json()\n\n    // Use custom token name if specified, otherwise default to access_token\n    const tokenName = flow['x-tokenName'] || 'access_token'\n    const accessToken = responseData[tokenName]\n    const refreshToken = responseData.refresh_token\n\n    return [null, { accessToken, ...(typeof refreshToken === 'string' ? { refreshToken } : {}) }]\n  } catch {\n    return [new Error('Failed to get an access token. Please check your credentials.'), null]\n  }\n}\n"],"mappings":"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"}

package/dist/v2/blocks/scalar-auth-selector-block/helpers/openid-discovery-to-flows.d.ts

@@ -1,5 +1,5 @@
 import { type SecretsOpenIdConnect } from '@scalar/workspace-store/entities/auth';
-import type { OpenIDConnectDiscovery } from './fetch-openid-connect-discovery';
+import type { OpenIDConnectDiscovery } from './fetch-openid-connect-discovery.js';
 /** Takes in an open ID Connect discovery response and converts it into an oauth flow to be used for authorization */
 export declare const openIDDiscoveryToFlows: (discovery: OpenIDConnectDiscovery) => SecretsOpenIdConnect;
 //# sourceMappingURL=openid-discovery-to-flows.d.ts.map

package/dist/v2/blocks/scalar-auth-selector-block/helpers/openid-discovery-to-flows.js

@@ -0,0 +1,39 @@
+import { coerceValue } from "@scalar/workspace-store/schemas/typebox-coerce";
+import { OpenIDConnectSchema } from "@scalar/workspace-store/entities/auth";
+//#region src/v2/blocks/scalar-auth-selector-block/helpers/openid-discovery-to-flows.ts
+/** Takes in an open ID Connect discovery response and converts it into an oauth flow to be used for authorization */
+var openIDDiscoveryToFlows = (discovery) => {
+	const scopes = Object.fromEntries((discovery.scopes_supported ?? []).map((scope) => [scope, ""]));
+	const grantTypes = new Set(discovery.grant_types_supported ?? ["authorization_code", "implicit"]);
+	const authorizationUrl = discovery.authorization_endpoint;
+	const tokenUrl = discovery.token_endpoint;
+	const usePkce = discovery.code_challenge_methods_supported?.includes("S256") ? "SHA-256" : discovery.code_challenge_methods_supported?.includes("plain") ? "plain" : "no";
+	const flows = {};
+	if (grantTypes.has("implicit") && authorizationUrl) flows.implicit = {
+		authorizationUrl,
+		refreshUrl: authorizationUrl,
+		scopes
+	};
+	if (grantTypes.has("password") && tokenUrl) flows.password = {
+		tokenUrl,
+		refreshUrl: tokenUrl,
+		scopes
+	};
+	if (grantTypes.has("client_credentials") && tokenUrl) flows.clientCredentials = {
+		tokenUrl,
+		refreshUrl: tokenUrl,
+		scopes
+	};
+	if (grantTypes.has("authorization_code") && authorizationUrl && tokenUrl) flows.authorizationCode = {
+		authorizationUrl,
+		tokenUrl,
+		refreshUrl: tokenUrl,
+		"x-usePkce": usePkce,
+		scopes
+	};
+	return coerceValue(OpenIDConnectSchema, flows);
+};
+//#endregion
+export { openIDDiscoveryToFlows };
+
+//# sourceMappingURL=openid-discovery-to-flows.js.map

package/dist/v2/blocks/scalar-auth-selector-block/helpers/openid-discovery-to-flows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openid-discovery-to-flows.js","names":[],"sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/helpers/openid-discovery-to-flows.ts"],"sourcesContent":["import { OpenIDConnectSchema, type SecretsOpenIdConnect } from '@scalar/workspace-store/entities/auth'\nimport { coerceValue } from '@scalar/workspace-store/schemas/typebox-coerce'\nimport type { OAuthFlowsObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport type { OpenIDConnectDiscovery } from './fetch-openid-connect-discovery'\n\n/** Takes in an open ID Connect discovery response and converts it into an oauth flow to be used for authorization */\nexport const openIDDiscoveryToFlows = (discovery: OpenIDConnectDiscovery): SecretsOpenIdConnect => {\n  const scopes = Object.fromEntries((discovery.scopes_supported ?? []).map((scope) => [scope, '']))\n  const grantTypes = new Set(discovery.grant_types_supported ?? ['authorization_code', 'implicit'])\n  const authorizationUrl = discovery.authorization_endpoint\n  const tokenUrl = discovery.token_endpoint\n\n  const usePkce = discovery.code_challenge_methods_supported?.includes('S256')\n    ? 'SHA-256'\n    : discovery.code_challenge_methods_supported?.includes('plain')\n      ? 'plain'\n      : 'no'\n\n  const flows: OAuthFlowsObject = {}\n\n  // Implicit\n  if (grantTypes.has('implicit') && authorizationUrl) {\n    flows.implicit = {\n      authorizationUrl,\n      refreshUrl: authorizationUrl,\n      scopes,\n    }\n  }\n\n  // Password\n  if (grantTypes.has('password') && tokenUrl) {\n    flows.password = {\n      tokenUrl,\n      refreshUrl: tokenUrl,\n      scopes,\n    }\n  }\n\n  // Client Credentials\n  if (grantTypes.has('client_credentials') && tokenUrl) {\n    flows.clientCredentials = {\n      tokenUrl,\n      refreshUrl: tokenUrl,\n      scopes,\n    }\n  }\n\n  // Authorization Code\n  if (grantTypes.has('authorization_code') && authorizationUrl && tokenUrl) {\n    flows.authorizationCode = {\n      authorizationUrl,\n      tokenUrl,\n      refreshUrl: tokenUrl,\n      'x-usePkce': usePkce,\n      scopes,\n    }\n  }\n\n  return coerceValue(OpenIDConnectSchema, flows)\n}\n"],"mappings":";;;;AAOA,IAAa,0BAA0B,cAA4D;CACjG,MAAM,SAAS,OAAO,aAAa,UAAU,oBAAoB,EAAE,EAAE,KAAK,UAAU,CAAC,OAAO,GAAG,CAAC,CAAC;CACjG,MAAM,aAAa,IAAI,IAAI,UAAU,yBAAyB,CAAC,sBAAsB,WAAW,CAAC;CACjG,MAAM,mBAAmB,UAAU;CACnC,MAAM,WAAW,UAAU;CAE3B,MAAM,UAAU,UAAU,kCAAkC,SAAS,OAAO,GACxE,YACA,UAAU,kCAAkC,SAAS,QAAQ,GAC3D,UACA;CAEN,MAAM,QAA0B,EAAE;AAGlC,KAAI,WAAW,IAAI,WAAW,IAAI,iBAChC,OAAM,WAAW;EACf;EACA,YAAY;EACZ;EACD;AAIH,KAAI,WAAW,IAAI,WAAW,IAAI,SAChC,OAAM,WAAW;EACf;EACA,YAAY;EACZ;EACD;AAIH,KAAI,WAAW,IAAI,qBAAqB,IAAI,SAC1C,OAAM,oBAAoB;EACxB;EACA,YAAY;EACZ;EACD;AAIH,KAAI,WAAW,IAAI,qBAAqB,IAAI,oBAAoB,SAC9D,OAAM,oBAAoB;EACxB;EACA;EACA,YAAY;EACZ,aAAa;EACb;EACD;AAGH,QAAO,YAAY,qBAAqB,MAAM"}

package/dist/v2/blocks/scalar-auth-selector-block/helpers/security-scheme.js

@@ -0,0 +1,109 @@
+import { authOptions } from "./auth-options.js";
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { generateHash } from "@scalar/helpers/string/generate-hash";
+//#region src/v2/blocks/scalar-auth-selector-block/helpers/security-scheme.ts
+var requirementSignature = (requirement) => JSON.stringify(Object.keys(requirement));
+/**
+* Format a scheme object into a display object
+*
+* We also add a hash to the id to ensure it is unique across
+* multiple requirements of the same scheme with different scopes
+*/
+var formatScheme = ({ name, value }) => ({
+	id: generateHash(JSON.stringify(value)),
+	label: name,
+	value,
+	isDeletable: true
+});
+/** Formats complex security schemes */
+var formatComplexScheme = (scheme) => formatScheme({
+	name: Object.keys(scheme).join(" & "),
+	value: scheme
+});
+/**
+* Formats a security requirement into a SecuritySchemeOption.
+* Handles both simple (single key) and complex (multiple keys) auth schemes.
+*/
+var formatSecurityRequirement = (requirement, securitySchemes) => {
+	const keys = Object.keys(requirement);
+	if (keys.length > 1) return formatComplexScheme(requirement);
+	if (keys[0]) {
+		if (!getResolvedRef(securitySchemes[keys[0]])) return;
+		return formatScheme({
+			name: keys[0],
+			value: requirement
+		});
+	}
+};
+/**
+* Generates the options for the security scheme combobox
+*
+* Contains either a flat list, or different groups of required, available, and add new
+*/
+var getSecuritySchemeOptions = (security, securitySchemes, selectedSchemes, canAddNewAuth = false) => {
+	const selectedByRequirement = new Map(selectedSchemes.map((selectedScheme) => [requirementSignature(selectedScheme), selectedScheme]));
+	/**
+	* Build required schemes formatted as options and track scheme names in a single pass.
+	* We use names (not full IDs) because we want to exclude any scheme that is already
+	* required, regardless of its specific scopes or hash.
+	*/
+	const { requiredFormatted, requiredSchemeNames, existingIds } = security.reduce((acc, requirement) => {
+		const formatted = formatSecurityRequirement(selectedByRequirement.get(requirementSignature(requirement)) ?? requirement, securitySchemes);
+		if (formatted) {
+			acc.requiredFormatted.push(formatted);
+			acc.existingIds.add(formatted.id);
+		}
+		for (const name of Object.keys(requirement)) acc.requiredSchemeNames.add(name);
+		return acc;
+	}, {
+		requiredFormatted: [],
+		requiredSchemeNames: /* @__PURE__ */ new Set(),
+		existingIds: /* @__PURE__ */ new Set()
+	});
+	const availableFormatted = [];
+	for (const [name, schemeRef] of Object.entries(securitySchemes)) {
+		if (requiredSchemeNames.has(name)) continue;
+		if (getResolvedRef(schemeRef)) {
+			const formatted = formatScheme({
+				name,
+				value: { [name]: [] }
+			});
+			availableFormatted.push(formatted);
+			existingIds.add(formatted.id);
+		}
+	}
+	/**
+	* Add selected schemes to available if they do not already exist
+	* This ensures that selected schemes with specific scopes are always available as options
+	*/
+	for (const selectedScheme of selectedSchemes) {
+		const formatted = formatSecurityRequirement(selectedScheme, securitySchemes);
+		if (formatted && !existingIds.has(formatted.id)) {
+			availableFormatted.push(formatted);
+			existingIds.add(formatted.id);
+		}
+	}
+	const options = [{
+		label: "Required authentication",
+		options: requiredFormatted
+	}, {
+		label: "Available authentication",
+		options: availableFormatted
+	}];
+	if (!canAddNewAuth) return requiredFormatted.length ? options : availableFormatted;
+	options.push({
+		label: "Add new authentication",
+		options: Object.entries(authOptions).map(([key, value]) => ({
+			id: key,
+			label: value.label,
+			value: { [key]: [] },
+			payload: value.payload,
+			isDeletable: false
+		}))
+	});
+	return options;
+};
+//#endregion
+export { formatComplexScheme, formatScheme, getSecuritySchemeOptions };
+
+//# sourceMappingURL=security-scheme.js.map

package/dist/v2/blocks/scalar-auth-selector-block/helpers/security-scheme.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-scheme.js","names":[],"sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/helpers/security-scheme.ts"],"sourcesContent":["import { generateHash } from '@scalar/helpers/string/generate-hash'\nimport { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport type {\n  ComponentsObject,\n  OpenApiDocument,\n  SecurityRequirementObject,\n  SecuritySchemeObject,\n} from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport { authOptions } from '@/v2/blocks/scalar-auth-selector-block/helpers/auth-options'\n\n/** A single security scheme option used in the auth dropdown */\nexport type SecuritySchemeOption = {\n  id: string\n  label: string\n  value: SecurityRequirementObject\n  isDeletable?: boolean\n  payload?: SecuritySchemeObject\n}\n\n/** A group of security scheme options used in the auth dropdown */\nexport type SecuritySchemeGroup = {\n  label: string\n  options: SecuritySchemeOption[]\n}\n\nconst requirementSignature = (requirement: SecurityRequirementObject): string =>\n  JSON.stringify(Object.keys(requirement))\n\n/**\n * Format a scheme object into a display object\n *\n * We also add a hash to the id to ensure it is unique across\n * multiple requirements of the same scheme with different scopes\n */\nexport const formatScheme = ({ name, value }: { name: string; value: SecurityRequirementObject }) => ({\n  id: generateHash(JSON.stringify(value)),\n  label: name,\n  value,\n  isDeletable: true,\n})\n\n/** Formats complex security schemes */\nexport const formatComplexScheme = (scheme: NonNullable<OpenApiDocument['security']>[number]) =>\n  formatScheme({\n    name: Object.keys(scheme).join(' & '),\n    value: scheme,\n  })\n\n/**\n * Formats a security requirement into a SecuritySchemeOption.\n * Handles both simple (single key) and complex (multiple keys) auth schemes.\n */\nconst formatSecurityRequirement = (\n  requirement: SecurityRequirementObject,\n  securitySchemes: NonNullable<ComponentsObject['securitySchemes']>,\n): SecuritySchemeOption | undefined => {\n  const keys = Object.keys(requirement)\n\n  // Complex auth (multiple keys)\n  if (keys.length > 1) {\n    return formatComplexScheme(requirement)\n  }\n\n  // Simple auth (single key)\n  if (keys[0]) {\n    const scheme = getResolvedRef(securitySchemes[keys[0]])\n    if (!scheme) {\n      return undefined\n    }\n    return formatScheme({ name: keys[0], value: requirement })\n  }\n\n  return undefined\n}\n\n/**\n * Generates the options for the security scheme combobox\n *\n * Contains either a flat list, or different groups of required, available, and add new\n */\nexport const getSecuritySchemeOptions = (\n  security: NonNullable<OpenApiDocument['security']>,\n  securitySchemes: NonNullable<ComponentsObject['securitySchemes']>,\n  /** We need to add the selected schemes if they do not already exist in the calculated options */\n  selectedSchemes: SecurityRequirementObject[],\n  /** Allows adding authentication which is not in the document */\n  canAddNewAuth = false,\n): SecuritySchemeOption[] | SecuritySchemeGroup[] => {\n  const selectedByRequirement = new Map(\n    selectedSchemes.map((selectedScheme) => [requirementSignature(selectedScheme), selectedScheme]),\n  )\n\n  /**\n   * Build required schemes formatted as options and track scheme names in a single pass.\n   * We use names (not full IDs) because we want to exclude any scheme that is already\n   * required, regardless of its specific scopes or hash.\n   */\n  const { requiredFormatted, requiredSchemeNames, existingIds } = security.reduce(\n    (acc, requirement) => {\n      // If a required requirement is selected with scopes, use that selected value to\n      // keep a single option entry and avoid a phantom duplicate.\n      const requirementValue = selectedByRequirement.get(requirementSignature(requirement)) ?? requirement\n      const formatted = formatSecurityRequirement(requirementValue, securitySchemes)\n      if (formatted) {\n        acc.requiredFormatted.push(formatted)\n        acc.existingIds.add(formatted.id)\n      }\n      for (const name of Object.keys(requirement)) {\n        acc.requiredSchemeNames.add(name)\n      }\n      return acc\n    },\n    {\n      requiredFormatted: [] as SecuritySchemeOption[],\n      requiredSchemeNames: new Set<string>(),\n      existingIds: new Set<string>(),\n    },\n  )\n\n  // Build available schemes (excluding schemes that are in the required list)\n  const availableFormatted: SecuritySchemeOption[] = []\n  for (const [name, schemeRef] of Object.entries(securitySchemes)) {\n    if (requiredSchemeNames.has(name)) {\n      continue\n    }\n\n    const scheme = getResolvedRef(schemeRef)\n    if (scheme) {\n      const formatted = formatScheme({ name, value: { [name]: [] } })\n      availableFormatted.push(formatted)\n      existingIds.add(formatted.id)\n    }\n  }\n\n  /**\n   * Add selected schemes to available if they do not already exist\n   * This ensures that selected schemes with specific scopes are always available as options\n   */\n  for (const selectedScheme of selectedSchemes) {\n    const formatted = formatSecurityRequirement(selectedScheme, securitySchemes)\n    if (formatted && !existingIds.has(formatted.id)) {\n      availableFormatted.push(formatted)\n      existingIds.add(formatted.id)\n    }\n  }\n\n  const options = [\n    { label: 'Required authentication', options: requiredFormatted },\n    { label: 'Available authentication', options: availableFormatted },\n  ]\n\n  // We don't return the groups if we don't have any required schemes\n  if (!canAddNewAuth) {\n    return requiredFormatted.length ? options : availableFormatted\n  }\n\n  // Add new authentication options (unless explicitly hidden)\n  options.push({\n    label: 'Add new authentication',\n    options: Object.entries(authOptions).map(([key, value]) => ({\n      id: key,\n      label: value.label,\n      value: { [key]: [] },\n      payload: value.payload,\n      isDeletable: false,\n    })),\n  })\n\n  return options\n}\n"],"mappings":";;;;AA0BA,IAAM,wBAAwB,gBAC5B,KAAK,UAAU,OAAO,KAAK,YAAY,CAAC;;;;;;;AAQ1C,IAAa,gBAAgB,EAAE,MAAM,aAAiE;CACpG,IAAI,aAAa,KAAK,UAAU,MAAM,CAAC;CACvC,OAAO;CACP;CACA,aAAa;CACd;;AAGD,IAAa,uBAAuB,WAClC,aAAa;CACX,MAAM,OAAO,KAAK,OAAO,CAAC,KAAK,MAAM;CACrC,OAAO;CACR,CAAC;;;;;AAMJ,IAAM,6BACJ,aACA,oBACqC;CACrC,MAAM,OAAO,OAAO,KAAK,YAAY;AAGrC,KAAI,KAAK,SAAS,EAChB,QAAO,oBAAoB,YAAY;AAIzC,KAAI,KAAK,IAAI;AAEX,MAAI,CADW,eAAe,gBAAgB,KAAK,IAAI,CAErD;AAEF,SAAO,aAAa;GAAE,MAAM,KAAK;GAAI,OAAO;GAAa,CAAC;;;;;;;;AAW9D,IAAa,4BACX,UACA,iBAEA,iBAEA,gBAAgB,UACmC;CACnD,MAAM,wBAAwB,IAAI,IAChC,gBAAgB,KAAK,mBAAmB,CAAC,qBAAqB,eAAe,EAAE,eAAe,CAAC,CAChG;;;;;;CAOD,MAAM,EAAE,mBAAmB,qBAAqB,gBAAgB,SAAS,QACtE,KAAK,gBAAgB;EAIpB,MAAM,YAAY,0BADO,sBAAsB,IAAI,qBAAqB,YAAY,CAAC,IAAI,aAC3B,gBAAgB;AAC9E,MAAI,WAAW;AACb,OAAI,kBAAkB,KAAK,UAAU;AACrC,OAAI,YAAY,IAAI,UAAU,GAAG;;AAEnC,OAAK,MAAM,QAAQ,OAAO,KAAK,YAAY,CACzC,KAAI,oBAAoB,IAAI,KAAK;AAEnC,SAAO;IAET;EACE,mBAAmB,EAAE;EACrB,qCAAqB,IAAI,KAAa;EACtC,6BAAa,IAAI,KAAa;EAC/B,CACF;CAGD,MAAM,qBAA6C,EAAE;AACrD,MAAK,MAAM,CAAC,MAAM,cAAc,OAAO,QAAQ,gBAAgB,EAAE;AAC/D,MAAI,oBAAoB,IAAI,KAAK,CAC/B;AAIF,MADe,eAAe,UAAU,EAC5B;GACV,MAAM,YAAY,aAAa;IAAE;IAAM,OAAO,GAAG,OAAO,EAAE,EAAE;IAAE,CAAC;AAC/D,sBAAmB,KAAK,UAAU;AAClC,eAAY,IAAI,UAAU,GAAG;;;;;;;AAQjC,MAAK,MAAM,kBAAkB,iBAAiB;EAC5C,MAAM,YAAY,0BAA0B,gBAAgB,gBAAgB;AAC5E,MAAI,aAAa,CAAC,YAAY,IAAI,UAAU,GAAG,EAAE;AAC/C,sBAAmB,KAAK,UAAU;AAClC,eAAY,IAAI,UAAU,GAAG;;;CAIjC,MAAM,UAAU,CACd;EAAE,OAAO;EAA2B,SAAS;EAAmB,EAChE;EAAE,OAAO;EAA4B,SAAS;EAAoB,CACnE;AAGD,KAAI,CAAC,cACH,QAAO,kBAAkB,SAAS,UAAU;AAI9C,SAAQ,KAAK;EACX,OAAO;EACP,SAAS,OAAO,QAAQ,YAAY,CAAC,KAAK,CAAC,KAAK,YAAY;GAC1D,IAAI;GACJ,OAAO,MAAM;GACb,OAAO,GAAG,MAAM,EAAE,EAAE;GACpB,SAAS,MAAM;GACf,aAAa;GACd,EAAE;EACJ,CAAC;AAEF,QAAO"}

package/dist/v2/blocks/scalar-auth-selector-block/index.d.ts

@@ -1,6 +1,6 @@
-export { default as AuthSelector } from './components/AuthSelector.vue';
-export { isAuthOptional } from './helpers/is-auth-optional';
-export { type MergedSecuritySchemes, mergeSecurity } from './helpers/merge-security';
-export type { OAuth2Tokens } from './helpers/oauth';
+export { default as AuthSelector } from './components/AuthSelector.vue.js';
+export { isAuthOptional } from './helpers/is-auth-optional.js';
+export { type MergedSecuritySchemes, mergeSecurity } from './helpers/merge-security.js';
+export type { OAuth2Tokens } from './helpers/oauth.js';
 export type { SecuritySchemeObjectSecret } from './helpers/secret-types';
 //# sourceMappingURL=index.d.ts.map

package/dist/v2/blocks/scalar-auth-selector-block/index.js

@@ -1,6 +1,4 @@
-import "../../../CodeInput-BTN8cC5h.js";
-import "../../../DataTableInput-RydMDjn2.js";
-import "../../../code-input-iq-moLxi.js";
-import "../../../data-table-PL7e8NRO.js";
-import { n as AuthSelector_default, r as isAuthOptional, t as mergeSecurity } from "../../../scalar-auth-selector-block-Bs79QOMA.js";
+import { isAuthOptional } from "./helpers/is-auth-optional.js";
+import AuthSelector_default from "./components/AuthSelector.vue.js";
+import { mergeSecurity } from "./helpers/merge-security.js";
 export { AuthSelector_default as AuthSelector, isAuthOptional, mergeSecurity };

package/dist/v2/components/callout/Callout.vue.js

@@ -0,0 +1,9 @@
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.js";
+import Callout_vue_vue_type_script_setup_true_lang_default from "./Callout.vue.script.js";
+/* empty css                      */
+//#region src/v2/components/callout/Callout.vue
+var Callout_default = /* @__PURE__ */ _plugin_vue_export_helper_default(Callout_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-fa58cbab"]]);
+//#endregion
+export { Callout_default as default };
+
+//# sourceMappingURL=Callout.vue.js.map

package/dist/v2/components/callout/Callout.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Callout.vue.js","names":[],"sources":["../../../../src/v2/components/callout/Callout.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport {\n  ScalarIconCheckCircle,\n  ScalarIconInfo,\n  ScalarIconWarning,\n  ScalarIconWarningCircle,\n} from '@scalar/icons'\n\ntype CalloutType = 'info' | 'success' | 'warning' | 'danger' | 'neutral'\n\nconst { type } = defineProps<{\n  type: CalloutType\n}>()\n\nconst slots = defineSlots<{\n  default: () => string\n  actions?: () => string\n}>()\n\nconst iconsMapping = {\n  info: ScalarIconInfo,\n  success: ScalarIconCheckCircle,\n  warning: ScalarIconWarning,\n  danger: ScalarIconWarningCircle,\n  neutral: ScalarIconInfo,\n} satisfies Record<CalloutType, unknown>\n</script>\n\n<template>\n  <div :class=\"`callout t-editor__callout callout__${type}`\">\n    <div class=\"flex w-full flex-col gap-2\">\n      <div class=\"flex items-start gap-2\">\n        <div\n          class=\"callout-content__icon\"\n          data-scalar-name=\"callout-icon\">\n          <component\n            :is=\"iconsMapping[type]\"\n            class=\"size-5 shrink-0\" />\n        </div>\n        <div class=\"callout-content__text\">\n          <slots.default />\n        </div>\n      </div>\n      <div\n        v-if=\"slots.actions\"\n        class=\"flex justify-end gap-2\">\n        <slots.actions />\n      </div>\n    </div>\n  </div>\n</template>\n<style scoped>\n/* ----------------------------------------------------- */\n/* Custom Callout Styles */\n\n.dark-mode .t-editor__callout,\n.light-mode .t-editor__callout {\n  --callout-font-size: var(--scalar-small);\n\n  --callout-neutral-primary: var(--scalar-color-3);\n  --callout-neutral-secondary: color-mix(\n    in srgb,\n    var(--scalar-background-2),\n    transparent 50%\n  );\n  --callout-neutral-font-color: var(--scalar-color-1);\n\n  --callout-success-primary: var(--scalar-color-green);\n  --callout-success-secondary: color-mix(\n    in srgb,\n    var(--scalar-color-green),\n    transparent 97%\n  );\n  --callout-success-font-color: var(--scalar-color-1);\n\n  --callout-danger-primary: var(--scalar-color-red);\n  --callout-danger-secondary: color-mix(\n    in srgb,\n    var(--scalar-color-red),\n    transparent 97%\n  );\n  --callout-danger-font-color: var(--scalar-color-1);\n\n  --callout-warning-primary: var(--scalar-color-yellow);\n  --callout-warning-secondary: color-mix(\n    in srgb,\n    var(--scalar-color-yellow),\n    transparent 97%\n  );\n  --callout-warning-font-color: var(--scalar-color-1);\n\n  --callout-info-primary: var(--scalar-color-blue);\n  --callout-info-secondary: color-mix(\n    in srgb,\n    var(--scalar-color-blue),\n    transparent 97%\n  );\n  --callout-info-font-color: var(--scalar-color-1);\n\n  --callout-line-height: 22px;\n}\n\n.t-editor__callout {\n  border-radius: var(--scalar-radius);\n  margin-top: var(--scalar-block-spacing);\n  padding: 10px 14px;\n\n  --callout-primary: var(--scalar-border-color);\n  --callout-secondary: var(--scalar-background-2);\n  --callout-svg: var(--callout-primary);\n\n  background: var(--callout-secondary);\n  border: var(--scalar-border-width) solid\n    color-mix(in srgb, var(--callout-primary), transparent 50%);\n}\n\n.t-editor__callout .callout-content__text {\n  font-size: var(--callout-font-size);\n  flex: 1 1 0%;\n  line-height: var(--callout-line-height);\n}\n\n.t-editor__callout .callout-content__icon {\n  position: relative;\n  border-radius: var(--scalar-radius);\n  width: 18px;\n  height: fit-content;\n  color: var(--callout-svg);\n  display: flex;\n  align-items: center;\n  justify-content: center;\n}\n\n.t-editor__callout .callout-content__icon svg,\n.t-editor__callout .callout-content__icon img {\n  width: 18px;\n  height: 18px;\n}\n\n/* vertical align icon to text, don't remove this */\n.t-editor__callout .callout-content__icon:before {\n  content: '\\200b';\n  line-height: var(--callout-line-height);\n}\n\n/* Apply callout colors */\n.t-editor__callout.callout__neutral {\n  --callout-primary: var(--callout-neutral-primary);\n  --callout-secondary: var(--callout-neutral-secondary);\n  --callout-font-color: var(--callout-neutral-font-color);\n  --callout-svg: var(--callout-neutral-font-color);\n}\n\n.t-editor__callout.callout__info {\n  --callout-primary: var(--callout-info-primary);\n  --callout-secondary: var(--callout-info-secondary);\n  --callout-font-color: var(--callout-info-font-color);\n  --callout-svg: var(--callout-info-primary);\n}\n\n.t-editor__callout.callout__warning {\n  --callout-primary: var(--callout-warning-primary);\n  --callout-secondary: var(--callout-warning-secondary);\n  --callout-font-color: var(--callout-warning-font-color);\n  --callout-svg: var(--callout-warning-primary);\n}\n\n.t-editor__callout.callout__success {\n  --callout-primary: var(--callout-success-primary);\n  --callout-secondary: var(--callout-success-secondary);\n  --callout-font-color: var(--callout-success-font-color);\n  --callout-svg: var(--callout-success-primary);\n}\n\n.t-editor__callout.callout__danger {\n  --callout-primary: var(--callout-danger-primary);\n  --callout-secondary: var(--callout-danger-secondary);\n  --callout-font-color: var(--callout-danger-font-color);\n  --callout-svg: var(--callout-danger-primary);\n}\n</style>\n"],"mappings":""}

package/dist/v2/components/callout/Callout.vue.script.js

@@ -0,0 +1,35 @@
+import { createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, normalizeClass, openBlock, resolveDynamicComponent, useSlots } from "vue";
+import { ScalarIconCheckCircle, ScalarIconInfo, ScalarIconWarning, ScalarIconWarningCircle } from "@scalar/icons";
+//#region src/v2/components/callout/Callout.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "flex w-full flex-col gap-2" };
+var _hoisted_2 = { class: "flex items-start gap-2" };
+var _hoisted_3 = {
+	class: "callout-content__icon",
+	"data-scalar-name": "callout-icon"
+};
+var _hoisted_4 = { class: "callout-content__text" };
+var _hoisted_5 = {
+	key: 0,
+	class: "flex justify-end gap-2"
+};
+var Callout_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "Callout",
+	props: { type: {} },
+	setup(__props) {
+		const slots = useSlots();
+		const iconsMapping = {
+			info: ScalarIconInfo,
+			success: ScalarIconCheckCircle,
+			warning: ScalarIconWarning,
+			danger: ScalarIconWarningCircle,
+			neutral: ScalarIconInfo
+		};
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass(`callout t-editor__callout callout__${__props.type}`) }, [createElementVNode("div", _hoisted_1, [createElementVNode("div", _hoisted_2, [createElementVNode("div", _hoisted_3, [(openBlock(), createBlock(resolveDynamicComponent(iconsMapping[__props.type]), { class: "size-5 shrink-0" }))]), createElementVNode("div", _hoisted_4, [createVNode(slots.default)])]), slots.actions ? (openBlock(), createElementBlock("div", _hoisted_5, [createVNode(slots.actions)])) : createCommentVNode("", true)])], 2);
+		};
+	}
+});
+//#endregion
+export { Callout_vue_vue_type_script_setup_true_lang_default as default };
+
+//# sourceMappingURL=Callout.vue.script.js.map