@scalar/api-reference 1.38.1 → 1.39.0

package/dist/components/Content/Schema/SchemaProperty.vue2.js

@@ -1,36 +1,42 @@
-import { defineComponent as w, computed as t, createBlock as d, openBlock as n, resolveDynamicComponent as A, normalizeClass as T, withCtx as c, createCommentVNode as s, createElementBlock as o, createVNode as m, createSlots as q, unref as i, toDisplayString as v, Fragment as f, createTextVNode as P, renderList as E } from "vue";
-import { ScalarMarkdown as O } from "@scalar/components";
-import { isDefined as F } from "@scalar/helpers/array/is-defined";
-import { getResolvedRef as y } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import { isArraySchema as u } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
-import { isTypeObject as M } from "./helpers/is-type-object.js";
-import { optimizeValueForDisplay as $ } from "./helpers/optimize-value-for-display.js";
-import { compositions as I } from "./helpers/schema-composition.js";
-import C from "./Schema.vue.js";
-import z from "./SchemaComposition.vue.js";
-import U from "./SchemaEnumValues.vue.js";
-import Z from "./SchemaPropertyHeading.vue.js";
-import L from "../../Anchor/WithBreadcrumb.vue2.js";
-import G from "../../../features/specification-extension/SpecificationExtension.vue2.js";
-const J = {
+import { defineComponent, computed, createBlock, openBlock, resolveDynamicComponent, normalizeClass, withCtx, createCommentVNode, createElementBlock, createVNode, createSlots, unref, toDisplayString, Fragment, createTextVNode, renderList } from "vue";
+import { ScalarMarkdown } from "@scalar/components";
+import { isDefined } from "@scalar/helpers/array/is-defined";
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { isArraySchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
+import { isTypeObject } from "./helpers/is-type-object.js";
+import { optimizeValueForDisplay } from "./helpers/optimize-value-for-display.js";
+import { compositions } from "./helpers/schema-composition.js";
+import Schema from "./Schema.vue.js";
+import _sfc_main$2 from "./SchemaComposition.vue.js";
+import SchemaEnumValues from "./SchemaEnumValues.vue.js";
+import SchemaPropertyHeading from "./SchemaPropertyHeading.vue.js";
+import _sfc_main$1 from "../../Anchor/WithBreadcrumb.vue2.js";
+import _sfc_main$3 from "../../../features/specification-extension/SpecificationExtension.vue2.js";
+const _hoisted_1 = {
   key: 0,
   class: "property-name-pattern-properties"
-}, K = {
+};
+const _hoisted_2 = {
   key: 1,
   class: "property-name-additional-properties"
-}, Q = {
+};
+const _hoisted_3 = {
   key: 1,
   class: "property-description"
-}, W = {
+};
+const _hoisted_4 = {
   key: 2,
   class: "property-description"
-}, X = {
+};
+const _hoisted_5 = {
   key: 4,
   class: "children"
-}, Y = {
+};
+const _hoisted_6 = {
   key: 0,
   class: "children"
-}, de = /* @__PURE__ */ w({
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "SchemaProperty",
   props: {
     is: {},
@@ -38,151 +44,224 @@ const J = {
     noncollapsible: { type: Boolean },
     level: { default: 0 },
     name: {},
-    required: { type: Boolean, default: !1 },
-    compact: { type: Boolean, default: !1 },
+    required: { type: Boolean, default: false },
+    compact: { type: Boolean, default: false },
     discriminator: {},
     description: {},
-    hideModelNames: { type: Boolean, default: !1 },
+    hideModelNames: { type: Boolean, default: false },
     hideHeading: { type: Boolean },
     variant: {},
     breadcrumb: {},
+    eventBus: {},
     options: {}
   },
-  setup(j) {
-    const p = j, b = {
+  setup(__props) {
+    const props = __props;
+    const childBreadcrumb = computed(
+      () => props.breadcrumb && props.name ? [...props.breadcrumb, props.name] : void 0
+    );
+    const descriptions = {
       integer: {
         _default: "Integer numbers.",
         int32: "Signed 32-bit integers (commonly used integer type).",
         int64: "Signed 64-bit integers (long type)."
       },
       string: {
-        date: "full-date notation as defined by RFC 3339, section 5.6, for example, 2017-07-21",
+        "date": "full-date notation as defined by RFC 3339, section 5.6, for example, 2017-07-21",
         "date-time": "the date-time notation as defined by RFC 3339, section 5.6, for example, 2017-07-21T17:32:28Z",
-        password: "a hint to UIs to mask the input",
-        base64: "base64-encoded characters, for example, U3dhZ2dlciByb2Nrcw==",
-        byte: "base64-encoded characters, for example, U3dhZ2dlciByb2Nrcw==",
-        binary: "binary data, used to describe files"
+        "password": "a hint to UIs to mask the input",
+        "base64": "base64-encoded characters, for example, U3dhZ2dlciByb2Nrcw==",
+        "byte": "base64-encoded characters, for example, U3dhZ2dlciByb2Nrcw==",
+        "binary": "binary data, used to describe files"
+      }
+    };
+    const generatePropertyDescription = (property) => {
+      if (!property) {
+        return null;
+      }
+      if (!descriptions[property.type]) {
+        return null;
+      }
+      return descriptions[property.type]?.[property.format || property.contentEncoding || "_default"] || null;
+    };
+    const getEnumFromValue = (value) => value?.enum || value?.items?.enum || [];
+    const optimizedValue = computed(() => optimizeValueForDisplay(props.schema));
+    const displayDescription = computed(() => {
+      const value = optimizedValue.value;
+      if (!value) {
+        return null;
+      }
+      if ("properties" in value) {
+        return null;
       }
-    }, h = (e) => !e || !b[e.type] ? null : b[e.type][e.format || e.contentEncoding || "_default"], B = (e) => e?.enum || e?.items?.enum || [], a = t(() => $(p.schema)), g = t(() => {
-      const e = a.value;
-      return !e || "properties" in e || "additionalProperties" in e || "patternProperties" in e || e?.allOf || e?.allOf ? null : p.description || e?.description || null;
-    }), N = (e, r, l) => r || e?.deprecated || e?.const !== void 0 || e?.enum && e.enum.length === 1 || e?.type || e?.nullable === !0 || e?.writeOnly || e?.readOnly || l, k = t(() => {
-      const e = a.value;
-      if (!e || !u(e) || typeof e.items != "object")
-        return !1;
-      const r = e.items;
-      return "type" in r && r.type && (Array.isArray(r.type) ? r.type.includes("object") : ["object"].includes(r.type)) || "properties" in r || "$ref" in r || "discriminator" in r || "allOf" in r || "oneOf" in r || "anyOf" in r;
-    }), S = (e) => {
-      const r = a.value;
-      return r && u(r) === !1 || !r?.items || typeof r.items != "object" || !(e in r.items) ? !1 : !k.value;
-    }, R = t(() => k.value), D = t(() => {
-      if (!a.value)
-        return !1;
-      const e = a.value, r = M(e), l = "properties" in e || "additionalProperties" in e;
-      return r && l;
-    }), H = t(() => p.level <= 1), V = t(() => a.value ? I.map((e) => a.value?.[e] && !(u(a.value) && a.value?.items && typeof e == "string" && typeof a.value.items == "object" && e in a.value.items) ? {
-      composition: e,
-      value: a.value
-    } : S(e) && a.value && u(a.value) && a.value.items ? {
-      composition: e,
-      value: a.value.items
-    } : null).filter(F) : []);
-    return (e, r) => (n(), d(A(e.is ?? "li"), {
-      class: T(["property", [
-        `property--level-${e.level}`,
-        {
-          "property--compact": e.compact,
-          "property--deprecated": a.value?.deprecated
+      if ("additionalProperties" in value) {
+        return null;
+      }
+      if ("patternProperties" in value) {
+        return null;
+      }
+      if (value?.allOf) {
+        return null;
+      }
+      if (value?.allOf) {
+        return null;
+      }
+      return props.description || value?.description || null;
+    });
+    const displayPropertyHeading = (value, name, required) => {
+      return name || value?.deprecated || value?.const !== void 0 || value?.enum && value.enum.length === 1 || value?.type || value?.nullable === true || value?.writeOnly || value?.readOnly || required;
+    };
+    const hasComplexArrayItems = computed(() => {
+      const value = optimizedValue.value;
+      if (!value || !isArraySchema(value) || typeof value.items !== "object") {
+        return false;
+      }
+      const items = value.items;
+      return "type" in items && items.type && (Array.isArray(items.type) ? items.type.includes("object") : ["object"].includes(items.type)) || "properties" in items || "$ref" in items || "discriminator" in items || "allOf" in items || "oneOf" in items || "anyOf" in items;
+    });
+    const shouldRenderArrayItemComposition = (composition) => {
+      const value = optimizedValue.value;
+      if (value && isArraySchema(value) === false || !value?.items || typeof value.items !== "object" || !(composition in value.items)) {
+        return false;
+      }
+      return !hasComplexArrayItems.value;
+    };
+    const shouldRenderArrayOfObjects = computed(() => hasComplexArrayItems.value);
+    const shouldRenderObjectProperties = computed(() => {
+      if (!optimizedValue.value) {
+        return false;
+      }
+      const value = optimizedValue.value;
+      const isObjectType = isTypeObject(value);
+      const hasPropertiesToRender = "properties" in value || "additionalProperties" in value;
+      return isObjectType && hasPropertiesToRender;
+    });
+    const shouldHaveLink = computed(() => props.level <= 1);
+    const compositionsToRender = computed(() => {
+      if (!optimizedValue.value) {
+        return [];
+      }
+      return compositions.map((composition) => {
+        const hasPropertyComposition = optimizedValue.value?.[composition] && !(isArraySchema(optimizedValue.value) && optimizedValue.value?.items && typeof composition === "string" && typeof optimizedValue.value.items === "object" && composition in optimizedValue.value.items);
+        if (hasPropertyComposition) {
+          return {
+            composition,
+            value: optimizedValue.value
+          };
+        }
+        if (shouldRenderArrayItemComposition(composition) && optimizedValue.value && isArraySchema(optimizedValue.value) && optimizedValue.value.items) {
+          return {
+            composition,
+            value: optimizedValue.value.items
+          };
         }
-      ]])
-    }, {
-      default: c(() => [
-        N(a.value, e.name, e.required) ? (n(), d(Z, {
-          key: 0,
-          class: "group",
-          enum: B(a.value).length > 0,
-          hideModelNames: e.hideModelNames,
-          isDiscriminator: e.discriminator && e.discriminator.propertyName === e.name,
-          required: e.required,
-          value: a.value
-        }, q({ _: 2 }, [
-          e.name ? {
-            name: "name",
-            fn: c(() => [
-              m(i(L), {
-                breadcrumb: H.value && e.breadcrumb ? [...e.breadcrumb, e.name] : void 0
-              }, {
-                default: c(() => [
-                  e.variant === "patternProperties" ? (n(), o("span", J, v(e.name), 1)) : e.variant === "additionalProperties" ? (n(), o("span", K, v(e.name), 1)) : (n(), o(f, { key: 2 }, [
-                    P(v(e.name), 1)
-                  ], 64))
-                ]),
-                _: 1
-              }, 8, ["breadcrumb"])
-            ]),
-            key: "0"
-          } : void 0,
-          a.value?.example ? {
-            name: "example",
-            fn: c(() => [
-              P(" Example: " + v(a.value.example), 1)
-            ]),
-            key: "1"
-          } : void 0
-        ]), 1032, ["enum", "hideModelNames", "isDiscriminator", "required", "value"])) : s("", !0),
-        g.value ? (n(), o("div", Q, [
-          m(i(O), { value: g.value }, null, 8, ["value"])
-        ])) : h(a.value) ? (n(), o("div", W, [
-          m(i(O), {
-            value: h(a.value) || ""
-          }, null, 8, ["value"])
-        ])) : s("", !0),
-        (a.value?.enum || a.value && i(u)(a.value) && i(y)(a.value?.items)?.enum || []).length ? (n(), d(U, {
-          key: 3,
-          value: a.value
-        }, null, 8, ["value"])) : s("", !0),
-        D.value ? (n(), o("div", X, [
-          m(C, {
-            breadcrumb: e.breadcrumb && e.name ? [...e.breadcrumb, e.name] : void 0,
-            compact: e.compact,
-            level: e.level + 1,
-            name: e.name,
-            noncollapsible: e.noncollapsible,
-            options: e.options,
-            schema: a.value
-          }, null, 8, ["breadcrumb", "compact", "level", "name", "noncollapsible", "options", "schema"])
-        ])) : s("", !0),
-        a.value && i(u)(a.value) && typeof a.value.items == "object" ? (n(), o(f, { key: 5 }, [
-          R.value ? (n(), o("div", Y, [
-            m(C, {
-              compact: e.compact,
-              level: e.level + 1,
-              name: e.name,
-              noncollapsible: e.noncollapsible,
-              options: e.options,
-              schema: i(y)(a.value.items)
-            }, null, 8, ["compact", "level", "name", "noncollapsible", "options", "schema"])
-          ])) : s("", !0)
-        ], 64)) : s("", !0),
-        (n(!0), o(f, null, E(V.value, (l) => (n(), d(z, {
-          key: l.composition,
-          breadcrumb: e.breadcrumb,
-          compact: e.compact,
-          composition: l.composition,
-          discriminator: e.schema?.discriminator,
-          hideHeading: e.hideHeading,
-          level: e.level,
-          name: e.name,
-          noncollapsible: e.noncollapsible,
-          options: e.options,
-          schema: i(y)(p.schema)
-        }, null, 8, ["breadcrumb", "compact", "composition", "discriminator", "hideHeading", "level", "name", "noncollapsible", "options", "schema"]))), 128)),
-        m(i(G), { value: a.value }, null, 8, ["value"])
-      ]),
-      _: 1
-    }, 8, ["class"]));
+        return null;
+      }).filter(isDefined);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(_ctx.is ?? "li"), {
+        class: normalizeClass(["property", [
+          `property--level-${_ctx.level}`,
+          {
+            "property--compact": _ctx.compact,
+            "property--deprecated": optimizedValue.value?.deprecated
+          }
+        ]])
+      }, {
+        default: withCtx(() => [
+          displayPropertyHeading(optimizedValue.value, _ctx.name, _ctx.required) ? (openBlock(), createBlock(SchemaPropertyHeading, {
+            key: 0,
+            class: "group",
+            enum: getEnumFromValue(optimizedValue.value).length > 0,
+            hideModelNames: _ctx.hideModelNames,
+            isDiscriminator: _ctx.discriminator && _ctx.discriminator.propertyName === _ctx.name,
+            required: _ctx.required,
+            value: optimizedValue.value
+          }, createSlots({ _: 2 }, [
+            _ctx.name ? {
+              name: "name",
+              fn: withCtx(() => [
+                createVNode(unref(_sfc_main$1), {
+                  breadcrumb: shouldHaveLink.value ? childBreadcrumb.value : void 0,
+                  eventBus: _ctx.eventBus
+                }, {
+                  default: withCtx(() => [
+                    _ctx.variant === "patternProperties" ? (openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(_ctx.name), 1)) : _ctx.variant === "additionalProperties" ? (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(_ctx.name), 1)) : (openBlock(), createElementBlock(Fragment, { key: 2 }, [
+                      createTextVNode(toDisplayString(_ctx.name), 1)
+                    ], 64))
+                  ]),
+                  _: 1
+                }, 8, ["breadcrumb", "eventBus"])
+              ]),
+              key: "0"
+            } : void 0,
+            optimizedValue.value?.example ? {
+              name: "example",
+              fn: withCtx(() => [
+                createTextVNode(" Example: " + toDisplayString(optimizedValue.value.example), 1)
+              ]),
+              key: "1"
+            } : void 0
+          ]), 1032, ["enum", "hideModelNames", "isDiscriminator", "required", "value"])) : createCommentVNode("", true),
+          displayDescription.value ? (openBlock(), createElementBlock("div", _hoisted_3, [
+            createVNode(unref(ScalarMarkdown), { value: displayDescription.value }, null, 8, ["value"])
+          ])) : generatePropertyDescription(optimizedValue.value) ? (openBlock(), createElementBlock("div", _hoisted_4, [
+            createVNode(unref(ScalarMarkdown), {
+              value: generatePropertyDescription(optimizedValue.value) || ""
+            }, null, 8, ["value"])
+          ])) : createCommentVNode("", true),
+          (optimizedValue.value?.enum || optimizedValue.value && unref(isArraySchema)(optimizedValue.value) && unref(getResolvedRef)(optimizedValue.value?.items)?.enum || []).length ? (openBlock(), createBlock(SchemaEnumValues, {
+            key: 3,
+            value: optimizedValue.value
+          }, null, 8, ["value"])) : createCommentVNode("", true),
+          shouldRenderObjectProperties.value ? (openBlock(), createElementBlock("div", _hoisted_5, [
+            createVNode(Schema, {
+              breadcrumb: childBreadcrumb.value,
+              compact: _ctx.compact,
+              eventBus: _ctx.eventBus,
+              level: _ctx.level + 1,
+              name: _ctx.name,
+              noncollapsible: _ctx.noncollapsible,
+              options: _ctx.options,
+              schema: optimizedValue.value
+            }, null, 8, ["breadcrumb", "compact", "eventBus", "level", "name", "noncollapsible", "options", "schema"])
+          ])) : createCommentVNode("", true),
+          optimizedValue.value && unref(isArraySchema)(optimizedValue.value) && typeof optimizedValue.value.items === "object" ? (openBlock(), createElementBlock(Fragment, { key: 5 }, [
+            shouldRenderArrayOfObjects.value ? (openBlock(), createElementBlock("div", _hoisted_6, [
+              createVNode(Schema, {
+                compact: _ctx.compact,
+                eventBus: _ctx.eventBus,
+                level: _ctx.level + 1,
+                name: _ctx.name,
+                noncollapsible: _ctx.noncollapsible,
+                options: _ctx.options,
+                schema: unref(getResolvedRef)(optimizedValue.value.items)
+              }, null, 8, ["compact", "eventBus", "level", "name", "noncollapsible", "options", "schema"])
+            ])) : createCommentVNode("", true)
+          ], 64)) : createCommentVNode("", true),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(compositionsToRender.value, (compositionData) => {
+            return openBlock(), createBlock(_sfc_main$2, {
+              key: compositionData.composition,
+              breadcrumb: _ctx.breadcrumb,
+              compact: _ctx.compact,
+              composition: compositionData.composition,
+              discriminator: _ctx.schema?.discriminator,
+              eventBus: _ctx.eventBus,
+              hideHeading: _ctx.hideHeading,
+              level: _ctx.level,
+              name: _ctx.name,
+              noncollapsible: _ctx.noncollapsible,
+              options: _ctx.options,
+              schema: unref(getResolvedRef)(props.schema)
+            }, null, 8, ["breadcrumb", "compact", "composition", "discriminator", "eventBus", "hideHeading", "level", "name", "noncollapsible", "options", "schema"]);
+          }), 128)),
+          createVNode(unref(_sfc_main$3), { value: optimizedValue.value }, null, 8, ["value"])
+        ]),
+        _: 1
+      }, 8, ["class"]);
+    };
   }
 });
 export {
-  de as default
+  _sfc_main as default
 };

package/dist/components/Content/Schema/SchemaPropertyDetail.vue.js

@@ -1,7 +1,7 @@
-import o from "./SchemaPropertyDetail.vue2.js";
+import _sfc_main from "./SchemaPropertyDetail.vue2.js";
 /* empty css                          */
-import t from "../../../_virtual/_plugin-vue_export-helper.js";
-const m = /* @__PURE__ */ t(o, [["__scopeId", "data-v-827ea49d"]]);
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.js";
+const SchemaPropertyDetail = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-827ea49d"]]);
 export {
-  m as default
+  SchemaPropertyDetail as default
 };

package/dist/components/Content/Schema/SchemaPropertyDetail.vue2.js

@@ -1,35 +1,40 @@
-import { defineComponent as a, createElementBlock as t, openBlock as o, normalizeClass as l, createCommentVNode as p, renderSlot as r, createTextVNode as n } from "vue";
-const d = {
+import { defineComponent, createElementBlock, openBlock, normalizeClass, createCommentVNode, renderSlot, createTextVNode } from "vue";
+const _hoisted_1 = {
   key: 0,
   class: "property-detail-prefix"
-}, i = {
+};
+const _hoisted_2 = {
   key: 1,
   class: "property-detail-value"
-}, u = {
+};
+const _hoisted_3 = {
   key: 2,
   class: "property-detail-value"
-}, m = /* @__PURE__ */ a({
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "SchemaPropertyDetail",
   props: {
     truncate: { type: Boolean },
     code: { type: Boolean }
   },
-  setup(c) {
-    return (e, s) => (o(), t("span", {
-      class: l(["property-detail", { "property-detail-truncate": e.truncate }])
-    }, [
-      e.$slots.prefix ? (o(), t("div", d, [
-        r(e.$slots, "prefix", {}, void 0, !0),
-        s[0] || (s[0] = n("  "))
-      ])) : p("", !0),
-      e.code ? (o(), t("code", i, [
-        r(e.$slots, "default", {}, void 0, !0)
-      ])) : (o(), t("span", u, [
-        r(e.$slots, "default", {}, void 0, !0)
-      ]))
-    ], 2));
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("span", {
+        class: normalizeClass(["property-detail", { "property-detail-truncate": _ctx.truncate }])
+      }, [
+        _ctx.$slots.prefix ? (openBlock(), createElementBlock("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "prefix", {}, void 0, true),
+          _cache[0] || (_cache[0] = createTextVNode("  ", -1))
+        ])) : createCommentVNode("", true),
+        _ctx.code ? (openBlock(), createElementBlock("code", _hoisted_2, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ])) : (openBlock(), createElementBlock("span", _hoisted_3, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]))
+      ], 2);
+    };
   }
 });
 export {
-  m as default
+  _sfc_main as default
 };

package/dist/components/Content/Schema/SchemaPropertyExamples.vue.js

@@ -1,7 +1,7 @@
-import o from "./SchemaPropertyExamples.vue2.js";
+import _sfc_main from "./SchemaPropertyExamples.vue2.js";
 /* empty css                            */
-import r from "../../../_virtual/_plugin-vue_export-helper.js";
-const p = /* @__PURE__ */ r(o, [["__scopeId", "data-v-64e15694"]]);
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.js";
+const SchemaPropertyExamples = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-dd79da55"]]);
 export {
-  p as default
+  SchemaPropertyExamples as default
 };