@scalar/api-reference 1.43.5 → 1.43.7

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

@@ -0,0 +1,74 @@
+import { isClient } from "@scalar/api-client/v2/blocks/operation-code-sample";
+import { isObject } from "@scalar/helpers/object/is-object";
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { clientStorage, authStorage } from "./storage.js";
+const SECRET_KEY_PREFIX = "x-scalar-secret-";
+const loadClientFromStorage = (store) => {
+  const storedClient = clientStorage().get();
+  if (isClient(storedClient) && !store.workspace["x-scalar-default-client"]) {
+    store.update("x-scalar-default-client", storedClient);
+  }
+};
+const isSecretKey = (key) => key.startsWith(SECRET_KEY_PREFIX);
+const mergeSecrets = (current, stored) => {
+  if (!isObject(current) || !isObject(stored)) {
+    return;
+  }
+  for (const [key, storedValue] of Object.entries(stored)) {
+    if (isSecretKey(key) && storedValue && current[key] === "") {
+      current[key] = storedValue;
+      continue;
+    }
+    mergeSecrets(getResolvedRef(current[key]), storedValue);
+  }
+};
+const restoreAuthSecretsFromStorage = (store) => {
+  const slug = store.workspace["x-scalar-active-document"];
+  const activeDocument = store.workspace.activeDocument;
+  if (!activeDocument || !slug) {
+    console.warn("Active document not found in workspace, skipping auth secrets loading");
+    return;
+  }
+  const securitySchemes = activeDocument.components?.securitySchemes ?? {};
+  const storedAuthSchemes = authStorage().getSchemas(slug);
+  for (const [key, storedScheme] of Object.entries(storedAuthSchemes)) {
+    const currentScheme = getResolvedRef(securitySchemes[key]);
+    if (isObject(currentScheme)) {
+      mergeSecrets(currentScheme, storedScheme);
+    }
+  }
+};
+const isSchemeValid = (scheme, availableSchemes) => Object.keys(scheme).every((key) => availableSchemes.has(key));
+const clampSelectedIndex = (selectedIndex, schemesLength) => selectedIndex >= schemesLength ? schemesLength - 1 : selectedIndex;
+const loadAuthSchemesFromStorage = (store) => {
+  const slug = store.workspace["x-scalar-active-document"];
+  const activeDocument = store.workspace.activeDocument;
+  if (!activeDocument || !slug) {
+    console.warn("Active document not found in workspace, skipping auth schemes loading");
+    return;
+  }
+  if (activeDocument["x-scalar-selected-security"]) {
+    restoreAuthSecretsFromStorage(store);
+    return;
+  }
+  const authPersistence = authStorage();
+  const storedSelectedAuthSchemes = authPersistence.getSelectedSchemes(slug);
+  const availableSchemes = new Set(Object.keys(activeDocument.components?.securitySchemes ?? {}));
+  const selectedSchemes = storedSelectedAuthSchemes["x-scalar-selected-security"]?.selectedSchemes;
+  const validSchemes = selectedSchemes?.filter((scheme) => isSchemeValid(scheme, availableSchemes));
+  if (validSchemes && validSchemes.length > 0) {
+    const selectedIndex = storedSelectedAuthSchemes["x-scalar-selected-security"]?.selectedIndex ?? 0;
+    const clampedIndex = clampSelectedIndex(selectedIndex, validSchemes.length);
+    activeDocument["x-scalar-selected-security"] = {
+      selectedIndex: clampedIndex,
+      selectedSchemes: validSchemes
+    };
+  }
+  restoreAuthSecretsFromStorage(store);
+};
+export {
+  isSecretKey,
+  loadAuthSchemesFromStorage,
+  loadClientFromStorage,
+  mergeSecrets
+};

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

@@ -1,5 +1,20 @@
 import type { ClientPlugin } from '@scalar/api-client/v2/helpers';
 import type { ApiReferenceConfigurationRaw } from '@scalar/types/api-reference';
-/** Map the config functions to plugins */
-export declare const mapConfigPlugins: (config: ApiReferenceConfigurationRaw) => ClientPlugin[];
+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.
+ *
+ * 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.
+ * The old callback receives only the URL string, while the new hook receives
+ * the full response object.
+ *
+ * @param config - Reactive configuration object containing optional hook callbacks
+ * @returns Array containing a single plugin with the mapped hooks
+ */
+export declare const mapConfigPlugins: (config: ComputedRef<ApiReferenceConfigurationRaw>) => ClientPlugin[];
 //# sourceMappingURL=map-config-plugins.d.ts.map

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":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAA;AAE/E,0CAA0C;AAC1C,eAAO,MAAM,gBAAgB,GAAI,QAAQ,4BAA4B,KAAG,YAAY,EAkCnF,CAAA"}
+{"version":3,"file":"map-config-plugins.d.ts","sourceRoot":"","sources":["../../src/helpers/map-config-plugins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAA;AAC/E,OAAO,EAAE,KAAK,WAAW,EAAS,MAAM,KAAK,CAAA;AAE7C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,WAAW,CAAC,4BAA4B,CAAC,KAAG,YAAY,EAwChG,CAAA"}

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

@@ -1,28 +1,26 @@
+import { watch } from "vue";
 const mapConfigPlugins = (config) => {
-  const plugins = [];
-  if (config.onBeforeRequest) {
-    plugins.push({
-      hooks: {
-        beforeRequest: async (payload) => {
-          const result = await config.onBeforeRequest?.(payload);
-          if (result) {
-            return result;
-          }
-          return payload;
-        }
+  const plugin = { hooks: {} };
+  watch(
+    [() => config.value.onBeforeRequest, () => config.value.onRequestSent],
+    ([onBeforeRequest, onRequestSent]) => {
+      if (!plugin.hooks) {
+        plugin.hooks = {};
       }
-    });
-  }
-  if (config.onRequestSent) {
-    plugins.push({
-      hooks: {
-        responseReceived: (payload) => {
-          config.onRequestSent?.(payload.request.url);
+      plugin.hooks.beforeRequest = onBeforeRequest ? async (payload) => {
+        const result = await onBeforeRequest(payload);
+        if (result === void 0) {
+          return payload;
         }
-      }
-    });
-  }
-  return plugins;
+        return result;
+      } : void 0;
+      plugin.hooks.responseReceived = onRequestSent ? (payload) => {
+        onRequestSent(payload.request.url);
+      } : void 0;
+    },
+    { immediate: true }
+  );
+  return [plugin];
 };
 export {
   mapConfigPlugins

package/dist/helpers/map-config-to-workspace-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map-config-to-workspace-store.d.ts","sourceRoot":"","sources":["../../src/helpers/map-config-to-workspace-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAA;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAGpE,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,GAAG,EAA2C,MAAM,KAAK,CAAA;AAE9F,eAAO,MAAM,yBAAyB,GAAI,gCAIvC;IACD,MAAM,EAAE,gBAAgB,CAAC,4BAA4B,CAAC,CAAA;IACtD,KAAK,EAAE,cAAc,CAAA;IACrB,UAAU,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;CACzB,SAmDA,CAAA"}
+{"version":3,"file":"map-config-to-workspace-store.d.ts","sourceRoot":"","sources":["../../src/helpers/map-config-to-workspace-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAA;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAGpE,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,GAAG,EAA4B,MAAM,KAAK,CAAA;AAE/E,eAAO,MAAM,yBAAyB,GAAI,gCAIvC;IACD,MAAM,EAAE,gBAAgB,CAAC,4BAA4B,CAAC,CAAA;IACtD,KAAK,EAAE,cAAc,CAAA;IACrB,UAAU,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;CACzB,SA2CA,CAAA"}

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

@@ -1,19 +1,12 @@
 import { isClient } from "@scalar/api-client/v2/blocks/operation-code-sample";
-import { safeLocalStorage, REFERENCE_LS_KEYS } from "@scalar/helpers/object/local-storage";
 import { useSeoMeta } from "@unhead/vue";
 import { useFavicon } from "@vueuse/core";
-import { onBeforeMount, watch, toValue, computed } from "vue";
+import { watch, toValue, computed } from "vue";
 const mapConfigToWorkspaceStore = ({
   config,
   store,
   isDarkMode
 }) => {
-  onBeforeMount(() => {
-    const storedClient = safeLocalStorage().getItem(REFERENCE_LS_KEYS.SELECTED_CLIENT);
-    if (isClient(storedClient) && !store.workspace["x-scalar-default-client"]) {
-      store.update("x-scalar-default-client", storedClient);
-    }
-  });
   watch(
     () => toValue(config).defaultHttpClient,
     (newValue) => {

package/dist/helpers/storage.d.ts

@@ -1,4 +1,4 @@
-import { type XScalarSelectedSecurity } from '@scalar/workspace-store/schemas/extensions/security/x-scalar-selected-security';
+import type { XScalarSelectedSecurity } from '@scalar/workspace-store/schemas/extensions/security/x-scalar-selected-security';
 import { type SecuritySchemes } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
 /**
  * Provides an interface to store and retrieve the selected client value
@@ -24,7 +24,7 @@ export declare const authStorage: () => {
     /**
      * Retrieves and coerces the authentication schemes stored in local storage.
      */
-    getSchemas: () => {
+    getSchemas: (slug: string) => {
         [x: string]: ({
             description?: string | undefined;
         } & {
@@ -324,20 +324,20 @@ export declare const authStorage: () => {
      * Stores the authentication schemes in local storage.
      * @param value The SecuritySchemes object to stringify and store.
      */
-    setSchemas: (prefix: string, value: SecuritySchemes) => void;
+    setSchemas: (slug: string, value: SecuritySchemes) => void;
     /**
      * Retrieves and coerces the selected authentication schemes stored in local storage.
      */
-    getSelectedSchemes: () => {
+    getSelectedSchemes: (slug: string) => {
         'x-scalar-selected-security'?: {
             selectedIndex: number;
-            selectedSchemes: unknown[];
+            selectedSchemes: {}[];
         } | undefined;
     };
     /**
      * Stores the user's selected authentication schemes in local storage.
      * @param value The XScalarSelectedSecurity object to stringify and store.
      */
-    setSelectedSchemes: (prefix: string, value: XScalarSelectedSecurity) => void;
+    setSelectedSchemes: (slug: string, value: XScalarSelectedSecurity) => void;
 };
 //# sourceMappingURL=storage.d.ts.map

package/dist/helpers/storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/helpers/storage.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,uBAAuB,EAE7B,MAAM,gFAAgF,CAAA;AAEvF,OAAO,EACL,KAAK,eAAe,EAErB,MAAM,8DAA8D,CAAA;AAKrE;;;GAGG;AACH,eAAO,MAAM,aAAa;IAGtB;;OAEG;;IAIH;;;OAGG;iBACU,MAAM;CAItB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW;IAIpB;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKH;;;OAGG;yBACkB,MAAM,SAAS,eAAe;IAGnD;;OAEG;;;;;;;IAKH;;;OAGG;iCAC0B,MAAM,SAAS,uBAAuB;CAItE,CAAA"}
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/helpers/storage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gFAAgF,CAAA;AAE7H,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,8DAA8D,CAAA;AAKrE;;;GAGG;AACH,eAAO,MAAM,aAAa;IAGtB;;OAEG;;IAIH;;;OAGG;iBACU,MAAM;CAItB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW;IAYpB;;OAEG;uBACgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIzB;;;OAGG;uBACgB,MAAM,SAAS,eAAe;IAGjD;;OAEG;+BACwB,MAAM;;;;;;IAIjC;;;OAGG;+BACwB,MAAM,SAAS,uBAAuB;CAIpE,CAAA"}

package/dist/helpers/storage.js

@@ -1,7 +1,6 @@
 import { REFERENCE_LS_KEYS, safeLocalStorage } from "@scalar/helpers/object/local-storage";
-import { XScalarSelectedSecuritySchema } from "@scalar/workspace-store/schemas/extensions/security/x-scalar-selected-security";
 import { coerceValue } from "@scalar/workspace-store/schemas/typebox-coerce";
-import { SecuritySchemesSchema } from "@scalar/workspace-store/schemas/v3.1/strict/openapi-document";
+import { XScalarSelectedSecuritySchema, SecuritySchemesSchema } from "@scalar/workspace-store/schemas/v3.1/strict/openapi-document";
 const storage = safeLocalStorage();
 const clientStorage = () => {
   const key = REFERENCE_LS_KEYS.SELECTED_CLIENT;
@@ -24,34 +23,40 @@ const clientStorage = () => {
 const authStorage = () => {
   const schemasKey = REFERENCE_LS_KEYS.AUTH_SCHEMES;
   const selectedSchemesKey = REFERENCE_LS_KEYS.SELECTED_AUTH_SCHEMES;
+  const getAuthId = (type, prefix) => {
+    const getKey = (type2) => {
+      return type2 === "schemas" ? schemasKey : selectedSchemesKey;
+    };
+    return `${prefix}-${getKey(type)}`;
+  };
   return {
     /**
      * Retrieves and coerces the authentication schemes stored in local storage.
      */
-    getSchemas: () => {
-      const parsed = JSON.parse(storage.getItem(schemasKey) ?? "{}");
+    getSchemas: (slug) => {
+      const parsed = JSON.parse(storage.getItem(getAuthId("schemas", slug)) ?? "{}");
       return coerceValue(SecuritySchemesSchema, parsed);
     },
     /**
      * Stores the authentication schemes in local storage.
      * @param value The SecuritySchemes object to stringify and store.
      */
-    setSchemas: (prefix, value) => {
-      storage.setItem(`${prefix}-schemasKey`, JSON.stringify(value));
+    setSchemas: (slug, value) => {
+      storage.setItem(getAuthId("schemas", slug), JSON.stringify(value));
     },
     /**
      * Retrieves and coerces the selected authentication schemes stored in local storage.
      */
-    getSelectedSchemes: () => {
-      const parsed = JSON.parse(storage.getItem(selectedSchemesKey) ?? "{}");
+    getSelectedSchemes: (slug) => {
+      const parsed = JSON.parse(storage.getItem(getAuthId("selectedSchemes", slug)) ?? "{}");
       return coerceValue(XScalarSelectedSecuritySchema, parsed);
     },
     /**
      * Stores the user's selected authentication schemes in local storage.
      * @param value The XScalarSelectedSecurity object to stringify and store.
      */
-    setSelectedSchemes: (prefix, value) => {
-      storage.setItem(`${prefix}-selectedSchemesKey`, JSON.stringify(value));
+    setSelectedSchemes: (slug, value) => {
+      storage.setItem(getAuthId("selectedSchemes", slug), JSON.stringify(value));
     }
   };
 };

package/dist/style.css

@@ -9184,7 +9184,7 @@ to {
   scrollbar-width: none;
   overflow: auto;
 }
-.commandmenu[data-v-f2bbd082] {
+.commandmenu[data-v-dd90fe74] {
   box-shadow: var(--scalar-shadow-2);
   border-radius: var(--scalar-radius-lg);
   background-color: var(--scalar-background-1);
@@ -9193,20 +9193,20 @@ to {
   max-width: 580px;
   max-height: 60dvh;
   margin: 12px;
-  animation: .3s ease-in-out .1s forwards fadeincommandmenu-f2bbd082;
+  animation: .3s ease-in-out .1s forwards fadeincommandmenu-dd90fe74;
   position: fixed;
   top: 150px;
   left: 50%;
   transform: translate3d(-50%, 10px, 0);
 }
-.commandmenu-overlay[data-v-f2bbd082] {
+.commandmenu-overlay[data-v-dd90fe74] {
   cursor: pointer;
   background: #0003;
-  animation: .3s ease-in-out forwards fadeincommand-f2bbd082;
+  animation: .3s ease-in-out forwards fadeincommand-dd90fe74;
   position: fixed;
   inset: 0;
 }
-@keyframes fadeincommand-f2bbd082 {
+@keyframes fadeincommand-dd90fe74 {
 0% {
     opacity: 0;
 }
@@ -9214,7 +9214,7 @@ to {
     opacity: 1;
 }
 }
-@keyframes fadeincommandmenu-f2bbd082 {
+@keyframes fadeincommandmenu-dd90fe74 {
 0% {
     opacity: 0;
     transform: translate3d(-50%, 10px, 0);
@@ -10101,10 +10101,10 @@ to {
   white-space: nowrap;
   display: flex;
 }
-[data-v-1434cda7] .cm-editor {
+[data-v-e07e86c7] .cm-editor {
   padding: 0;
 }
-[data-v-1434cda7] .cm-content {
+[data-v-e07e86c7] .cm-content {
   font-family: var(--scalar-font);
   font-size: var(--scalar-small);
   background-color: #0000;
@@ -10113,27 +10113,27 @@ to {
   padding: 5px 8px;
   display: flex;
 }
-[data-v-1434cda7] .cm-content:has(.cm-pill) {
+[data-v-e07e86c7] .cm-content:has(.cm-pill) {
   padding: 5px 8px;
 }
-[data-v-1434cda7] .cm-content .cm-pill:not(:last-of-type) {
+[data-v-e07e86c7] .cm-content .cm-pill:not(:last-of-type) {
   margin-right: .5px;
 }
-[data-v-1434cda7] .cm-content .cm-pill:not(:first-of-type) {
+[data-v-e07e86c7] .cm-content .cm-pill:not(:first-of-type) {
   margin-left: .5px;
 }
-[data-v-1434cda7] .cm-line {
+[data-v-e07e86c7] .cm-line {
   text-overflow: ellipsis;
   padding: 0;
   overflow: hidden;
 }
-.filemask[data-v-1434cda7] {
+.filemask[data-v-e07e86c7] {
   -webkit-mask-image: linear-gradient(to right, transparent 0, var(--scalar-background-2) 20px);
   -webkit-mask-image: linear-gradient(to right, transparent 0, var(--scalar-background-2) 20px);
   -webkit-mask-image: linear-gradient(to right, transparent 0, var(--scalar-background-2) 20px);
   mask-image: linear-gradient(to right, transparent 0, var(--scalar-background-2) 20px);
 }
-[data-v-cbed7b55] .cm-content {
+[data-v-0a6f7696] .cm-content {
   font-size: var(--scalar-small);
 }
 .form-group[data-v-43df1726] {
@@ -10182,31 +10182,31 @@ input[data-v-3157c3c7]::placeholder {
   -webkit-text-security: disc;
   -moz-text-security: disc;
 }
-.request-section-content[data-v-13f5983a] {
+.request-section-content[data-v-35cedd3d] {
   --scalar-border-width: .5px;
 }
-.request-section-content-filter[data-v-13f5983a] {
+.request-section-content-filter[data-v-35cedd3d] {
   box-shadow: 0 -10px 0 10px var(--scalar-background-1);
 }
-.request-item:focus-within .request-meta-buttons[data-v-13f5983a] {
+.request-item:focus-within .request-meta-buttons[data-v-35cedd3d] {
   opacity: 1;
 }
-.group-hover-input[data-v-13f5983a] {
+.group-hover-input[data-v-35cedd3d] {
   border-width: var(--scalar-border-width);
   border-color: #0000;
 }
-.group:hover .group-hover-input[data-v-13f5983a] {
+.group:hover .group-hover-input[data-v-35cedd3d] {
   background: var(--scalar-background-1);
 }
 @supports (color: color-mix(in lab, red, red)) {
-.group:hover .group-hover-input[data-v-13f5983a] {
+.group:hover .group-hover-input[data-v-35cedd3d] {
     background: color-mix(in srgb, var(--scalar-background-1), var(--scalar-background-2));
 }
 }
-.group:hover .group-hover-input[data-v-13f5983a] {
+.group:hover .group-hover-input[data-v-35cedd3d] {
   border-color: var(--scalar-border-color);
 }
-.group-hover-input[data-v-13f5983a]:focus {
+.group-hover-input[data-v-35cedd3d]:focus {
   border-color: var(--scalar-border-color) !important;
   background: none !important;
 }
@@ -11141,10 +11141,10 @@ to {
   transform: translate3d(calc(-100% - 4.5px), 0, 0);
 }
 .indent-border-line-offset[data-v-4f5a9d1f]:before {
-  left: var(--0bed2d4e);
+  left: var(--v0bed2d4e);
 }
 .indent-padding-left[data-v-4f5a9d1f] {
-  padding-left: calc(var(--57ee1db0)  + 6px);
+  padding-left: calc(var(--v57ee1db0)  + 6px);
 }
 .sidebar-folderitem[data-v-4f5a9d1f] .ellipsis-position {
   right: 6px;
@@ -11548,7 +11548,7 @@ to {
 
 /* Configurable Layout Variables */
 @layer scalar-config {
-.scalar-api-reference[data-v-8456284e] {
+.scalar-api-reference[data-v-9b26f178] {
     --refs-sidebar-width: var(--scalar-sidebar-width, 0px);
     /* The header height */
     --refs-header-height: calc(
@@ -11564,7 +11564,7 @@ to {
     );
     --refs-content-max-width: var(--scalar-content-max-width, 1540px);
 }
-.scalar-api-reference.references-classic[data-v-8456284e] {
+.scalar-api-reference.references-classic[data-v-9b26f178] {
     /* Classic layout is wider */
     --refs-content-max-width: var(--scalar-content-max-width, 1420px);
     min-height: 100dvh;
@@ -11572,14 +11572,14 @@ to {
 }
 
   /* When the toolbar is present, we need to offset the content */
-.scalar-api-reference[data-v-8456284e]:has(.api-reference-toolbar) {
+.scalar-api-reference[data-v-9b26f178]:has(.api-reference-toolbar) {
     --refs-content-offset: 48px;
 }
 }
 
 /* ----------------------------------------------------- */
 /* References Layout */
-.references-layout[data-v-8456284e] {
+.references-layout[data-v-9b26f178] {
   /* Try to fill the container */
   min-height: 100dvh;
   min-width: 100%;
@@ -11603,39 +11603,39 @@ to {
 
   background: var(--scalar-background-1);
 }
-.references-editor[data-v-8456284e] {
+.references-editor[data-v-9b26f178] {
   grid-area: editor;
   display: flex;
   min-width: 0;
   background: var(--scalar-background-1);
 }
-.references-rendered[data-v-8456284e] {
+.references-rendered[data-v-9b26f178] {
   position: relative;
   grid-area: rendered;
   min-width: 0;
   background: var(--scalar-background-1);
 }
-.scalar-api-reference.references-classic[data-v-8456284e],
-.references-classic .references-rendered[data-v-8456284e] {
+.scalar-api-reference.references-classic[data-v-9b26f178],
+.references-classic .references-rendered[data-v-9b26f178] {
   height: initial !important;
   max-height: initial !important;
 }
 @layer scalar-config {
-.references-sidebar[data-v-8456284e] {
+.references-sidebar[data-v-9b26f178] {
     /* Set a default width if references are enabled */
     --refs-sidebar-width: var(--scalar-sidebar-width, 280px);
 }
 }
 
 /* Footer */
-.references-footer[data-v-8456284e] {
+.references-footer[data-v-9b26f178] {
   grid-area: footer;
 }
 /* ----------------------------------------------------- */
 /* Responsive / Mobile Layout */
 @media (max-width: 1000px) {
   /* Stack view on mobile */
-.references-layout[data-v-8456284e] {
+.references-layout[data-v-9b26f178] {
     grid-template-columns: 100%;
     grid-template-rows: var(--scalar-header-height, 0px) 0px auto auto;
 
@@ -11645,13 +11645,13 @@ to {
       'rendered'
       'footer';
 }
-.references-editable[data-v-8456284e] {
+.references-editable[data-v-9b26f178] {
     grid-template-areas:
       'header'
       'navigation'
       'editor';
 }
-.references-rendered[data-v-8456284e] {
+.references-rendered[data-v-9b26f178] {
     position: static;
 }
 }
@@ -11662,12 +11662,12 @@ to {
 * when the new elements are available
 */
 @media (max-width: 1000px) {
-.scalar-api-references-standalone-mobile[data-v-8456284e] {
+.scalar-api-references-standalone-mobile[data-v-9b26f178] {
     --scalar-header-height: 50px;
 }
 }
 
-.darklight-reference[data-v-8456284e] {
+.darklight-reference[data-v-9b26f178] {
   width: 100%;
   margin-top: auto;
 }

package/package.json

@@ -20,7 +20,7 @@
     "vue",
     "vue3"
   ],
-  "version": "1.43.5",
+  "version": "1.43.7",
   "engines": {
     "node": ">=20"
   },
@@ -85,51 +85,51 @@
     "github-slugger": "^2.0.0",
     "js-base64": "^3.7.8",
     "microdiff": "^1.5.0",
-    "nanoid": "5.1.5",
-    "type-fest": "5.0.0",
-    "vue": "^3.5.21",
-    "zod": "^4.1.11",
-    "@scalar/api-client": "2.18.1",
+    "nanoid": "^5.1.6",
+    "type-fest": "^5.3.1",
+    "vue": "^3.5.26",
+    "zod": "^4.3.5",
+    "@scalar/api-client": "2.18.3",
     "@scalar/code-highlight": "0.2.2",
-    "@scalar/components": "0.16.20",
-    "@scalar/helpers": "0.2.7",
-    "@scalar/json-magic": "0.9.0",
-    "@scalar/openapi-parser": "0.23.13",
-    "@scalar/oas-utils": "0.6.17",
-    "@scalar/openapi-upgrader": "0.1.7",
+    "@scalar/components": "0.16.22",
+    "@scalar/icons": "0.5.2",
+    "@scalar/helpers": "0.2.8",
+    "@scalar/oas-utils": "0.6.19",
+    "@scalar/json-magic": "0.9.1",
+    "@scalar/openapi-parser": "0.24.1",
     "@scalar/openapi-types": "0.5.3",
-    "@scalar/object-utils": "1.2.21",
-    "@scalar/sidebar": "0.7.10",
-    "@scalar/snippetz": "0.6.4",
+    "@scalar/object-utils": "1.2.22",
+    "@scalar/openapi-upgrader": "0.1.7",
+    "@scalar/sidebar": "0.7.12",
+    "@scalar/snippetz": "0.6.5",
     "@scalar/themes": "0.13.26",
-    "@scalar/types": "0.5.7",
-    "@scalar/icons": "0.5.2",
+    "@scalar/types": "0.5.8",
     "@scalar/use-toasts": "0.9.1",
-    "@scalar/workspace-store": "0.24.7",
-    "@scalar/use-hooks": "0.3.6"
+    "@scalar/use-hooks": "0.3.6",
+    "@scalar/workspace-store": "0.24.9"
   },
   "devDependencies": {
-    "@hono/node-server": "1.19.5",
+    "@hono/node-server": "^1.19.7",
     "@playwright/test": "1.56.0",
     "@tailwindcss/vite": "^4.1.18",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-vue": "6.0.1",
-    "@vue/server-renderer": "^3.5.17",
+    "@vitejs/plugin-vue": "^6.0.3",
+    "@vue/server-renderer": "^3.5.26",
     "@vue/test-utils": "2.4.6",
     "hono": "4.11.4",
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
     "rollup-plugin-webpack-stats": "^0.2.5",
     "tailwindcss": "^4.1.18",
-    "vite": "7.3.0",
-    "vite-plugin-banner": "^0.7.1",
-    "vite-plugin-css-injected-by-js": "^3.4.0",
-    "vitest": "3.2.4",
+    "vite": "^7.3.1",
+    "vite-plugin-banner": "^0.8.1",
+    "vite-plugin-css-injected-by-js": "^3.5.2",
+    "vitest": "4.0.16",
     "@scalar/build-tooling": "0.4.1",
-    "@scalar/core": "0.3.31",
-    "@scalar/galaxy": "0.5.12",
-    "@scalar/react-renderer": "0.3.0"
+    "@scalar/core": "0.3.32",
+    "@scalar/react-renderer": "0.3.0",
+    "@scalar/galaxy": "0.5.12"
   },
   "scripts": {
     "build": "pnpm build:default && pnpm build:standalone && pnpm types:build",