@scalar/api-reference 1.43.4 → 1.43.7

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

@@ -1,11 +1,15 @@
 import { defineComponent, computed, createBlock, openBlock, resolveDynamicComponent, normalizeClass, withCtx, createCommentVNode, createElementBlock, createVNode, createSlots, unref, createTextVNode, toDisplayString, Fragment, renderList } from "vue";
 import { ScalarWrappingText, 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 { getCompositionsToRender } from "./helpers/get-compositions-to-render.js";
+import { getEnumValues } from "./helpers/get-enum-values.js";
+import { getPropertyDescription } from "./helpers/get-property-description.js";
+import { hasComplexArrayItems } from "./helpers/has-complex-array-items.js";
 import { optimizeValueForDisplay } from "./helpers/optimize-value-for-display.js";
-import { compositions } from "./helpers/schema-composition.js";
+import { shouldDisplayDescription } from "./helpers/should-display-description.js";
+import { shouldDisplayHeading } from "./helpers/should-display-heading.js";
 import Schema from "./Schema.vue.js";
 import _sfc_main$2 from "./SchemaComposition.vue.js";
 import SchemaEnumValues from "./SchemaEnumValues.vue.js";
@@ -25,17 +29,13 @@ const _hoisted_3 = {
   class: "property-description"
 };
 const _hoisted_4 = {
-  key: 2,
-  class: "property-description"
+  key: 3,
+  class: "children"
 };
 const _hoisted_5 = {
   key: 4,
   class: "children"
 };
-const _hoisted_6 = {
-  key: 0,
-  class: "children"
-};
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "SchemaProperty",
   props: {
@@ -57,149 +57,94 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   },
   setup(__props) {
     const props = __props;
+    const optimizedValue = computed(() => optimizeValueForDisplay(props.schema));
     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-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"
-      }
-    };
-    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 shouldHaveLink = computed(() => props.level <= 1);
+    const hasComplexArrayItemsComputed = computed(
+      () => hasComplexArrayItems(optimizedValue.value)
+    );
+    const hasEnum = computed(() => enumValues.value.length > 0);
+    const shouldRenderObjectProperties = computed(() => {
       const value = optimizedValue.value;
       if (!value) {
-        return null;
-      }
-      if ("properties" in value) {
-        return null;
-      }
-      if ("additionalProperties" in value) {
-        return null;
-      }
-      if ("patternProperties" in value) {
-        return null;
-      }
-      if (value?.allOf) {
-        return null;
-      }
-      if (value?.allOf) {
-        return null;
+        return false;
       }
-      return props.description || value?.description || null;
+      return isTypeObject(value) && ("properties" in value || "additionalProperties" in value);
     });
-    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 shouldRenderArrayOfObjects = 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;
+      return hasComplexArrayItemsComputed.value;
     });
-    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 enumValues = computed(() => getEnumValues(optimizedValue.value));
+    const propertyDescription = computed(
+      () => getPropertyDescription(optimizedValue.value)
+    );
+    const displayDescription = computed(
+      () => shouldDisplayDescription(optimizedValue.value, props.description)
+    );
+    const shouldDisplayHeadingComputed = computed(
+      () => shouldDisplayHeading(optimizedValue.value, props.name, props.required)
+    );
+    const compositionsToRender = computed(
+      () => getCompositionsToRender(optimizedValue.value)
+    );
+    const resolvedArrayItems = computed(() => {
       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 [];
+      if (!value || !isArraySchema(value) || typeof value.items !== "object") {
+        return void 0;
       }
-      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
-          };
-        }
-        return null;
-      }).filter(isDefined);
+      return getResolvedRef(value.items);
     });
+    const isDiscriminatorProperty = computed(
+      () => Boolean(props.name && props.discriminator?.propertyName === props.name)
+    );
     return (_ctx, _cache) => {
-      return openBlock(), createBlock(resolveDynamicComponent(_ctx.is ?? "li"), {
+      return openBlock(), createBlock(resolveDynamicComponent(__props.is ?? "li"), {
         class: normalizeClass(["property", [
-          `property--level-${_ctx.level}`,
+          `property--level-${__props.level}`,
           {
-            "property--compact": _ctx.compact,
+            "property--compact": __props.compact,
             "property--deprecated": optimizedValue.value?.deprecated
           }
         ]])
       }, {
         default: withCtx(() => [
-          displayPropertyHeading(optimizedValue.value, _ctx.name, _ctx.required) ? (openBlock(), createBlock(SchemaPropertyHeading, {
+          shouldDisplayHeadingComputed.value ? (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,
+            enum: hasEnum.value,
+            hideModelNames: __props.hideModelNames,
+            isDiscriminator: isDiscriminatorProperty.value,
+            required: __props.required,
             value: optimizedValue.value
           }, createSlots({ _: 2 }, [
-            _ctx.name ? {
+            __props.name ? {
               name: "name",
               fn: withCtx(() => [
                 createVNode(unref(_sfc_main$1), {
                   breadcrumb: shouldHaveLink.value ? childBreadcrumb.value : void 0,
-                  eventBus: _ctx.eventBus
+                  eventBus: __props.eventBus
                 }, {
                   default: withCtx(() => [
-                    _ctx.variant === "patternProperties" ? (openBlock(), createElementBlock("span", _hoisted_1, [
+                    __props.variant === "patternProperties" ? (openBlock(), createElementBlock("span", _hoisted_1, [
                       createVNode(unref(ScalarWrappingText), {
-                        text: _ctx.name,
-                        preset: "property"
+                        preset: "property",
+                        text: __props.name
                       }, null, 8, ["text"])
-                    ])) : _ctx.variant === "additionalProperties" ? (openBlock(), createElementBlock("span", _hoisted_2, [
+                    ])) : __props.variant === "additionalProperties" ? (openBlock(), createElementBlock("span", _hoisted_2, [
                       createVNode(unref(ScalarWrappingText), {
-                        text: _ctx.name,
-                        preset: "property"
+                        preset: "property",
+                        text: __props.name
                       }, null, 8, ["text"])
                     ])) : (openBlock(), createBlock(unref(ScalarWrappingText), {
                       key: 2,
-                      text: _ctx.name,
-                      preset: "property"
+                      preset: "property",
+                      text: __props.name
                     }, null, 8, ["text"]))
                   ]),
                   _: 1
@@ -215,55 +160,51 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
               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, [
+          displayDescription.value || propertyDescription.value ? (openBlock(), createElementBlock("div", _hoisted_3, [
             createVNode(unref(ScalarMarkdown), {
-              value: generatePropertyDescription(optimizedValue.value) || ""
+              value: displayDescription.value || propertyDescription.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,
+          hasEnum.value ? (openBlock(), createBlock(SchemaEnumValues, {
+            key: 2,
             value: optimizedValue.value
           }, null, 8, ["value"])) : createCommentVNode("", true),
-          shouldRenderObjectProperties.value ? (openBlock(), createElementBlock("div", _hoisted_5, [
+          shouldRenderObjectProperties.value ? (openBlock(), createElementBlock("div", _hoisted_4, [
             createVNode(Schema, {
               breadcrumb: childBreadcrumb.value,
-              compact: _ctx.compact,
-              eventBus: _ctx.eventBus,
-              level: _ctx.level + 1,
-              name: _ctx.name,
-              noncollapsible: _ctx.noncollapsible,
-              options: _ctx.options,
+              compact: __props.compact,
+              eventBus: __props.eventBus,
+              level: __props.level + 1,
+              name: __props.name,
+              noncollapsible: __props.noncollapsible,
+              options: __props.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),
+          shouldRenderArrayOfObjects.value && resolvedArrayItems.value ? (openBlock(), createElementBlock("div", _hoisted_5, [
+            createVNode(Schema, {
+              compact: __props.compact,
+              eventBus: __props.eventBus,
+              level: __props.level + 1,
+              name: __props.name,
+              noncollapsible: __props.noncollapsible,
+              options: __props.options,
+              schema: resolvedArrayItems.value
+            }, null, 8, ["compact", "eventBus", "level", "name", "noncollapsible", "options", "schema"])
+          ])) : 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,
+              breadcrumb: __props.breadcrumb,
+              compact: __props.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,
+              discriminator: __props.schema?.discriminator,
+              eventBus: __props.eventBus,
+              hideHeading: __props.hideHeading,
+              level: __props.level,
+              name: __props.name,
+              noncollapsible: __props.noncollapsible,
+              options: __props.options,
               schema: unref(getResolvedRef)(props.schema)
             }, null, 8, ["breadcrumb", "compact", "composition", "discriminator", "eventBus", "hideHeading", "level", "name", "noncollapsible", "options", "schema"]);
           }), 128)),

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

@@ -20,13 +20,13 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   setup(__props) {
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("span", {
-        class: normalizeClass(["property-detail", { "property-detail-truncate": _ctx.truncate }])
+        class: normalizeClass(["property-detail", { "property-detail-truncate": __props.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, [
+        __props.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)

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

@@ -27,7 +27,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const { copyToClipboard } = useClipboard();
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock(Fragment, null, [
-        _ctx.example ? (openBlock(), createElementBlock("div", _hoisted_1, [
+        __props.example ? (openBlock(), createElementBlock("div", _hoisted_1, [
           _cache[1] || (_cache[1] = createElementVNode("button", {
             class: "property-example-label",
             type: "button"
@@ -38,9 +38,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
             createElementVNode("button", {
               class: "property-example-value group",
               type: "button",
-              onClick: _cache[0] || (_cache[0] = ($event) => unref(copyToClipboard)(unref(formatExample)(_ctx.example)))
+              onClick: _cache[0] || (_cache[0] = ($event) => unref(copyToClipboard)(unref(formatExample)(__props.example)))
             }, [
-              createElementVNode("span", null, toDisplayString(unref(formatExample)(_ctx.example)), 1),
+              createElementVNode("span", null, toDisplayString(unref(formatExample)(__props.example)), 1),
               createVNode(unref(ScalarIcon), {
                 class: "group-hover:text-c-1 text-c-3 ml-auto min-h-3 min-w-3",
                 icon: "Clipboard",
@@ -49,12 +49,12 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
             ])
           ])
         ])) : createCommentVNode("", true),
-        _ctx.examples && typeof _ctx.examples === "object" && Object.keys(_ctx.examples).length > 0 ? (openBlock(), createElementBlock("div", _hoisted_3, [
+        __props.examples && typeof __props.examples === "object" && Object.keys(__props.examples).length > 0 ? (openBlock(), createElementBlock("div", _hoisted_3, [
           createElementVNode("button", _hoisted_4, [
-            createElementVNode("span", null, toDisplayString(Object.keys(_ctx.examples).length === 1 ? "Example" : "Examples"), 1)
+            createElementVNode("span", null, toDisplayString(Object.keys(__props.examples).length === 1 ? "Example" : "Examples"), 1)
           ]),
           createElementVNode("div", _hoisted_5, [
-            (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.examples, (ex, key) => {
+            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.examples, (ex, key) => {
               return openBlock(), createElementBlock("button", {
                 key,
                 class: "property-example-value group",

package/dist/components/Content/Schema/helpers/get-compositions-to-render.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+import { type CompositionKeyword } from './schema-composition.js';
+export type CompositionToRender = {
+    composition: CompositionKeyword;
+    value: SchemaObject;
+};
+/**
+ * Computes which compositions should be rendered and with which values
+ *
+ * @param value - The schema object to check for compositions
+ * @returns Array of compositions to render with their values
+ */
+export declare const getCompositionsToRender: (value: SchemaObject | undefined) => CompositionToRender[];
+//# sourceMappingURL=get-compositions-to-render.d.ts.map

package/dist/components/Content/Schema/helpers/get-compositions-to-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-compositions-to-render.d.ts","sourceRoot":"","sources":["../../../../../src/components/Content/Schema/helpers/get-compositions-to-render.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAGhG,OAAO,EAAE,KAAK,kBAAkB,EAAgB,MAAM,sBAAsB,CAAA;AAG5E,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,kBAAkB,CAAA;IAC/B,KAAK,EAAE,YAAY,CAAA;CACpB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAAI,OAAO,YAAY,GAAG,SAAS,KAAG,mBAAmB,EAgC5F,CAAA"}

package/dist/components/Content/Schema/helpers/get-compositions-to-render.js

@@ -0,0 +1,31 @@
+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 { compositions } from "./schema-composition.js";
+import { shouldRenderArrayItemComposition } from "./should-render-array-item-composition.js";
+const getCompositionsToRender = (value) => {
+  if (!value) {
+    return [];
+  }
+  return compositions.map((composition) => {
+    if (shouldRenderArrayItemComposition(value, composition) && isArraySchema(value) && value.items) {
+      return {
+        composition,
+        value: getResolvedRef(value.items)
+      };
+    }
+    if (value[composition]) {
+      const hasArrayItemComposition = isArraySchema(value) && value.items && typeof value.items === "object" && composition in value.items;
+      if (!hasArrayItemComposition) {
+        return {
+          composition,
+          value: getResolvedRef(value)
+        };
+      }
+    }
+    return null;
+  }).filter(isDefined);
+};
+export {
+  getCompositionsToRender
+};

package/dist/components/Content/Schema/helpers/get-enum-values.d.ts

@@ -0,0 +1,9 @@
+import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+/**
+ * Extract enum values from schema or array items
+ *
+ * @param value - The schema object to extract enum values from
+ * @returns Array of enum values, or empty array if no enum found
+ */
+export declare const getEnumValues: (value: SchemaObject | undefined) => unknown[];
+//# sourceMappingURL=get-enum-values.d.ts.map

package/dist/components/Content/Schema/helpers/get-enum-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-enum-values.d.ts","sourceRoot":"","sources":["../../../../../src/components/Content/Schema/helpers/get-enum-values.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAGhG;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,YAAY,GAAG,SAAS,KAAG,OAAO,EAmBtE,CAAA"}

package/dist/components/Content/Schema/helpers/get-enum-values.js

@@ -0,0 +1,20 @@
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { isArraySchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
+const getEnumValues = (value) => {
+  if (!value) {
+    return [];
+  }
+  if (value.enum) {
+    return value.enum;
+  }
+  if (isArraySchema(value) && typeof value.items === "object") {
+    const resolvedItems = getResolvedRef(value.items);
+    if (resolvedItems && "enum" in resolvedItems && resolvedItems.enum) {
+      return resolvedItems.enum;
+    }
+  }
+  return [];
+};
+export {
+  getEnumValues
+};

package/dist/components/Content/Schema/helpers/get-property-description.d.ts

@@ -0,0 +1,9 @@
+import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+/**
+ * Generate property description from type/format
+ *
+ * @param value - The schema object to generate description from
+ * @returns Description string or null if no description available
+ */
+export declare const getPropertyDescription: (value: SchemaObject | undefined) => string | null;
+//# sourceMappingURL=get-property-description.d.ts.map

package/dist/components/Content/Schema/helpers/get-property-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-property-description.d.ts","sourceRoot":"","sources":["../../../../../src/components/Content/Schema/helpers/get-property-description.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAoBhG;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,OAAO,YAAY,GAAG,SAAS,KAAG,MAAM,GAAG,IAkBjF,CAAA"}

package/dist/components/Content/Schema/helpers/get-property-description.js

@@ -0,0 +1,34 @@
+import { isSchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
+const TYPE_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-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"
+  }
+};
+const getPropertyDescription = (value) => {
+  if (!isSchema(value)) {
+    return null;
+  }
+  const type = Array.isArray(value.type) ? value.type[0] : value.type;
+  if (!type) {
+    return null;
+  }
+  const typeDescriptions = TYPE_DESCRIPTIONS[type];
+  if (!typeDescriptions) {
+    return null;
+  }
+  const format = "format" in value && value.format || "contentEncoding" in value && value.contentEncoding || "_default";
+  return typeDescriptions[format] ?? null;
+};
+export {
+  getPropertyDescription
+};

package/dist/components/Content/Schema/helpers/has-complex-array-items.d.ts

@@ -0,0 +1,10 @@
+import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+/**
+ * Checks if array items have complex structure
+ * like: objects, references, discriminators, compositions, or nested arrays with complex items
+ *
+ * @param value - The schema object to check
+ * @returns true if the array has complex items, false otherwise
+ */
+export declare const hasComplexArrayItems: (value: SchemaObject | undefined) => boolean;
+//# sourceMappingURL=has-complex-array-items.d.ts.map

package/dist/components/Content/Schema/helpers/has-complex-array-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-complex-array-items.d.ts","sourceRoot":"","sources":["../../../../../src/components/Content/Schema/helpers/has-complex-array-items.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAkDhG;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,YAAY,GAAG,SAAS,KAAG,OA4BtE,CAAA"}

package/dist/components/Content/Schema/helpers/has-complex-array-items.js

@@ -0,0 +1,48 @@
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { isArraySchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
+const COMPOSITION_KEYWORDS = ["allOf", "oneOf", "anyOf"];
+const isObjectType = (schema) => {
+  if ("type" in schema && schema.type) {
+    if (Array.isArray(schema.type)) {
+      return schema.type.includes("object");
+    }
+    return schema.type === "object";
+  }
+  return "properties" in schema;
+};
+const hasComplexFeatures = (schema) => "$ref" in schema || "discriminator" in schema || COMPOSITION_KEYWORDS.some((keyword) => keyword in schema);
+const hasComplexNestedArrayItems = (items) => {
+  if (!isArraySchema(items) || typeof items.items !== "object") {
+    return false;
+  }
+  if ("$ref" in items.items) {
+    return true;
+  }
+  const nestedItems = getResolvedRef(items.items);
+  if (!nestedItems) {
+    return false;
+  }
+  return isObjectType(nestedItems) || hasComplexFeatures(nestedItems) || isArraySchema(nestedItems);
+};
+const hasComplexArrayItems = (value) => {
+  if (!value || !isArraySchema(value) || typeof value.items !== "object") {
+    return false;
+  }
+  if ("$ref" in value.items) {
+    return true;
+  }
+  const items = getResolvedRef(value.items);
+  if (!items) {
+    return false;
+  }
+  if (hasComplexFeatures(items)) {
+    return true;
+  }
+  if (isObjectType(items)) {
+    return true;
+  }
+  return hasComplexNestedArrayItems(items);
+};
+export {
+  hasComplexArrayItems
+};

package/dist/components/Content/Schema/helpers/should-display-description.d.ts

@@ -0,0 +1,10 @@
+import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+/**
+ * Determine if description should be displayed
+ *
+ * @param schema - The schema object to check
+ * @param propDescription - Optional description from props
+ * @returns Description string to display, or null if should not be displayed
+ */
+export declare const shouldDisplayDescription: (schema: SchemaObject | undefined, propDescription?: string) => string | null;
+//# sourceMappingURL=should-display-description.d.ts.map

package/dist/components/Content/Schema/helpers/should-display-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"should-display-description.d.ts","sourceRoot":"","sources":["../../../../../src/components/Content/Schema/helpers/should-display-description.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAEhG;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GAAI,QAAQ,YAAY,GAAG,SAAS,EAAE,kBAAkB,MAAM,KAAG,MAAM,GAAG,IAW9G,CAAA"}

package/dist/components/Content/Schema/helpers/should-display-description.js

@@ -0,0 +1,12 @@
+const shouldDisplayDescription = (schema, propDescription) => {
+  if (!schema) {
+    return null;
+  }
+  if ("properties" in schema || "additionalProperties" in schema || "patternProperties" in schema || schema.allOf) {
+    return null;
+  }
+  return propDescription || schema.description || null;
+};
+export {
+  shouldDisplayDescription
+};

package/dist/components/Content/Schema/helpers/should-display-heading.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+/**
+ * Determine if property heading should be displayed
+ *
+ * @param schema - The schema object to check
+ * @param name - Optional property name
+ * @param required - Whether the property is required
+ * @returns true if heading should be displayed, false otherwise
+ */
+export declare const shouldDisplayHeading: (schema: SchemaObject | undefined, name?: string, required?: boolean) => boolean;
+//# sourceMappingURL=should-display-heading.d.ts.map

package/dist/components/Content/Schema/helpers/should-display-heading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"should-display-heading.d.ts","sourceRoot":"","sources":["../../../../../src/components/Content/Schema/helpers/should-display-heading.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAEhG;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,YAAY,GAAG,SAAS,EAAE,OAAO,MAAM,EAAE,kBAAgB,KAAG,OAqBxG,CAAA"}