@scalar/api-reference 1.60.0 → 1.62.0

package/dist/features/localization/translations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/features/localization/translations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAA4B,MAAM,6BAA6B,CAAA;AAUtG,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQwC,CAAA;AAEvE,eAAO,MAAM,cAAc,EAAE,yBAAgC,CAAA;AAE7D,eAAO,MAAM,WAAW,aAAoC,CAAA"}

package/dist/features/localization/translations.js

@@ -0,0 +1,27 @@
+import { ar } from "./locales/ar.js";
+import { de } from "./locales/de.js";
+import { en } from "./locales/en.js";
+import { es } from "./locales/es.js";
+import { fr } from "./locales/fr.js";
+import { ru } from "./locales/ru.js";
+import { zhCn } from "./locales/zh-cn.js";
+//#region src/features/localization/translations.ts
+var localeTranslations = {
+	en,
+	ru,
+	es,
+	fr,
+	de,
+	"zh-CN": zhCn,
+	ar
+};
+var RTL_LOCALES = new Set([
+	"ar",
+	"fa",
+	"he",
+	"ur"
+]);
+//#endregion
+export { RTL_LOCALES, localeTranslations };
+
+//# sourceMappingURL=translations.js.map

package/dist/features/localization/translations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.js","names":[],"sources":["../../../src/features/localization/translations.ts"],"sourcesContent":["import type { ApiReferenceBuiltInLocale, ApiReferenceTranslations } from '@scalar/types/api-reference'\n\nimport { ar } from './locales/ar'\nimport { de } from './locales/de'\nimport { en } from './locales/en'\nimport { es } from './locales/es'\nimport { fr } from './locales/fr'\nimport { ru } from './locales/ru'\nimport { zhCn } from './locales/zh-cn'\n\nexport const localeTranslations = {\n  en,\n  ru,\n  es,\n  fr,\n  de,\n  'zh-CN': zhCn,\n  ar,\n} satisfies Record<ApiReferenceBuiltInLocale, ApiReferenceTranslations>\n\nexport const DEFAULT_LOCALE: ApiReferenceBuiltInLocale = 'en'\n\nexport const RTL_LOCALES = new Set(['ar', 'fa', 'he', 'ur'])\n"],"mappings":";;;;;;;;AAUA,IAAa,qBAAqB;CAChC;CACA;CACA;CACA;CACA;CACA,SAAS;CACT;CACD;AAID,IAAa,cAAc,IAAI,IAAI;CAAC;CAAM;CAAM;CAAM;CAAK,CAAC"}

package/dist/features/localization/use-localization.d.ts

@@ -0,0 +1,18 @@
+import type { ApiReferenceLocale, ApiReferenceLocalization, ApiReferenceTextDirection, ApiReferenceTranslationKey, ApiReferenceTranslations } from '@scalar/types/api-reference';
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+type LocalizationContext = {
+    locale: ComputedRef<ApiReferenceLocale>;
+    direction: ComputedRef<ApiReferenceTextDirection>;
+    translations: ComputedRef<ApiReferenceTranslations>;
+    translate: (key: ApiReferenceTranslationKey, params?: Record<string, number | string>) => string;
+};
+type ResolvedLocalization = {
+    locale: ApiReferenceLocale;
+    direction: ApiReferenceTextDirection;
+    translations: ApiReferenceTranslations;
+};
+export declare const resolveLocalization: (localization?: ApiReferenceLocalization) => ResolvedLocalization;
+export declare const provideLocalization: (localization: MaybeRefOrGetter<ApiReferenceLocalization | undefined>) => LocalizationContext;
+export declare const useLocalization: () => LocalizationContext;
+export {};
+//# sourceMappingURL=use-localization.d.ts.map

package/dist/features/localization/use-localization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-localization.d.ts","sourceRoot":"","sources":["../../../src/features/localization/use-localization.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,kBAAkB,EAClB,wBAAwB,EACxB,yBAAyB,EACzB,0BAA0B,EAC1B,wBAAwB,EACzB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,KAAK,WAAW,EAAqB,KAAK,gBAAgB,EAAsC,MAAM,KAAK,CAAA;AAIpH,KAAK,mBAAmB,GAAG;IACzB,MAAM,EAAE,WAAW,CAAC,kBAAkB,CAAC,CAAA;IACvC,SAAS,EAAE,WAAW,CAAC,yBAAyB,CAAC,CAAA;IACjD,YAAY,EAAE,WAAW,CAAC,wBAAwB,CAAC,CAAA;IACnD,SAAS,EAAE,CAAC,GAAG,EAAE,0BAA0B,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,MAAM,CAAA;CACjG,CAAA;AAED,KAAK,oBAAoB,GAAG;IAC1B,MAAM,EAAE,kBAAkB,CAAA;IAC1B,SAAS,EAAE,yBAAyB,CAAA;IACpC,YAAY,EAAE,wBAAwB,CAAA;CACvC,CAAA;AAoCD,eAAO,MAAM,mBAAmB,GAAI,eAAe,wBAAwB,KAAG,oBAa7E,CAAA;AA+CD,eAAO,MAAM,mBAAmB,GAAI,cAAc,gBAAgB,CAAC,wBAAwB,GAAG,SAAS,CAAC,wBAMvG,CAAA;AAED,eAAO,MAAM,eAAe,QAAO,mBACgC,CAAA"}

package/dist/features/localization/use-localization.js

@@ -0,0 +1,58 @@
+import { RTL_LOCALES, localeTranslations } from "./translations.js";
+import { computed, inject, provide, toValue } from "vue";
+import { isObject } from "@scalar/helpers/object/is-object";
+import { mergeObjects } from "@scalar/helpers/object/merge-objects";
+//#region src/features/localization/use-localization.ts
+var LOCALIZATION_SYMBOL = Symbol("LOCALIZATION");
+var resolveBuiltInLocale = (locale) => {
+	if (!locale) return "en";
+	if (locale in localeTranslations) return locale;
+	const normalized = locale.replace("_", "-").toLowerCase();
+	if (normalized.startsWith("zh")) return "zh-CN";
+	const language = normalized.split("-")[0];
+	return Object.keys(localeTranslations).find((key) => key.toLowerCase() === language) ?? "en";
+};
+var resolveDirection = (localization) => {
+	if (localization?.direction && localization.direction !== "auto") return localization.direction;
+	const language = (localization?.locale ?? "en").replace("_", "-").split("-")[0]?.toLowerCase();
+	return language && RTL_LOCALES.has(language) ? "rtl" : "ltr";
+};
+var resolveLocalization = (localization) => {
+	const locale = localization?.locale ?? "en";
+	const builtInLocale = resolveBuiltInLocale(locale);
+	const translations = mergeObjects(mergeObjects(localeTranslations.en, localeTranslations[builtInLocale]), localization?.translations);
+	return {
+		locale,
+		direction: resolveDirection(localization),
+		translations
+	};
+};
+var getTranslationValue = (translations, key) => key.split(".").reduce((value, segment) => {
+	if (!isObject(value)) return;
+	return value[segment];
+}, translations);
+var translateApiReference = (translations, key, params) => {
+	const value = getTranslationValue(translations, key);
+	const template = typeof value === "string" ? value : key;
+	if (!params) return template;
+	return Object.entries(params).reduce((result, [param, paramValue]) => result.replaceAll(`{${param}}`, String(paramValue)), template);
+};
+var createLocalizationContext = (localization) => {
+	const resolved = computed(() => resolveLocalization(toValue(localization)));
+	return {
+		locale: computed(() => resolved.value.locale),
+		direction: computed(() => resolved.value.direction),
+		translations: computed(() => resolved.value.translations),
+		translate: (key, params) => translateApiReference(resolved.value.translations, key, params)
+	};
+};
+var provideLocalization = (localization) => {
+	const context = createLocalizationContext(localization);
+	provide(LOCALIZATION_SYMBOL, context);
+	return context;
+};
+var useLocalization = () => inject(LOCALIZATION_SYMBOL, createLocalizationContext(void 0));
+//#endregion
+export { provideLocalization, resolveLocalization, useLocalization };
+
+//# sourceMappingURL=use-localization.js.map

package/dist/features/localization/use-localization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-localization.js","names":[],"sources":["../../../src/features/localization/use-localization.ts"],"sourcesContent":["import { isObject } from '@scalar/helpers/object/is-object'\nimport { mergeObjects } from '@scalar/helpers/object/merge-objects'\nimport type {\n  ApiReferenceLocale,\n  ApiReferenceLocalization,\n  ApiReferenceTextDirection,\n  ApiReferenceTranslationKey,\n  ApiReferenceTranslations,\n} from '@scalar/types/api-reference'\nimport { type ComputedRef, type InjectionKey, type MaybeRefOrGetter, computed, inject, provide, toValue } from 'vue'\n\nimport { DEFAULT_LOCALE, RTL_LOCALES, localeTranslations } from './translations'\n\ntype LocalizationContext = {\n  locale: ComputedRef<ApiReferenceLocale>\n  direction: ComputedRef<ApiReferenceTextDirection>\n  translations: ComputedRef<ApiReferenceTranslations>\n  translate: (key: ApiReferenceTranslationKey, params?: Record<string, number | string>) => string\n}\n\ntype ResolvedLocalization = {\n  locale: ApiReferenceLocale\n  direction: ApiReferenceTextDirection\n  translations: ApiReferenceTranslations\n}\n\nconst LOCALIZATION_SYMBOL: InjectionKey<LocalizationContext> = Symbol('LOCALIZATION')\n\nconst resolveBuiltInLocale = (locale?: ApiReferenceLocale): keyof typeof localeTranslations => {\n  if (!locale) {\n    return DEFAULT_LOCALE\n  }\n\n  if (locale in localeTranslations) {\n    return locale as keyof typeof localeTranslations\n  }\n\n  const normalized = locale.replace('_', '-').toLowerCase()\n\n  if (normalized.startsWith('zh')) {\n    return 'zh-CN'\n  }\n\n  const language = normalized.split('-')[0]\n  const match = Object.keys(localeTranslations).find((key) => key.toLowerCase() === language)\n\n  return (match as keyof typeof localeTranslations | undefined) ?? DEFAULT_LOCALE\n}\n\nconst resolveDirection = (localization?: ApiReferenceLocalization): ApiReferenceTextDirection => {\n  if (localization?.direction && localization.direction !== 'auto') {\n    return localization.direction\n  }\n\n  const locale = localization?.locale ?? DEFAULT_LOCALE\n  const language = locale.replace('_', '-').split('-')[0]?.toLowerCase()\n\n  return language && RTL_LOCALES.has(language) ? 'rtl' : 'ltr'\n}\n\nexport const resolveLocalization = (localization?: ApiReferenceLocalization): ResolvedLocalization => {\n  const locale = localization?.locale ?? DEFAULT_LOCALE\n  const builtInLocale = resolveBuiltInLocale(locale)\n  const translations = mergeObjects(\n    mergeObjects(localeTranslations.en, localeTranslations[builtInLocale]),\n    localization?.translations,\n  )\n\n  return {\n    locale,\n    direction: resolveDirection(localization),\n    translations,\n  }\n}\n\nconst getTranslationValue = (translations: ApiReferenceTranslations, key: ApiReferenceTranslationKey) =>\n  key.split('.').reduce<unknown>((value, segment) => {\n    if (!isObject(value)) {\n      return undefined\n    }\n\n    return value[segment]\n  }, translations)\n\nconst translateApiReference = (\n  translations: ApiReferenceTranslations,\n  key: ApiReferenceTranslationKey,\n  params?: Record<string, number | string>,\n): string => {\n  const value = getTranslationValue(translations, key)\n\n  if (typeof value !== 'string' && import.meta.env.DEV) {\n    console.warn(`[@scalar/api-reference] Missing translation for key \"${key}\". Falling back to the key itself.`)\n  }\n\n  const template = typeof value === 'string' ? value : key\n\n  if (!params) {\n    return template\n  }\n\n  return Object.entries(params).reduce(\n    (result, [param, paramValue]) => result.replaceAll(`{${param}}`, String(paramValue)),\n    template,\n  )\n}\n\nconst createLocalizationContext = (\n  localization: MaybeRefOrGetter<ApiReferenceLocalization | undefined>,\n): LocalizationContext => {\n  const resolved = computed(() => resolveLocalization(toValue(localization)))\n\n  return {\n    locale: computed(() => resolved.value.locale),\n    direction: computed(() => resolved.value.direction),\n    translations: computed(() => resolved.value.translations),\n    translate: (key, params) => translateApiReference(resolved.value.translations, key, params),\n  }\n}\n\nexport const provideLocalization = (localization: MaybeRefOrGetter<ApiReferenceLocalization | undefined>) => {\n  const context = createLocalizationContext(localization)\n\n  provide(LOCALIZATION_SYMBOL, context)\n\n  return context\n}\n\nexport const useLocalization = (): LocalizationContext =>\n  inject(LOCALIZATION_SYMBOL, createLocalizationContext(undefined))\n"],"mappings":";;;;;AA0BA,IAAM,sBAAyD,OAAO,eAAe;AAErF,IAAM,wBAAwB,WAAiE;AAC7F,KAAI,CAAC,OACH,QAAA;AAGF,KAAI,UAAU,mBACZ,QAAO;CAGT,MAAM,aAAa,OAAO,QAAQ,KAAK,IAAI,CAAC,aAAa;AAEzD,KAAI,WAAW,WAAW,KAAK,CAC7B,QAAO;CAGT,MAAM,WAAW,WAAW,MAAM,IAAI,CAAC;AAGvC,QAFc,OAAO,KAAK,mBAAmB,CAAC,MAAM,QAAQ,IAAI,aAAa,KAAK,SAAS,IAAA;;AAK7F,IAAM,oBAAoB,iBAAuE;AAC/F,KAAI,cAAc,aAAa,aAAa,cAAc,OACxD,QAAO,aAAa;CAItB,MAAM,YADS,cAAc,UAAA,MACL,QAAQ,KAAK,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,aAAa;AAEtE,QAAO,YAAY,YAAY,IAAI,SAAS,GAAG,QAAQ;;AAGzD,IAAa,uBAAuB,iBAAkE;CACpG,MAAM,SAAS,cAAc,UAAA;CAC7B,MAAM,gBAAgB,qBAAqB,OAAO;CAClD,MAAM,eAAe,aACnB,aAAa,mBAAmB,IAAI,mBAAmB,eAAe,EACtE,cAAc,aACf;AAED,QAAO;EACL;EACA,WAAW,iBAAiB,aAAa;EACzC;EACD;;AAGH,IAAM,uBAAuB,cAAwC,QACnE,IAAI,MAAM,IAAI,CAAC,QAAiB,OAAO,YAAY;AACjD,KAAI,CAAC,SAAS,MAAM,CAClB;AAGF,QAAO,MAAM;GACZ,aAAa;AAElB,IAAM,yBACJ,cACA,KACA,WACW;CACX,MAAM,QAAQ,oBAAoB,cAAc,IAAI;CAMpD,MAAM,WAAW,OAAO,UAAU,WAAW,QAAQ;AAErD,KAAI,CAAC,OACH,QAAO;AAGT,QAAO,OAAO,QAAQ,OAAO,CAAC,QAC3B,QAAQ,CAAC,OAAO,gBAAgB,OAAO,WAAW,IAAI,MAAM,IAAI,OAAO,WAAW,CAAC,EACpF,SACD;;AAGH,IAAM,6BACJ,iBACwB;CACxB,MAAM,WAAW,eAAe,oBAAoB,QAAQ,aAAa,CAAC,CAAC;AAE3E,QAAO;EACL,QAAQ,eAAe,SAAS,MAAM,OAAO;EAC7C,WAAW,eAAe,SAAS,MAAM,UAAU;EACnD,cAAc,eAAe,SAAS,MAAM,aAAa;EACzD,YAAY,KAAK,WAAW,sBAAsB,SAAS,MAAM,cAAc,KAAK,OAAO;EAC5F;;AAGH,IAAa,uBAAuB,iBAAyE;CAC3G,MAAM,UAAU,0BAA0B,aAAa;AAEvD,SAAQ,qBAAqB,QAAQ;AAErC,QAAO;;AAGT,IAAa,wBACX,OAAO,qBAAqB,0BAA0B,KAAA,EAAU,CAAC"}

package/dist/features/multiple-documents/DocumentSelector.vue.script.js

@@ -1,6 +1,6 @@
 import { computed, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, normalizeClass, openBlock, toDisplayString, unref, withCtx } from "vue";
-import { ScalarIconCaretDown } from "@scalar/icons";
 import { ScalarListbox } from "@scalar/components/listbox";
+import { ScalarIconCaretDown } from "@scalar/icons";
 //#region src/features/multiple-documents/DocumentSelector.vue?vue&type=script&setup=true&lang.ts
 var _hoisted_1 = {
 	key: 0,

package/dist/features/test-request-button/TestRequestButton.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TestRequestButton.vue.d.ts","sourceRoot":"","sources":["../../../src/features/test-request-button/TestRequestButton.vue"],"names":[],"mappings":"AA0FA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAEnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AAIvE,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,+BAA+B,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACzD,CAAC;AAuFF,QAAA,MAAM,YAAY,kSAEhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}
+{"version":3,"file":"TestRequestButton.vue.d.ts","sourceRoot":"","sources":["../../../src/features/test-request-button/TestRequestButton.vue"],"names":[],"mappings":"AA4FA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAEnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AAKvE,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,+BAA+B,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACzD,CAAC;AA0FF,QAAA,MAAM,YAAY,kSAEhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/features/test-request-button/TestRequestButton.vue.js

@@ -2,7 +2,7 @@ import _plugin_vue_export_helper_default from "../../_virtual/_plugin-vue_export
 import TestRequestButton_vue_vue_type_script_setup_true_lang_default from "./TestRequestButton.vue.script.js";
 /* empty css                                */
 //#region src/features/test-request-button/TestRequestButton.vue
-var TestRequestButton_default = /* @__PURE__ */ _plugin_vue_export_helper_default(TestRequestButton_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-15e312d9"]]);
+var TestRequestButton_default = /* @__PURE__ */ _plugin_vue_export_helper_default(TestRequestButton_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-ad72d914"]]);
 //#endregion
 export { TestRequestButton_default as default };
 

package/dist/features/test-request-button/TestRequestButton.vue.js.map

@@ -1 +1 @@
-{"version":3,"file":"TestRequestButton.vue.js","names":[],"sources":["../../../src/features/test-request-button/TestRequestButton.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport type { HttpMethod } from '@scalar/helpers/http/http-methods'\nimport { ScalarIconPlay } from '@scalar/icons'\nimport type { WorkspaceEventBus } from '@scalar/workspace-store/events'\n\nimport ScreenReader from '@/components/ScreenReader.vue'\n\nconst {\n  id,\n  method,\n  path,\n  eventBus,\n  exampleName,\n  requestBodyCompositionSelection,\n} = defineProps<{\n  id: string\n  method: HttpMethod\n  path: string\n  eventBus: WorkspaceEventBus\n  exampleName?: string\n  requestBodyCompositionSelection?: Record<string, number>\n}>()\n\n/** Route via ID and optionally with example name */\nconst handleClick = () => {\n  // Include exampleName in payload if provided\n  const payload = {\n    id,\n    ...(exampleName && { exampleName }),\n    ...(requestBodyCompositionSelection &&\n      Object.keys(requestBodyCompositionSelection).length > 0 && {\n        requestBodyCompositionSelection,\n      }),\n  }\n  eventBus.emit('ui:open:client-modal', payload)\n}\n</script>\n<template>\n  <!-- Render the Test Request Button -->\n  <button\n    class=\"show-api-client-button\"\n    :method=\"method\"\n    type=\"button\"\n    @click.stop=\"handleClick\">\n    <ScalarIconPlay\n      class=\"size-3\"\n      weight=\"fill\" />\n    <span>Test Request</span>\n    <ScreenReader>({{ method }} {{ path }})</ScreenReader>\n  </button>\n</template>\n<style scoped>\n.show-api-client-button {\n  appearance: none;\n  border: none;\n  padding: 1px 6px;\n  white-space: nowrap;\n  border-radius: var(--scalar-radius);\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  font-weight: var(--scalar-semibold);\n  font-size: var(--scalar-small);\n  line-height: 22px;\n  color: var(--scalar-background-2);\n  font-family: var(--scalar-font);\n  background: var(--scalar-button-1);\n  position: relative;\n  cursor: pointer;\n  box-sizing: border-box;\n  box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.1);\n\n  outline-offset: 2px;\n}\n.show-api-client-button span,\n.show-api-client-button svg {\n  fill: currentColor;\n  color: var(--scalar-button-1-color);\n  z-index: 1;\n}\n.show-api-client-button:hover {\n  background: var(--scalar-button-1-hover);\n}\n.show-api-client-button svg {\n  margin-right: 4px;\n}\n</style>\n"],"mappings":""}
+{"version":3,"file":"TestRequestButton.vue.js","names":[],"sources":["../../../src/features/test-request-button/TestRequestButton.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport type { HttpMethod } from '@scalar/helpers/http/http-methods'\nimport { ScalarIconPlay } from '@scalar/icons'\nimport type { WorkspaceEventBus } from '@scalar/workspace-store/events'\n\nimport ScreenReader from '@/components/ScreenReader.vue'\nimport { useLocalization } from '@/features/localization'\n\nconst {\n  id,\n  method,\n  path,\n  eventBus,\n  exampleName,\n  requestBodyCompositionSelection,\n} = defineProps<{\n  id: string\n  method: HttpMethod\n  path: string\n  eventBus: WorkspaceEventBus\n  exampleName?: string\n  requestBodyCompositionSelection?: Record<string, number>\n}>()\nconst { translate } = useLocalization()\n\n/** Route via ID and optionally with example name */\nconst handleClick = () => {\n  // Include exampleName in payload if provided\n  const payload = {\n    id,\n    ...(exampleName && { exampleName }),\n    ...(requestBodyCompositionSelection &&\n      Object.keys(requestBodyCompositionSelection).length > 0 && {\n        requestBodyCompositionSelection,\n      }),\n  }\n  eventBus.emit('ui:open:client-modal', payload)\n}\n</script>\n<template>\n  <!-- Render the Test Request Button -->\n  <button\n    class=\"show-api-client-button\"\n    :method=\"method\"\n    type=\"button\"\n    @click.stop=\"handleClick\">\n    <ScalarIconPlay\n      class=\"size-3\"\n      weight=\"fill\" />\n    <span>{{ translate('operation.testRequest') }}</span>\n    <ScreenReader>({{ method }} {{ path }})</ScreenReader>\n  </button>\n</template>\n<style scoped>\n.show-api-client-button {\n  appearance: none;\n  border: none;\n  padding: 1px 6px;\n  white-space: nowrap;\n  border-radius: var(--scalar-radius);\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  font-weight: var(--scalar-semibold);\n  font-size: var(--scalar-small);\n  line-height: 22px;\n  color: var(--scalar-background-2);\n  font-family: var(--scalar-font);\n  background: var(--scalar-button-1);\n  position: relative;\n  cursor: pointer;\n  box-sizing: border-box;\n  box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.1);\n\n  outline-offset: 2px;\n}\n.show-api-client-button span,\n.show-api-client-button svg {\n  fill: currentColor;\n  color: var(--scalar-button-1-color);\n  z-index: 1;\n}\n.show-api-client-button:hover {\n  background: var(--scalar-button-1-hover);\n}\n.show-api-client-button svg {\n  margin-right: 4px;\n}\n</style>\n"],"mappings":""}

package/dist/features/test-request-button/TestRequestButton.vue.script.js

@@ -1,3 +1,4 @@
+import { useLocalization } from "../localization/use-localization.js";
 import ScreenReader_default from "../../components/ScreenReader.vue.js";
 import { createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, openBlock, toDisplayString, unref, withCtx, withModifiers } from "vue";
 import { ScalarIconPlay } from "@scalar/icons";
@@ -14,6 +15,7 @@ var TestRequestButton_vue_vue_type_script_setup_true_lang_default = /* @__PURE__
 		requestBodyCompositionSelection: {}
 	},
 	setup(__props) {
+		const { translate } = useLocalization();
 		/** Route via ID and optionally with example name */
 		const handleClick = () => {
 			const payload = {
@@ -34,7 +36,7 @@ var TestRequestButton_vue_vue_type_script_setup_true_lang_default = /* @__PURE__
 					class: "size-3",
 					weight: "fill"
 				}),
-				_cache[0] || (_cache[0] = createElementVNode("span", null, "Test Request", -1)),
+				createElementVNode("span", null, toDisplayString(unref(translate)("operation.testRequest")), 1),
 				createVNode(ScreenReader_default, null, {
 					default: withCtx(() => [createTextVNode("(" + toDisplayString(__props.method) + " " + toDisplayString(__props.path) + ")", 1)]),
 					_: 1

package/dist/features/test-request-button/TestRequestButton.vue.script.js.map

@@ -1 +1 @@
-{"version":3,"file":"TestRequestButton.vue.script.js","names":[],"sources":["../../../src/features/test-request-button/TestRequestButton.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport type { HttpMethod } from '@scalar/helpers/http/http-methods'\nimport { ScalarIconPlay } from '@scalar/icons'\nimport type { WorkspaceEventBus } from '@scalar/workspace-store/events'\n\nimport ScreenReader from '@/components/ScreenReader.vue'\n\nconst {\n  id,\n  method,\n  path,\n  eventBus,\n  exampleName,\n  requestBodyCompositionSelection,\n} = defineProps<{\n  id: string\n  method: HttpMethod\n  path: string\n  eventBus: WorkspaceEventBus\n  exampleName?: string\n  requestBodyCompositionSelection?: Record<string, number>\n}>()\n\n/** Route via ID and optionally with example name */\nconst handleClick = () => {\n  // Include exampleName in payload if provided\n  const payload = {\n    id,\n    ...(exampleName && { exampleName }),\n    ...(requestBodyCompositionSelection &&\n      Object.keys(requestBodyCompositionSelection).length > 0 && {\n        requestBodyCompositionSelection,\n      }),\n  }\n  eventBus.emit('ui:open:client-modal', payload)\n}\n</script>\n<template>\n  <!-- Render the Test Request Button -->\n  <button\n    class=\"show-api-client-button\"\n    :method=\"method\"\n    type=\"button\"\n    @click.stop=\"handleClick\">\n    <ScalarIconPlay\n      class=\"size-3\"\n      weight=\"fill\" />\n    <span>Test Request</span>\n    <ScreenReader>({{ method }} {{ path }})</ScreenReader>\n  </button>\n</template>\n<style scoped>\n.show-api-client-button {\n  appearance: none;\n  border: none;\n  padding: 1px 6px;\n  white-space: nowrap;\n  border-radius: var(--scalar-radius);\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  font-weight: var(--scalar-semibold);\n  font-size: var(--scalar-small);\n  line-height: 22px;\n  color: var(--scalar-background-2);\n  font-family: var(--scalar-font);\n  background: var(--scalar-button-1);\n  position: relative;\n  cursor: pointer;\n  box-sizing: border-box;\n  box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.1);\n\n  outline-offset: 2px;\n}\n.show-api-client-button span,\n.show-api-client-button svg {\n  fill: currentColor;\n  color: var(--scalar-button-1-color);\n  z-index: 1;\n}\n.show-api-client-button:hover {\n  background: var(--scalar-button-1-hover);\n}\n.show-api-client-button svg {\n  margin-right: 4px;\n}\n</style>\n"],"mappings":";;;;;;;;;;;;;;;;;EAwBA,MAAM,oBAAoB;GAExB,MAAM,UAAU;IACd,IAAC,QAAA;IACD,GAAI,QAAA,eAAe,EAAE,aAAU,QAAA,aAAG;IAClC,GAAI,QAAA,mCACF,OAAO,KAAK,QAAA,gCAAgC,CAAC,SAAS,KAAK,EACzD,iCAA8B,QAAA,iCAC/B;IACL;AACA,WAAA,SAAS,KAAK,wBAAwB,QAAO;;;uBAK7C,mBAUS,UAAA;IATP,OAAM;IACL,QAAQ,QAAA;IACT,MAAK;IACJ,SAAK,cAAO,aAAW,CAAA,OAAA,CAAA;;IACxB,YAEkB,MAAA,eAAA,EAAA;KADhB,OAAM;KACN,QAAO;;8BACT,mBAAyB,QAAA,MAAnB,gBAAY,GAAA;IAClB,YAAsD,sBAAA,MAAA;4BAAvC,CAAA,gBAAD,MAAC,gBAAG,QAAA,OAAM,GAAG,MAAC,gBAAG,QAAA,KAAI,GAAG,KAAC,EAAA,CAAA,CAAA"}
+{"version":3,"file":"TestRequestButton.vue.script.js","names":[],"sources":["../../../src/features/test-request-button/TestRequestButton.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport type { HttpMethod } from '@scalar/helpers/http/http-methods'\nimport { ScalarIconPlay } from '@scalar/icons'\nimport type { WorkspaceEventBus } from '@scalar/workspace-store/events'\n\nimport ScreenReader from '@/components/ScreenReader.vue'\nimport { useLocalization } from '@/features/localization'\n\nconst {\n  id,\n  method,\n  path,\n  eventBus,\n  exampleName,\n  requestBodyCompositionSelection,\n} = defineProps<{\n  id: string\n  method: HttpMethod\n  path: string\n  eventBus: WorkspaceEventBus\n  exampleName?: string\n  requestBodyCompositionSelection?: Record<string, number>\n}>()\nconst { translate } = useLocalization()\n\n/** Route via ID and optionally with example name */\nconst handleClick = () => {\n  // Include exampleName in payload if provided\n  const payload = {\n    id,\n    ...(exampleName && { exampleName }),\n    ...(requestBodyCompositionSelection &&\n      Object.keys(requestBodyCompositionSelection).length > 0 && {\n        requestBodyCompositionSelection,\n      }),\n  }\n  eventBus.emit('ui:open:client-modal', payload)\n}\n</script>\n<template>\n  <!-- Render the Test Request Button -->\n  <button\n    class=\"show-api-client-button\"\n    :method=\"method\"\n    type=\"button\"\n    @click.stop=\"handleClick\">\n    <ScalarIconPlay\n      class=\"size-3\"\n      weight=\"fill\" />\n    <span>{{ translate('operation.testRequest') }}</span>\n    <ScreenReader>({{ method }} {{ path }})</ScreenReader>\n  </button>\n</template>\n<style scoped>\n.show-api-client-button {\n  appearance: none;\n  border: none;\n  padding: 1px 6px;\n  white-space: nowrap;\n  border-radius: var(--scalar-radius);\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  font-weight: var(--scalar-semibold);\n  font-size: var(--scalar-small);\n  line-height: 22px;\n  color: var(--scalar-background-2);\n  font-family: var(--scalar-font);\n  background: var(--scalar-button-1);\n  position: relative;\n  cursor: pointer;\n  box-sizing: border-box;\n  box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.1);\n\n  outline-offset: 2px;\n}\n.show-api-client-button span,\n.show-api-client-button svg {\n  fill: currentColor;\n  color: var(--scalar-button-1-color);\n  z-index: 1;\n}\n.show-api-client-button:hover {\n  background: var(--scalar-button-1-hover);\n}\n.show-api-client-button svg {\n  margin-right: 4px;\n}\n</style>\n"],"mappings":";;;;;;;;;;;;;;;;;EAuBA,MAAM,EAAE,cAAc,iBAAgB;;EAGtC,MAAM,oBAAoB;GAExB,MAAM,UAAU;IACd,IAAC,QAAA;IACD,GAAI,QAAA,eAAe,EAAE,aAAU,QAAA,aAAG;IAClC,GAAI,QAAA,mCACF,OAAO,KAAK,QAAA,gCAAgC,CAAC,SAAS,KAAK,EACzD,iCAA8B,QAAA,iCAC/B;IACL;AACA,WAAA,SAAS,KAAK,wBAAwB,QAAO;;;uBAK7C,mBAUS,UAAA;IATP,OAAM;IACL,QAAQ,QAAA;IACT,MAAK;IACJ,SAAK,cAAO,aAAW,CAAA,OAAA,CAAA;;IACxB,YAEkB,MAAA,eAAA,EAAA;KADhB,OAAM;KACN,QAAO;;IACT,mBAAqD,QAAA,MAAA,gBAA5C,MAAA,UAAS,CAAA,wBAAA,CAAA,EAAA,EAAA;IAClB,YAAsD,sBAAA,MAAA;4BAAvC,CAAA,gBAAD,MAAC,gBAAG,QAAA,OAAM,GAAG,MAAC,gBAAG,QAAA,KAAI,GAAG,KAAC,EAAA,CAAA,CAAA"}

package/dist/helpers/get-async-api-message-payload-schema.d.ts

@@ -0,0 +1,18 @@
+import type { AsyncApiMessageObject } from '@scalar/types/asyncapi/3.1';
+import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+/**
+ * Unwraps an AsyncAPI schema-bearing value into the `SchemaObject` shape the shared OpenAPI
+ * `Schema`/`Model` components expect.
+ *
+ * AsyncAPI reuses JSON Schema, but a value may need extra handling:
+ * - The value itself may be a `$ref`; it is resolved to its `$ref-value`.
+ * - A Multi Format Schema Object (`schemaFormat` plus a nested `schema`) is unwrapped to its
+ *   payload, so we render the inner JSON Schema rather than the wrapper.
+ * - Boolean (`true`/`false`) and non-JSON-Schema payloads are skipped.
+ */
+export declare const unwrapAsyncApiSchema: (value: unknown) => SchemaObject | undefined;
+/** Resolves an AsyncAPI message `payload` into the `SchemaObject` the shared Schema component expects. */
+export declare const getAsyncApiMessagePayloadSchema: (message: AsyncApiMessageObject) => SchemaObject | undefined;
+/** Resolves an AsyncAPI message `headers` into the `SchemaObject` the shared Schema component expects. */
+export declare const getAsyncApiMessageHeadersSchema: (message: AsyncApiMessageObject) => SchemaObject | undefined;
+//# sourceMappingURL=get-async-api-message-payload-schema.d.ts.map

package/dist/helpers/get-async-api-message-payload-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-async-api-message-payload-schema.d.ts","sourceRoot":"","sources":["../../src/helpers/get-async-api-message-payload-schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAEvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAShG;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,KAAG,YAAY,GAAG,SAYpE,CAAA;AAED,0GAA0G;AAC1G,eAAO,MAAM,+BAA+B,GAAI,SAAS,qBAAqB,KAAG,YAAY,GAAG,SACzD,CAAA;AAEvC,0GAA0G;AAC1G,eAAO,MAAM,+BAA+B,GAAI,SAAS,qBAAqB,KAAG,YAAY,GAAG,SACzD,CAAA"}

package/dist/helpers/get-async-api-message-payload-schema.js

@@ -0,0 +1,33 @@
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { isObject } from "@scalar/helpers/object/is-object";
+//#region src/helpers/get-async-api-message-payload-schema.ts
+/**
+* A resolved schema-bearing value may be a JSON Schema object, a boolean (`true`/`false`)
+* schema, or a Multi Format Schema wrapper, so accept only plain objects and treat them as the
+* `SchemaObject` the shared Schema/Model rendering expects.
+*/
+var isSchemaObject = (value) => isObject(value);
+/**
+* Unwraps an AsyncAPI schema-bearing value into the `SchemaObject` shape the shared OpenAPI
+* `Schema`/`Model` components expect.
+*
+* AsyncAPI reuses JSON Schema, but a value may need extra handling:
+* - The value itself may be a `$ref`; it is resolved to its `$ref-value`.
+* - A Multi Format Schema Object (`schemaFormat` plus a nested `schema`) is unwrapped to its
+*   payload, so we render the inner JSON Schema rather than the wrapper.
+* - Boolean (`true`/`false`) and non-JSON-Schema payloads are skipped.
+*/
+var unwrapAsyncApiSchema = (value) => {
+	if (value === void 0) return;
+	const resolved = getResolvedRef(value);
+	const schema = isObject(resolved) && "schemaFormat" in resolved ? getResolvedRef(resolved.schema) : resolved;
+	return isSchemaObject(schema) ? schema : void 0;
+};
+/** Resolves an AsyncAPI message `payload` into the `SchemaObject` the shared Schema component expects. */
+var getAsyncApiMessagePayloadSchema = (message) => unwrapAsyncApiSchema(message.payload);
+/** Resolves an AsyncAPI message `headers` into the `SchemaObject` the shared Schema component expects. */
+var getAsyncApiMessageHeadersSchema = (message) => unwrapAsyncApiSchema(message.headers);
+//#endregion
+export { getAsyncApiMessageHeadersSchema, getAsyncApiMessagePayloadSchema, unwrapAsyncApiSchema };
+
+//# sourceMappingURL=get-async-api-message-payload-schema.js.map

package/dist/helpers/get-async-api-message-payload-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-async-api-message-payload-schema.js","names":[],"sources":["../../src/helpers/get-async-api-message-payload-schema.ts"],"sourcesContent":["import { isObject } from '@scalar/helpers/object/is-object'\nimport type { AsyncApiMessageObject } from '@scalar/types/asyncapi/3.1'\nimport { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\n/**\n * A resolved schema-bearing value may be a JSON Schema object, a boolean (`true`/`false`)\n * schema, or a Multi Format Schema wrapper, so accept only plain objects and treat them as the\n * `SchemaObject` the shared Schema/Model rendering expects.\n */\nconst isSchemaObject = (value: unknown): value is SchemaObject => isObject(value)\n\n/**\n * Unwraps an AsyncAPI schema-bearing value into the `SchemaObject` shape the shared OpenAPI\n * `Schema`/`Model` components expect.\n *\n * AsyncAPI reuses JSON Schema, but a value may need extra handling:\n * - The value itself may be a `$ref`; it is resolved to its `$ref-value`.\n * - A Multi Format Schema Object (`schemaFormat` plus a nested `schema`) is unwrapped to its\n *   payload, so we render the inner JSON Schema rather than the wrapper.\n * - Boolean (`true`/`false`) and non-JSON-Schema payloads are skipped.\n */\nexport const unwrapAsyncApiSchema = (value: unknown): SchemaObject | undefined => {\n  if (value === undefined) {\n    return undefined\n  }\n\n  // Resolve the value the same way OpenAPI model rendering does (plain `$ref-value`).\n  const resolved = getResolvedRef(value)\n\n  // Multi Format Schema Objects carry the real schema under `schema`; unwrap to that payload.\n  const schema = isObject(resolved) && 'schemaFormat' in resolved ? getResolvedRef(resolved.schema) : resolved\n\n  return isSchemaObject(schema) ? schema : undefined\n}\n\n/** Resolves an AsyncAPI message `payload` into the `SchemaObject` the shared Schema component expects. */\nexport const getAsyncApiMessagePayloadSchema = (message: AsyncApiMessageObject): SchemaObject | undefined =>\n  unwrapAsyncApiSchema(message.payload)\n\n/** Resolves an AsyncAPI message `headers` into the `SchemaObject` the shared Schema component expects. */\nexport const getAsyncApiMessageHeadersSchema = (message: AsyncApiMessageObject): SchemaObject | undefined =>\n  unwrapAsyncApiSchema(message.headers)\n"],"mappings":";;;;;;;;AAUA,IAAM,kBAAkB,UAA0C,SAAS,MAAM;;;;;;;;;;;AAYjF,IAAa,wBAAwB,UAA6C;AAChF,KAAI,UAAU,KAAA,EACZ;CAIF,MAAM,WAAW,eAAe,MAAM;CAGtC,MAAM,SAAS,SAAS,SAAS,IAAI,kBAAkB,WAAW,eAAe,SAAS,OAAO,GAAG;AAEpG,QAAO,eAAe,OAAO,GAAG,SAAS,KAAA;;;AAI3C,IAAa,mCAAmC,YAC9C,qBAAqB,QAAQ,QAAQ;;AAGvC,IAAa,mCAAmC,YAC9C,qBAAqB,QAAQ,QAAQ"}

package/dist/helpers/get-async-api-model-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-async-api-model-schema.d.ts","sourceRoot":"","sources":["../../src/helpers/get-async-api-model-schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAShG;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GAAI,UAAU,gBAAgB,EAAE,MAAM,MAAM,KAAG,YAAY,GAAG,SAmBhG,CAAA"}
+{"version":3,"file":"get-async-api-model-schema.d.ts","sourceRoot":"","sources":["../../src/helpers/get-async-api-model-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAIhG;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GAAI,UAAU,gBAAgB,EAAE,MAAM,MAAM,KAAG,YAAY,GAAG,SAWhG,CAAA"}

package/dist/helpers/get-async-api-model-schema.js

@@ -1,13 +1,7 @@
+import { unwrapAsyncApiSchema } from "./get-async-api-message-payload-schema.js";
 import { getResolvedRef, mergeSiblingReferences } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import { isObject } from "@scalar/helpers/object/is-object";
 //#region src/helpers/get-async-api-model-schema.ts
 /**
-* A resolved `components.schemas` entry may be a JSON Schema object, a boolean (`true`/`false`)
-* schema, or a Multi Format Schema wrapper, so accept only plain objects and treat them as the
-* `SchemaObject` the shared Model rendering and search helpers expect.
-*/
-var isSchemaObject = (value) => isObject(value);
-/**
 * Resolves a named schema from an AsyncAPI document's `components.schemas` into the `SchemaObject`
 * shape the shared OpenAPI Model components and search indexing expect.
 *
@@ -21,10 +15,7 @@ var isSchemaObject = (value) => isObject(value);
 var getAsyncApiModelSchema = (document, name) => {
 	if (!document.components) return;
 	const entry = getResolvedRef(document.components, mergeSiblingReferences).schemas?.[name];
-	if (entry === void 0) return;
-	const resolved = getResolvedRef(entry);
-	const schema = isObject(resolved) && "schemaFormat" in resolved ? getResolvedRef(resolved.schema) : resolved;
-	return isSchemaObject(schema) ? schema : void 0;
+	return unwrapAsyncApiSchema(entry);
 };
 //#endregion
 export { getAsyncApiModelSchema };

package/dist/helpers/get-async-api-model-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-async-api-model-schema.js","names":[],"sources":["../../src/helpers/get-async-api-model-schema.ts"],"sourcesContent":["import { isObject } from '@scalar/helpers/object/is-object'\nimport type { AsyncApiDocument } from '@scalar/types/asyncapi/3.1'\nimport { getResolvedRef, mergeSiblingReferences } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\n/**\n * A resolved `components.schemas` entry may be a JSON Schema object, a boolean (`true`/`false`)\n * schema, or a Multi Format Schema wrapper, so accept only plain objects and treat them as the\n * `SchemaObject` the shared Model rendering and search helpers expect.\n */\nconst isSchemaObject = (value: unknown): value is SchemaObject => isObject(value)\n\n/**\n * Resolves a named schema from an AsyncAPI document's `components.schemas` into the `SchemaObject`\n * shape the shared OpenAPI Model components and search indexing expect.\n *\n * AsyncAPI keeps reusable schemas in the same place OpenAPI does, but an entry may need extra handling:\n * - `components` or the schema itself may be a `$ref`; siblings are merged so keys declared alongside\n *   a `$ref` are kept rather than dropped.\n * - A Multi Format Schema Object (`schemaFormat` plus a nested `schema`) is unwrapped to its payload,\n *   so we index and render the inner JSON Schema rather than the wrapper.\n * - Boolean (`true`/`false`) and non-JSON-Schema payloads are skipped.\n */\nexport const getAsyncApiModelSchema = (document: AsyncApiDocument, name: string): SchemaObject | undefined => {\n  if (!document.components) {\n    return undefined\n  }\n\n  // Merge siblings at the components level so schemas declared alongside a `$ref` are kept.\n  const components = getResolvedRef(document.components, mergeSiblingReferences)\n  const entry = components.schemas?.[name]\n  if (entry === undefined) {\n    return undefined\n  }\n\n  // Resolve the schema itself the same way OpenAPI model rendering does (plain `$ref-value`).\n  const resolved = getResolvedRef(entry)\n\n  // Multi Format Schema Objects carry the real schema under `schema`; unwrap to that payload.\n  const schema = isObject(resolved) && 'schemaFormat' in resolved ? getResolvedRef(resolved.schema) : resolved\n\n  return isSchemaObject(schema) ? schema : undefined\n}\n"],"mappings":";;;;;;;;AAUA,IAAM,kBAAkB,UAA0C,SAAS,MAAM;;;;;;;;;;;;AAajF,IAAa,0BAA0B,UAA4B,SAA2C;AAC5G,KAAI,CAAC,SAAS,WACZ;CAKF,MAAM,QADa,eAAe,SAAS,YAAY,uBAAuB,CACrD,UAAU;AACnC,KAAI,UAAU,KAAA,EACZ;CAIF,MAAM,WAAW,eAAe,MAAM;CAGtC,MAAM,SAAS,SAAS,SAAS,IAAI,kBAAkB,WAAW,eAAe,SAAS,OAAO,GAAG;AAEpG,QAAO,eAAe,OAAO,GAAG,SAAS,KAAA"}
+{"version":3,"file":"get-async-api-model-schema.js","names":[],"sources":["../../src/helpers/get-async-api-model-schema.ts"],"sourcesContent":["import type { AsyncApiDocument } from '@scalar/types/asyncapi/3.1'\nimport { getResolvedRef, mergeSiblingReferences } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport { unwrapAsyncApiSchema } from './get-async-api-message-payload-schema'\n\n/**\n * Resolves a named schema from an AsyncAPI document's `components.schemas` into the `SchemaObject`\n * shape the shared OpenAPI Model components and search indexing expect.\n *\n * AsyncAPI keeps reusable schemas in the same place OpenAPI does, but an entry may need extra handling:\n * - `components` or the schema itself may be a `$ref`; siblings are merged so keys declared alongside\n *   a `$ref` are kept rather than dropped.\n * - A Multi Format Schema Object (`schemaFormat` plus a nested `schema`) is unwrapped to its payload,\n *   so we index and render the inner JSON Schema rather than the wrapper.\n * - Boolean (`true`/`false`) and non-JSON-Schema payloads are skipped.\n */\nexport const getAsyncApiModelSchema = (document: AsyncApiDocument, name: string): SchemaObject | undefined => {\n  if (!document.components) {\n    return undefined\n  }\n\n  // Merge siblings at the components level so schemas declared alongside a `$ref` are kept.\n  const components = getResolvedRef(document.components, mergeSiblingReferences)\n  const entry = components.schemas?.[name]\n\n  // Resolve `$ref`s and unwrap Multi Format Schema Objects into the plain JSON Schema shape.\n  return unwrapAsyncApiSchema(entry)\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,IAAa,0BAA0B,UAA4B,SAA2C;AAC5G,KAAI,CAAC,SAAS,WACZ;CAKF,MAAM,QADa,eAAe,SAAS,YAAY,uBAAuB,CACrD,UAAU;AAGnC,QAAO,qBAAqB,MAAM"}

package/dist/helpers/is-introduction-entry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The auto-generated "Introduction" navigation entry always uses the `introduction` slug, so its id
+ * ends with this suffix regardless of the active locale or the displayed title.
+ */
+export declare const INTRODUCTION_ENTRY_ID_SUFFIX = "/description/introduction";
+/**
+ * Whether a navigation entry is the auto-generated introduction section.
+ *
+ * We match on the stable entry id instead of the English title so localization does not accidentally
+ * rewrite unrelated description headings that happen to be called "Introduction".
+ */
+export declare const isIntroductionEntry: (entry: {
+    type?: string;
+    id?: string;
+}) => boolean;
+//# sourceMappingURL=is-introduction-entry.d.ts.map

package/dist/helpers/is-introduction-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-introduction-entry.d.ts","sourceRoot":"","sources":["../../src/helpers/is-introduction-entry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,4BAA4B,8BAA8B,CAAA;AAEvE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,KAAG,OAC8B,CAAA"}

package/dist/helpers/is-introduction-entry.js

@@ -0,0 +1,17 @@
+//#region src/helpers/is-introduction-entry.ts
+/**
+* The auto-generated "Introduction" navigation entry always uses the `introduction` slug, so its id
+* ends with this suffix regardless of the active locale or the displayed title.
+*/
+var INTRODUCTION_ENTRY_ID_SUFFIX = "/description/introduction";
+/**
+* Whether a navigation entry is the auto-generated introduction section.
+*
+* We match on the stable entry id instead of the English title so localization does not accidentally
+* rewrite unrelated description headings that happen to be called "Introduction".
+*/
+var isIntroductionEntry = (entry) => entry.type === "text" && typeof entry.id === "string" && entry.id.endsWith("/description/introduction");
+//#endregion
+export { INTRODUCTION_ENTRY_ID_SUFFIX, isIntroductionEntry };
+
+//# sourceMappingURL=is-introduction-entry.js.map

package/dist/helpers/is-introduction-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-introduction-entry.js","names":[],"sources":["../../src/helpers/is-introduction-entry.ts"],"sourcesContent":["/**\n * The auto-generated \"Introduction\" navigation entry always uses the `introduction` slug, so its id\n * ends with this suffix regardless of the active locale or the displayed title.\n */\nexport const INTRODUCTION_ENTRY_ID_SUFFIX = '/description/introduction'\n\n/**\n * Whether a navigation entry is the auto-generated introduction section.\n *\n * We match on the stable entry id instead of the English title so localization does not accidentally\n * rewrite unrelated description headings that happen to be called \"Introduction\".\n */\nexport const isIntroductionEntry = (entry: { type?: string; id?: string }): boolean =>\n  entry.type === 'text' && typeof entry.id === 'string' && entry.id.endsWith(INTRODUCTION_ENTRY_ID_SUFFIX)\n"],"mappings":";;;;;AAIA,IAAa,+BAA+B;;;;;;;AAQ5C,IAAa,uBAAuB,UAClC,MAAM,SAAS,UAAU,OAAO,MAAM,OAAO,YAAY,MAAM,GAAG,SAAA,4BAAsC"}

package/dist/helpers/load-from-perssistance.js

@@ -1,5 +1,5 @@
 import { authStorage, clientStorage } from "./storage.js";
-import { isSelectedClient } from "@scalar/api-client/blocks/operation-code-sample";
+import { isSelectedClient } from "@scalar/blocks/code-example";
 //#region src/helpers/load-from-perssistance.ts
 /**
 * Loads the default HTTP client from storage and applies it to the workspace.

package/dist/helpers/load-from-perssistance.js.map

@@ -1 +1 @@
-{"version":3,"file":"load-from-perssistance.js","names":[],"sources":["../../src/helpers/load-from-perssistance.ts"],"sourcesContent":["import { isSelectedClient } from '@scalar/api-client/blocks/operation-code-sample'\nimport type { WorkspaceStore } from '@scalar/workspace-store/client'\n\nimport { authStorage, clientStorage } from '@/helpers/storage'\n\n/**\n * Loads the default HTTP client from storage and applies it to the workspace.\n * Only updates if no default client is already set. Accepts both built-in client\n * ids and custom sample ids (e.g. `custom/python`) so a custom selection persists.\n */\nexport const loadClientFromStorage = (store: WorkspaceStore): void => {\n  const storedClient = clientStorage().get()\n\n  if (isSelectedClient(storedClient) && !store.workspace['x-scalar-default-client']) {\n    store.update('x-scalar-default-client', storedClient)\n  }\n}\n\n/**\n * Loads the authentication data from storage and applies it to the workspace.\n * Only updates if no authentication data is already set.\n */\nexport const loadAuthFromStorage = (store: WorkspaceStore, slug: string): void => {\n  const authPersistence = authStorage()\n  const auth = authPersistence.getAuth(slug)\n  store.auth.load({ [slug]: auth })\n}\n"],"mappings":";;;;;;;;AAUA,IAAa,yBAAyB,UAAgC;CACpE,MAAM,eAAe,eAAe,CAAC,KAAK;AAE1C,KAAI,iBAAiB,aAAa,IAAI,CAAC,MAAM,UAAU,2BACrD,OAAM,OAAO,2BAA2B,aAAa;;;;;;AAQzD,IAAa,uBAAuB,OAAuB,SAAuB;CAEhF,MAAM,OADkB,aAAa,CACR,QAAQ,KAAK;AAC1C,OAAM,KAAK,KAAK,GAAG,OAAO,MAAM,CAAC"}
+{"version":3,"file":"load-from-perssistance.js","names":[],"sources":["../../src/helpers/load-from-perssistance.ts"],"sourcesContent":["import { isSelectedClient } from '@scalar/blocks/code-example'\nimport type { WorkspaceStore } from '@scalar/workspace-store/client'\n\nimport { authStorage, clientStorage } from '@/helpers/storage'\n\n/**\n * Loads the default HTTP client from storage and applies it to the workspace.\n * Only updates if no default client is already set. Accepts both built-in client\n * ids and custom sample ids (e.g. `custom/python`) so a custom selection persists.\n */\nexport const loadClientFromStorage = (store: WorkspaceStore): void => {\n  const storedClient = clientStorage().get()\n\n  if (isSelectedClient(storedClient) && !store.workspace['x-scalar-default-client']) {\n    store.update('x-scalar-default-client', storedClient)\n  }\n}\n\n/**\n * Loads the authentication data from storage and applies it to the workspace.\n * Only updates if no authentication data is already set.\n */\nexport const loadAuthFromStorage = (store: WorkspaceStore, slug: string): void => {\n  const authPersistence = authStorage()\n  const auth = authPersistence.getAuth(slug)\n  store.auth.load({ [slug]: auth })\n}\n"],"mappings":";;;;;;;;AAUA,IAAa,yBAAyB,UAAgC;CACpE,MAAM,eAAe,eAAe,CAAC,KAAK;AAE1C,KAAI,iBAAiB,aAAa,IAAI,CAAC,MAAM,UAAU,2BACrD,OAAM,OAAO,2BAA2B,aAAa;;;;;;AAQzD,IAAa,uBAAuB,OAAuB,SAAuB;CAEhF,MAAM,OADkB,aAAa,CACR,QAAQ,KAAK;AAC1C,OAAM,KAAK,KAAK,GAAG,OAAO,MAAM,CAAC"}

package/dist/helpers/map-config-plugins.d.ts

@@ -5,9 +5,14 @@ import { type ComputedRef } from 'vue';
 /**
  * Maps API reference configuration callbacks to client plugins.
  *
- * This function transforms the legacy onBeforeRequest and onRequestSent callbacks
- * into the new plugin hook system. The mapping is reactive, so changes to the
- * configuration will automatically update the plugin hooks.
+ * This function transforms the onBeforeRequest, onRequestBuilt, and onRequestSent
+ * callbacks into the new plugin hook system. The mapping is reactive, so changes
+ * to the configuration will automatically update the plugin hooks.
+ *
+ * Note: onRequestBuilt is mapped to the requestBuilt hook so the callback receives
+ * the exact fetch Request that is sent over the wire. Mutating its headers modifies
+ * the outgoing request, and hashing its body produces a hash that matches what the
+ * server receives (a rebuilt multipart body would get a different boundary).
  *
  * Note: onRequestSent is mapped to responseReceived hook. This is not a perfect
  * one-to-one mapping, but it maintains backward compatibility with the old API.

package/dist/helpers/map-config-plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map-config-plugins.d.ts","sourceRoot":"","sources":["../../src/helpers/map-config-plugins.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2EAA2E,CAAA;AACnH,OAAO,EAAE,KAAK,WAAW,EAAS,MAAM,KAAK,CAAA;AAE7C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,WAAW,CAAC,yBAAyB,CAAC,EAC9C,aAAa,WAAW,CAAC,kBAAkB,CAAC,KAC3C,YAAY,EAmDd,CAAA"}
+{"version":3,"file":"map-config-plugins.d.ts","sourceRoot":"","sources":["../../src/helpers/map-config-plugins.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2EAA2E,CAAA;AACnH,OAAO,EAAE,KAAK,WAAW,EAAS,MAAM,KAAK,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,WAAW,CAAC,yBAAyB,CAAC,EAC9C,aAAa,WAAW,CAAC,kBAAkB,CAAC,KAC3C,YAAY,EAuEd,CAAA"}

package/dist/helpers/map-config-plugins.js

@@ -5,9 +5,14 @@ import { buildSafeBodyRequest } from "@scalar/helpers/http/can-method-have-body"
 /**
 * Maps API reference configuration callbacks to client plugins.
 *
-* This function transforms the legacy onBeforeRequest and onRequestSent callbacks
-* into the new plugin hook system. The mapping is reactive, so changes to the
-* configuration will automatically update the plugin hooks.
+* This function transforms the onBeforeRequest, onRequestBuilt, and onRequestSent
+* callbacks into the new plugin hook system. The mapping is reactive, so changes
+* to the configuration will automatically update the plugin hooks.
+*
+* Note: onRequestBuilt is mapped to the requestBuilt hook so the callback receives
+* the exact fetch Request that is sent over the wire. Mutating its headers modifies
+* the outgoing request, and hashing its body produces a hash that matches what the
+* server receives (a rebuilt multipart body would get a different boundary).
 *
 * Note: onRequestSent is mapped to responseReceived hook. This is not a perfect
 * one-to-one mapping, but it maintains backward compatibility with the old API.
@@ -21,9 +26,10 @@ var mapConfigPlugins = (config, environment) => {
 	const plugin = { hooks: {} };
 	watch([
 		() => config.value.onBeforeRequest,
+		() => config.value.onRequestBuilt,
 		() => config.value.onRequestSent,
 		() => environment.value
-	], ([onBeforeRequest, onRequestSent, environment]) => {
+	], ([onBeforeRequest, onRequestBuilt, onRequestSent, environment]) => {
 		const envVariables = getEnvironmentVariables(environment);
 		if (!plugin.hooks) plugin.hooks = {};
 		plugin.hooks.beforeRequest = onBeforeRequest ? async (payload) => {
@@ -42,6 +48,18 @@ var mapConfigPlugins = (config, environment) => {
 			});
 		} : void 0;
 		/**
+		* Maps onRequestBuilt to the requestBuilt hook. The payload request is the
+		* exact fetch Request that will be sent, so header mutations apply and body
+		* hashes match what goes over the wire.
+		*/
+		plugin.hooks.requestBuilt = onRequestBuilt ? async (payload) => {
+			await onRequestBuilt({
+				request: payload.request,
+				requestBuilder: payload.requestBuilder,
+				envVariables
+			});
+		} : void 0;
+		/**
 		* Maps onRequestSent to responseReceived hook.
 		* The old API only passed the URL string, so we extract it from the request.
 		*/

package/dist/helpers/map-config-plugins.js.map

@@ -1 +1 @@
-{"version":3,"file":"map-config-plugins.js","names":[],"sources":["../../src/helpers/map-config-plugins.ts"],"sourcesContent":["import { buildSafeBodyRequest } from '@scalar/helpers/http/can-method-have-body'\nimport type { ClientPlugin } from '@scalar/oas-utils/helpers'\nimport type { ApiReferenceConfiguration } from '@scalar/types/api-reference'\nimport { buildRequest, getEnvironmentVariables } from '@scalar/workspace-store/request-example'\nimport type { XScalarEnvironment } from '@scalar/workspace-store/schemas/extensions/document/x-scalar-environments'\nimport { type ComputedRef, watch } from 'vue'\n\n/**\n * Maps API reference configuration callbacks to client plugins.\n *\n * This function transforms the legacy onBeforeRequest and onRequestSent callbacks\n * into the new plugin hook system. The mapping is reactive, so changes to the\n * configuration will automatically update the plugin hooks.\n *\n * Note: onRequestSent is mapped to responseReceived hook. This is not a perfect\n * one-to-one mapping, but it maintains backward compatibility with the old API.\n * The old callback receives only the URL string, while the new hook receives\n * the full response object.\n *\n * @param config - Reactive configuration object containing optional hook callbacks\n * @returns Array containing a single plugin with the mapped hooks\n */\nexport const mapConfigPlugins = (\n  config: ComputedRef<ApiReferenceConfiguration>,\n  environment: ComputedRef<XScalarEnvironment>,\n): ClientPlugin[] => {\n  // Create a new plugin with the hooks which is going to be updated by the watcher when config changes\n  const plugin: ClientPlugin = { hooks: {} }\n\n  watch(\n    [() => config.value.onBeforeRequest, () => config.value.onRequestSent, () => environment.value],\n    ([onBeforeRequest, onRequestSent, environment]) => {\n      // Get the environment variables for the current environment\n      const envVariables = getEnvironmentVariables(environment)\n\n      // Initialize the hooks object if it doesn't exist\n      if (!plugin.hooks) {\n        plugin.hooks = {}\n      }\n\n      plugin.hooks.beforeRequest = onBeforeRequest\n        ? async (payload) => {\n            const built = buildRequest(payload.requestBuilder, {\n              envVariables,\n              allowMissingRequestServerBase: true,\n            })\n            if (!built.ok) {\n              console.error(\n                '[@scalar/api-reference] onBeforeRequest was not run because the request could not be built:',\n                built.message ?? built.error,\n              )\n              return\n            }\n            await onBeforeRequest({\n              // We need to build the request to get the fetch `Request`\n              request: buildSafeBodyRequest(...built.data.requestPayload),\n              requestBuilder: payload.requestBuilder,\n              envVariables,\n            })\n          }\n        : undefined\n\n      /**\n       * Maps onRequestSent to responseReceived hook.\n       * The old API only passed the URL string, so we extract it from the request.\n       */\n      plugin.hooks.responseReceived = onRequestSent\n        ? (payload) => {\n            onRequestSent(payload.request.url)\n          }\n        : undefined\n    },\n    { immediate: true },\n  )\n\n  return [plugin]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAsBA,IAAa,oBACX,QACA,gBACmB;CAEnB,MAAM,SAAuB,EAAE,OAAO,EAAE,EAAE;AAE1C,OACE;QAAO,OAAO,MAAM;QAAuB,OAAO,MAAM;QAAqB,YAAY;EAAM,GAC9F,CAAC,iBAAiB,eAAe,iBAAiB;EAEjD,MAAM,eAAe,wBAAwB,YAAY;AAGzD,MAAI,CAAC,OAAO,MACV,QAAO,QAAQ,EAAE;AAGnB,SAAO,MAAM,gBAAgB,kBACzB,OAAO,YAAY;GACjB,MAAM,QAAQ,aAAa,QAAQ,gBAAgB;IACjD;IACA,+BAA+B;IAChC,CAAC;AACF,OAAI,CAAC,MAAM,IAAI;AACb,YAAQ,MACN,+FACA,MAAM,WAAW,MAAM,MACxB;AACD;;AAEF,SAAM,gBAAgB;IAEpB,SAAS,qBAAqB,GAAG,MAAM,KAAK,eAAe;IAC3D,gBAAgB,QAAQ;IACxB;IACD,CAAC;MAEJ,KAAA;;;;;AAMJ,SAAO,MAAM,mBAAmB,iBAC3B,YAAY;AACX,iBAAc,QAAQ,QAAQ,IAAI;MAEpC,KAAA;IAEN,EAAE,WAAW,MAAM,CACpB;AAED,QAAO,CAAC,OAAO"}
+{"version":3,"file":"map-config-plugins.js","names":[],"sources":["../../src/helpers/map-config-plugins.ts"],"sourcesContent":["import { buildSafeBodyRequest } from '@scalar/helpers/http/can-method-have-body'\nimport type { ClientPlugin } from '@scalar/oas-utils/helpers'\nimport type { ApiReferenceConfiguration } from '@scalar/types/api-reference'\nimport { buildRequest, getEnvironmentVariables } from '@scalar/workspace-store/request-example'\nimport type { XScalarEnvironment } from '@scalar/workspace-store/schemas/extensions/document/x-scalar-environments'\nimport { type ComputedRef, watch } from 'vue'\n\n/**\n * Maps API reference configuration callbacks to client plugins.\n *\n * This function transforms the onBeforeRequest, onRequestBuilt, and onRequestSent\n * callbacks into the new plugin hook system. The mapping is reactive, so changes\n * to the configuration will automatically update the plugin hooks.\n *\n * Note: onRequestBuilt is mapped to the requestBuilt hook so the callback receives\n * the exact fetch Request that is sent over the wire. Mutating its headers modifies\n * the outgoing request, and hashing its body produces a hash that matches what the\n * server receives (a rebuilt multipart body would get a different boundary).\n *\n * Note: onRequestSent is mapped to responseReceived hook. This is not a perfect\n * one-to-one mapping, but it maintains backward compatibility with the old API.\n * The old callback receives only the URL string, while the new hook receives\n * the full response object.\n *\n * @param config - Reactive configuration object containing optional hook callbacks\n * @returns Array containing a single plugin with the mapped hooks\n */\nexport const mapConfigPlugins = (\n  config: ComputedRef<ApiReferenceConfiguration>,\n  environment: ComputedRef<XScalarEnvironment>,\n): ClientPlugin[] => {\n  // Create a new plugin with the hooks which is going to be updated by the watcher when config changes\n  const plugin: ClientPlugin = { hooks: {} }\n\n  watch(\n    [\n      () => config.value.onBeforeRequest,\n      () => config.value.onRequestBuilt,\n      () => config.value.onRequestSent,\n      () => environment.value,\n    ],\n    ([onBeforeRequest, onRequestBuilt, onRequestSent, environment]) => {\n      // Get the environment variables for the current environment\n      const envVariables = getEnvironmentVariables(environment)\n\n      // Initialize the hooks object if it doesn't exist\n      if (!plugin.hooks) {\n        plugin.hooks = {}\n      }\n\n      plugin.hooks.beforeRequest = onBeforeRequest\n        ? async (payload) => {\n            const built = buildRequest(payload.requestBuilder, {\n              envVariables,\n              allowMissingRequestServerBase: true,\n            })\n            if (!built.ok) {\n              console.error(\n                '[@scalar/api-reference] onBeforeRequest was not run because the request could not be built:',\n                built.message ?? built.error,\n              )\n              return\n            }\n            await onBeforeRequest({\n              // We need to build the request to get the fetch `Request`\n              request: buildSafeBodyRequest(...built.data.requestPayload),\n              requestBuilder: payload.requestBuilder,\n              envVariables,\n            })\n          }\n        : undefined\n\n      /**\n       * Maps onRequestBuilt to the requestBuilt hook. The payload request is the\n       * exact fetch Request that will be sent, so header mutations apply and body\n       * hashes match what goes over the wire.\n       */\n      plugin.hooks.requestBuilt = onRequestBuilt\n        ? async (payload) => {\n            await onRequestBuilt({\n              request: payload.request,\n              requestBuilder: payload.requestBuilder,\n              envVariables,\n            })\n          }\n        : undefined\n\n      /**\n       * Maps onRequestSent to responseReceived hook.\n       * The old API only passed the URL string, so we extract it from the request.\n       */\n      plugin.hooks.responseReceived = onRequestSent\n        ? (payload) => {\n            onRequestSent(payload.request.url)\n          }\n        : undefined\n    },\n    { immediate: true },\n  )\n\n  return [plugin]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAa,oBACX,QACA,gBACmB;CAEnB,MAAM,SAAuB,EAAE,OAAO,EAAE,EAAE;AAE1C,OACE;QACQ,OAAO,MAAM;QACb,OAAO,MAAM;QACb,OAAO,MAAM;QACb,YAAY;EACnB,GACA,CAAC,iBAAiB,gBAAgB,eAAe,iBAAiB;EAEjE,MAAM,eAAe,wBAAwB,YAAY;AAGzD,MAAI,CAAC,OAAO,MACV,QAAO,QAAQ,EAAE;AAGnB,SAAO,MAAM,gBAAgB,kBACzB,OAAO,YAAY;GACjB,MAAM,QAAQ,aAAa,QAAQ,gBAAgB;IACjD;IACA,+BAA+B;IAChC,CAAC;AACF,OAAI,CAAC,MAAM,IAAI;AACb,YAAQ,MACN,+FACA,MAAM,WAAW,MAAM,MACxB;AACD;;AAEF,SAAM,gBAAgB;IAEpB,SAAS,qBAAqB,GAAG,MAAM,KAAK,eAAe;IAC3D,gBAAgB,QAAQ;IACxB;IACD,CAAC;MAEJ,KAAA;;;;;;AAOJ,SAAO,MAAM,eAAe,iBACxB,OAAO,YAAY;AACjB,SAAM,eAAe;IACnB,SAAS,QAAQ;IACjB,gBAAgB,QAAQ;IACxB;IACD,CAAC;MAEJ,KAAA;;;;;AAMJ,SAAO,MAAM,mBAAmB,iBAC3B,YAAY;AACX,iBAAc,QAAQ,QAAQ,IAAI;MAEpC,KAAA;IAEN,EAAE,WAAW,MAAM,CACpB;AAED,QAAO,CAAC,OAAO"}

package/dist/helpers/map-config-to-workspace-store.js

@@ -1,6 +1,6 @@
 import { computed, toValue, watch } from "vue";
 import { useFavicon } from "@vueuse/core";
-import { isClient } from "@scalar/api-client/blocks/operation-code-sample";
+import { isClient } from "@scalar/blocks/code-example";
 import { useSeoMeta } from "@unhead/vue";
 //#region src/helpers/map-config-to-workspace-store.ts
 var mapConfigToWorkspaceStore = ({ config, store, isDarkMode }) => {

package/dist/helpers/map-config-to-workspace-store.js.map

@@ -1 +1 @@
-{"version":3,"file":"map-config-to-workspace-store.js","names":[],"sources":["../../src/helpers/map-config-to-workspace-store.ts"],"sourcesContent":["import { isClient } from '@scalar/api-client/blocks/operation-code-sample'\nimport type { ApiReferenceConfigurationRaw } from '@scalar/types/api-reference'\nimport type { WorkspaceStore } from '@scalar/workspace-store/client'\nimport { useSeoMeta } from '@unhead/vue'\nimport { useFavicon } from '@vueuse/core'\nimport { type MaybeRefOrGetter, type Ref, computed, toValue, watch } from 'vue'\n\nexport const mapConfigToWorkspaceStore = ({\n  config,\n  store,\n  isDarkMode,\n}: {\n  config: MaybeRefOrGetter<ApiReferenceConfigurationRaw>\n  store: WorkspaceStore\n  isDarkMode: Ref<boolean>\n}) => {\n  // Update the workspace store if default client changes\n  watch(\n    () => toValue(config).defaultHttpClient,\n    (newValue) => {\n      if (newValue) {\n        const { targetKey, clientKey } = newValue\n\n        const clientId = `${targetKey}/${clientKey}`\n        if (isClient(clientId)) {\n          store.update('x-scalar-default-client', clientId)\n        }\n      }\n    },\n    { immediate: true },\n  )\n\n  /** Update the dark mode state when props change */\n  watch(\n    () => toValue(config).darkMode,\n    (isDark) => store.update('x-scalar-color-mode', isDark ? 'dark' : 'light'),\n  )\n\n  // Temporary mapping of isDarkMode until we update the standalone component\n  watch(\n    () => isDarkMode.value,\n    (newIsDark) => store.update('x-scalar-color-mode', newIsDark ? 'dark' : 'light'),\n    { immediate: true },\n  )\n\n  if (toValue(config).metaData) {\n    useSeoMeta(toValue(config).metaData)\n  }\n\n  // Update the active proxy when the proxyUrl changes\n  watch(\n    () => toValue(config).proxyUrl,\n    (newProxyUrl) => store.update('x-scalar-active-proxy', newProxyUrl),\n    { immediate: true },\n  )\n\n  const favicon = computed(() => toValue(config).favicon)\n  useFavicon(favicon)\n}\n"],"mappings":";;;;;AAOA,IAAa,6BAA6B,EACxC,QACA,OACA,iBAKI;AAEJ,aACQ,QAAQ,OAAO,CAAC,oBACrB,aAAa;AACZ,MAAI,UAAU;GACZ,MAAM,EAAE,WAAW,cAAc;GAEjC,MAAM,WAAW,GAAG,UAAU,GAAG;AACjC,OAAI,SAAS,SAAS,CACpB,OAAM,OAAO,2BAA2B,SAAS;;IAIvD,EAAE,WAAW,MAAM,CACpB;;AAGD,aACQ,QAAQ,OAAO,CAAC,WACrB,WAAW,MAAM,OAAO,uBAAuB,SAAS,SAAS,QAAQ,CAC3E;AAGD,aACQ,WAAW,QAChB,cAAc,MAAM,OAAO,uBAAuB,YAAY,SAAS,QAAQ,EAChF,EAAE,WAAW,MAAM,CACpB;AAED,KAAI,QAAQ,OAAO,CAAC,SAClB,YAAW,QAAQ,OAAO,CAAC,SAAS;AAItC,aACQ,QAAQ,OAAO,CAAC,WACrB,gBAAgB,MAAM,OAAO,yBAAyB,YAAY,EACnE,EAAE,WAAW,MAAM,CACpB;AAGD,YADgB,eAAe,QAAQ,OAAO,CAAC,QAAQ,CACpC"}
+{"version":3,"file":"map-config-to-workspace-store.js","names":[],"sources":["../../src/helpers/map-config-to-workspace-store.ts"],"sourcesContent":["import { isClient } from '@scalar/blocks/code-example'\nimport type { ApiReferenceConfigurationRaw } from '@scalar/types/api-reference'\nimport type { WorkspaceStore } from '@scalar/workspace-store/client'\nimport { useSeoMeta } from '@unhead/vue'\nimport { useFavicon } from '@vueuse/core'\nimport { type MaybeRefOrGetter, type Ref, computed, toValue, watch } from 'vue'\n\nexport const mapConfigToWorkspaceStore = ({\n  config,\n  store,\n  isDarkMode,\n}: {\n  config: MaybeRefOrGetter<ApiReferenceConfigurationRaw>\n  store: WorkspaceStore\n  isDarkMode: Ref<boolean>\n}) => {\n  // Update the workspace store if default client changes\n  watch(\n    () => toValue(config).defaultHttpClient,\n    (newValue) => {\n      if (newValue) {\n        const { targetKey, clientKey } = newValue\n\n        const clientId = `${targetKey}/${clientKey}`\n        if (isClient(clientId)) {\n          store.update('x-scalar-default-client', clientId)\n        }\n      }\n    },\n    { immediate: true },\n  )\n\n  /** Update the dark mode state when props change */\n  watch(\n    () => toValue(config).darkMode,\n    (isDark) => store.update('x-scalar-color-mode', isDark ? 'dark' : 'light'),\n  )\n\n  // Temporary mapping of isDarkMode until we update the standalone component\n  watch(\n    () => isDarkMode.value,\n    (newIsDark) => store.update('x-scalar-color-mode', newIsDark ? 'dark' : 'light'),\n    { immediate: true },\n  )\n\n  if (toValue(config).metaData) {\n    useSeoMeta(toValue(config).metaData)\n  }\n\n  // Update the active proxy when the proxyUrl changes\n  watch(\n    () => toValue(config).proxyUrl,\n    (newProxyUrl) => store.update('x-scalar-active-proxy', newProxyUrl),\n    { immediate: true },\n  )\n\n  const favicon = computed(() => toValue(config).favicon)\n  useFavicon(favicon)\n}\n"],"mappings":";;;;;AAOA,IAAa,6BAA6B,EACxC,QACA,OACA,iBAKI;AAEJ,aACQ,QAAQ,OAAO,CAAC,oBACrB,aAAa;AACZ,MAAI,UAAU;GACZ,MAAM,EAAE,WAAW,cAAc;GAEjC,MAAM,WAAW,GAAG,UAAU,GAAG;AACjC,OAAI,SAAS,SAAS,CACpB,OAAM,OAAO,2BAA2B,SAAS;;IAIvD,EAAE,WAAW,MAAM,CACpB;;AAGD,aACQ,QAAQ,OAAO,CAAC,WACrB,WAAW,MAAM,OAAO,uBAAuB,SAAS,SAAS,QAAQ,CAC3E;AAGD,aACQ,WAAW,QAChB,cAAc,MAAM,OAAO,uBAAuB,YAAY,SAAS,QAAQ,EAChF,EAAE,WAAW,MAAM,CACpB;AAED,KAAI,QAAQ,OAAO,CAAC,SAClB,YAAW,QAAQ,OAAO,CAAC,SAAS;AAItC,aACQ,QAAQ,OAAO,CAAC,WACrB,gBAAgB,MAAM,OAAO,yBAAyB,YAAY,EACnE,EAAE,WAAW,MAAM,CACpB;AAGD,YADgB,eAAe,QAAQ,OAAO,CAAC,QAAQ,CACpC"}

package/dist/helpers/storage.d.ts

@@ -24,6 +24,20 @@ export declare const authStorage: () => {
      * Retrieves and coerces the authentication schemes stored in local storage.
      */
     getAuth: (slug: string) => {
+        selected: {
+            path?: {
+                [x: string]: {
+                    [x: string]: {
+                        selectedIndex: number;
+                        selectedSchemes: {}[];
+                    };
+                };
+            } | undefined;
+            document?: {
+                selectedIndex: number;
+                selectedSchemes: {}[];
+            } | undefined;
+        };
         secrets: {
             [x: string]: ({
                 type: "apiKey";
@@ -230,20 +244,6 @@ export declare const authStorage: () => {
                 type: "openIdConnect";
             };
         };
-        selected: {
-            path?: {
-                [x: string]: {
-                    [x: string]: {
-                        selectedIndex: number;
-                        selectedSchemes: {}[];
-                    };
-                };
-            } | undefined;
-            document?: {
-                selectedIndex: number;
-                selectedSchemes: {}[];
-            } | undefined;
-        };
     };
     /**
      * Stores the authentication schemes in local storage.