@scalar/api-reference 1.28.7 → 1.28.9

package/dist/helpers/freeze-element.js

@@ -0,0 +1,20 @@
+const s = (t) => {
+  if (!t)
+    return () => null;
+  const e = t.getBoundingClientRect().top, r = new MutationObserver(() => {
+    const n = t.getBoundingClientRect().top;
+    if (n !== e) {
+      const o = n - e;
+      window.scrollBy(0, o);
+    }
+  });
+  return r.observe(document.body, {
+    childList: !0,
+    subtree: !0,
+    attributes: !0,
+    characterData: !0
+  }), () => r.disconnect();
+};
+export {
+  s as freezeElement
+};

package/dist/helpers/get-request.d.ts

@@ -1,9 +1,9 @@
 import type { WorkspaceStore } from '@scalar/api-client/store';
 /** Grabs the request from a path + method */
 export declare const getRequest: (requests: WorkspaceStore["requests"], path: string, method: string) => {
+    uid: string & import("zod").BRAND<"operation">;
     path: string;
     type: "request";
-    uid: string & import("zod").BRAND<"operation">;
     selectedSecuritySchemeUids: ((string & import("zod").BRAND<"securityScheme">) | (string & import("zod").BRAND<"securityScheme">)[])[];
     selectedServerUid: (string & import("zod").BRAND<"server">) | null;
     servers: (string & import("zod").BRAND<"server">)[];
@@ -22,12 +22,12 @@ export declare const getRequest: (requests: WorkspaceStore["requests"], path: st
     deprecated?: boolean | undefined;
     operationId?: string | undefined;
     parameters?: {
-        required: boolean;
         name: string;
-        in: "path" | "cookie" | "query" | "header";
+        required: boolean;
+        in: "cookie" | "path" | "query" | "header";
         deprecated: boolean;
-        example?: unknown;
         description?: string | undefined;
+        example?: unknown;
         schema?: unknown;
         content?: unknown;
         style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;

package/dist/helpers/get-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-request.d.ts","sourceRoot":"","sources":["../../src/helpers/get-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAE9D,6CAA6C;AAC7C,eAAO,MAAM,UAAU,aAAc,cAAc,CAAC,UAAU,CAAC,QAAQ,MAAM,UAAU,MAAM;;;yBAE2yT,KAAK;kDAA4E,KAAK,8CAA8C,KAAK;wCAA6E,KAAK;8BAA6D,KAAK;+BAAyD,KAAK;;;;;;mBAAwR,CAAC;;;;;;;;;;;;;eAA0f,CAAC;mBAAkC,CAAC;cAAwC,CAAC;eAA8B,CAAC;aAA4B,CAAC;gBAA8H,CAAC;iBAAoD,CAAC;mBAAkC,CAAC;;;;;kCAAiM,eAAe;aAD77W,CAAA"}
+{"version":3,"file":"get-request.d.ts","sourceRoot":"","sources":["../../src/helpers/get-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAE9D,6CAA6C;AAC7C,eAAO,MAAM,UAAU,aAAc,cAAc,CAAC,UAAU,CAAC,QAAQ,MAAM,UAAU,MAAM;yBAE4vT,KAAK;;;kDAA2H,KAAK,8CAA8C,KAAK;wCAA6E,KAAK;8BAA6D,KAAK;+BAAyD,KAAK;;;;;;mBAAwR,CAAC;;;;;;;;;;;;;mBAA8f,CAAC;eAAyC,CAAC;cAA6B,CAAC;eAA8B,CAAC;aAA4B,CAAC;gBAA8H,CAAC;iBAAoD,CAAC;mBAAkC,CAAC;;;;;kCAAiM,eAAe;aAD77W,CAAA"}

package/dist/hooks/useMultipleDocuments.d.ts

@@ -1,58 +1,53 @@
 import type { NavState } from '../hooks/useNavState.js';
-import { type ApiReferenceConfiguration, type ApiReferenceConfigurationWithSources } from '@scalar/types/api-reference';
+import { type AnyApiReferenceConfiguration } from '@scalar/types/api-reference';
 import { type Ref } from 'vue';
 type UseMultipleDocumentsProps = {
     /**
      * Configuration for the API reference.
      * Can be a single configuration or an array of configurations for multiple documents.
      */
-    configuration: Ref<Partial<ApiReferenceConfiguration> | Partial<ApiReferenceConfiguration>[] | Partial<ApiReferenceConfigurationWithSources> | undefined>;
+    configuration: Ref<AnyApiReferenceConfiguration | undefined>;
     /** The initial index to pre-select a document, if there is no query parameter available */
     initialIndex?: number;
 } & NavState;
 export declare const useMultipleDocuments: ({ configuration, initialIndex, isIntersectionEnabled, hash, hashPrefix, }: UseMultipleDocumentsProps) => {
     selectedConfiguration: import("vue").ComputedRef<{
-        hideClientButton: boolean;
-        showSidebar: boolean;
-        theme: "alternate" | "default" | "moon" | "purple" | "solarized" | "bluePlanet" | "deepSpace" | "saturn" | "kepler" | "elysiajs" | "fastify" | "mars" | "none";
-        layout: "modern" | "classic";
-        isEditable: boolean;
-        isLoading: boolean;
-        hideModels: boolean;
-        hideDownloadButton: boolean;
-        hideTestRequestButton: boolean;
-        hideSearch: boolean;
-        hideDarkModeToggle: boolean;
-        withDefaultFonts: boolean;
         url?: string | undefined;
         content?: string | Record<string, any> | ((...args: unknown[]) => Record<string, any>) | null | undefined;
         title?: string | undefined;
         slug?: string | undefined;
-        spec?: {
-            url?: string | undefined;
-            content?: string | Record<string, any> | ((...args: unknown[]) => Record<string, any>) | null | undefined;
-            title?: string | undefined;
-            slug?: string | undefined;
-        } | undefined;
+        default?: boolean;
+        hideClientButton?: boolean | undefined;
+        showSidebar?: boolean | undefined;
+        theme?: "default" | "alternate" | "moon" | "purple" | "solarized" | "bluePlanet" | "deepSpace" | "saturn" | "kepler" | "elysiajs" | "fastify" | "mars" | "none" | undefined;
+        layout?: "modern" | "classic" | undefined;
+        isEditable?: boolean | undefined;
+        isLoading?: boolean | undefined;
+        hideModels?: boolean | undefined;
+        hideDownloadButton?: boolean | undefined;
+        hideTestRequestButton?: boolean | undefined;
+        hideSearch?: boolean | undefined;
+        hideDarkModeToggle?: boolean | undefined;
+        withDefaultFonts?: boolean | undefined;
         authentication?: any;
         baseServerURL?: string | undefined;
         proxyUrl?: string | undefined;
-        searchHotKey?: "c" | "r" | "o" | "n" | "a" | "b" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "p" | "q" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | undefined;
+        searchHotKey?: "o" | "n" | "c" | "r" | "a" | "b" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "p" | "q" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | undefined;
         servers?: any[] | undefined;
         _integration?: "go" | "elysiajs" | "fastify" | "adonisjs" | "docusaurus" | "dotnet" | "express" | "fastapi" | "hono" | "html" | "laravel" | "litestar" | "nestjs" | "nextjs" | "nitro" | "nuxt" | "platformatic" | "react" | "rust" | "vue" | null | undefined;
-        proxy?: string | undefined;
         darkMode?: boolean | undefined;
         forceDarkModeState?: "dark" | "light" | undefined;
         metaData?: any;
         favicon?: string | undefined;
         hiddenClients?: true | string[] | Record<string, boolean | string[]> | undefined;
         defaultHttpClient?: {
-            targetKey: "c" | "clojure" | "csharp" | "go" | "http" | "java" | "js" | "kotlin" | "node" | "objc" | "ocaml" | "php" | "powershell" | "python" | "r" | "ruby" | "shell" | "swift" | "dart";
+            targetKey: "http" | "c" | "clojure" | "csharp" | "go" | "java" | "js" | "kotlin" | "node" | "objc" | "ocaml" | "php" | "powershell" | "python" | "r" | "ruby" | "shell" | "swift" | "dart";
             clientKey: string;
         } | undefined;
         customCss?: string | undefined;
         onSpecUpdate?: ((args_0: string, ...args: unknown[]) => void) | undefined;
         onServerChange?: ((args_0: string, ...args: unknown[]) => void) | undefined;
+        onDocumentSelect?: ((...args: unknown[]) => void | Promise<void>) | undefined;
         pathRouting?: {
             basePath: string;
         } | undefined;
@@ -80,6 +75,14 @@ export declare const useMultipleDocuments: ({ configuration, initialIndex, isInt
         defaultOpenAllTags?: boolean | undefined;
         tagsSorter?: "alpha" | ((args_0: any, args_1: any, ...args: unknown[]) => number) | undefined;
         operationsSorter?: "method" | "alpha" | ((args_0: any, args_1: any, ...args: unknown[]) => number) | undefined;
+        sources?: ({
+            url?: string | undefined;
+            content?: string | Record<string, any> | ((...args: unknown[]) => Record<string, any>) | null | undefined;
+            title?: string | undefined;
+            slug?: string | undefined;
+        } & {
+            default?: boolean;
+        })[] | undefined;
     }>;
     availableDocuments: import("vue").ComputedRef<{
         url?: string | undefined;

package/dist/hooks/useMultipleDocuments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMultipleDocuments.d.ts","sourceRoot":"","sources":["../../src/hooks/useMultipleDocuments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAEnD,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,oCAAoC,EAI1C,MAAM,6BAA6B,CAAA;AAGpC,OAAO,EAAE,KAAK,GAAG,EAAwB,MAAM,KAAK,CAAA;AAKpD,KAAK,yBAAyB,GAAG;IAC/B;;;OAGG;IACH,aAAa,EAAE,GAAG,CACd,OAAO,CAAC,yBAAyB,CAAC,GAClC,OAAO,CAAC,yBAAyB,CAAC,EAAE,GACpC,OAAO,CAAC,oCAAoC,CAAC,GAC7C,SAAS,CACZ,CAAA;IACD,2FAA2F;IAC3F,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,GAAG,QAAQ,CAAA;AAsCZ,eAAO,MAAM,oBAAoB,8EAM9B,yBAAyB;;;;;;;;;;;;;;;mDAgI63xB,GAAG;;;;eAAoJ,CAAC;mBAAqC,CAAC,mCAAmC,GAAG;iBAA0E,CAAC;gBAAkC,CAAC;;;;;;;;;;;;;;;;;;;yCAAwsC,GAAI;2CAA6E,GAAI;;;;;gBAA0J,CAAC;WAA4B,GAAI;;gBAAyF,CAAC;WAA4B,GAAI;;gBAAuF,CAAC;WAA4B,GAAI;;;;uBAAkJ,CAAC;mBAAqC,CAAC;WAA4B,GAAI;;;kBAAmH,CAAC;WAA4B,GAAI;qBAA0D,GAAG;qCAAuE,GAAI;;2DAAgK,GAAI;4EAAgH,GAAI;;;;mDA9H3q3B,GAAE;;;;;;;;CA6HxB,CAAA"}
+{"version":3,"file":"useMultipleDocuments.d.ts","sourceRoot":"","sources":["../../src/hooks/useMultipleDocuments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAEnD,OAAO,EACL,KAAK,4BAA4B,EAGlC,MAAM,6BAA6B,CAAA;AAGpC,OAAO,EAAE,KAAK,GAAG,EAAwB,MAAM,KAAK,CAAA;AAKpD,KAAK,yBAAyB,GAAG;IAC/B;;;OAGG;IACH,aAAa,EAAE,GAAG,CAAC,4BAA4B,GAAG,SAAS,CAAC,CAAA;IAC5D,2FAA2F;IAC3F,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,GAAG,QAAQ,CAAA;AA4CZ,eAAO,MAAM,oBAAoB,8EAM9B,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCA8Ii80B,GAAI;2CAA6E,GAAI;6BAAgE,GAAG;;;;;gBAA0K,CAAC;WAA4B,GAAI;;gBAAyF,CAAC;WAA4B,GAAI;;gBAAuF,CAAC;WAA4B,GAAI;;;;uBAAkJ,CAAC;mBAAqC,CAAC;WAA4B,GAAI;;;kBAAmH,CAAC;WAA4B,GAAI;qBAA0D,GAAG;qCAAuE,GAAI;;2DAAgK,GAAI;4EAAgH,GAAI;;;uDAxIxz3B,GAAG;;;;;;;;;mDAAH,GAAG;;;;;;;;CAuIT,CAAA"}

package/dist/hooks/useMultipleDocuments.js

@@ -1,67 +1,83 @@
 import { isDefined as S } from "@scalar/oas-utils/helpers";
-import { isConfigurationWithSources as p, apiReferenceConfigurationSchema as m } from "@scalar/types/api-reference";
-import y from "github-slugger";
-import { computed as v, ref as R, watch as b } from "vue";
-const d = "api", w = new y(), A = (e, r = 0) => {
+import { isConfigurationWithSources as m } from "@scalar/types/api-reference";
+import h from "github-slugger";
+import { computed as p, ref as y, watch as b } from "vue";
+const w = "api", g = new h(), I = (l, a = 0) => {
+  const e = {
+    ...l,
+    // @ts-expect-error this is before parsing so we transform the old style
+    ...l.spec ?? {}
+  };
   if (!(!(e != null && e.url) && !(e != null && e.content)))
-    return w.reset(), e.title ? {
+    return g.reset(), e.title ? {
       ...e,
-      slug: e.slug || w.slug(e.title),
+      slug: e.slug || g.slug(e.title),
       title: e.title
     } : e.slug ? {
       ...e,
       title: e.slug
     } : {
       ...e,
-      slug: `api-${r + 1}`,
-      title: `API #${r + 1}`
+      slug: `api-${a + 1}`,
+      title: `API #${a + 1}`
     };
-}, N = ({
-  configuration: e,
-  initialIndex: r,
-  isIntersectionEnabled: s,
-  hash: o,
-  hashPrefix: f
+}, P = ({
+  configuration: l,
+  initialIndex: a,
+  isIntersectionEnabled: e,
+  hash: c,
+  hashPrefix: d
 }) => {
-  const a = v(() => {
-    var l;
-    return e.value ? (p(e.value) ? ((l = e.value) == null ? void 0 : l.sources) ?? [] : [e.value].flat().map((t) => t)).map((t, n) => t && A(t, n)).filter(S) : [];
-  }), g = (i) => {
-    if (typeof window > "u" || a.value.length === 1)
-      return;
-    const l = new URL(window.location.href), t = a.value[i], n = (t == null ? void 0 : t.slug) ?? i.toString();
-    l.searchParams.set(d, n), l.hash = "", window.history.replaceState({}, "", l.toString()), o.value = "", f.value = "", s.value = !1, typeof window < "u" && window.scrollTo({ top: 0, behavior: "instant" });
-  }, u = R((() => {
+  const r = p(() => l.value ? (m(l.value) ? (
+    // This IFFE is needed for the type guard as it doens't persist into the callback scope
+    (() => {
+      const { sources: t, ...u } = l.value;
+      return (t == null ? void 0 : t.map((n) => ({ ...u, ...n }))) ?? [];
+    })()
+  ) : [l.value].flat()).map((t, u) => t && I(t, u)).filter(S) : []), o = y((() => {
     if (typeof window > "u")
-      return typeof r == "number" ? r : 0;
-    const l = new URL(window.location.href).searchParams.get(d) || "0", t = a.value.findIndex((h) => h.slug === l);
-    if (t !== -1)
-      return t;
-    const n = Number.parseInt(l, 10);
-    return !isNaN(n) && n >= 0 && n < a.value.length ? n : typeof r == "number" ? r : 0;
-  })()), c = v(() => {
-    var l, t;
-    if (e.value && p(e.value))
-      return m.parse({
-        ...e.value,
-        ...(t = (l = e.value) == null ? void 0 : l.sources) == null ? void 0 : t[u.value],
-        ...a.value[u.value]
-      });
-    const i = [e.value].flat()[u.value] ?? {};
-    return m.parse({
-      ...i,
-      ...a.value[u.value]
-    });
+      return typeof a == "number" ? a : 0;
+    const t = new URL(window.location.href).searchParams.get(w);
+    if (t) {
+      const n = r.value.findIndex((f) => f.slug === t);
+      if (n !== -1)
+        return n;
+      const s = Number.parseInt(t, 10);
+      if (!isNaN(s) && s >= 0 && s < r.value.length)
+        return s;
+    }
+    const u = r.value.findIndex((n) => "default" in n && n.default === !0);
+    return u !== -1 ? u : typeof a == "number" ? a : 0;
+  })()), v = p(() => {
+    var t, u;
+    return l.value && m(l.value) ? {
+      ...l.value,
+      ...(u = (t = l.value) == null ? void 0 : t.sources) == null ? void 0 : u[o.value],
+      ...r.value[o.value]
+    } : {
+      ...[l.value].flat()[o.value] ?? {},
+      ...r.value[o.value]
+    };
   });
-  return b(u, g, { flush: "sync" }), {
-    selectedConfiguration: c,
-    availableDocuments: a,
-    selectedDocumentIndex: u,
-    isIntersectionEnabled: s,
-    hash: o,
-    hashPrefix: f
+  return b(
+    o,
+    (i) => {
+      var s, f;
+      if (typeof window > "u" || r.value.length === 1)
+        return;
+      const t = new URL(window.location.href), u = r.value[i], n = (u == null ? void 0 : u.slug) ?? i.toString();
+      t.searchParams.set(w, n), t.hash = "", window.history.replaceState({}, "", t.toString()), c.value = "", d.value = "", e.value = !1, typeof window < "u" && window.scrollTo({ top: 0, behavior: "instant" }), (f = (s = v.value).onDocumentSelect) == null || f.call(s);
+    },
+    { flush: "sync" }
+  ), {
+    selectedConfiguration: v,
+    availableDocuments: r,
+    selectedDocumentIndex: o,
+    isIntersectionEnabled: e,
+    hash: c,
+    hashPrefix: d
   };
 };
 export {
-  N as useMultipleDocuments
+  P as useMultipleDocuments
 };

package/dist/hooks/useReactiveSpec.d.ts

@@ -8,7 +8,7 @@ export declare function useReactiveSpec({ specConfig, proxyUrl, }: {
     proxyUrl?: MaybeRefOrGetter<string>;
 }): {
     rawSpec: import("vue").Ref<string, string>;
-    parsedSpec: {
+    parsedSpec: import("vue").Ref<{
         tags?: {
             name: string;
             description: string;
@@ -166,15 +166,232 @@ export declare function useReactiveSpec({ specConfig, proxyUrl, }: {
             description?: string | undefined;
         } | undefined;
         servers?: {
+            url?: string | undefined;
+            description?: string | undefined;
+            variables?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject> | undefined;
+        }[] | {
             url?: string | undefined;
             description?: string | undefined;
             variables?: {
                 [variable: string]: import("@scalar/openapi-types").OpenAPIV3.ServerVariableObject;
             } | undefined;
-        }[] | {
+        }[] | undefined;
+        components?: {
+            schemas?: {
+                [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.SchemaObject;
+            } | undefined;
+            responses?: {
+                [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.ResponseObject;
+            } | undefined;
+            parameters?: {
+                [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.ParameterObject;
+            } | undefined;
+            examples?: {
+                [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.ExampleObject;
+            } | undefined;
+            requestBodies?: {
+                [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.RequestBodyObject;
+            } | undefined;
+            headers?: {
+                [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.HeaderObject;
+            } | undefined;
+            securitySchemes?: {
+                [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.SecuritySchemeObject;
+            } | undefined;
+            links?: {
+                [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.LinkObject;
+            } | undefined;
+            callbacks?: {
+                [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.CallbackObject;
+            } | undefined;
+        } | {
+            schemas?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.SchemaObject> | undefined;
+            responses?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ResponseObject> | undefined;
+            parameters?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ParameterObject> | undefined;
+            examples?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ExampleObject> | undefined;
+            requestBodies?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.RequestBodyObject> | undefined;
+            headers?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.HeaderObject> | undefined;
+            securitySchemes?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.SecuritySchemeObject> | undefined;
+            links?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.LinkObject> | undefined;
+            callbacks?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.CallbackObject> | undefined;
+            pathItems?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.PathItemObject> | undefined;
+        } | undefined;
+        webhooks?: import("@scalar/types").Webhooks | undefined;
+        definitions?: import("@scalar/types").Definitions | undefined;
+        swagger?: import("@scalar/openapi-types").OpenAPIV2.Document["swagger"];
+        openapi?: import("@scalar/openapi-types").OpenAPIV3.Document["openapi"] | import("@scalar/openapi-types").OpenAPIV3_1.Document["openapi"];
+        'x-tagGroups'?: {
+            name: string;
+            tags: string[];
+        }[] | undefined;
+        security?: import("@scalar/openapi-types").OpenAPIV3.SecurityRequirementObject[] | undefined;
+    }, import("@scalar/types").Spec | {
+        tags?: {
+            name: string;
+            description: string;
+            operations: {
+                httpVerb: "GET" | "HEAD" | "PATCH" | "POST" | "PUT" | "TRACE" | "CONNECT" | "DELETE" | "OPTIONS";
+                path: string;
+                operationId?: string | undefined;
+                name?: string | undefined;
+                description?: string | undefined;
+                information?: {
+                    description?: string | undefined;
+                    operationId?: (string | number) | undefined;
+                    parameters?: {
+                        name: string;
+                        in?: string | undefined;
+                        description?: string | undefined;
+                        required?: boolean | undefined;
+                        deprecated?: boolean | undefined;
+                        allowEmptyValue?: boolean | undefined;
+                        style?: ("form" | "simple") | undefined;
+                        explode?: boolean | undefined;
+                        allowReserved?: boolean | undefined;
+                        schema?: {
+                            type: string;
+                            name?: string | undefined;
+                            example?: any;
+                            default?: any;
+                            format?: string | undefined;
+                            description?: string | undefined;
+                            properties?: Record<string, import("@scalar/types").Schema> | undefined;
+                        } | undefined;
+                        example?: any;
+                        examples?: (Map<string, any> & Omit<Map<string, any>, keyof Map<any, any>>) | undefined;
+                        content?: import("@scalar/types").RequestBodyMimeTypes | undefined;
+                        headers?: {
+                            [key: string]: import("@scalar/openapi-types").OpenAPI.HeaderObject;
+                        } | undefined;
+                    }[] | undefined;
+                    responses?: Record<string, import("@scalar/openapi-types").OpenAPI.ResponseObject> | undefined;
+                    security?: import("@scalar/openapi-types").OpenAPIV3.SecurityRequirementObject[] | undefined;
+                    requestBody?: {
+                        description?: string | undefined;
+                        required?: boolean | undefined;
+                        content?: import("@scalar/types").RequestBodyMimeTypes | undefined;
+                    } | undefined;
+                    summary?: string | undefined;
+                    tags?: string[] | undefined;
+                    deprecated?: boolean | undefined;
+                    servers?: {
+                        url?: string | undefined;
+                        description?: string | undefined;
+                        variables?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject> | undefined;
+                    }[] | undefined;
+                    'x-custom-examples'?: {
+                        lang: string;
+                        label: string;
+                        source: string;
+                    }[] | undefined;
+                    'x-scalar-stability'?: import("@scalar/types").XScalarStability | undefined;
+                    'x-codeSamples'?: {
+                        lang: string;
+                        label: string;
+                        source: string;
+                    }[] | undefined;
+                    'x-code-samples'?: {
+                        lang: string;
+                        label: string;
+                        source: string;
+                    }[] | undefined;
+                } | undefined;
+                servers?: {
+                    url?: string | undefined;
+                    description?: string | undefined;
+                    variables?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject> | undefined;
+                }[] | undefined;
+                pathParameters?: {
+                    name: string;
+                    in?: string | undefined;
+                    description?: string | undefined;
+                    required?: boolean | undefined;
+                    deprecated?: boolean | undefined;
+                    allowEmptyValue?: boolean | undefined;
+                    style?: ("form" | "simple") | undefined;
+                    explode?: boolean | undefined;
+                    allowReserved?: boolean | undefined;
+                    schema?: {
+                        type: string;
+                        name?: string | undefined;
+                        example?: any;
+                        default?: any;
+                        format?: string | undefined;
+                        description?: string | undefined;
+                        properties?: Record<string, import("@scalar/types").Schema> | undefined;
+                    } | undefined;
+                    example?: any;
+                    examples?: (Map<string, any> & Omit<Map<string, any>, keyof Map<any, any>>) | undefined;
+                    content?: import("@scalar/types").RequestBodyMimeTypes | undefined;
+                    headers?: {
+                        [key: string]: import("@scalar/openapi-types").OpenAPI.HeaderObject;
+                    } | undefined;
+                }[] | undefined;
+            }[];
+            'x-displayName'?: string | undefined;
+        }[] | undefined;
+        info: {
+            title?: string | undefined;
+            description?: string | undefined;
+            termsOfService?: string | undefined;
+            contact?: {
+                name?: string | undefined;
+                url?: string | undefined;
+                email?: string | undefined;
+            } | undefined;
+            license?: {
+                name?: string | undefined;
+                url?: string | undefined;
+            } | undefined;
+            version?: string | undefined;
+        } | {
+            title?: string | undefined;
+            description?: string | undefined;
+            termsOfService?: string | undefined;
+            contact?: {
+                name?: string | undefined;
+                url?: string | undefined;
+                email?: string | undefined;
+            } | undefined;
+            license?: {
+                name?: string | undefined;
+                url?: string | undefined;
+            } | undefined;
+            version?: string | undefined;
+        } | {
+            title?: string | undefined;
+            description?: string | undefined;
+            termsOfService?: string | undefined;
+            contact?: {
+                name?: string | undefined;
+                url?: string | undefined;
+                email?: string | undefined;
+            } | undefined;
+            version?: string | undefined;
+            summary?: string | undefined;
+            license?: {
+                name?: string | undefined;
+                url?: string | undefined;
+                identifier?: string | undefined;
+            } | undefined;
+        } | undefined;
+        host?: import("@scalar/openapi-types").OpenAPIV2.Document["host"];
+        basePath?: import("@scalar/openapi-types").OpenAPIV2.Document["basePath"];
+        schemes?: import("@scalar/openapi-types").OpenAPIV2.Document["schemes"];
+        externalDocs?: {
+            url: string;
+            description?: string | undefined;
+        } | undefined;
+        servers?: {
             url?: string | undefined;
             description?: string | undefined;
             variables?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject> | undefined;
+        }[] | {
+            url?: string | undefined;
+            description?: string | undefined;
+            variables?: {
+                [variable: string]: import("@scalar/openapi-types").OpenAPIV3.ServerVariableObject;
+            } | undefined;
         }[] | undefined;
         components?: {
             schemas?: {
@@ -225,7 +442,7 @@ export declare function useReactiveSpec({ specConfig, proxyUrl, }: {
             tags: string[];
         }[] | undefined;
         security?: import("@scalar/openapi-types").OpenAPIV3.SecurityRequirementObject[] | undefined;
-    };
+    }>;
     specErrors: import("vue").Ref<string | null, string | null>;
 };
 //# sourceMappingURL=useReactiveSpec.d.ts.map

package/dist/hooks/useReactiveSpec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useReactiveSpec.d.ts","sourceRoot":"","sources":["../../src/hooks/useReactiveSpec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAiC,MAAM,KAAK,CAAA;AAoD1E;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAC9B,UAAU,EACV,QAAQ,GACT,EAAE;IACD,UAAU,CAAC,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,CAAA;IAChD,QAAQ,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDA"}
+{"version":3,"file":"useReactiveSpec.d.ts","sourceRoot":"","sources":["../../src/hooks/useReactiveSpec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,KAAK,CAAA;AAoDhE;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAC9B,UAAU,EACV,QAAQ,GACT,EAAE;IACD,UAAU,CAAC,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,CAAA;IAChD,QAAQ,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwDA"}

package/dist/hooks/useReactiveSpec.js

@@ -1,46 +1,48 @@
-import { isValidUrl as d, fetchSpecFromUrl as f, prettyPrintJson as h } from "@scalar/oas-utils/helpers";
-import { ref as u, reactive as g, watch as m, toValue as s } from "vue";
+import { isValidUrl as d, fetchSpecFromUrl as u, prettyPrintJson as h } from "@scalar/oas-utils/helpers";
+import { ref as s, watch as m, toValue as p } from "vue";
 import { parse as v } from "../helpers/parse.js";
 import { createEmptySpecification as l } from "../helpers/createEmptySpecification.js";
-const y = async ({ url: e, content: r }, n) => {
+const y = async ({ url: e, content: o }, n) => {
   if (e) {
-    const a = performance.now();
+    const i = performance.now();
     try {
-      const c = d(e) ? await f(e, n) : await f(e), o = performance.now();
-      return console.log(`fetch: ${Math.round(o - a)} ms (${e})`), console.log("size:", Math.round(c.length / 1024), "kB"), c;
+      const c = d(e) ? await u(e, n) : await u(e), r = performance.now();
+      return console.log(`fetch: ${Math.round(r - i)} ms (${e})`), console.log("size:", Math.round(c.length / 1024), "kB"), c;
     } catch (c) {
       console.error("Failed to fetch spec from URL:", c);
     }
   }
-  const t = typeof r == "function" ? r() : r;
+  const t = typeof o == "function" ? o() : o;
   if (typeof t == "string")
     return t;
   if (typeof t == "object")
     return h(t);
 };
-function C({
+function E({
   specConfig: e,
-  proxyUrl: r
+  proxyUrl: o
 }) {
-  const n = u(""), t = g(l()), a = u(null);
-  function c(o) {
-    return o ? v(o, {
-      proxyUrl: r ? s(r) : void 0
-    }).then((i) => {
-      a.value = null, Object.assign(t, {
-        ...i
-      });
-    }).catch((i) => {
-      a.value = i.toString();
-    }) : Object.assign(t, l());
+  const n = s(""), t = s(l()), i = s(null);
+  function c(r) {
+    if (!r) {
+      t.value = l();
+      return;
+    }
+    v(r, {
+      proxyUrl: o ? p(o) : void 0
+    }).then((a) => {
+      i.value = null, t.value = a;
+    }).catch((a) => {
+      i.value = a.toString();
+    });
   }
   return m(
-    () => s(e),
-    async (o) => {
-      var i;
-      if (o) {
-        const p = (i = await y(o, s(r))) == null ? void 0 : i.trim();
-        typeof p == "string" && (n.value = p);
+    () => p(e),
+    async (r) => {
+      var a;
+      if (r) {
+        const f = (a = await y(r, p(o))) == null ? void 0 : a.trim();
+        typeof f == "string" && (n.value = f);
       }
     },
     { immediate: !0, deep: !0 }
@@ -49,9 +51,9 @@ function C({
   }), {
     rawSpec: n,
     parsedSpec: t,
-    specErrors: a
+    specErrors: i
   };
 }
 export {
-  C as useReactiveSpec
+  E as useReactiveSpec
 };