@scalar/api-reference 1.49.0 → 1.49.2

package/dist/components/Content/Schema/helpers/get-ref-name.js

@@ -1,14 +0,0 @@
-import { REGEX } from "@scalar/helpers/regex/regex-helpers";
-const getRefName = (ref) => {
-  if (!ref) {
-    return null;
-  }
-  const match = ref.match(REGEX.REF_NAME);
-  if (match) {
-    return match[1];
-  }
-  return null;
-};
-export {
-  getRefName
-};

package/dist/components/Content/Schema/helpers/get-schema-type.js

@@ -1,47 +0,0 @@
-import { resolve } from "@scalar/workspace-store/resolve";
-import { isArraySchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
-const formatArrayType = (itemType) => {
-  if (!itemType) {
-    return "array";
-  }
-  const wrappedItemType = itemType.includes(" | ") ? `(${itemType})` : itemType;
-  return `array ${wrappedItemType}[]`;
-};
-const processArrayType = (value, isUnionType = false) => {
-  if (!value.items) {
-    return "array";
-  }
-  const itemType = getSchemaType(resolve.schema(value.items));
-  const baseType = formatArrayType(itemType);
-  if (isUnionType) {
-    return baseType;
-  }
-  return value.nullable ? `${baseType} | null` : baseType;
-};
-const getSchemaType = (valueOrRef) => {
-  if (!valueOrRef) {
-    return "";
-  }
-  const value = resolve.schema(valueOrRef);
-  if (value.const !== void 0) {
-    return "const";
-  }
-  if ("type" in value && Array.isArray(value.type)) {
-    if (value.type.includes("array") && value.items) {
-      const arrayType = processArrayType(value, true);
-      const otherTypes = value.type.filter((t) => t !== "array");
-      return otherTypes.length > 0 ? `${arrayType} | ${otherTypes.join(" | ")}` : arrayType;
-    }
-    return value.type.join(" | ");
-  }
-  if (isArraySchema(value)) {
-    return processArrayType(value, false);
-  }
-  if ("type" in value && value.type && value.contentEncoding) {
-    return `${value.type} • ${value.contentEncoding}`;
-  }
-  return "type" in value ? value.type : "";
-};
-export {
-  getSchemaType
-};

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

@@ -1,48 +0,0 @@
-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/is-empty-schema-object.js

@@ -1,13 +0,0 @@
-import { isTypeObject } from "./is-type-object.js";
-const isEmptySchemaObject = (schema) => {
-  if (!isTypeObject(schema)) {
-    return false;
-  }
-  const hasNoProperties = Object.keys(schema.properties ?? {}).length === 0;
-  const hasNoAdditionalProperties = schema.additionalProperties === void 0 || schema.additionalProperties === false;
-  const hasNoPatternProperties = Object.keys(schema.patternProperties ?? {}).length === 0;
-  return hasNoProperties && hasNoAdditionalProperties && hasNoPatternProperties;
-};
-export {
-  isEmptySchemaObject
-};

package/dist/components/Content/Schema/helpers/is-type-object.js

@@ -1,27 +0,0 @@
-const isTypeObject = (schema) => {
-  if (schema === null || typeof schema !== "object" || Array.isArray(schema)) {
-    return false;
-  }
-  const hasComposition = "oneOf" in schema || "anyOf" in schema || "allOf" in schema || "not" in schema;
-  if (hasComposition) {
-    return false;
-  }
-  const hasType = "type" in schema;
-  if (hasType && Array.isArray(schema.type)) {
-    return schema.type.includes("object");
-  }
-  const hasTypeObject = hasType && schema.type === "object";
-  if (hasTypeObject) {
-    return true;
-  }
-  if (hasType && !hasTypeObject) {
-    return false;
-  }
-  const hasProperties = "properties" in schema;
-  const hasAdditionalProperties = "additionalProperties" in schema;
-  const hasPatternProperties = "patternProperties" in schema;
-  return hasProperties || hasAdditionalProperties || hasPatternProperties;
-};
-export {
-  isTypeObject
-};

package/dist/components/Content/Schema/helpers/merge-all-of-schemas.js

@@ -1,215 +0,0 @@
-import { objectKeys } from "@scalar/helpers/object/object-keys";
-import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import { resolve } from "@scalar/workspace-store/resolve";
-import { isArraySchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
-const mergeAllOfSchemas = (schemas, rootSchema) => {
-  if (!schemas?.allOf?.length || !Array.isArray(schemas.allOf)) {
-    return rootSchema || {};
-  }
-  const result = {};
-  const { allOf: _, ...baseSchema } = schemas;
-  for (const _schema of schemas.allOf) {
-    if (!_schema || typeof _schema !== "object") {
-      continue;
-    }
-    const schema = resolve.schema(_schema);
-    if (schema.allOf) {
-      const nestedMerged = mergeAllOfSchemas(schema);
-      mergeSchemaIntoResult(result, nestedMerged);
-      continue;
-    }
-    mergeSchemaIntoResult(result, schema);
-  }
-  if (Object.keys(baseSchema).length > 0) {
-    mergeSchemaIntoResult(result, baseSchema, true);
-  }
-  if (rootSchema && typeof rootSchema === "object") {
-    if (rootSchema.allOf) {
-      const nestedMerged = mergeAllOfSchemas(rootSchema);
-      mergeSchemaIntoResult(result, nestedMerged, true);
-    } else {
-      mergeSchemaIntoResult(result, rootSchema, true);
-    }
-  }
-  return result;
-};
-const mergeSchemaIntoResult = (result, schema, override = false) => {
-  const schemaKeys = objectKeys(schema);
-  if (schemaKeys.length === 0) {
-    return;
-  }
-  for (const key of schemaKeys) {
-    const value = getResolvedRef(schema[key]);
-    if (value === void 0) {
-      continue;
-    }
-    if (key === "required") {
-      if (Array.isArray(value) && value.length > 0) {
-        if (result.required?.length) {
-          result.required = [.../* @__PURE__ */ new Set([...result.required, ...value])];
-        } else {
-          result.required = value.slice();
-        }
-      }
-    } else if (key === "properties") {
-      if (value && typeof value === "object") {
-        if (!result.properties) {
-          result.properties = {};
-        }
-        mergePropertiesIntoResult(result.properties, value);
-      }
-    } else if (key === "items") {
-      const items = resolve.schema(value);
-      if (items) {
-        if (isArraySchema(schema)) {
-          if (!result.items) {
-            result.items = {};
-          }
-          if (items.allOf) {
-            const mergedItems = mergeAllOfSchemas(items);
-            Object.assign(result.items, mergedItems);
-          } else {
-            mergeItemsIntoResult(getResolvedRef(result.items), items);
-          }
-        } else if (items.allOf) {
-          const mergedItems = mergeAllOfSchemas(items);
-          if ("properties" in mergedItems) {
-            if (!("properties" in result)) {
-              result.properties = {};
-            }
-            "properties" in result && mergePropertiesIntoResult(result.properties, mergedItems.properties);
-          }
-        } else if (!("items" in result)) {
-          result.items = items;
-        }
-      }
-    } else if (key === "enum") {
-      if (Array.isArray(value) && value.length > 0) {
-        result.enum = [.../* @__PURE__ */ new Set([...result.enum || [], ...value])];
-      }
-    } else if (key === "oneOf" || key === "anyOf") {
-      if (Array.isArray(value)) {
-        if (!("properties" in result)) {
-          result.properties = {};
-        }
-        for (const _option of value) {
-          const option = resolve.schema(_option);
-          if (option && "properties" in option && "properties" in result) {
-            mergePropertiesIntoResult(result.properties, option.properties);
-          }
-        }
-      }
-    } else if (key === "allOf") {
-      continue;
-    } else {
-      if (override || result[key] === void 0) {
-        result[key] = value;
-      }
-    }
-  }
-};
-const mergePropertiesIntoResult = (result, properties) => {
-  const propertyKeys = Object.keys(properties ?? {});
-  if (!properties || !result || propertyKeys.length === 0) {
-    return;
-  }
-  for (const key of propertyKeys) {
-    const schema = resolve.schema(properties[key]);
-    if (!schema) {
-      delete result[key];
-      continue;
-    }
-    if (typeof schema !== "object") {
-      result[key] = schema;
-      continue;
-    }
-    if (!result[key]) {
-      if (schema.allOf) {
-        result[key] = mergeAllOfSchemas(schema);
-      } else if (isArraySchema(schema) && resolve.schema(schema.items)?.allOf) {
-        result[key] = {
-          ...schema,
-          items: mergeAllOfSchemas(resolve.schema(schema.items))
-        };
-      } else if (properties[key]) {
-        result[key] = properties[key];
-      }
-      continue;
-    }
-    const existing = resolve.schema(result[key]);
-    if (schema.allOf) {
-      result[key] = mergeAllOfSchemas({ allOf: [existing, ...schema.allOf] });
-    } else if (isArraySchema(schema) && isArraySchema(existing) && schema.items) {
-      const existingItems = resolve.schema(existing.items);
-      result[key] = {
-        ...existing,
-        type: "array",
-        items: existingItems ? mergeItems(existingItems, resolve.schema(schema.items)) : resolve.schema(schema.items)
-      };
-    } else {
-      if ("properties" in existing && "properties" in schema) {
-        const merged = { ...existing, ...schema };
-        merged.properties = { ...existing.properties };
-        mergePropertiesIntoResult(merged.properties, schema.properties);
-        result[key] = merged;
-      } else {
-        result[key] = { ...schema, ...existing };
-      }
-    }
-  }
-};
-const mergeItemsIntoResult = (result, items) => {
-  if (items.allOf || result.allOf) {
-    const allOfSchemas = [];
-    if (result.allOf) {
-      for (const schema of result.allOf) {
-        allOfSchemas.push(resolve.schema(schema));
-      }
-    } else {
-      allOfSchemas.push(result);
-    }
-    if (items.allOf) {
-      for (const schema of items.allOf) {
-        allOfSchemas.push(resolve.schema(schema));
-      }
-    } else {
-      allOfSchemas.push(items);
-    }
-    const merged = mergeAllOfSchemas({ allOf: allOfSchemas });
-    Object.assign(result, merged);
-    return;
-  }
-  Object.assign(result, items);
-  if ("properties" in result && "properties" in items) {
-    mergePropertiesIntoResult(result.properties, items.properties);
-  }
-};
-const mergeItems = (existing, incoming) => {
-  if (existing.allOf || incoming.allOf) {
-    const allOfSchemas = [];
-    if (existing.allOf) {
-      for (const schema of existing.allOf) {
-        allOfSchemas.push(resolve.schema(schema));
-      }
-    } else {
-      allOfSchemas.push(existing);
-    }
-    if (incoming.allOf) {
-      for (const schema of incoming.allOf) {
-        allOfSchemas.push(resolve.schema(schema));
-      }
-    } else {
-      allOfSchemas.push(incoming);
-    }
-    return mergeAllOfSchemas({ allOf: allOfSchemas });
-  }
-  const merged = { ...existing, ...incoming };
-  if ("properties" in existing && "properties" in incoming) {
-    merged.properties = { ...existing.properties };
-    mergePropertiesIntoResult(merged.properties, incoming.properties);
-  }
-  return merged;
-};
-export {
-  mergeAllOfSchemas
-};

package/dist/components/Content/Schema/helpers/optimize-value-for-display.js

@@ -1,64 +0,0 @@
-import { resolve } from "@scalar/workspace-store/resolve";
-import { compositions } from "./schema-composition.js";
-function optimizeValueForDisplay(value) {
-  if (!value || typeof value !== "object") {
-    return value;
-  }
-  const composition = compositions.find((keyword) => keyword in value && keyword !== "not");
-  if (!composition) {
-    return { ...value };
-  }
-  const schemas = value[composition];
-  if (!Array.isArray(schemas)) {
-    return { ...value };
-  }
-  const { [composition]: _, nullable: originalNullable, ...rootProperties } = value;
-  const hasRootProperties = Object.keys(rootProperties).length > 0;
-  const { filteredSchemas, hasNullSchema } = schemas.reduce(
-    (acc, _schema) => {
-      const schema = resolve.schema(_schema);
-      if ("type" in schema && schema.type === "null") {
-        acc.hasNullSchema = true;
-      } else {
-        acc.filteredSchemas.push(schema);
-      }
-      return acc;
-    },
-    { filteredSchemas: [], hasNullSchema: false }
-  );
-  const shouldBeNullable = hasNullSchema || originalNullable === true;
-  if (filteredSchemas.length === 1) {
-    const mergedSchema = { ...rootProperties, ...filteredSchemas[0] };
-    if (shouldBeNullable) {
-      mergedSchema.nullable = true;
-    }
-    return mergedSchema;
-  }
-  const shouldMergeRootProperties = (composition === "oneOf" || composition === "anyOf") && (hasRootProperties || filteredSchemas.some((schema) => schema.allOf));
-  if (shouldMergeRootProperties) {
-    const mergedSchemas = filteredSchemas.map((_schema) => {
-      const schema = resolve.schema(_schema);
-      if (schema.allOf?.length === 1) {
-        const { allOf, ...otherProps } = schema;
-        return { ...rootProperties, ...otherProps, ...resolve.schema(allOf[0]) };
-      }
-      return { ...rootProperties, ...schema };
-    });
-    const result = { [composition]: mergedSchemas };
-    if (shouldBeNullable) {
-      result.nullable = true;
-    }
-    return result;
-  }
-  if (filteredSchemas.length !== schemas.length) {
-    const result = { ...value, [composition]: filteredSchemas };
-    if (shouldBeNullable) {
-      result.nullable = true;
-    }
-    return result;
-  }
-  return { ...value };
-}
-export {
-  optimizeValueForDisplay
-};

package/dist/components/Content/Schema/helpers/schema-composition.js

@@ -1,4 +0,0 @@
-const compositions = ["oneOf", "anyOf", "allOf", "not"];
-export {
-  compositions
-};

package/dist/components/Content/Schema/helpers/schema-name.js

@@ -1,24 +0,0 @@
-import { resolve } from "@scalar/workspace-store/resolve";
-import { getRefName } from "./get-ref-name.js";
-const getModelNameFromSchema = (schemaOrRef) => {
-  if (!schemaOrRef) {
-    return null;
-  }
-  const schema = resolve.schema(schemaOrRef);
-  if (schema.title) {
-    return schema.title;
-  }
-  if (schema.name) {
-    return schema.name;
-  }
-  if ("$ref" in schemaOrRef) {
-    const refName = getRefName(schemaOrRef.$ref);
-    if (refName) {
-      return refName;
-    }
-  }
-  return null;
-};
-export {
-  getModelNameFromSchema
-};

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

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

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

@@ -1,12 +0,0 @@
-const shouldDisplayHeading = (schema, name, required = false) => {
-  if (name || required) {
-    return true;
-  }
-  if (!schema) {
-    return false;
-  }
-  return schema.deprecated === true || schema.const !== void 0 || schema.enum?.length === 1 || "type" in schema && schema.type !== void 0 || "nullable" in schema && schema.nullable === true || schema.writeOnly === true || schema.readOnly === true;
-};
-export {
-  shouldDisplayHeading
-};

package/dist/components/Content/Schema/helpers/should-render-array-item-composition.js

@@ -1,15 +0,0 @@
-import { isArraySchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
-import { hasComplexArrayItems } from "./has-complex-array-items.js";
-const shouldRenderArrayItemComposition = (schema, composition) => {
-  if (!schema || !isArraySchema(schema)) {
-    return false;
-  }
-  const items = schema.items;
-  if (!items || typeof items !== "object" || !(composition in items)) {
-    return false;
-  }
-  return !hasComplexArrayItems(schema);
-};
-export {
-  shouldRenderArrayItemComposition
-};

package/dist/components/Content/Schema/helpers/sort-property-names.js

@@ -1,71 +0,0 @@
-import { resolve } from "@scalar/workspace-store/resolve";
-import { isTypeObject } from "./is-type-object.js";
-const reduceNamesToObject = (names, properties) => names.reduce((acc, name) => {
-  const prop = properties?.[name];
-  if (prop) {
-    acc[name] = prop;
-  }
-  return acc;
-}, {});
-const sortPropertyNames = (schema, discriminator, {
-  hideReadOnly = false,
-  hideWriteOnly = false,
-  orderSchemaPropertiesBy = "alpha",
-  orderRequiredPropertiesFirst = true
-} = {}) => {
-  if (!isTypeObject(schema) || !schema.properties) {
-    return [];
-  }
-  const propertyNames = Object.keys(schema.properties);
-  const requiredPropertiesSet = new Set(schema.required || []);
-  return propertyNames.sort((a, b) => {
-    const aDiscriminator = a === discriminator?.propertyName;
-    const bDiscriminator = b === discriminator?.propertyName;
-    const aRequired = requiredPropertiesSet.has(a);
-    const bRequired = requiredPropertiesSet.has(b);
-    if (aDiscriminator && !bDiscriminator) {
-      return -1;
-    }
-    if (!aDiscriminator && bDiscriminator) {
-      return 1;
-    }
-    const aSchema = schema.properties?.[a];
-    const bSchema = schema.properties?.[b];
-    const aOrder = aSchema && typeof aSchema === "object" && "x-order" in aSchema ? aSchema["x-order"] : void 0;
-    const bOrder = bSchema && typeof bSchema === "object" && "x-order" in bSchema ? bSchema["x-order"] : void 0;
-    if (aOrder !== void 0 && bOrder !== void 0) {
-      return Number(aOrder) - Number(bOrder);
-    }
-    if (aOrder !== void 0 && bOrder === void 0) {
-      return -1;
-    }
-    if (aOrder === void 0 && bOrder !== void 0) {
-      return 1;
-    }
-    if (orderRequiredPropertiesFirst) {
-      if (aRequired && !bRequired) {
-        return -1;
-      }
-      if (!aRequired && bRequired) {
-        return 1;
-      }
-    }
-    if (orderSchemaPropertiesBy === "alpha") {
-      return a.localeCompare(b);
-    }
-    return 0;
-  }).filter((property) => {
-    const resolved = schema.properties && resolve.schema(schema.properties[property]);
-    if (hideReadOnly && resolved?.readOnly === true) {
-      return false;
-    }
-    if (hideWriteOnly && resolved?.writeOnly === true) {
-      return false;
-    }
-    return true;
-  });
-};
-export {
-  reduceNamesToObject,
-  sortPropertyNames
-};

package/dist/components/Content/Tags/Tag.vue.js

@@ -1,46 +0,0 @@
-import { defineComponent, createBlock, openBlock, withCtx, renderSlot } from "vue";
-import ClassicLayout from "./components/ClassicLayout.vue.js";
-import ModernLayout from "./components/ModernLayout.vue.js";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "Tag",
-  props: {
-    tag: {},
-    layout: {},
-    moreThanOneTag: { type: Boolean },
-    isLoading: { type: Boolean },
-    isCollapsed: { type: Boolean },
-    eventBus: {}
-  },
-  setup(__props) {
-    return (_ctx, _cache) => {
-      return __props.layout === "classic" ? (openBlock(), createBlock(ClassicLayout, {
-        key: 0,
-        eventBus: __props.eventBus,
-        isCollapsed: __props.isCollapsed,
-        layout: __props.layout,
-        tag: __props.tag
-      }, {
-        default: withCtx(() => [
-          renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      }, 8, ["eventBus", "isCollapsed", "layout", "tag"])) : (openBlock(), createBlock(ModernLayout, {
-        key: 1,
-        eventBus: __props.eventBus,
-        isCollapsed: __props.isCollapsed,
-        isLoading: __props.isLoading,
-        layout: __props.layout,
-        moreThanOneTag: __props.moreThanOneTag,
-        tag: __props.tag
-      }, {
-        default: withCtx(() => [
-          renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      }, 8, ["eventBus", "isCollapsed", "isLoading", "layout", "moreThanOneTag", "tag"]));
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/dist/components/Content/Tags/Tag.vue2.js

@@ -1,4 +0,0 @@
-import _sfc_main from "./Tag.vue.js";
-export {
-  _sfc_main as default
-};

package/dist/components/Content/Tags/components/ClassicLayout.vue.js

@@ -1,7 +0,0 @@
-import _sfc_main from "./ClassicLayout.vue2.js";
-/* empty css                   */
-import _export_sfc from "../../../../_virtual/_plugin-vue_export-helper.js";
-const ClassicLayout = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-1124be5d"]]);
-export {
-  ClassicLayout as default
-};