@scalar/api-reference 1.43.4 → 1.43.7

package/dist/features/info-object/TermsOfService.vue.js

@@ -12,10 +12,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   },
   setup(__props) {
     return (_ctx, _cache) => {
-      return _ctx.value ? (openBlock(), createElementBlock("div", _hoisted_1, [
+      return __props.value ? (openBlock(), createElementBlock("div", _hoisted_1, [
         createElementVNode("a", {
           class: "text-c-1 hover:bg-b-2 mr-2 flex min-h-7 min-w-7 items-center rounded-lg border px-2 py-1 no-underline group-last:mr-0 xl:border-none",
-          href: _ctx.value,
+          href: __props.value,
           target: "_blank",
           rel: "noopener noreferrer"
         }, [

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

@@ -27,7 +27,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       () => formattedOptions.value.find((o) => o.id === props.modelValue)
     );
     return (_ctx, _cache) => {
-      return _ctx.options.length > 1 ? (openBlock(), createElementBlock("div", _hoisted_1, [
+      return __props.options.length > 1 ? (openBlock(), createElementBlock("div", _hoisted_1, [
         createVNode(unref(ScalarListbox), {
           modelValue: selected.value,
           options: formattedOptions.value,

package/dist/features/specification-extension/SpecificationExtension.vue2.js

@@ -25,7 +25,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       () => getCustomOpenApiExtensionComponents(customExtensionNames.value)
     );
     return (_ctx, _cache) => {
-      return typeof _ctx.value === "object" && customExtensions.value.length ? (openBlock(), createElementBlock("div", _hoisted_1, [
+      return typeof __props.value === "object" && customExtensions.value.length ? (openBlock(), createElementBlock("div", _hoisted_1, [
         (openBlock(true), createElementBlock(Fragment, null, renderList(customExtensions.value, (extension) => {
           return openBlock(), createBlock(unref(ScalarErrorBoundary), null, {
             default: withCtx(() => [
@@ -33,12 +33,12 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 key: 0,
                 ref_for: true
               }, {
-                [extension.name]: _ctx.value?.[extension.name],
+                [extension.name]: __props.value?.[extension.name],
                 component: extension.component
               }), null, 16)) : (openBlock(), createBlock(resolveDynamicComponent(extension.component), mergeProps({
                 key: 1,
                 ref_for: true
-              }, { [extension.name]: _ctx.value?.[extension.name] }), null, 16))
+              }, { [extension.name]: __props.value?.[extension.name] }), null, 16))
             ]),
             _: 2
           }, 1024);

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

@@ -15,7 +15,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("button", {
         class: "show-api-client-button",
-        method: _ctx.method,
+        method: __props.method,
         type: "button",
         onClick: withModifiers(handleClick, ["stop"])
       }, [
@@ -26,7 +26,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         _cache[0] || (_cache[0] = createElementVNode("span", null, "Test Request", -1)),
         createVNode(ScreenReader, null, {
           default: withCtx(() => [
-            createTextVNode("(" + toDisplayString(_ctx.method) + " " + toDisplayString(_ctx.path) + ")", 1)
+            createTextVNode("(" + toDisplayString(__props.method) + " " + toDisplayString(__props.path) + ")", 1)
           ]),
           _: 1
         })

package/dist/features/toolbar/ApiReferenceToolbar.vue.js

@@ -41,14 +41,14 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           createElementVNode("div", _hoisted_3, [
             createVNode(_sfc_main$1)
           ]),
-          _ctx.workspace ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
-            createVNode(_sfc_main$2, { workspace: _ctx.workspace }, null, 8, ["workspace"]),
-            createVNode(_sfc_main$3, { workspace: _ctx.workspace }, null, 8, ["workspace"])
+          __props.workspace ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+            createVNode(_sfc_main$2, { workspace: __props.workspace }, null, 8, ["workspace"]),
+            createVNode(_sfc_main$3, { workspace: __props.workspace }, null, 8, ["workspace"])
           ], 64)) : createCommentVNode("", true),
           createVNode(_sfc_main$4, {
             overrides: overrides.value,
             "onUpdate:overrides": _cache[0] || (_cache[0] = ($event) => overrides.value = $event),
-            configuration: _ctx.configuration
+            configuration: __props.configuration
           }, null, 8, ["overrides", "configuration"])
         ])
       ])) : createCommentVNode("", true);

package/dist/features/toolbar/ApiReferenceToolbarConfig.vue.js

@@ -86,7 +86,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 createVNode(_sfc_main$4, {
                   modelValue: overrides.value,
                   "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => overrides.value = $event),
-                  configuration: _ctx.configuration
+                  configuration: __props.configuration
                 }, null, 8, ["modelValue", "configuration"])
               ]),
               _: 1

package/dist/features/toolbar/ApiReferenceToolbarSdks.vue.js

@@ -62,7 +62,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
               }),
               createVNode(_sfc_main$2, {
                 sdks: selectedLanguages.value,
-                workspace: _ctx.workspace
+                workspace: __props.workspace
               }, null, 8, ["sdks", "workspace"]),
               createVNode(ApiReferenceToolbarBlurb, null, {
                 default: withCtx(() => [..._cache[2] || (_cache[2] = [

package/dist/features/toolbar/ApiReferenceToolbarShare.vue.js

@@ -20,7 +20,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
               createTextVNode("Temporary Link", -1)
             ])]),
             default: withCtx(() => [
-              createVNode(_sfc_main$2, { workspace: _ctx.workspace }, null, 8, ["workspace"])
+              createVNode(_sfc_main$2, { workspace: __props.workspace }, null, 8, ["workspace"])
             ]),
             _: 1
           }),
@@ -29,7 +29,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
               createTextVNode("Cloud Hosting", -1)
             ])]),
             default: withCtx(() => [
-              createVNode(_sfc_main$3, { workspace: _ctx.workspace }, null, 8, ["workspace"])
+              createVNode(_sfc_main$3, { workspace: __props.workspace }, null, 8, ["workspace"])
             ]),
             _: 1
           })

package/dist/features/toolbar/ApiReferenceToolbarShareRegister.vue.js

@@ -33,7 +33,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
             ]);
           }), 64))
         ]),
-        createVNode(_sfc_main$1, { workspace: _ctx.workspace }, {
+        createVNode(_sfc_main$1, { workspace: __props.workspace }, {
           default: withCtx(() => [..._cache[0] || (_cache[0] = [
             createTextVNode(" Deploy on Scalar ", -1)
           ])]),

package/dist/helpers/id-routing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"id-routing.d.ts","sourceRoot":"","sources":["../../src/helpers/id-routing.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,WAEhD,CAAA;AAED,mEAAmE;AACnE,eAAO,MAAM,aAAa,GAAI,UAAU,MAAM,GAAG,GAAG,EAAE,YAAY,MAAM,GAAG,SAAS,WAMnF,CAAA;AACD,mEAAmE;AACnE,eAAO,MAAM,aAAa,GAAI,UAAU,MAAM,GAAG,GAAG,EAAE,UAAU,MAAM,EAAE,YAAY,MAAM,GAAG,SAAS,WAqBrG,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,GAAG,GAAG,EAAE,UAAU,MAAM,GAAG,SAAS,EAAE,YAAY,MAAM,GAAG,SAAS,WAE3G,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,UAAU,MAAM,GAAG,SAAS,EAAE,iBAAiB,OAAO,oBAkBhG,CAAA;AAED,qEAAqE;AACrE,eAAO,MAAM,qBAAqB,GAAI,IAAI,MAAM,KAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAajF,CAAA"}
+{"version":3,"file":"id-routing.d.ts","sourceRoot":"","sources":["../../src/helpers/id-routing.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,WAEhD,CAAA;AAED,mEAAmE;AACnE,eAAO,MAAM,aAAa,GAAI,UAAU,MAAM,GAAG,GAAG,EAAE,YAAY,MAAM,GAAG,SAAS,WAMnF,CAAA;AACD,mEAAmE;AACnE,eAAO,MAAM,aAAa,GAAI,UAAU,MAAM,GAAG,GAAG,EAAE,UAAU,MAAM,EAAE,YAAY,MAAM,GAAG,SAAS,WAqBrG,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,GAAG,GAAG,EAAE,UAAU,MAAM,GAAG,SAAS,EAAE,YAAY,MAAM,GAAG,SAAS,WAE3G,CAAA;AAmBD;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,UAAU,MAAM,GAAG,SAAS,EAAE,iBAAiB,OAAO,oBAiBhG,CAAA;AAED,qEAAqE;AACrE,eAAO,MAAM,qBAAqB,GAAI,IAAI,MAAM,KAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAajF,CAAA"}

package/dist/helpers/id-routing.js

@@ -20,11 +20,17 @@ const getIdFromPath = (location, basePath, slugPrefix) => {
 const getIdFromUrl = (url, basePath, slugPrefix) => {
   return typeof basePath === "string" ? getIdFromPath(url, basePath, slugPrefix) : getIdFromHash(url, slugPrefix);
 };
+const stripFirstSegment = (id) => {
+  const hasTrailingSlash = id.endsWith("/");
+  const segments = id.split("/").filter(Boolean).slice(1);
+  const result = segments.join("/");
+  return hasTrailingSlash && result ? `${result}/` : result;
+};
 const makeUrlFromId = (_id, basePath, isMultiDocument) => {
   if (typeof window === "undefined") {
     return void 0;
   }
-  const id = isMultiDocument ? _id : _id.split("/").filter(Boolean).slice(1).join("/");
+  const id = isMultiDocument ? _id : stripFirstSegment(_id);
   const url = new URL(window.location.href);
   if (typeof basePath === "string") {
     const base = sanitizeBasePath(basePath);

package/dist/helpers/load-from-perssistance.d.ts

@@ -0,0 +1,32 @@
+import type { WorkspaceStore } from '@scalar/workspace-store/client';
+/**
+ * Loads the default HTTP client from storage and applies it to the workspace.
+ * Only updates if no default client is already set.
+ */
+export declare const loadClientFromStorage: (store: WorkspaceStore) => void;
+/**
+ * Checks if a key is a Scalar secret key.
+ * Secret keys start with 'x-scalar-secret-' prefix.
+ */
+export declare const isSecretKey: (key: string) => boolean;
+/**
+ * Recursively merges secret values from stored data into the current schema.
+ * Only merges secrets if the corresponding structure exists in the current schema.
+ *
+ * This function walks through both objects in parallel, copying any keys that
+ * start with 'x-scalar-secret-' from the stored object to the current object,
+ * but only if the path exists in the current schema.
+ *
+ * @param current - The current schema object (source of truth for structure)
+ * @param stored - The stored object containing secret values to restore
+ */
+export declare const mergeSecrets: (current: unknown, stored: unknown) => void;
+/**
+ * Loads authentication schemes and selected security settings from local storage.
+ *
+ * This function restores both the available security schemes and the user's
+ * selected security configuration for the active document. It validates that
+ * the stored schemes still exist in the current document before restoring them.
+ */
+export declare const loadAuthSchemesFromStorage: (store: WorkspaceStore) => void;
+//# sourceMappingURL=load-from-perssistance.d.ts.map

package/dist/helpers/load-from-perssistance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-from-perssistance.d.ts","sourceRoot":"","sources":["../../src/helpers/load-from-perssistance.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAYpE;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,cAAc,KAAG,IAM7D,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,OAA4C,CAAA;AAEtF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,OAAO,EAAE,QAAQ,OAAO,KAAG,IAgBhE,CAAA;AA4CD;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GAAI,OAAO,cAAc,KAAG,IAkClE,CAAA"}

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/plugins/hooks/usePluginManager.js

@@ -1,6 +1,6 @@
 import { createPluginManager } from "../plugin-manager.js";
 import { inject } from "vue";
-const PLUGIN_MANAGER_SYMBOL = Symbol();
+const PLUGIN_MANAGER_SYMBOL = /* @__PURE__ */ Symbol();
 const usePluginManager = () => {
   const manager = inject(PLUGIN_MANAGER_SYMBOL);
   if (!manager) {