@scalar/api-reference 1.49.2 → 1.49.4

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

@@ -0,0 +1,36 @@
+import { isSchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
+//#region src/components/Content/Schema/helpers/get-property-description.ts
+var 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"
+	}
+};
+/**
+* Generate property description from type/format
+*
+* @param value - The schema object to generate description from
+* @returns Description string or null if no description available
+*/
+var getPropertyDescription = (value) => {
+	if (!isSchema(value)) return null;
+	/** Just grab the first type from the array if it's an array */
+	const type = Array.isArray(value.type) ? value.type[0] : value.type;
+	if (!type) return null;
+	const typeDescriptions = TYPE_DESCRIPTIONS[type];
+	if (!typeDescriptions) return null;
+	return typeDescriptions["format" in value && value.format || "contentEncoding" in value && value.contentEncoding || "_default"] ?? null;
+};
+//#endregion
+export { getPropertyDescription };
+
+//# sourceMappingURL=get-property-description.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-property-description.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/get-property-description.ts"],"sourcesContent":["import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\nimport { isSchema } from '@scalar/workspace-store/schemas/v3.1/strict/type-guards'\n\n// Type descriptions for built-in types\nconst TYPE_DESCRIPTIONS: Record<string, Record<string, string>> = {\n  integer: {\n    _default: 'Integer numbers.',\n    int32: 'Signed 32-bit integers (commonly used integer type).',\n    int64: 'Signed 64-bit integers (long type).',\n  },\n  string: {\n    'date': 'full-date notation as defined by RFC 3339, section 5.6, for example, 2017-07-21',\n    'date-time': 'the date-time notation as defined by RFC 3339, section 5.6, for example, 2017-07-21T17:32:28Z',\n    'password': 'a hint to UIs to mask the input',\n    'base64': 'base64-encoded characters, for example, U3dhZ2dlciByb2Nrcw==',\n    'byte': 'base64-encoded characters, for example, U3dhZ2dlciByb2Nrcw==',\n    'binary': 'binary data, used to describe files',\n  },\n} as const\n\n/**\n * Generate property description from type/format\n *\n * @param value - The schema object to generate description from\n * @returns Description string or null if no description available\n */\nexport const getPropertyDescription = (value: SchemaObject | undefined): string | null => {\n  if (!isSchema(value)) {\n    return null\n  }\n  /** Just grab the first type from the array if it's an array */\n  const type = Array.isArray(value.type) ? value.type[0] : value.type\n  if (!type) {\n    return null\n  }\n\n  const typeDescriptions = TYPE_DESCRIPTIONS[type]\n  if (!typeDescriptions) {\n    return null\n  }\n\n  const format =\n    ('format' in value && value.format) || ('contentEncoding' in value && value.contentEncoding) || '_default'\n  return typeDescriptions[format] ?? null\n}\n"],"mappings":";;AAIA,IAAM,oBAA4D;CAChE,SAAS;EACP,UAAU;EACV,OAAO;EACP,OAAO;EACR;CACD,QAAQ;EACN,QAAQ;EACR,aAAa;EACb,YAAY;EACZ,UAAU;EACV,QAAQ;EACR,UAAU;EACX;CACF;;;;;;;AAQD,IAAa,0BAA0B,UAAmD;AACxF,KAAI,CAAC,SAAS,MAAM,CAClB,QAAO;;CAGT,MAAM,OAAO,MAAM,QAAQ,MAAM,KAAK,GAAG,MAAM,KAAK,KAAK,MAAM;AAC/D,KAAI,CAAC,KACH,QAAO;CAGT,MAAM,mBAAmB,kBAAkB;AAC3C,KAAI,CAAC,iBACH,QAAO;AAKT,QAAO,iBADJ,YAAY,SAAS,MAAM,UAAY,qBAAqB,SAAS,MAAM,mBAAoB,eAC/D"}

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

@@ -0,0 +1,19 @@
+import { REGEX } from "@scalar/helpers/regex/regex-helpers";
+//#region src/components/Content/Schema/helpers/get-ref-name.ts
+/**
+* Gets the "name" of the schema from the ref path
+* TODO: this will change so fix it when the new refs are out
+* Then add tests
+*
+* @example SchemaName from #/components/schemas/SchemaName
+*/
+var getRefName = (ref) => {
+	if (!ref) return null;
+	const match = ref.match(REGEX.REF_NAME);
+	if (match) return match[1];
+	return null;
+};
+//#endregion
+export { getRefName };
+
+//# sourceMappingURL=get-ref-name.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-ref-name.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/get-ref-name.ts"],"sourcesContent":["import { REGEX } from '@scalar/helpers/regex/regex-helpers'\n\n/**\n * Gets the \"name\" of the schema from the ref path\n * TODO: this will change so fix it when the new refs are out\n * Then add tests\n *\n * @example SchemaName from #/components/schemas/SchemaName\n */\nexport const getRefName = (ref: string) => {\n  if (!ref) {\n    return null\n  }\n\n  const match = ref.match(REGEX.REF_NAME)\n  if (match) {\n    return match[1]\n  }\n\n  return null\n}\n"],"mappings":";;;;;;;;;AASA,IAAa,cAAc,QAAgB;AACzC,KAAI,CAAC,IACH,QAAO;CAGT,MAAM,QAAQ,IAAI,MAAM,MAAM,SAAS;AACvC,KAAI,MACF,QAAO,MAAM;AAGf,QAAO"}

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

@@ -0,0 +1,49 @@
+import { resolve } from "@scalar/workspace-store/resolve";
+import { isArraySchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
+//#region src/components/Content/Schema/helpers/get-schema-type.ts
+/**
+* Formats an array type string with proper wrapping for union types.
+*/
+var formatArrayType = (itemType) => {
+	if (!itemType) return "array";
+	return `array ${itemType.includes(" | ") ? `(${itemType})` : itemType}[]`;
+};
+/**
+* Handles array type processing for both single array types and union types containing array.
+*/
+var processArrayType = (value, isUnionType = false) => {
+	if (!value.items) return "array";
+	const baseType = formatArrayType(getSchemaType(resolve.schema(value.items)));
+	if (isUnionType) return baseType;
+	return value.nullable ? `${baseType} | null` : baseType;
+};
+/**
+* Computes the structural type for a schema.
+* This helper always returns type information, never schema titles or ref names.
+*
+* Priority order:
+* 1. const values
+* 2. Array types (with special handling for items)
+* 3. type with contentEncoding
+* 4. raw type
+*/
+var 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 : "";
+};
+//#endregion
+export { getSchemaType };
+
+//# sourceMappingURL=get-schema-type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-schema-type.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/get-schema-type.ts"],"sourcesContent":["import { resolve } from '@scalar/workspace-store/resolve'\nimport type { ReferenceType, SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\nimport { isArraySchema } from '@scalar/workspace-store/schemas/v3.1/strict/type-guards'\n\n/**\n * Formats an array type string with proper wrapping for union types.\n */\nconst formatArrayType = (itemType: string): string => {\n  if (!itemType) {\n    return 'array'\n  }\n\n  const wrappedItemType = itemType.includes(' | ') ? `(${itemType})` : itemType\n  return `array ${wrappedItemType}[]`\n}\n\n/**\n * Handles array type processing for both single array types and union types containing array.\n */\nconst processArrayType = (value: Extract<SchemaObject, { type: 'array' }>, isUnionType: boolean = false): string => {\n  if (!value.items) {\n    return 'array'\n  }\n\n  const itemType = getSchemaType(resolve.schema(value.items))\n  const baseType = formatArrayType(itemType)\n\n  if (isUnionType) {\n    return baseType\n  }\n\n  // Handle nullable arrays for non-union types\n  return (value as any).nullable ? `${baseType} | null` : baseType\n}\n\n/**\n * Computes the structural type for a schema.\n * This helper always returns type information, never schema titles or ref names.\n *\n * Priority order:\n * 1. const values\n * 2. Array types (with special handling for items)\n * 3. type with contentEncoding\n * 4. raw type\n */\nexport const getSchemaType = (valueOrRef: SchemaObject | ReferenceType<SchemaObject>): string => {\n  // Early return for falsy values\n  if (!valueOrRef) {\n    return ''\n  }\n\n  const value = resolve.schema(valueOrRef)\n\n  // Handle const values first (highest priority)\n  if (value.const !== undefined) {\n    return 'const'\n  }\n\n  // Handle union types (array of types)\n  if ('type' in value && Array.isArray(value.type)) {\n    // Special case: union types containing 'array'\n    // TODO: Correctly type array of types in SchemaObject\n    if (value.type.includes('array') && (value as Extract<SchemaObject, { type: 'array' }>).items) {\n      const arrayType = processArrayType(value as Extract<SchemaObject, { type: 'array' }>, true)\n      const otherTypes = value.type.filter((t) => t !== 'array')\n\n      return otherTypes.length > 0 ? `${arrayType} | ${otherTypes.join(' | ')}` : arrayType\n    }\n\n    // Regular union types\n    return value.type.join(' | ')\n  }\n\n  // Handle single array type\n  if (isArraySchema(value)) {\n    return processArrayType(value, false)\n  }\n\n  // Handle type with content encoding\n  if ('type' in value && value.type && value.contentEncoding) {\n    return `${value.type} • ${value.contentEncoding}`\n  }\n\n  // Fallback to raw type\n  return 'type' in value ? (value.type as string) : ''\n}\n"],"mappings":";;;;;;AAOA,IAAM,mBAAmB,aAA6B;AACpD,KAAI,CAAC,SACH,QAAO;AAIT,QAAO,SADiB,SAAS,SAAS,MAAM,GAAG,IAAI,SAAS,KAAK,SACrC;;;;;AAMlC,IAAM,oBAAoB,OAAiD,cAAuB,UAAkB;AAClH,KAAI,CAAC,MAAM,MACT,QAAO;CAIT,MAAM,WAAW,gBADA,cAAc,QAAQ,OAAO,MAAM,MAAM,CAAC,CACjB;AAE1C,KAAI,YACF,QAAO;AAIT,QAAQ,MAAc,WAAW,GAAG,SAAS,WAAW;;;;;;;;;;;;AAa1D,IAAa,iBAAiB,eAAmE;AAE/F,KAAI,CAAC,WACH,QAAO;CAGT,MAAM,QAAQ,QAAQ,OAAO,WAAW;AAGxC,KAAI,MAAM,UAAU,KAAA,EAClB,QAAO;AAIT,KAAI,UAAU,SAAS,MAAM,QAAQ,MAAM,KAAK,EAAE;AAGhD,MAAI,MAAM,KAAK,SAAS,QAAQ,IAAK,MAAmD,OAAO;GAC7F,MAAM,YAAY,iBAAiB,OAAmD,KAAK;GAC3F,MAAM,aAAa,MAAM,KAAK,QAAQ,MAAM,MAAM,QAAQ;AAE1D,UAAO,WAAW,SAAS,IAAI,GAAG,UAAU,KAAK,WAAW,KAAK,MAAM,KAAK;;AAI9E,SAAO,MAAM,KAAK,KAAK,MAAM;;AAI/B,KAAI,cAAc,MAAM,CACtB,QAAO,iBAAiB,OAAO,MAAM;AAIvC,KAAI,UAAU,SAAS,MAAM,QAAQ,MAAM,gBACzC,QAAO,GAAG,MAAM,KAAK,KAAK,MAAM;AAIlC,QAAO,UAAU,QAAS,MAAM,OAAkB"}

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

@@ -0,0 +1,53 @@
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { isArraySchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
+//#region src/components/Content/Schema/helpers/has-complex-array-items.ts
+/** Composition keywords that indicate complex schema structure */
+var COMPOSITION_KEYWORDS = [
+	"allOf",
+	"oneOf",
+	"anyOf"
+];
+/**
+* Checks if a schema has object type (either explicit type: 'object' or has properties)
+*/
+var 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;
+};
+/**
+* Checks if a schema has complex features (refs, compositions, discriminators)
+*/
+var hasComplexFeatures = (schema) => "$ref" in schema || "discriminator" in schema || COMPOSITION_KEYWORDS.some((keyword) => keyword in schema);
+/**
+* Checks if nested array items are complex
+*/
+var 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);
+};
+/**
+* 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
+*/
+var 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);
+};
+//#endregion
+export { hasComplexArrayItems };
+
+//# sourceMappingURL=has-complex-array-items.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"has-complex-array-items.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/has-complex-array-items.ts"],"sourcesContent":["import { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\nimport { isArraySchema } from '@scalar/workspace-store/schemas/v3.1/strict/type-guards'\n\n/** Composition keywords that indicate complex schema structure */\nconst COMPOSITION_KEYWORDS = ['allOf', 'oneOf', 'anyOf'] as const\n\n/**\n * Checks if a schema has object type (either explicit type: 'object' or has properties)\n */\nconst isObjectType = (schema: SchemaObject): boolean => {\n  // Check for explicit object type\n  if ('type' in schema && schema.type) {\n    if (Array.isArray(schema.type)) {\n      return schema.type.includes('object')\n    }\n    return schema.type === 'object'\n  }\n\n  // Check for properties (implicit object type)\n  return 'properties' in schema\n}\n\n/**\n * Checks if a schema has complex features (refs, compositions, discriminators)\n */\nconst hasComplexFeatures = (schema: SchemaObject): boolean =>\n  '$ref' in schema || 'discriminator' in schema || COMPOSITION_KEYWORDS.some((keyword) => keyword in schema)\n\n/**\n * Checks if nested array items are complex\n */\nconst hasComplexNestedArrayItems = (items: SchemaObject): boolean => {\n  if (!isArraySchema(items) || typeof items.items !== 'object') {\n    return false\n  }\n\n  // Check for $ref in original nested items before resolving\n  if ('$ref' in items.items) {\n    return true\n  }\n\n  const nestedItems = getResolvedRef(items.items)\n  if (!nestedItems) {\n    return false\n  }\n\n  // Check if nested items are complex (objects, refs, compositions, or further nested arrays)\n  return isObjectType(nestedItems) || hasComplexFeatures(nestedItems) || isArraySchema(nestedItems)\n}\n\n/**\n * Checks if array items have complex structure\n * like: objects, references, discriminators, compositions, or nested arrays with complex items\n *\n * @param value - The schema object to check\n * @returns true if the array has complex items, false otherwise\n */\nexport const hasComplexArrayItems = (value: SchemaObject | undefined): boolean => {\n  // Early return for invalid inputs\n  if (!value || !isArraySchema(value) || typeof value.items !== 'object') {\n    return false\n  }\n\n  // Check for $ref in original items before resolving (in case ref can't be resolved)\n  if ('$ref' in value.items) {\n    return true\n  }\n\n  const items = getResolvedRef(value.items)\n  if (!items) {\n    return false\n  }\n\n  // Check for complex features (refs, compositions, discriminators)\n  if (hasComplexFeatures(items)) {\n    return true\n  }\n\n  // Check if items are objects\n  if (isObjectType(items)) {\n    return true\n  }\n\n  // Check if items are nested arrays with complex items\n  return hasComplexNestedArrayItems(items)\n}\n"],"mappings":";;;;AAKA,IAAM,uBAAuB;CAAC;CAAS;CAAS;CAAQ;;;;AAKxD,IAAM,gBAAgB,WAAkC;AAEtD,KAAI,UAAU,UAAU,OAAO,MAAM;AACnC,MAAI,MAAM,QAAQ,OAAO,KAAK,CAC5B,QAAO,OAAO,KAAK,SAAS,SAAS;AAEvC,SAAO,OAAO,SAAS;;AAIzB,QAAO,gBAAgB;;;;;AAMzB,IAAM,sBAAsB,WAC1B,UAAU,UAAU,mBAAmB,UAAU,qBAAqB,MAAM,YAAY,WAAW,OAAO;;;;AAK5G,IAAM,8BAA8B,UAAiC;AACnE,KAAI,CAAC,cAAc,MAAM,IAAI,OAAO,MAAM,UAAU,SAClD,QAAO;AAIT,KAAI,UAAU,MAAM,MAClB,QAAO;CAGT,MAAM,cAAc,eAAe,MAAM,MAAM;AAC/C,KAAI,CAAC,YACH,QAAO;AAIT,QAAO,aAAa,YAAY,IAAI,mBAAmB,YAAY,IAAI,cAAc,YAAY;;;;;;;;;AAUnG,IAAa,wBAAwB,UAA6C;AAEhF,KAAI,CAAC,SAAS,CAAC,cAAc,MAAM,IAAI,OAAO,MAAM,UAAU,SAC5D,QAAO;AAIT,KAAI,UAAU,MAAM,MAClB,QAAO;CAGT,MAAM,QAAQ,eAAe,MAAM,MAAM;AACzC,KAAI,CAAC,MACH,QAAO;AAIT,KAAI,mBAAmB,MAAM,CAC3B,QAAO;AAIT,KAAI,aAAa,MAAM,CACrB,QAAO;AAIT,QAAO,2BAA2B,MAAM"}

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

@@ -0,0 +1,18 @@
+import { isTypeObject } from "./is-type-object.js";
+//#region src/components/Content/Schema/helpers/is-empty-schema-object.ts
+/**
+* Determines if the given schema is an empty object schema.
+* An empty object schema is defined as a schema with type 'object'
+* and no defined properties, no additionalProperties (or set to false), and no patternProperties.
+*/
+var 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;
+};
+//#endregion
+export { isEmptySchemaObject };
+
+//# sourceMappingURL=is-empty-schema-object.js.map

package/dist/components/Content/Schema/helpers/is-empty-schema-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty-schema-object.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/is-empty-schema-object.ts"],"sourcesContent":["import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport { isTypeObject } from '@/components/Content/Schema/helpers/is-type-object'\n\n/**\n * Determines if the given schema is an empty object schema.\n * An empty object schema is defined as a schema with type 'object'\n * and no defined properties, no additionalProperties (or set to false), and no patternProperties.\n */\nexport const isEmptySchemaObject = (schema: SchemaObject | undefined): boolean => {\n  if (!isTypeObject(schema)) {\n    return false\n  }\n\n  const hasNoProperties = Object.keys(schema.properties ?? {}).length === 0\n  const hasNoAdditionalProperties = schema.additionalProperties === undefined || schema.additionalProperties === false\n  const hasNoPatternProperties = Object.keys(schema.patternProperties ?? {}).length === 0\n\n  return hasNoProperties && hasNoAdditionalProperties && hasNoPatternProperties\n}\n"],"mappings":";;;;;;;AASA,IAAa,uBAAuB,WAA8C;AAChF,KAAI,CAAC,aAAa,OAAO,CACvB,QAAO;CAGT,MAAM,kBAAkB,OAAO,KAAK,OAAO,cAAc,EAAE,CAAC,CAAC,WAAW;CACxE,MAAM,4BAA4B,OAAO,yBAAyB,KAAA,KAAa,OAAO,yBAAyB;CAC/G,MAAM,yBAAyB,OAAO,KAAK,OAAO,qBAAqB,EAAE,CAAC,CAAC,WAAW;AAEtF,QAAO,mBAAmB,6BAA6B"}

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

@@ -0,0 +1,18 @@
+//#region src/components/Content/Schema/helpers/is-type-object.ts
+var isTypeObject = (schema) => {
+	if (schema === null || typeof schema !== "object" || Array.isArray(schema)) return false;
+	if ("oneOf" in schema || "anyOf" in schema || "allOf" in schema || "not" in schema) 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;
+};
+//#endregion
+export { isTypeObject };
+
+//# sourceMappingURL=is-type-object.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-type-object.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/is-type-object.ts"],"sourcesContent":["import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\n/*\n * Checks whether a JSON schema is of type object\n */\nexport const isTypeObject = (schema: unknown): schema is Extract<SchemaObject, { type: 'object' }> => {\n  // null, primitive types, arrays\n  if (schema === null || typeof schema !== 'object' || Array.isArray(schema)) {\n    return false\n  }\n\n  // Check for composition keywords - if present, this should be handled by composition logic\n  const hasComposition = 'oneOf' in schema || 'anyOf' in schema || 'allOf' in schema || 'not' in schema\n\n  // If it has composition keywords, it should not be treated as a simple object schema\n  if (hasComposition) {\n    return false\n  }\n\n  const hasType = 'type' in schema\n\n  // Handle union types (type: ['object', 'null'])\n  if (hasType && Array.isArray(schema.type)) {\n    return schema.type.includes('object')\n  }\n\n  const hasTypeObject = hasType && schema.type === 'object'\n\n  // type: object\n  if (hasTypeObject) {\n    return true\n  }\n\n  // type: string, number, boolean, array, etc.\n  if (hasType && !hasTypeObject) {\n    return false\n  }\n\n  const hasProperties = 'properties' in schema\n  const hasAdditionalProperties = 'additionalProperties' in schema\n  const hasPatternProperties = 'patternProperties' in schema\n\n  return hasProperties || hasAdditionalProperties || hasPatternProperties\n}\n"],"mappings":";AAKA,IAAa,gBAAgB,WAAyE;AAEpG,KAAI,WAAW,QAAQ,OAAO,WAAW,YAAY,MAAM,QAAQ,OAAO,CACxE,QAAO;AAOT,KAHuB,WAAW,UAAU,WAAW,UAAU,WAAW,UAAU,SAAS,OAI7F,QAAO;CAGT,MAAM,UAAU,UAAU;AAG1B,KAAI,WAAW,MAAM,QAAQ,OAAO,KAAK,CACvC,QAAO,OAAO,KAAK,SAAS,SAAS;CAGvC,MAAM,gBAAgB,WAAW,OAAO,SAAS;AAGjD,KAAI,cACF,QAAO;AAIT,KAAI,WAAW,CAAC,cACd,QAAO;CAGT,MAAM,gBAAgB,gBAAgB;CACtC,MAAM,0BAA0B,0BAA0B;CAC1D,MAAM,uBAAuB,uBAAuB;AAEpD,QAAO,iBAAiB,2BAA2B"}

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

@@ -0,0 +1,175 @@
+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";
+import { objectKeys } from "@scalar/helpers/object/object-keys";
+//#region src/components/Content/Schema/helpers/merge-all-of-schemas.ts
+/**
+* Merges multiple OpenAPI schema objects into a single schema object.
+* Handles nested allOf compositions and merges properties recursively.
+*
+* @param schemas - Array of OpenAPI schema objects to merge
+* @param rootSchema - Optional root schema to merge with the result
+* @returns Merged schema object
+*/
+var 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) {
+			mergeSchemaIntoResult(result, mergeAllOfSchemas(schema));
+			continue;
+		}
+		mergeSchemaIntoResult(result, schema);
+	}
+	if (Object.keys(baseSchema).length > 0) mergeSchemaIntoResult(result, baseSchema, true);
+	if (rootSchema && typeof rootSchema === "object") if (rootSchema.allOf) mergeSchemaIntoResult(result, mergeAllOfSchemas(rootSchema), true);
+	else mergeSchemaIntoResult(result, rootSchema, true);
+	return result;
+};
+/**
+* Efficiently merges a source schema into a target result object.
+* Handles all schema merging logic in a single optimized function.
+*
+* @param result - The target schema object to merge into
+* @param schema - The source schema object to merge from
+* @param override - Whether to override existing properties (default: false)
+*/
+var 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 = [...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 = [...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;
+	}
+};
+/**
+* Efficiently merges properties into a result object without creating new objects.
+*/
+var 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
+		};
+	}
+};
+/**
+* Efficiently merges array items into a result object.
+*/
+var 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);
+};
+/**
+* Helper function for merging items that returns a new object.
+*/
+var 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;
+};
+//#endregion
+export { mergeAllOfSchemas };
+
+//# sourceMappingURL=merge-all-of-schemas.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge-all-of-schemas.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/merge-all-of-schemas.ts"],"sourcesContent":["import { objectKeys } from '@scalar/helpers/object/object-keys'\nimport { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport { resolve } from '@scalar/workspace-store/resolve'\nimport type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\nimport { isArraySchema } from '@scalar/workspace-store/schemas/v3.1/strict/type-guards'\n\n/**\n * Merges multiple OpenAPI schema objects into a single schema object.\n * Handles nested allOf compositions and merges properties recursively.\n *\n * @param schemas - Array of OpenAPI schema objects to merge\n * @param rootSchema - Optional root schema to merge with the result\n * @returns Merged schema object\n */\nexport const mergeAllOfSchemas = (schemas: SchemaObject | undefined, rootSchema?: SchemaObject): SchemaObject => {\n  // Handle max depth, empty or invalid input\n  if (!schemas?.allOf?.length || !Array.isArray(schemas.allOf)) {\n    return rootSchema || ({} as SchemaObject)\n  }\n\n  // Initialize result object once\n  const result = {} as SchemaObject\n\n  // Extract base schema properties (everything except allOf)\n  const { allOf: _, ...baseSchema } = schemas\n\n  // Process allOf schemas first\n  for (const _schema of schemas.allOf) {\n    if (!_schema || typeof _schema !== 'object') {\n      continue\n    }\n\n    // Resolve ref if present\n    const schema = resolve.schema(_schema)\n\n    // Handle nested allOf recursively\n    if (schema.allOf) {\n      const nestedMerged = mergeAllOfSchemas(schema)\n      mergeSchemaIntoResult(result, nestedMerged)\n      continue\n    }\n\n    mergeSchemaIntoResult(result, schema)\n  }\n\n  // Apply base schema properties with precedence over allOf properties\n  if (Object.keys(baseSchema).length > 0) {\n    mergeSchemaIntoResult(result, baseSchema, true)\n  }\n\n  // Process root schema last if provided\n  if (rootSchema && typeof rootSchema === 'object') {\n    if (rootSchema.allOf) {\n      const nestedMerged = mergeAllOfSchemas(rootSchema)\n      mergeSchemaIntoResult(result, nestedMerged, true)\n    } else {\n      mergeSchemaIntoResult(result, rootSchema, true)\n    }\n  }\n\n  return result\n}\n\n/**\n * Efficiently merges a source schema into a target result object.\n * Handles all schema merging logic in a single optimized function.\n *\n * @param result - The target schema object to merge into\n * @param schema - The source schema object to merge from\n * @param override - Whether to override existing properties (default: false)\n */\nconst mergeSchemaIntoResult = (result: SchemaObject, schema: SchemaObject, override: boolean = false): void => {\n  // Early return if schema is empty\n  const schemaKeys = objectKeys(schema)\n  if (schemaKeys.length === 0) {\n    return\n  }\n\n  // Loop through all schema properties and handle them appropriately\n  for (const key of schemaKeys) {\n    const value = getResolvedRef(schema[key]) as any\n\n    if (value === undefined) {\n      continue\n    }\n\n    // Required\n    if ((key as string) === 'required') {\n      // Merge required fields with deduplication\n      if (Array.isArray(value) && value.length > 0) {\n        // @ts-expect-error\n        if (result.required?.length) {\n          // @ts-expect-error\n          result.required = [...new Set([...result.required, ...value])]\n        } else {\n          // @ts-expect-error\n          result.required = value.slice()\n        }\n      }\n    }\n    // Properties\n    else if ((key as string) === 'properties') {\n      // Merge properties recursively\n      if (value && typeof value === 'object') {\n        // @ts-expect-error\n        if (!result.properties) {\n          // @ts-expect-error\n          result.properties = {}\n        }\n\n        // @ts-expect-error\n        mergePropertiesIntoResult(result.properties, value)\n      }\n    }\n    // Items\n    else if ((key as string) === 'items') {\n      // Handle items (for both arrays and objects with items)\n      const items = resolve.schema(value)\n      if (items) {\n        if (isArraySchema(schema)) {\n          // @ts-expect-error\n          if (!result.items) {\n            // @ts-expect-error\n            result.items = {}\n          }\n\n          // Handle allOf within array items\n          if (items.allOf) {\n            const mergedItems = mergeAllOfSchemas(items)\n            // @ts-expect-error\n            Object.assign(result.items, mergedItems)\n          } else {\n            // @ts-expect-error\n            mergeItemsIntoResult(getResolvedRef(result.items), items)\n          }\n        }\n        // For non-array types with items.allOf, merge into properties\n        else if (items.allOf) {\n          const mergedItems = mergeAllOfSchemas(items)\n          if ('properties' in mergedItems) {\n            if (!('properties' in result)) {\n              // @ts-expect-error\n              result.properties = {}\n            }\n\n            'properties' in result && mergePropertiesIntoResult(result.properties, mergedItems.properties)\n          }\n        }\n        // For non-array types without allOf, still set items if not already set\n        else if (!('items' in result)) {\n          // @ts-expect-error\n          result.items = items\n        }\n      }\n    }\n    // Enum\n    else if (key === 'enum') {\n      if (Array.isArray(value) && value.length > 0) {\n        result.enum = [...new Set([...(result.enum || []), ...value])]\n      }\n    }\n    // OneOf/AnyOf\n    else if (key === 'oneOf' || key === 'anyOf') {\n      // Merge oneOf/anyOf subschema\n      if (Array.isArray(value)) {\n        if (!('properties' in result)) {\n          // @ts-expect-error\n          result.properties = {}\n        }\n        for (const _option of value) {\n          const option = resolve.schema(_option)\n          if (option && 'properties' in option && 'properties' in result) {\n            mergePropertiesIntoResult(result.properties, option.properties)\n          }\n        }\n      }\n    }\n    // Skip allOf as it's handled at a higher level\n    else if (key === 'allOf') {\n      continue\n    }\n    // For all other properties, preserve the first occurrence or override if specified\n    else {\n      if (override || result[key] === undefined) {\n        result[key] = value\n      }\n    }\n  }\n}\n\n/**\n * Efficiently merges properties into a result object without creating new objects.\n */\nconst mergePropertiesIntoResult = (\n  result: Extract<SchemaObject, { type: 'object' }>['properties'],\n  properties: Extract<SchemaObject, { type: 'object' }>['properties'],\n): void => {\n  const propertyKeys = Object.keys(properties ?? {})\n  if (!properties || !result || propertyKeys.length === 0) {\n    return\n  }\n\n  for (const key of propertyKeys) {\n    const schema = resolve.schema(properties[key])\n    if (!schema) {\n      delete result[key]\n      continue\n    }\n\n    if (typeof schema !== 'object') {\n      result[key] = schema\n      continue\n    }\n\n    if (!result[key]) {\n      // Handle new property with allOf\n      if (schema.allOf) {\n        result[key] = mergeAllOfSchemas(schema)\n      } else if (isArraySchema(schema) && resolve.schema(schema.items)?.allOf) {\n        result[key] = {\n          ...schema,\n          items: mergeAllOfSchemas(resolve.schema(schema.items)),\n        }\n      } else if (properties[key]) {\n        result[key] = properties[key]\n      }\n      continue\n    }\n\n    // Merge existing property\n    const existing = resolve.schema(result[key])\n\n    if (schema.allOf) {\n      result[key] = mergeAllOfSchemas({ allOf: [existing, ...schema.allOf] } as SchemaObject)\n    } else if (isArraySchema(schema) && isArraySchema(existing) && schema.items) {\n      const existingItems = resolve.schema(existing.items)\n      result[key] = {\n        ...existing,\n        type: 'array',\n        items: existingItems ? mergeItems(existingItems, resolve.schema(schema.items)) : resolve.schema(schema.items),\n      }\n    } else {\n      // Create merged object with properties handled separately\n      if ('properties' in existing && 'properties' in schema) {\n        const merged = { ...existing, ...schema }\n        merged.properties = { ...existing.properties }\n        mergePropertiesIntoResult(merged.properties, schema.properties)\n        result[key] = merged\n      }\n      // Simple merge without property recursion\n      else {\n        result[key] = { ...schema, ...existing }\n      }\n    }\n  }\n}\n\n/**\n * Efficiently merges array items into a result object.\n */\nconst mergeItemsIntoResult = (result: SchemaObject, items: SchemaObject): void => {\n  // Handle allOf in items\n  if (items.allOf || result.allOf) {\n    // Build array without spreads for better performance\n    const allOfSchemas: SchemaObject[] = []\n\n    if (result.allOf) {\n      for (const schema of result.allOf) {\n        allOfSchemas.push(resolve.schema(schema))\n      }\n    } else {\n      allOfSchemas.push(result)\n    }\n\n    if (items.allOf) {\n      for (const schema of items.allOf) {\n        allOfSchemas.push(resolve.schema(schema))\n      }\n    } else {\n      allOfSchemas.push(items)\n    }\n\n    const merged = mergeAllOfSchemas({ allOf: allOfSchemas } as SchemaObject)\n    Object.assign(result, merged)\n    return\n  }\n\n  // Regular merge\n  Object.assign(result, items)\n\n  // Merge properties if both have them\n  if ('properties' in result && 'properties' in items) {\n    mergePropertiesIntoResult(result.properties, items.properties)\n  }\n}\n\n/**\n * Helper function for merging items that returns a new object.\n */\nconst mergeItems = (existing: SchemaObject, incoming: SchemaObject): SchemaObject => {\n  // Handle allOf in either schema\n  if (existing.allOf || incoming.allOf) {\n    // Build array without spreads for better performance\n    const allOfSchemas: SchemaObject[] = []\n\n    if (existing.allOf) {\n      for (const schema of existing.allOf) {\n        allOfSchemas.push(resolve.schema(schema))\n      }\n    } else {\n      allOfSchemas.push(existing)\n    }\n\n    if (incoming.allOf) {\n      for (const schema of incoming.allOf) {\n        allOfSchemas.push(resolve.schema(schema))\n      }\n    } else {\n      allOfSchemas.push(incoming)\n    }\n\n    return mergeAllOfSchemas({ allOf: allOfSchemas } as SchemaObject)\n  }\n\n  const merged = { ...existing, ...incoming }\n\n  // Recursively merge properties if both have properties\n  if ('properties' in existing && 'properties' in incoming) {\n    // @ts-expect-error\n    merged.properties = { ...existing.properties }\n    // @ts-expect-error\n    mergePropertiesIntoResult(merged.properties, incoming.properties)\n  }\n\n  return merged as SchemaObject\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,68 @@
+import { compositions } from "./schema-composition.js";
+import { resolve } from "@scalar/workspace-store/resolve";
+//#region src/components/Content/Schema/helpers/optimize-value-for-display.ts
+/**
+* Optimize the value by removing nulls from compositions and merging root properties.
+*
+* TODO: figure out what this does
+*/
+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;
+	}
+	if ((composition === "oneOf" || composition === "anyOf") && (hasRootProperties || filteredSchemas.some((schema) => schema.allOf))) {
+		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 };
+}
+//#endregion
+export { optimizeValueForDisplay };
+
+//# sourceMappingURL=optimize-value-for-display.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optimize-value-for-display.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/optimize-value-for-display.ts"],"sourcesContent":["import { resolve } from '@scalar/workspace-store/resolve'\nimport type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport { compositions } from './schema-composition'\n\n/**\n * Optimize the value by removing nulls from compositions and merging root properties.\n *\n * TODO: figure out what this does\n */\nexport function optimizeValueForDisplay(value: SchemaObject | undefined): SchemaObject | undefined {\n  if (!value || typeof value !== 'object') {\n    return value\n  }\n\n  // Find the composition keyword early to avoid unnecessary work\n  const composition = compositions.find((keyword) => keyword in value && keyword !== 'not')\n\n  // If there's no relevant composition keyword, return a shallow copy\n  if (!composition) {\n    return { ...value }\n  }\n\n  const schemas = value[composition]\n  if (!Array.isArray(schemas)) {\n    return { ...value }\n  }\n\n  // Extract root properties efficiently (excluding composition and nullable)\n  const { [composition]: _, nullable: originalNullable, ...rootProperties } = value as any\n  const hasRootProperties = Object.keys(rootProperties).length > 0\n\n  // Check for null schemas and filter them out in one pass\n  const { filteredSchemas, hasNullSchema } = schemas.reduce(\n    (acc, _schema) => {\n      const schema = resolve.schema(_schema)\n\n      if ('type' in schema && schema.type === 'null') {\n        acc.hasNullSchema = true\n      } else {\n        acc.filteredSchemas.push(schema)\n      }\n      return acc\n    },\n    { filteredSchemas: [] as SchemaObject[], hasNullSchema: false },\n  )\n\n  // Determine if nullable should be set\n  const shouldBeNullable = hasNullSchema || originalNullable === true\n\n  // If only one schema remains after filtering, merge with root properties\n  if (filteredSchemas.length === 1) {\n    const mergedSchema = { ...rootProperties, ...filteredSchemas[0] }\n    if (shouldBeNullable) {\n      mergedSchema.nullable = true\n    }\n    return mergedSchema\n  }\n\n  // Check if root properties should be merged into schemas\n  const shouldMergeRootProperties =\n    (composition === 'oneOf' || composition === 'anyOf') &&\n    (hasRootProperties || filteredSchemas.some((schema) => schema.allOf))\n\n  if (shouldMergeRootProperties) {\n    const mergedSchemas = filteredSchemas.map((_schema) => {\n      const schema = resolve.schema(_schema)\n\n      // Flatten single-item allOf and merge with root properties\n      if (schema.allOf?.length === 1) {\n        const { allOf, ...otherProps } = schema\n        return { ...rootProperties, ...otherProps, ...resolve.schema(allOf[0]) }\n      }\n      return { ...rootProperties, ...schema }\n    })\n\n    // @ts-expect-error - We avoid using coerceValue here as it may be dangerous, so we type cast\n    const result = { [composition]: mergedSchemas } as SchemaObject\n    if (shouldBeNullable) {\n      // @ts-expect-error We use nullable\n      result.nullable = true\n    }\n    return result\n  }\n\n  // Return with filtered schemas if any nulls were removed\n  if (filteredSchemas.length !== schemas.length) {\n    const result: SchemaObject = { ...value, [composition]: filteredSchemas }\n    if (shouldBeNullable) {\n      // @ts-expect-error We use nullable\n      result.nullable = true\n    }\n    return result\n  }\n\n  return { ...value }\n}\n"],"mappings":";;;;;;;;AAUA,SAAgB,wBAAwB,OAA2D;AACjG,KAAI,CAAC,SAAS,OAAO,UAAU,SAC7B,QAAO;CAIT,MAAM,cAAc,aAAa,MAAM,YAAY,WAAW,SAAS,YAAY,MAAM;AAGzF,KAAI,CAAC,YACH,QAAO,EAAE,GAAG,OAAO;CAGrB,MAAM,UAAU,MAAM;AACtB,KAAI,CAAC,MAAM,QAAQ,QAAQ,CACzB,QAAO,EAAE,GAAG,OAAO;CAIrB,MAAM,GAAG,cAAc,GAAG,UAAU,kBAAkB,GAAG,mBAAmB;CAC5E,MAAM,oBAAoB,OAAO,KAAK,eAAe,CAAC,SAAS;CAG/D,MAAM,EAAE,iBAAiB,kBAAkB,QAAQ,QAChD,KAAK,YAAY;EAChB,MAAM,SAAS,QAAQ,OAAO,QAAQ;AAEtC,MAAI,UAAU,UAAU,OAAO,SAAS,OACtC,KAAI,gBAAgB;MAEpB,KAAI,gBAAgB,KAAK,OAAO;AAElC,SAAO;IAET;EAAE,iBAAiB,EAAE;EAAoB,eAAe;EAAO,CAChE;CAGD,MAAM,mBAAmB,iBAAiB,qBAAqB;AAG/D,KAAI,gBAAgB,WAAW,GAAG;EAChC,MAAM,eAAe;GAAE,GAAG;GAAgB,GAAG,gBAAgB;GAAI;AACjE,MAAI,iBACF,cAAa,WAAW;AAE1B,SAAO;;AAQT,MAHG,gBAAgB,WAAW,gBAAgB,aAC3C,qBAAqB,gBAAgB,MAAM,WAAW,OAAO,MAAM,GAEvC;EAC7B,MAAM,gBAAgB,gBAAgB,KAAK,YAAY;GACrD,MAAM,SAAS,QAAQ,OAAO,QAAQ;AAGtC,OAAI,OAAO,OAAO,WAAW,GAAG;IAC9B,MAAM,EAAE,OAAO,GAAG,eAAe;AACjC,WAAO;KAAE,GAAG;KAAgB,GAAG;KAAY,GAAG,QAAQ,OAAO,MAAM,GAAG;KAAE;;AAE1E,UAAO;IAAE,GAAG;IAAgB,GAAG;IAAQ;IACvC;EAGF,MAAM,SAAS,GAAG,cAAc,eAAe;AAC/C,MAAI,iBAEF,QAAO,WAAW;AAEpB,SAAO;;AAIT,KAAI,gBAAgB,WAAW,QAAQ,QAAQ;EAC7C,MAAM,SAAuB;GAAE,GAAG;IAAQ,cAAc;GAAiB;AACzE,MAAI,iBAEF,QAAO,WAAW;AAEpB,SAAO;;AAGT,QAAO,EAAE,GAAG,OAAO"}

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

@@ -0,0 +1,11 @@
+//#region src/components/Content/Schema/helpers/schema-composition.ts
+var compositions = [
+	"oneOf",
+	"anyOf",
+	"allOf",
+	"not"
+];
+//#endregion
+export { compositions };
+
+//# sourceMappingURL=schema-composition.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-composition.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/schema-composition.ts"],"sourcesContent":["/** Composition */\nexport type CompositionKeyword = 'oneOf' | 'anyOf' | 'allOf' | 'not'\n\nexport const compositions: CompositionKeyword[] = ['oneOf', 'anyOf', 'allOf', 'not']\n"],"mappings":";AAGA,IAAa,eAAqC;CAAC;CAAS;CAAS;CAAS;CAAM"}

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

@@ -0,0 +1,23 @@
+import { getRefName } from "./get-ref-name.js";
+import { resolve } from "@scalar/workspace-store/resolve";
+//#region src/components/Content/Schema/helpers/schema-name.ts
+/**
+* Extract schema name from various schema formats
+*
+* Handles $ref, title, name, type, and schema dictionary lookup
+*/
+var 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;
+};
+//#endregion
+export { getModelNameFromSchema };
+
+//# sourceMappingURL=schema-name.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-name.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/schema-name.ts"],"sourcesContent":["import { resolve } from '@scalar/workspace-store/resolve'\nimport type { SchemaObject, SchemaReferenceType } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport { getRefName } from './get-ref-name'\n\n/**\n * Extract schema name from various schema formats\n *\n * Handles $ref, title, name, type, and schema dictionary lookup\n */\nexport const getModelNameFromSchema = (\n  schemaOrRef: SchemaObject | SchemaReferenceType<SchemaObject>,\n): string | null => {\n  if (!schemaOrRef) {\n    return null\n  }\n\n  const schema = resolve.schema(schemaOrRef)\n\n  // Direct title/name properties - use direct property access for better performance\n  if (schema.title) {\n    return schema.title\n  }\n\n  if (schema.name) {\n    return schema.name\n  }\n\n  if ('$ref' in schemaOrRef) {\n    // Fall back to the schema key when the referenced schema has no human-friendly name.\n    const refName = getRefName(schemaOrRef.$ref)\n    if (refName) {\n      return refName\n    }\n  }\n\n  return null\n}\n"],"mappings":";;;;;;;;AAUA,IAAa,0BACX,gBACkB;AAClB,KAAI,CAAC,YACH,QAAO;CAGT,MAAM,SAAS,QAAQ,OAAO,YAAY;AAG1C,KAAI,OAAO,MACT,QAAO,OAAO;AAGhB,KAAI,OAAO,KACT,QAAO,OAAO;AAGhB,KAAI,UAAU,aAAa;EAEzB,MAAM,UAAU,WAAW,YAAY,KAAK;AAC5C,MAAI,QACF,QAAO;;AAIX,QAAO"}

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

@@ -0,0 +1,17 @@
+//#region src/components/Content/Schema/helpers/should-display-description.ts
+/**
+* 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
+*/
+var shouldDisplayDescription = (schema, propDescription) => {
+	if (!schema) return null;
+	if (schema.allOf) return null;
+	return propDescription || schema.description || null;
+};
+//#endregion
+export { shouldDisplayDescription };
+
+//# sourceMappingURL=should-display-description.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"should-display-description.js","names":[],"sources":["../../../../../src/components/Content/Schema/helpers/should-display-description.ts"],"sourcesContent":["import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\n/**\n * Determine if description should be displayed\n *\n * @param schema - The schema object to check\n * @param propDescription - Optional description from props\n * @returns Description string to display, or null if should not be displayed\n */\nexport const shouldDisplayDescription = (schema: SchemaObject | undefined, propDescription?: string): string | null => {\n  if (!schema) {\n    return null\n  }\n\n  // Don't show description for schemas with compositions to avoid duplicate descriptions\n  if (schema.allOf) {\n    return null\n  }\n\n  return propDescription || schema.description || null\n}\n"],"mappings":";;;;;;;;AASA,IAAa,4BAA4B,QAAkC,oBAA4C;AACrH,KAAI,CAAC,OACH,QAAO;AAIT,KAAI,OAAO,MACT,QAAO;AAGT,QAAO,mBAAmB,OAAO,eAAe"}

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

@@ -0,0 +1,18 @@
+//#region src/components/Content/Schema/helpers/should-display-heading.ts
+/**
+* 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
+*/
+var 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;
+};
+//#endregion
+export { shouldDisplayHeading };
+
+//# sourceMappingURL=should-display-heading.js.map