@scalar/api-reference 1.28.8 → 1.28.10

package/dist/hooks/useMultipleDocuments.js

@@ -1,81 +1,83 @@
-import { isDefined as h } from "@scalar/oas-utils/helpers";
-import { isConfigurationWithSources as p, apiReferenceConfigurationSchema as w } from "@scalar/types/api-reference";
-import y from "github-slugger";
-import { computed as g, ref as R, watch as b } from "vue";
-const c = "api", S = new y(), I = (e, u = 0) => {
+import { isDefined as S } from "@scalar/oas-utils/helpers";
+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 S.reset(), e.title ? {
+    return g.reset(), e.title ? {
       ...e,
-      slug: e.slug || S.slug(e.title),
+      slug: e.slug || g.slug(e.title),
       title: e.title
     } : e.slug ? {
       ...e,
       title: e.slug
     } : {
       ...e,
-      slug: `api-${u + 1}`,
-      title: `API #${u + 1}`
+      slug: `api-${a + 1}`,
+      title: `API #${a + 1}`
     };
-}, T = ({
-  configuration: e,
-  initialIndex: u,
-  isIntersectionEnabled: o,
-  hash: d,
-  hashPrefix: v
+}, P = ({
+  configuration: l,
+  initialIndex: a,
+  isIntersectionEnabled: e,
+  hash: c,
+  hashPrefix: d
 }) => {
-  const r = g(() => e.value ? (p(e.value) ? (
+  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, ...l } = e.value;
-      return (t == null ? void 0 : t.map((n) => ({ ...l, ...n }))) ?? [];
+      const { sources: t, ...u } = l.value;
+      return (t == null ? void 0 : t.map((n) => ({ ...u, ...n }))) ?? [];
     })()
-  ) : [e.value].flat()).map((t, l) => t && I(t, l)).filter(h) : []), i = R((() => {
+  ) : [l.value].flat()).map((t, u) => t && I(t, u)).filter(S) : []), o = y((() => {
     if (typeof window > "u")
-      return typeof u == "number" ? u : 0;
-    const t = new URL(window.location.href).searchParams.get(c);
+      return typeof a == "number" ? a : 0;
+    const t = new URL(window.location.href).searchParams.get(w);
     if (t) {
-      const n = r.value.findIndex((s) => s.slug === t);
+      const n = r.value.findIndex((f) => f.slug === t);
       if (n !== -1)
         return n;
-      const a = Number.parseInt(t, 10);
-      if (!isNaN(a) && a >= 0 && a < r.value.length)
-        return a;
+      const s = Number.parseInt(t, 10);
+      if (!isNaN(s) && s >= 0 && s < r.value.length)
+        return s;
     }
-    const l = r.value.findIndex((n) => "default" in n && n.default === !0);
-    return l !== -1 ? l : typeof u == "number" ? u : 0;
-  })()), m = g(() => {
-    var t, l;
-    if (e.value && p(e.value))
-      return w.parse({
-        ...e.value,
-        ...(l = (t = e.value) == null ? void 0 : t.sources) == null ? void 0 : l[i.value],
-        ...r.value[i.value]
-      });
-    const f = [e.value].flat()[i.value] ?? {};
-    return w.parse({
-      ...f,
-      ...r.value[i.value]
-    });
+    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(
-    i,
-    (f) => {
-      var a, s;
+    o,
+    (i) => {
+      var s, f;
       if (typeof window > "u" || r.value.length === 1)
         return;
-      const t = new URL(window.location.href), l = r.value[f], n = (l == null ? void 0 : l.slug) ?? f.toString();
-      t.searchParams.set(c, n), t.hash = "", window.history.replaceState({}, "", t.toString()), d.value = "", v.value = "", o.value = !1, typeof window < "u" && window.scrollTo({ top: 0, behavior: "instant" }), (s = (a = m.value).onDocumentSelect) == null || s.call(a);
+      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: m,
+    selectedConfiguration: v,
     availableDocuments: r,
-    selectedDocumentIndex: i,
-    isIntersectionEnabled: o,
-    hash: d,
-    hashPrefix: v
+    selectedDocumentIndex: o,
+    isIntersectionEnabled: e,
+    hash: c,
+    hashPrefix: d
   };
 };
 export {
-  T 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
 };