@scalar/api-reference 1.38.1 → 1.39.0

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

@@ -1,39 +1,60 @@
-import { getResolvedRef as a } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import { isArraySchema as y } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
-import { getRefName as s } from "./get-ref-name.js";
-const p = (t) => t ? `array ${t.includes(" | ") ? `(${t})` : t}[]` : "array", i = (t, r = !1) => {
-  if (!t.items)
-    return r ? "array" : t.title || t.xml?.name || "array";
-  const e = c(t.items), n = p(e);
-  return r ? n : t.nullable ? `${n} | null` : n;
-}, c = (t) => {
-  if (!t)
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { isArraySchema } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
+import { getRefName } from "./get-ref-name.js";
+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 isUnionType ? "array" : value.title || value.xml?.name || "array";
+  }
+  const itemType = getSchemaType(value.items);
+  const baseType = formatArrayType(itemType);
+  if (isUnionType) {
+    return baseType;
+  }
+  return value.nullable ? `${baseType} | null` : baseType;
+};
+const getSchemaType = (valueOrRef) => {
+  if (!valueOrRef) {
     return "";
-  const r = a(t);
-  if (r.const !== void 0)
+  }
+  const value = getResolvedRef(valueOrRef);
+  if (value.const !== void 0) {
     return "const";
-  if ("type" in r && Array.isArray(r.type)) {
-    if (r.type.includes("array") && r.items) {
-      const e = i(r, !0), n = r.type.filter((o) => o !== "array");
-      return n.length > 0 ? `${e} | ${n.join(" | ")}` : e;
+  }
+  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 r.type.join(" | ");
-  }
-  if (y(r))
-    return i(r, !1);
-  if (r.title)
-    return r.title;
-  if (r.xml?.name)
-    return r.xml.name;
-  if ("type" in r && r.type && r.contentEncoding)
-    return `${r.type} • ${r.contentEncoding}`;
-  if ("$ref" in t) {
-    const e = s(t);
-    if (e)
-      return e;
-  }
-  return "type" in r ? r.type : "";
+    return value.type.join(" | ");
+  }
+  if (isArraySchema(value)) {
+    return processArrayType(value, false);
+  }
+  if (value.title) {
+    return value.title;
+  }
+  if (value.xml?.name) {
+    return value.xml.name;
+  }
+  if ("type" in value && value.type && value.contentEncoding) {
+    return `${value.type} • ${value.contentEncoding}`;
+  }
+  if ("$ref" in valueOrRef) {
+    const refName = getRefName(valueOrRef);
+    if (refName) {
+      return refName;
+    }
+  }
+  return "type" in value ? value.type : "";
 };
 export {
-  c as getSchemaType
+  getSchemaType
 };

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

@@ -1,17 +1,27 @@
-const s = (t) => {
-  if (t === null || typeof t != "object" || Array.isArray(t) || "oneOf" in t || "anyOf" in t || "allOf" in t || "not" in t)
-    return !1;
-  const r = "type" in t;
-  if (r && Array.isArray(t.type))
-    return t.type.includes("object");
-  const n = r && t.type === "object";
-  if (n)
-    return !0;
-  if (r && !n)
-    return !1;
-  const i = "properties" in t, o = "additionalProperties" in t, e = "patternProperties" in t;
-  return i || o || e;
+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 {
-  s as isTypeObject
+  isTypeObject
 };

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

@@ -1,135 +1,214 @@
-import { objectKeys as m } from "@scalar/helpers/object/object-keys";
-import { getResolvedRef as p } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import { isArraySchema as O } from "@scalar/workspace-store/schemas/v3.1/strict/type-guards";
-const l = (e, f) => {
-  if (!e?.allOf?.length || !Array.isArray(e.allOf))
-    return f || {};
-  const s = {}, { allOf: r, ...i } = e;
-  for (const o of e.allOf) {
-    if (!o || typeof o != "object")
+import { objectKeys } from "@scalar/helpers/object/object-keys";
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+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 t = p(o);
-    if (t.allOf) {
-      const n = l(t);
-      c(s, n);
+    }
+    const schema = getResolvedRef(_schema);
+    if (schema.allOf) {
+      const nestedMerged = mergeAllOfSchemas(schema);
+      mergeSchemaIntoResult(result, nestedMerged);
       continue;
     }
-    c(s, t);
+    mergeSchemaIntoResult(result, schema);
   }
-  if (Object.keys(i).length > 0 && c(s, i, !0), f && typeof f == "object")
-    if (f.allOf) {
-      const o = l(f);
-      c(s, o, !0);
-    } else
-      c(s, f, !0);
-  return s;
-}, c = (e, f, s = !1) => {
-  const r = m(f);
-  if (r.length !== 0)
-    for (const i of r) {
-      const o = p(f[i]);
-      if (o !== void 0)
-        if (i === "required")
-          Array.isArray(o) && o.length > 0 && (e.required?.length ? e.required = [.../* @__PURE__ */ new Set([...e.required, ...o])] : e.required = o.slice());
-        else if (i === "properties")
-          o && typeof o == "object" && (e.properties || (e.properties = {}), a(e.properties, o));
-        else if (i === "items") {
-          const t = p(o);
-          if (t)
-            if (O(f))
-              if (e.items || (e.items = {}), t.allOf) {
-                const n = l(t);
-                Object.assign(e.items, n);
-              } else
-                y(p(e.items), t);
-            else if (t.allOf) {
-              const n = l(t);
-              "properties" in n && ("properties" in e || (e.properties = {}), "properties" in e && a(e.properties, n.properties));
-            } else "items" in e || (e.items = t);
-        } else if (i === "enum")
-          Array.isArray(o) && o.length > 0 && (e.enum = [.../* @__PURE__ */ new Set([...e.enum || [], ...o])]);
-        else if (i === "oneOf" || i === "anyOf") {
-          if (Array.isArray(o)) {
-            "properties" in e || (e.properties = {});
-            for (const t of o) {
-              const n = p(t);
-              n.properties && "properties" in e && a(e.properties, n.properties);
+  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 = getResolvedRef(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 (i === "allOf")
-            continue;
-          (s || e[i] === void 0) && (e[i] = o);
+        } else if (!("items" in result)) {
+          result.items = items;
         }
-    }
-}, a = (e, f) => {
-  const s = Object.keys(f ?? {});
-  if (!(!f || !e || s.length === 0))
-    for (const r of s) {
-      const i = p(f[r]);
-      if (!i || typeof i != "object") {
-        e[r] = i;
-        continue;
       }
-      if (!e[r]) {
-        i.allOf ? e[r] = l(i) : O(i) && p(i.items)?.allOf ? e[r] = {
-          ...i,
-          items: l(p(i.items))
-        } : e[r] = f[r];
-        continue;
+    } else if (key === "enum") {
+      if (Array.isArray(value) && value.length > 0) {
+        result.enum = [.../* @__PURE__ */ new Set([...result.enum || [], ...value])];
       }
-      const o = p(e[r]);
-      if (i.allOf)
-        e[r] = l({ allOf: [o, ...i.allOf] });
-      else if (O(i) && O(o) && i.items) {
-        const t = p(o.items);
-        e[r] = {
-          ...o,
-          type: "array",
-          items: t ? h(t, p(i.items)) : p(i.items)
+    } else if (key === "oneOf" || key === "anyOf") {
+      if (Array.isArray(value)) {
+        if (!("properties" in result)) {
+          result.properties = {};
+        }
+        for (const _option of value) {
+          const option = getResolvedRef(_option);
+          if (option.properties && "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 = getResolvedRef(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) && getResolvedRef(schema.items)?.allOf) {
+        result[key] = {
+          ...schema,
+          items: mergeAllOfSchemas(getResolvedRef(schema.items))
         };
-      } else if ("properties" in o && "properties" in i) {
-        const t = { ...o, ...i };
-        t.properties = { ...o.properties }, a(t.properties, i.properties), e[r] = t;
-      } else
-        e[r] = { ...i, ...o };
+      } else if (properties[key]) {
+        result[key] = properties[key];
+      }
+      continue;
     }
-}, y = (e, f) => {
-  if (f.allOf || e.allOf) {
-    const s = [];
-    if (e.allOf)
-      for (const i of e.allOf)
-        s.push(p(i));
-    else
-      s.push(e);
-    if (f.allOf)
-      for (const i of f.allOf)
-        s.push(p(i));
-    else
-      s.push(f);
-    const r = l({ allOf: s });
-    Object.assign(e, r);
+    const existing = getResolvedRef(result[key]);
+    if (schema.allOf) {
+      result[key] = mergeAllOfSchemas({ allOf: [existing, ...schema.allOf] });
+    } else if (isArraySchema(schema) && isArraySchema(existing) && schema.items) {
+      const existingItems = getResolvedRef(existing.items);
+      result[key] = {
+        ...existing,
+        type: "array",
+        items: existingItems ? mergeItems(existingItems, getResolvedRef(schema.items)) : getResolvedRef(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(getResolvedRef(schema));
+      }
+    } else {
+      allOfSchemas.push(result);
+    }
+    if (items.allOf) {
+      for (const schema of items.allOf) {
+        allOfSchemas.push(getResolvedRef(schema));
+      }
+    } else {
+      allOfSchemas.push(items);
+    }
+    const merged = mergeAllOfSchemas({ allOf: allOfSchemas });
+    Object.assign(result, merged);
     return;
   }
-  Object.assign(e, f), "properties" in e && "properties" in f && a(e.properties, f.properties);
-}, h = (e, f) => {
-  if (e.allOf || f.allOf) {
-    const r = [];
-    if (e.allOf)
-      for (const i of e.allOf)
-        r.push(p(i));
-    else
-      r.push(e);
-    if (f.allOf)
-      for (const i of f.allOf)
-        r.push(p(i));
-    else
-      r.push(f);
-    return l({ allOf: r });
+  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(getResolvedRef(schema));
+      }
+    } else {
+      allOfSchemas.push(existing);
+    }
+    if (incoming.allOf) {
+      for (const schema of incoming.allOf) {
+        allOfSchemas.push(getResolvedRef(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);
   }
-  const s = { ...e, ...f };
-  return "properties" in e && "properties" in f && (s.properties = { ...e.properties }, a(s.properties, f.properties)), s;
+  return merged;
 };
 export {
-  l as mergeAllOfSchemas
+  mergeAllOfSchemas
 };

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

@@ -1 +1 @@
-{"version":3,"file":"optimize-value-for-display.d.ts","sourceRoot":"","sources":["../../../../../src/components/Content/Schema/helpers/optimize-value-for-display.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAIhG;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAuFjG"}
+{"version":3,"file":"optimize-value-for-display.d.ts","sourceRoot":"","sources":["../../../../../src/components/Content/Schema/helpers/optimize-value-for-display.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAIhG;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAsFjG"}

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

@@ -1,42 +1,64 @@
-import { getResolvedRef as h } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import { compositions as d } from "./schema-composition.js";
-function N(t) {
-  if (!t || typeof t != "object")
-    return t;
-  const r = d.find((e) => e in t && e !== "not");
-  if (!r)
-    return { ...t };
-  const i = t[r];
-  if (!Array.isArray(i))
-    return { ...t };
-  const { [r]: b, nullable: u, ...n } = t, m = Object.keys(n).length > 0, { filteredSchemas: o, hasNullSchema: a } = i.reduce(
-    (e, l) => {
-      const s = h(l);
-      return "type" in s && s.type === "null" ? e.hasNullSchema = !0 : e.filteredSchemas.push(s), e;
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+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 = getResolvedRef(_schema);
+      if ("type" in schema && schema.type === "null") {
+        acc.hasNullSchema = true;
+      } else {
+        acc.filteredSchemas.push(schema);
+      }
+      return acc;
     },
-    { filteredSchemas: [], hasNullSchema: !1 }
-  ), c = a || u === !0;
-  if (o.length === 1) {
-    const e = { ...n, ...o[0] };
-    return c && (e.nullable = !0), e;
+    { 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 ((r === "oneOf" || r === "anyOf") && (m || o.some((e) => e.allOf))) {
-    const e = o.map((s) => {
-      const f = h(s);
-      if (f.allOf?.length === 1) {
-        const { allOf: p, ...g } = f;
-        return { ...n, ...g, ...h(p[0]) };
+  const shouldMergeRootProperties = (composition === "oneOf" || composition === "anyOf") && (hasRootProperties || filteredSchemas.some((schema) => schema.allOf));
+  if (shouldMergeRootProperties) {
+    const mergedSchemas = filteredSchemas.map((_schema) => {
+      const schema = getResolvedRef(_schema);
+      if (schema.allOf?.length === 1) {
+        const { allOf, ...otherProps } = schema;
+        return { ...rootProperties, ...otherProps, ...getResolvedRef(allOf[0]) };
       }
-      return { ...n, ...f };
-    }), l = { [r]: e };
-    return c && (l.nullable = !0), l;
+      return { ...rootProperties, ...schema };
+    });
+    const result = { [composition]: mergedSchemas };
+    if (shouldBeNullable) {
+      result.nullable = true;
+    }
+    return result;
   }
-  if (o.length !== i.length) {
-    const e = { ...t, [r]: o };
-    return c && (e.nullable = !0), e;
+  if (filteredSchemas.length !== schemas.length) {
+    const result = { ...value, [composition]: filteredSchemas };
+    if (shouldBeNullable) {
+      result.nullable = true;
+    }
+    return result;
   }
-  return { ...t };
+  return { ...value };
 }
 export {
-  N as optimizeValueForDisplay
+  optimizeValueForDisplay
 };

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

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