cf-json-schema-viz 0.1.0

package/dist/index.js

@@ -0,0 +1,1195 @@
+import { isRootNode, isRegularNode, SchemaCombinerName, isMirroredNode, isReferenceNode, isBooleanishNode, SchemaNodeKind, SchemaTree } from '@stoplight/json-schema-tree';
+import { clsx } from 'clsx';
+import { atom, useSetAtom, useAtomValue, Provider } from 'jotai';
+import * as React2 from 'react';
+import { isPlainObject, extractPointerFromRef, pointerToPath, getLastPathSegment } from '@stoplight/json';
+import { atomFamily } from 'jotai/utils';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { CaretRight, CaretDown, Check, Warning } from '@phosphor-icons/react';
+import { Select as Select$1 } from '@base-ui/react/select';
+import { Menu } from '@base-ui/react/menu';
+
+// src/components/JsonSchemaViewer.tsx
+var JSVOptionsContext = React2.createContext({
+  defaultExpandedDepth: 0,
+  viewMode: "standalone",
+  hideExamples: false
+});
+var useJSVOptionsContext = () => React2.useContext(JSVOptionsContext);
+var JSVOptionsContextProvider = JSVOptionsContext.Provider;
+
+// src/guards/isNonNullable.ts
+function isNonNullable(maybeNullable) {
+  return maybeNullable !== void 0 && maybeNullable !== null;
+}
+
+// src/tree/utils.ts
+var isNonEmptyParentNode = (node) => isRegularNode(node) && !!node.children && node.children.length > 0;
+function isFlattenableNode(node) {
+  if (!isRegularNode(node)) return false;
+  if (!isArrayNode(node) && !isDictionaryNode(node) || !isNonNullable(node.children) || node.children.length === 0) {
+    return false;
+  }
+  return node.children.length === 1 && (isRegularNode(node.children[0]) && (!isArrayNode(node) || !isDictionaryNode(node.children[0])) || isReferenceNode(node.children[0]) && node.children[0].error !== null);
+}
+function isPrimitiveArray(node) {
+  return isFlattenableNode(node) && isArrayNode(node) && isRegularNode(node.children[0]) && node.children[0].simple;
+}
+function isPrimitiveDictionary(node) {
+  return isFlattenableNode(node) && isDictionaryNode(node) && isRegularNode(node.children[0]) && node.children[0].simple;
+}
+function isComplexArray(node) {
+  return isFlattenableNode(node) && isArrayNode(node) && isRegularNode(node.children[0]) && !node.children[0].simple;
+}
+function isComplexDictionary(node) {
+  return isFlattenableNode(node) && isDictionaryNode(node) && isRegularNode(node.children[0]) && !node.children[0].simple;
+}
+function isDictionaryNode(node) {
+  return isRegularNode(node) && node.primaryType === SchemaNodeKind.Object && isPlainObject(node.fragment.additionalProperties);
+}
+function isArrayNode(node) {
+  return isRegularNode(node) && node.primaryType === SchemaNodeKind.Array;
+}
+function visibleChildren(node) {
+  if (!isRegularNode(node) || isPrimitiveArray(node) || isPrimitiveDictionary(node)) {
+    return [];
+  }
+  if (isComplexArray(node) || isComplexDictionary(node)) {
+    return node.children[0].children ?? [];
+  }
+  return node.children ?? [];
+}
+function isPropertyRequired(schemaNode) {
+  const { parent } = schemaNode;
+  if (parent === null || !isRegularNode(parent) || schemaNode.subpath.length === 0) {
+    return false;
+  }
+  return !!parent.required?.includes(schemaNode.subpath[schemaNode.subpath.length - 1]);
+}
+function isValidViewMode(node, viewMode) {
+  const { validations } = node;
+  if (!!validations.writeOnly === !!validations.readOnly) {
+    return true;
+  }
+  return !(viewMode === "read" && !!validations.writeOnly || viewMode === "write" && !!validations.readOnly);
+}
+function isRenderableNode(node) {
+  if (node.parent === null) return true;
+  if (isDictionaryNode(node.parent)) {
+    return node.subpath.length !== 2 || node.subpath[0] !== "properties";
+  }
+  if (isArrayNode(node.parent)) {
+    return node.subpath[0] !== "additionalItems";
+  }
+  if (isRegularNode(node.parent) && node.parent.primaryType === SchemaNodeKind.Object && isBooleanishNode(node)) {
+    return !(node.subpath.length === 1 || node.subpath[0] === "additionalProperties");
+  }
+  return true;
+}
+function shouldNodeBeIncluded(node, viewMode = "standalone") {
+  return (isReferenceNode(node) || isRootNode(node) || isRenderableNode(node)) && (!isRegularNode(node) || isValidViewMode(node, viewMode));
+}
+var hoveredNodeAtom = atom(null);
+var isNodeHoveredAtom = atomFamily(
+  (node) => atom((get) => node === get(hoveredNodeAtom))
+);
+atomFamily(
+  (parent) => atom((get) => {
+    const hoveredNode = get(hoveredNodeAtom);
+    if (!hoveredNode || hoveredNode === parent) return false;
+    return hoveredNode.parent === parent;
+  })
+);
+
+// src/components/PathCrumbs/state.ts
+var pathCrumbsAtom = atom((get) => {
+  const node = get(hoveredNodeAtom);
+  if (!node) return [];
+  return propertyPathToObjectPath(node);
+});
+function propertyPathToObjectPath(node) {
+  const objectPath = [];
+  let currentNode = node;
+  while (currentNode && !isRootNode(currentNode)) {
+    if (isRegularNode(currentNode)) {
+      const pathPart = currentNode.subpath[currentNode.subpath.length - 1];
+      if (currentNode.primaryType === "array") {
+        const key = `${pathPart || ""}[]`;
+        if (objectPath[objectPath.length - 1]) {
+          objectPath[objectPath.length - 1] = key;
+        } else {
+          objectPath.push(key);
+        }
+      } else if (pathPart && (currentNode.subpath.length !== 2 || !["allOf", "oneOf", "anyOf"].includes(currentNode.subpath[0]))) {
+        objectPath.push(currentNode.subpath[currentNode.subpath.length - 1]);
+      }
+    }
+    currentNode = currentNode.parent;
+  }
+  return objectPath.reverse();
+}
+var SCROLL_THRESHOLD = 20;
+var PathCrumbs = ({ parentCrumbs = [] }) => {
+  const pathCrumbs = useAtomValue(pathCrumbsAtom);
+  const { disableCrumbs } = useJSVOptionsContext();
+  const crumbsRef = React2.useRef(null);
+  const [style, setStyle] = React2.useState({
+    position: "fixed",
+    top: -100,
+    // Start off-screen
+    left: 0,
+    width: 0
+  });
+  const [hasScrolled, setHasScrolled] = React2.useState(false);
+  React2.useEffect(() => {
+    const crumbsEl = crumbsRef.current;
+    if (!crumbsEl) return;
+    const scrollContainer = crumbsEl.closest(".jsv-root");
+    if (!scrollContainer) return;
+    const updatePosition = () => {
+      const containerRect = scrollContainer.getBoundingClientRect();
+      const scrolled = scrollContainer.scrollTop > SCROLL_THRESHOLD;
+      setHasScrolled(scrolled);
+      setStyle({
+        position: "fixed",
+        top: Math.max(0, containerRect.top),
+        left: containerRect.left,
+        width: containerRect.width
+      });
+    };
+    updatePosition();
+    scrollContainer.addEventListener("scroll", updatePosition);
+    window.addEventListener("scroll", updatePosition);
+    window.addEventListener("resize", updatePosition);
+    return () => {
+      scrollContainer.removeEventListener("scroll", updatePosition);
+      window.removeEventListener("scroll", updatePosition);
+      window.removeEventListener("resize", updatePosition);
+    };
+  }, []);
+  if (disableCrumbs) {
+    return null;
+  }
+  const parentCrumbElems = [];
+  parentCrumbs.forEach((crumb, i) => {
+    parentCrumbElems.push(/* @__PURE__ */ jsx("span", { children: crumb }, i));
+  });
+  const pathCrumbElems = [];
+  pathCrumbs.forEach((crumb, i) => {
+    if (pathCrumbs[i + 1]) {
+      pathCrumbElems.push(/* @__PURE__ */ jsx("span", { children: crumb }, i));
+    } else {
+      pathCrumbElems.push(
+        /* @__PURE__ */ jsx("span", { className: "jsv-crumb-current", children: crumb }, i)
+      );
+    }
+  });
+  const hasCrumbs = parentCrumbElems.length > 0 || pathCrumbElems.length > 0;
+  const isVisible = hasCrumbs && hasScrolled;
+  return /* @__PURE__ */ jsxs("div", { ref: crumbsRef, className: "jsv-crumbs", style, "data-visible": isVisible, children: [
+    parentCrumbElems.map((elem, i) => /* @__PURE__ */ jsxs(React2.Fragment, { children: [
+      elem,
+      i < parentCrumbElems.length - 1 && /* @__PURE__ */ jsx("span", { children: "/" })
+    ] }, `parent-${i}`)),
+    parentCrumbElems.length > 0 && pathCrumbElems.length > 0 && /* @__PURE__ */ jsx("span", { children: "/" }),
+    pathCrumbElems.map((elem, i) => /* @__PURE__ */ jsxs(React2.Fragment, { children: [
+      elem,
+      i < pathCrumbElems.length - 1 && /* @__PURE__ */ jsx("span", { style: { fontWeight: 700 }, children: "." })
+    ] }, `path-${i}`))
+  ] });
+};
+({
+  [SchemaCombinerName.AllOf]: "and",
+  [SchemaCombinerName.AnyOf]: "and/or",
+  [SchemaCombinerName.OneOf]: "or"
+});
+var COMMON_JSON_SCHEMA_AND_OAS_FORMATS = {
+  // strings are omitted because they are the default type to apply format to
+  number: ["byte", "int32", "int64", "float", "double"],
+  get integer() {
+    return this.number;
+  }
+};
+var COMBINER_NAME_MAP = {
+  allOf: "all of",
+  anyOf: "any of",
+  oneOf: "one of"
+};
+var SKIP_HASHING = false;
+function fnv1a52(str) {
+  const FNV_PRIME = 16777619;
+  const FNV_OFFSET = 2166136261;
+  let hash2 = FNV_OFFSET;
+  for (let i = 0; i < str.length; i++) {
+    hash2 ^= str.charCodeAt(i);
+    hash2 = Math.imul(hash2, FNV_PRIME);
+  }
+  const hash32 = hash2 >>> 0;
+  return hash32.toString(16).padStart(8, "0");
+}
+var hash = (value, skipHashing = SKIP_HASHING) => {
+  return skipHashing ? value : fnv1a52(value);
+};
+function getStoplightId(fragment) {
+  if (typeof fragment === "boolean") return void 0;
+  const xStoplight = fragment["x-stoplight"];
+  if (isPlainObject(xStoplight)) {
+    const id = xStoplight.id;
+    return typeof id === "string" ? id : void 0;
+  }
+  return void 0;
+}
+var getNodeId = (node, parentId) => {
+  const nodeId = getStoplightId(node.fragment);
+  if (nodeId) return nodeId;
+  const key = node.path[node.path.length - 1];
+  return hash(["schema_property", parentId, String(key)].join("-"));
+};
+var getOriginalNodeId = (node, parentId) => {
+  const nodeId = getStoplightId(node.originalFragment);
+  if (nodeId) return nodeId;
+  const key = node.path[node.path.length - 1];
+  return hash(["schema_property", parentId, String(key)].join("-"));
+};
+
+// src/utils/extractVendorExtensions.ts
+function extractVendorExtensions(fragment) {
+  if (typeof fragment === "boolean") {
+    return [0, {}];
+  }
+  const extensionKeys = Object.entries(fragment).filter(([key]) => key.startsWith("x-"));
+  let vendorExtensions = {};
+  for (const [key, value] of extensionKeys) {
+    vendorExtensions[key] = value;
+  }
+  return [extensionKeys.length, vendorExtensions];
+}
+var Caret = ({ isExpanded }) => /* @__PURE__ */ jsx(
+  "span",
+  {
+    className: clsx("jsv-caret", isExpanded && "jsv-caret-expanded"),
+    role: "button",
+    "aria-expanded": isExpanded,
+    children: /* @__PURE__ */ jsx(CaretRight, { size: 12, weight: "bold" })
+  }
+);
+var ChildStack = React2.memo(
+  ({
+    childNodes,
+    currentNestingLevel,
+    className,
+    RowComponent = SchemaRow,
+    parentNodeId,
+    parentChangeType
+  }) => {
+    const { renderRootTreeLines } = useJSVOptionsContext();
+    const rootLevel = renderRootTreeLines ? 0 : 1;
+    const isRootLevel = currentNestingLevel < rootLevel;
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: clsx(
+          "jsv-child-stack",
+          !isRootLevel && "jsv-child-stack-nested",
+          className
+        ),
+        "data-level": currentNestingLevel,
+        children: childNodes.map((childNode) => /* @__PURE__ */ jsx(
+          RowComponent,
+          {
+            schemaNode: childNode,
+            nestingLevel: currentNestingLevel + 1,
+            parentNodeId,
+            parentChangeType
+          },
+          childNode.id
+        ))
+      }
+    );
+  }
+);
+ChildStack.displayName = "ChildStack";
+var Description = ({ value }) => {
+  const [showAll, setShowAll] = React2.useState(false);
+  if (typeof value !== "string" || value.trim().length === 0) return null;
+  const paragraphs = value.split("\n\n");
+  if (paragraphs.length <= 1 || showAll) {
+    return /* @__PURE__ */ jsx("div", { className: "jsv-description", "data-test": "property-description", children: value });
+  }
+  const firstParagraph = paragraphs[0];
+  return /* @__PURE__ */ jsx("div", { className: "jsv-description", "data-test": "property-description", children: /* @__PURE__ */ jsxs("p", { children: [
+    /* @__PURE__ */ jsx("span", { className: "mr-1", children: firstParagraph }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: "text-jsv-primary cursor-pointer hover:underline",
+        onClick: () => setShowAll(true),
+        children: "Show all..."
+      }
+    )
+  ] }) });
+};
+var Divider = ({ hoveredAtom }) => {
+  const isHovered = useAtomValue(hoveredAtom);
+  return /* @__PURE__ */ jsx("span", { className: clsx("jsv-divider", isHovered && "jsv-divider-visible") });
+};
+function getInternalSchemaError(schemaNode) {
+  let errorMessage;
+  const fragment = schemaNode.fragment;
+  if (!isPlainObject(fragment)) return;
+  const xStoplight = fragment["x-stoplight"];
+  if (isPlainObject(xStoplight) && typeof xStoplight["error-message"] === "string") {
+    errorMessage = xStoplight["error-message"];
+  } else {
+    const fragmentErrorMessage = fragment["x-sl-error-message"];
+    if (typeof fragmentErrorMessage === "string") {
+      errorMessage = fragmentErrorMessage;
+    } else {
+      const items = fragment["items"];
+      if (isPlainObject(items)) {
+        const itemsErrorMessage = items["x-sl-error-message"];
+        if (typeof itemsErrorMessage === "string") {
+          errorMessage = itemsErrorMessage;
+        }
+      }
+    }
+  }
+  return errorMessage;
+}
+function useRefNode(schemaNode) {
+  return React2.useMemo(() => {
+    if (isReferenceNode(schemaNode)) {
+      return schemaNode;
+    }
+    if (isRegularNode(schemaNode) && (isFlattenableNode(schemaNode) || schemaNode.primaryType === SchemaNodeKind.Array && schemaNode.children?.length === 1)) {
+      return schemaNode.children?.find(isReferenceNode) ?? null;
+    }
+    return null;
+  }, [schemaNode]);
+}
+var Error = ({ schemaNode }) => {
+  const refNode = useRefNode(schemaNode);
+  const error = getInternalSchemaError(schemaNode) ?? refNode?.error;
+  if (typeof error !== "string") return null;
+  return /* @__PURE__ */ jsx("span", { className: "inline-block ml-1.5", title: error, children: /* @__PURE__ */ jsx(Warning, { className: "jsv-error", size: 16, "aria-label": error }) });
+};
+var NodeAnnotation = ({ change, style }) => {
+  if (!change) return null;
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: clsx(
+        "jsv-annotation",
+        change.type === "added" && "jsv-annotation-added",
+        change.type === "removed" && "jsv-annotation-removed",
+        change.type === "modified" && "jsv-annotation-modified"
+      ),
+      style,
+      "aria-label": `${change.type} property`
+    }
+  );
+};
+var useHasProperties = ({ required, deprecated, validations: { readOnly, writeOnly } }) => {
+  const { viewMode } = useJSVOptionsContext();
+  const showVisibilityValidations = viewMode === "standalone" && !!readOnly !== !!writeOnly;
+  return deprecated || showVisibilityValidations || required;
+};
+var Properties = ({
+  required,
+  deprecated,
+  validations: { readOnly, writeOnly }
+}) => {
+  const { viewMode } = useJSVOptionsContext();
+  const showVisibilityValidations = viewMode === "standalone" && !!readOnly !== !!writeOnly;
+  const visibility = showVisibilityValidations ? readOnly ? /* @__PURE__ */ jsx("span", { className: "jsv-badge jsv-badge-readonly", "data-test": "property-read-only", children: "read-only" }) : /* @__PURE__ */ jsx("span", { className: "jsv-badge jsv-badge-readonly", "data-test": "property-write-only", children: "write-only" }) : null;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    deprecated ? /* @__PURE__ */ jsx("span", { className: "jsv-badge jsv-badge-deprecated", "data-test": "property-deprecated", children: "deprecated" }) : null,
+    visibility,
+    required && /* @__PURE__ */ jsx("span", { className: "jsv-badge jsv-badge-required", "data-test": "property-required", children: "required" })
+  ] });
+};
+var Select = ({
+  "aria-label": ariaLabel,
+  options,
+  value,
+  onChange,
+  prefix
+}) => {
+  return /* @__PURE__ */ jsxs(
+    Select$1.Root,
+    {
+      value,
+      onValueChange: (newValue) => {
+        if (newValue !== null) {
+          onChange(newValue);
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsxs(
+          Select$1.Trigger,
+          {
+            "aria-label": ariaLabel,
+            className: "jsv-select-trigger",
+            children: [
+              /* @__PURE__ */ jsx(Select$1.Value, { placeholder: "", children: (val) => {
+                const selectedOption = options.find((opt) => opt.value === val);
+                return /* @__PURE__ */ jsxs(Fragment, { children: [
+                  prefix,
+                  selectedOption?.label ?? val
+                ] });
+              } }),
+              /* @__PURE__ */ jsx(Select$1.Icon, { children: /* @__PURE__ */ jsx(CaretDown, { size: 12 }) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(Select$1.Portal, { children: /* @__PURE__ */ jsx(Select$1.Positioner, { className: "jsv-select-positioner", sideOffset: 4, children: /* @__PURE__ */ jsx(Select$1.Popup, { className: "jsv-select-popup", children: options.map((option) => /* @__PURE__ */ jsxs(
+          Select$1.Item,
+          {
+            value: option.value,
+            className: "jsv-select-item",
+            children: [
+              /* @__PURE__ */ jsx(Select$1.ItemIndicator, { className: "jsv-select-item-indicator", children: /* @__PURE__ */ jsx(Check, { size: 12, weight: "bold" }) }),
+              /* @__PURE__ */ jsx(Select$1.ItemText, { children: option.label })
+            ]
+          },
+          option.value
+        )) }) }) })
+      ]
+    }
+  );
+};
+function getApplicableFormats(schemaNode) {
+  const fragment = schemaNode.fragment;
+  if (isPlainObject(fragment) && fragment["contentMediaType"] === "application/octet-stream" && schemaNode.types && schemaNode.types.length > 0) {
+    return [schemaNode.types[0], "binary"];
+  }
+  if (schemaNode.format === null) {
+    return null;
+  }
+  if (schemaNode.types !== null) {
+    for (const type of schemaNode.types) {
+      if (!(type in COMMON_JSON_SCHEMA_AND_OAS_FORMATS)) continue;
+      if (COMMON_JSON_SCHEMA_AND_OAS_FORMATS[type].includes(schemaNode.format)) {
+        return [type, schemaNode.format];
+      }
+    }
+  }
+  return [SchemaNodeKind.String, schemaNode.format];
+}
+
+// src/utils/printName.ts
+function upperFirst(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function printName(schemaNode, { shouldUseRefNameFallback = false } = {}) {
+  if (!isFlattenableNode(schemaNode)) {
+    return schemaNode.title ?? (shouldUseRefNameFallback ? getNodeNameFromOriginalRef(schemaNode) : void 0);
+  }
+  return printFlattenedName(schemaNode, { shouldUseRefNameFallback });
+}
+function printFlattenedName(schemaNode, { shouldUseRefNameFallback = false }) {
+  if (!isNonNullable(schemaNode.children) || schemaNode.children.length === 0) {
+    return schemaNode.title ?? (shouldUseRefNameFallback ? getNodeNameFromOriginalRef(schemaNode) : void 0);
+  }
+  if (schemaNode.children.length === 1 && isReferenceNode(schemaNode.children[0])) {
+    const value = `$ref(${schemaNode.children[0].value})`;
+    return isDictionaryNode(schemaNode) ? `dictionary[string, ${value}]` : `${value}[]`;
+  }
+  const format = isDictionaryNode(schemaNode) ? "dictionary[string, %s]" : "array[%s]";
+  if (isPrimitiveArray(schemaNode) || isPrimitiveDictionary(schemaNode)) {
+    const val = schemaNode.children?.reduce((mergedTypes, child) => {
+      if (mergedTypes === null) return null;
+      if (!isRegularNode(child)) return null;
+      if (child.types !== null && child.types.length > 0) {
+        const formats = getApplicableFormats(child);
+        for (const type of child.types) {
+          if (mergedTypes.includes(type)) continue;
+          if (formats !== null && formats[0] === type) {
+            mergedTypes.push(`${type}<${formats[1]}>`);
+          } else {
+            mergedTypes.push(type);
+          }
+        }
+      }
+      return mergedTypes;
+    }, []) ?? null;
+    if (val !== null && val.length > 0) {
+      return format.replace("%s", val.join(" or "));
+    }
+    return isDictionaryNode(schemaNode) ? "dictionary[string, any]" : "array";
+  }
+  if (isComplexArray(schemaNode) || isComplexDictionary(schemaNode)) {
+    const firstChild = schemaNode.children[0];
+    if (firstChild.title) {
+      return format.replace("%s", firstChild.title);
+    } else if (shouldUseRefNameFallback && getNodeNameFromOriginalRef(schemaNode)) {
+      return format.replace("%s", getNodeNameFromOriginalRef(schemaNode) ?? "any");
+    } else if (firstChild.primaryType) {
+      return format.replace("%s", firstChild.primaryType);
+    } else if (firstChild.combiners?.length) {
+      return format.replace("%s", firstChild.combiners.join(" "));
+    }
+    return isComplexArray(schemaNode) ? "array" : format.replace("%s", "any");
+  }
+  return void 0;
+}
+function getNodeNameFromOriginalRef(node) {
+  if (typeof node.originalFragment.$ref === "string") {
+    return upperFirst(getLastPathSegment(node.originalFragment.$ref));
+  }
+  return void 0;
+}
+function shouldRenderName(type) {
+  return type === SchemaNodeKind.Array || type === SchemaNodeKind.Object || type === "$ref";
+}
+function getTypes(schemaNode) {
+  return [schemaNode.types, schemaNode.combiners].reduce(
+    (values, value) => {
+      if (value === null) {
+        return values;
+      }
+      values.push(...value);
+      return values;
+    },
+    []
+  );
+}
+var Types = ({ schemaNode }) => {
+  if (isReferenceNode(schemaNode)) {
+    return /* @__PURE__ */ jsx("span", { className: "jsv-type", "data-test": "property-type-ref", children: schemaNode.value ?? "$ref" });
+  }
+  if (isBooleanishNode(schemaNode)) {
+    return /* @__PURE__ */ jsx("span", { className: "jsv-type", "data-test": "property-type", children: schemaNode.fragment ? "any" : "never" });
+  }
+  if (!isRegularNode(schemaNode)) {
+    return null;
+  }
+  const formats = getApplicableFormats(schemaNode);
+  const types = getTypes(schemaNode);
+  if (types.length === 0) {
+    return /* @__PURE__ */ jsx("span", { className: "jsv-type", "data-test": "property-type", children: formats === null ? "any" : `<${formats[1]}>` });
+  }
+  const rendered = types.map((type, i, { length }) => {
+    let printedName;
+    if (shouldRenderName(type)) {
+      printedName = printName(schemaNode);
+    }
+    printedName ?? (printedName = type + (formats === null || formats[0] !== type ? "" : `<${formats[1]}>`));
+    return /* @__PURE__ */ jsxs(React2.Fragment, { children: [
+      /* @__PURE__ */ jsx("span", { className: "jsv-type", "data-test": "property-type", children: printedName }),
+      i < length - 1 && /* @__PURE__ */ jsx("span", { className: "jsv-type", children: " or " }, `${i}-sep`)
+    ] }, type);
+  });
+  return rendered.length > 1 ? /* @__PURE__ */ jsx("span", { className: "truncate", children: rendered }) : /* @__PURE__ */ jsx(Fragment, { children: rendered });
+};
+Types.displayName = "JsonSchemaViewer.Types";
+var numberValidationNames = [
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "exclusiveMinimum",
+  "exclusiveMaximum"
+];
+var exampleValidationNames = ["examples"];
+var excludedValidations = ["exclusiveMinimum", "exclusiveMaximum", "readOnly", "writeOnly"];
+var numberValidationFormatters = {
+  minimum: (value) => `>= ${value}`,
+  exclusiveMinimum: (value) => `> ${value}`,
+  minItems: (value) => `>= ${value} items`,
+  minLength: (value) => `>= ${value} characters`,
+  maximum: (value) => `<= ${value}`,
+  exclusiveMaximum: (value) => `< ${value}`,
+  maxItems: (value) => `<= ${value} items`,
+  maxLength: (value) => `<= ${value} characters`
+};
+var createStringFormatter = (nowrap) => (value) => {
+  return nowrap && typeof value === "string" ? value : JSON.stringify(value);
+};
+var createValidationsFormatter = (name, options) => (value) => {
+  const values = Array.isArray(value) ? value : [value];
+  if (values.length) {
+    return {
+      name: options?.exact ? name : values.length > 1 ? `${name}s` : `${name}`,
+      values: values.map(createStringFormatter(options?.nowrap))
+    };
+  }
+  return null;
+};
+var validationFormatters = {
+  enum: createValidationsFormatter("Allowed value", { nowrap: true }),
+  examples: createValidationsFormatter("Example", { nowrap: true }),
+  multipleOf: createValidationsFormatter("Multiple of", { exact: true }),
+  pattern: createValidationsFormatter("Match pattern", { exact: true, nowrap: true }),
+  default: createValidationsFormatter("Default", { exact: true, nowrap: true }),
+  style: createValidationsFormatter("Style", { exact: true, nowrap: true })
+};
+var oasFormats = {
+  int32: {
+    minimum: 0 - 2 ** 31,
+    maximum: 2 ** 31 - 1
+  },
+  int64: {
+    minimum: Number.MIN_SAFE_INTEGER,
+    maximum: Number.MAX_SAFE_INTEGER
+  },
+  float: {
+    minimum: 0 - 2 ** 128,
+    maximum: 2 ** 128 - 1
+  },
+  double: {
+    minimum: 0 - Number.MAX_VALUE,
+    maximum: Number.MAX_VALUE
+  },
+  byte: {
+    pattern: "^[\\w\\d+\\/=]*$"
+  }
+};
+function isOasFormat(format) {
+  return format in oasFormats;
+}
+function filterOutOasFormatValidations(format, values) {
+  if (!isOasFormat(format)) {
+    return values;
+  }
+  const newValues = { ...values };
+  for (const [key, value] of Object.entries(oasFormats[format])) {
+    if (value === newValues[key]) {
+      delete newValues[key];
+    }
+  }
+  return newValues;
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function uniq(arr) {
+  return [...new Set(arr)];
+}
+var Validations = ({ validations, hideExamples }) => {
+  const numberValidations = pick(validations, numberValidationNames);
+  const keyValueValidations = omit(validations, [
+    ...Object.keys(numberValidations),
+    ...excludedValidations,
+    ...hideExamples ? exampleValidationNames : []
+  ]);
+  return /* @__PURE__ */ jsxs("div", { className: "jsv-validations", children: [
+    /* @__PURE__ */ jsx(NumberValidations, { validations: numberValidations }),
+    /* @__PURE__ */ jsx(KeyValueValidations, { validations: keyValueValidations })
+  ] });
+};
+var NumberValidations = ({ validations }) => {
+  const entries = Object.entries(validations);
+  if (!entries.length) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx("div", { className: "jsv-validations-row", "data-test": "property-validation", children: entries.map(([key, value]) => numberValidationFormatters[key](value)).map((value, i) => /* @__PURE__ */ jsx(Value, { name: value }, i)) });
+};
+var KeyValueValidations = ({ validations }) => /* @__PURE__ */ jsx(Fragment, { children: Object.keys(validations).filter((key) => Object.keys(validationFormatters).includes(key) && validations[key] !== void 0).map((key) => {
+  const validation = validationFormatters[key](validations[key]);
+  if (validation) {
+    return /* @__PURE__ */ jsx(KeyValueValidation, { name: validation.name, values: validation.values }, key);
+  } else {
+    return null;
+  }
+}) });
+var KeyValueValidation = ({ name, values }) => {
+  return /* @__PURE__ */ jsxs("div", { className: "jsv-validation", "data-test": "property-validation", children: [
+    /* @__PURE__ */ jsxs("span", { className: "jsv-validation-label", children: [
+      capitalize(name),
+      ":"
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "jsv-validation-values", children: uniq(values).map((value) => /* @__PURE__ */ jsx(Value, { name: value }, value)) })
+  ] });
+};
+var Value = ({ name }) => /* @__PURE__ */ jsx("span", { className: "jsv-validation-value", children: name });
+var getArrayValidations = (schemaNode) => {
+  if (schemaNode.children?.length === 1 && isRegularNode(schemaNode.children[0])) {
+    if (schemaNode.children[0].enum !== null) {
+      return { enum: schemaNode.children[0].enum };
+    } else if (schemaNode.children[0].fragment.pattern !== void 0) {
+      return { pattern: schemaNode.children[0].fragment.pattern };
+    }
+  }
+  return null;
+};
+function getValidationsFromSchema(schemaNode) {
+  return {
+    ...schemaNode.enum !== null ? { enum: schemaNode.enum } : schemaNode.primaryType === "array" ? (
+      // in case schemaNode is type: "array", check if its child has an additional validation
+      getArrayValidations(schemaNode)
+    ) : null,
+    ..."annotations" in schemaNode ? {
+      ...schemaNode.annotations.default !== void 0 ? { default: schemaNode.annotations.default } : null,
+      ...schemaNode.annotations.examples ? { examples: schemaNode.annotations.examples } : null
+    } : null,
+    ...getFilteredValidations(schemaNode)
+  };
+}
+function getFilteredValidations(schemaNode) {
+  if (schemaNode.format !== null) {
+    return filterOutOasFormatValidations(schemaNode.format, schemaNode.validations);
+  }
+  return schemaNode.validations;
+}
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function calculateChoiceTitle(node, isPlural) {
+  const primitiveSuffix = isPlural ? "s" : "";
+  if (isRegularNode(node)) {
+    const realName = printName(node, { shouldUseRefNameFallback: true });
+    if (realName) {
+      return realName;
+    }
+    return node.primaryType !== null ? node.primaryType + primitiveSuffix : String(node.originalFragment.title || "any");
+  }
+  if (isReferenceNode(node)) {
+    if (node.value) {
+      const value = extractPointerFromRef(node.value);
+      const lastPiece = !node.error && value ? last(pointerToPath(value)) : null;
+      if (typeof lastPiece === "string") {
+        return lastPiece.split(".")[0];
+      }
+    }
+    return "$ref" + primitiveSuffix;
+  }
+  return "any";
+}
+function makeChoice(node) {
+  return {
+    type: node,
+    title: calculateChoiceTitle(node, false)
+  };
+}
+function makeArrayChoice(node, combiner) {
+  const itemTitle = calculateChoiceTitle(node, true);
+  const title = itemTitle !== "any" ? `array ${combiner ? `(${combiner})` : null} [${itemTitle}]` : "array";
+  return {
+    type: node,
+    title
+  };
+}
+var useChoices = (schemaNode) => {
+  const choices = React2.useMemo(() => {
+    if (isComplexArray(schemaNode) && isNonEmptyParentNode(schemaNode.children[0]) && shouldShowChildSelector(schemaNode.children[0])) {
+      return schemaNode.children[0].children.map(
+        (child) => makeArrayChoice(child, schemaNode.children[0].combiners?.[0])
+      );
+    }
+    if (isNonEmptyParentNode(schemaNode) && shouldShowChildSelector(schemaNode)) {
+      return schemaNode.children.map(makeChoice);
+    }
+    return [makeChoice(schemaNode)];
+  }, [schemaNode]);
+  const defaultChoice = choices[0];
+  const [selectedChoice, setSelectedChoice] = React2.useState(defaultChoice);
+  React2.useEffect(() => {
+    setSelectedChoice(defaultChoice);
+  }, [defaultChoice]);
+  const actualSelectedChoice = selectedChoice && choices.includes(selectedChoice) ? selectedChoice : defaultChoice;
+  return { selectedChoice: actualSelectedChoice, setSelectedChoice, choices };
+};
+var shouldShowChildSelector = (schemaNode) => isNonEmptyParentNode(schemaNode) && ["anyOf", "oneOf"].includes(schemaNode.combiners?.[0] ?? "");
+var SchemaRow = React2.memo(
+  ({ schemaNode, nestingLevel, pl, parentNodeId, parentChangeType }) => {
+    const {
+      defaultExpandedDepth,
+      renderRowAddon,
+      renderExtensionAddon,
+      onGoToRef,
+      hideExamples,
+      renderRootTreeLines,
+      nodeHasChanged,
+      viewMode
+    } = useJSVOptionsContext();
+    const setHoveredNode = useSetAtom(hoveredNodeAtom);
+    const nodeId = getNodeId(schemaNode, parentNodeId);
+    const originalNodeId = schemaNode.originalFragment?.$ref ? getOriginalNodeId(schemaNode, parentNodeId) : nodeId;
+    const mode = viewMode === "standalone" ? void 0 : viewMode;
+    const hasChanged = nodeHasChanged?.({ nodeId: originalNodeId, mode });
+    const [isExpanded, setExpanded] = React2.useState(
+      !isMirroredNode(schemaNode) && nestingLevel <= defaultExpandedDepth
+    );
+    const { selectedChoice, setSelectedChoice, choices } = useChoices(schemaNode);
+    const typeToShow = selectedChoice.type;
+    const description = isRegularNode(typeToShow) ? typeToShow.annotations.description : null;
+    const rootLevel = renderRootTreeLines ? 1 : 2;
+    const childNodes = React2.useMemo(() => visibleChildren(typeToShow), [typeToShow]);
+    const combiner = isRegularNode(schemaNode) && schemaNode.combiners?.length ? schemaNode.combiners[0] : null;
+    const isCollapsible = childNodes.length > 0;
+    const isRootLevel = nestingLevel < rootLevel;
+    const required = isPropertyRequired(schemaNode);
+    const deprecated = isRegularNode(schemaNode) && schemaNode.deprecated;
+    const validations = isRegularNode(schemaNode) ? schemaNode.validations : {};
+    const hasProperties = useHasProperties({ required, deprecated, validations });
+    const [totalVendorExtensions, vendorExtensions] = React2.useMemo(
+      () => extractVendorExtensions(schemaNode.fragment),
+      [schemaNode.fragment]
+    );
+    const hasVendorProperties = totalVendorExtensions > 0;
+    const annotationRootOffset = renderRootTreeLines ? 0 : 8;
+    let annotationLeftOffset = -20 - annotationRootOffset;
+    if (nestingLevel > 1) {
+      annotationLeftOffset = -1 * 29 * Math.max(nestingLevel - 1, 1) - Math.min(nestingLevel, 2) * 2 - 16 - annotationRootOffset;
+      if (!renderRootTreeLines) {
+        annotationLeftOffset += 27;
+      }
+    }
+    if (parentChangeType === "added" && hasChanged && hasChanged.type === "removed") {
+      return null;
+    }
+    if (parentChangeType === "removed" && hasChanged && hasChanged.type === "added") {
+      return null;
+    }
+    const lastSubpath = schemaNode.subpath.length > 0 ? schemaNode.subpath[schemaNode.subpath.length - 1] : null;
+    const isHoveredAtom = isNodeHoveredAtom(schemaNode);
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: "jsv-row",
+          style: { paddingLeft: pl ? `${pl * 0.25}rem` : void 0 },
+          "data-id": originalNodeId,
+          "data-test": "schema-row",
+          onMouseEnter: (e) => {
+            e.stopPropagation();
+            setHoveredNode(selectedChoice.type);
+          },
+          children: [
+            !isRootLevel && /* @__PURE__ */ jsx("span", { className: clsx("jsv-nubbin", isCollapsible && "jsv-nubbin-short") }),
+            parentChangeType !== "added" && parentChangeType !== "removed" ? /* @__PURE__ */ jsx(NodeAnnotation, { change: hasChanged, style: { left: annotationLeftOffset } }) : null,
+            /* @__PURE__ */ jsxs("div", { className: clsx("jsv-row-content", isCollapsible && !isRootLevel && "jsv-ml-2"), children: [
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  className: clsx("jsv-row-header", isCollapsible && "jsv-cursor-pointer"),
+                  onClick: isCollapsible ? () => setExpanded(!isExpanded) : void 0,
+                  children: [
+                    isCollapsible ? /* @__PURE__ */ jsx(Caret, { isExpanded }) : null,
+                    /* @__PURE__ */ jsxs("div", { className: "jsv-types-container", children: [
+                      schemaNode.subpath.length > 0 && shouldShowPropertyName(schemaNode) && /* @__PURE__ */ jsx(
+                        "span",
+                        {
+                          className: "jsv-property-name",
+                          "data-test": `property-name-${lastSubpath}`,
+                          children: lastSubpath
+                        }
+                      ),
+                      choices.length === 1 && /* @__PURE__ */ jsx(Types, { schemaNode: typeToShow }),
+                      onGoToRef && isReferenceNode(schemaNode) && schemaNode.external ? /* @__PURE__ */ jsx(
+                        "a",
+                        {
+                          href: "#",
+                          className: "jsv-link",
+                          onClick: (e) => {
+                            e.preventDefault();
+                            e.stopPropagation();
+                            onGoToRef(schemaNode);
+                          },
+                          children: "(go to ref)"
+                        }
+                      ) : null,
+                      schemaNode.subpath.length > 1 && schemaNode.subpath[0] === "patternProperties" ? /* @__PURE__ */ jsx("span", { className: "jsv-type jsv-ml-2", children: "(pattern property)" }) : null,
+                      choices.length > 1 && /* @__PURE__ */ jsx(
+                        Select,
+                        {
+                          "aria-label": "Pick a type",
+                          prefix: combiner ? `${COMBINER_NAME_MAP[combiner]}: ` : void 0,
+                          options: choices.map((choice, index) => ({
+                            value: String(index),
+                            label: choice.title
+                          })),
+                          value: String(choices.indexOf(selectedChoice)),
+                          onChange: (selectedIndex) => setSelectedChoice(choices[Number(selectedIndex)])
+                        }
+                      )
+                    ] }),
+                    hasProperties && /* @__PURE__ */ jsx(Divider, { hoveredAtom: isHoveredAtom }),
+                    /* @__PURE__ */ jsx(Properties, { required, deprecated, validations })
+                  ]
+                }
+              ),
+              typeof description === "string" && (!combiner || schemaNode.parent?.fragment.description !== description) && description.length > 0 && /* @__PURE__ */ jsx(Description, { value: description }),
+              /* @__PURE__ */ jsx(
+                Validations,
+                {
+                  validations: isRegularNode(schemaNode) ? getValidationsFromSchema(schemaNode) : {},
+                  hideExamples
+                }
+              ),
+              hasVendorProperties && renderExtensionAddon ? /* @__PURE__ */ jsx("div", { children: renderExtensionAddon({ schemaNode, nestingLevel, vendorExtensions }) }) : null
+            ] }),
+            /* @__PURE__ */ jsx(Error, { schemaNode }),
+            renderRowAddon ? /* @__PURE__ */ jsx("div", { children: renderRowAddon({ schemaNode, nestingLevel }) }) : null
+          ]
+        }
+      ),
+      isCollapsible && isExpanded ? /* @__PURE__ */ jsx(
+        ChildStack,
+        {
+          schemaNode,
+          childNodes,
+          currentNestingLevel: nestingLevel,
+          parentNodeId: nodeId,
+          parentChangeType: parentChangeType ? parentChangeType : hasChanged ? hasChanged?.type : void 0
+        }
+      ) : null
+    ] });
+  }
+);
+SchemaRow.displayName = "SchemaRow";
+function shouldShowPropertyName(schemaNode) {
+  return schemaNode.subpath.length === 2 && (schemaNode.subpath[0] === "properties" || schemaNode.subpath[0] === "patternProperties");
+}
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}
+function getStoplightId2(fragment) {
+  if (typeof fragment === "boolean") return void 0;
+  const xStoplight = fragment["x-stoplight"];
+  if (isPlainObject(xStoplight)) {
+    const id = xStoplight.id;
+    return typeof id === "string" ? id : void 0;
+  }
+  return void 0;
+}
+var TopLevelSchemaRow = ({
+  schemaNode,
+  skipDescription
+}) => {
+  const { renderExtensionAddon } = useJSVOptionsContext();
+  const { selectedChoice, setSelectedChoice, choices } = useChoices(schemaNode);
+  const childNodes = React2.useMemo(() => visibleChildren(selectedChoice.type), [selectedChoice.type]);
+  const nestingLevel = 0;
+  const nodeId = getStoplightId2(schemaNode.fragment);
+  const [totalVendorExtensions, vendorExtensions] = React2.useMemo(
+    () => extractVendorExtensions(schemaNode.fragment),
+    [schemaNode.fragment]
+  );
+  const hasVendorProperties = totalVendorExtensions > 0;
+  if (isRegularNode(schemaNode) && isPureObjectNode(schemaNode)) {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      !skipDescription ? /* @__PURE__ */ jsx(Description, { value: schemaNode.annotations.description }) : null,
+      hasVendorProperties && renderExtensionAddon ? renderExtensionAddon({ schemaNode, nestingLevel, vendorExtensions }) : null,
+      /* @__PURE__ */ jsx(
+        ChildStack,
+        {
+          schemaNode,
+          childNodes,
+          currentNestingLevel: nestingLevel,
+          parentNodeId: nodeId
+        }
+      ),
+      /* @__PURE__ */ jsx(Error, { schemaNode })
+    ] });
+  }
+  if (isRegularNode(schemaNode) && choices.length > 1) {
+    const combiner = isRegularNode(schemaNode) && schemaNode.combiners?.length ? schemaNode.combiners[0] : null;
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      schemaNode.annotations.description !== schemaNode.parent?.fragment.description && /* @__PURE__ */ jsx(Description, { value: schemaNode.annotations.description }),
+      /* @__PURE__ */ jsxs("div", { className: "jsv-top-section", children: [
+        /* @__PURE__ */ jsxs(Menu.Root, { children: [
+          /* @__PURE__ */ jsxs(Menu.Trigger, { className: "jsv-select-trigger", children: [
+            selectedChoice.title,
+            /* @__PURE__ */ jsx(CaretDown, { size: 12 })
+          ] }),
+          /* @__PURE__ */ jsx(Menu.Portal, { children: /* @__PURE__ */ jsx(Menu.Positioner, { className: "jsv-select-positioner", children: /* @__PURE__ */ jsx(Menu.Popup, { className: "jsv-select-popup", children: choices.map((choice, index) => /* @__PURE__ */ jsx(
+            Menu.Item,
+            {
+              className: "jsv-select-item",
+              onClick: () => setSelectedChoice(choice),
+              children: choice.title
+            },
+            index
+          )) }) }) })
+        ] }),
+        combiner !== null ? /* @__PURE__ */ jsx("span", { className: "jsv-combiner-label", children: `(${COMBINER_NAME_MAP[combiner]})` }) : null
+      ] }),
+      childNodes.length > 0 ? /* @__PURE__ */ jsx(
+        ChildStack,
+        {
+          schemaNode,
+          childNodes,
+          currentNestingLevel: nestingLevel,
+          parentNodeId: nodeId
+        }
+      ) : combiner ? /* @__PURE__ */ jsx(SchemaRow, { schemaNode: selectedChoice.type, nestingLevel }) : null
+    ] });
+  }
+  if (isComplexArray(schemaNode) && isPureObjectNode(schemaNode.children[0])) {
+    const validations = isRegularNode(schemaNode) ? getValidationsFromSchema(schemaNode) : {};
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Description, { value: schemaNode.annotations.description }),
+      /* @__PURE__ */ jsx("div", { className: "jsv-top-label", children: "array of:" }),
+      !isEmpty(validations) && /* @__PURE__ */ jsx("div", { className: "jsv-validations", style: { marginBottom: "0.25rem" }, children: /* @__PURE__ */ jsx(Validations, { validations }) }),
+      childNodes.length > 0 ? /* @__PURE__ */ jsx(
+        ChildStack,
+        {
+          schemaNode,
+          childNodes,
+          currentNestingLevel: nestingLevel,
+          parentNodeId: nodeId
+        }
+      ) : null
+    ] });
+  }
+  return /* @__PURE__ */ jsx(SchemaRow, { schemaNode, nestingLevel });
+};
+function isPureObjectNode(schemaNode) {
+  return schemaNode.primaryType === "object" && schemaNode.types?.length === 1 && !isDictionaryNode(schemaNode);
+}
+var JsonSchemaViewer = ({
+  viewMode = "standalone",
+  defaultExpandedDepth = 1,
+  onGoToRef,
+  renderRowAddon,
+  renderExtensionAddon,
+  hideExamples,
+  renderRootTreeLines,
+  disableCrumbs,
+  nodeHasChanged,
+  skipTopLevelDescription,
+  ...rest
+}) => {
+  const options = React2.useMemo(
+    () => ({
+      defaultExpandedDepth,
+      viewMode,
+      onGoToRef,
+      renderRowAddon,
+      renderExtensionAddon,
+      hideExamples,
+      renderRootTreeLines,
+      disableCrumbs,
+      nodeHasChanged
+    }),
+    [
+      defaultExpandedDepth,
+      viewMode,
+      onGoToRef,
+      renderRowAddon,
+      renderExtensionAddon,
+      hideExamples,
+      renderRootTreeLines,
+      disableCrumbs,
+      nodeHasChanged
+    ]
+  );
+  return /* @__PURE__ */ jsx(JSVOptionsContextProvider, { value: options, children: /* @__PURE__ */ jsx(Provider, { children: /* @__PURE__ */ jsx(
+    JsonSchemaViewerInner,
+    {
+      viewMode,
+      skipTopLevelDescription,
+      ...rest
+    }
+  ) }) });
+};
+var JsonSchemaViewerInner = ({
+  schema,
+  viewMode,
+  className,
+  resolveRef,
+  maxRefDepth,
+  emptyText = "No schema defined",
+  onTreePopulated,
+  maxHeight,
+  parentCrumbs,
+  skipTopLevelDescription,
+  "data-theme": dataTheme
+}) => {
+  const setHoveredNode = useSetAtom(hoveredNodeAtom);
+  const onMouseLeave = React2.useCallback(() => {
+    setHoveredNode(null);
+  }, [setHoveredNode]);
+  const { jsonSchemaTreeRoot, nodeCount } = React2.useMemo(() => {
+    const jsonSchemaTree = new SchemaTree(schema, {
+      mergeAllOf: true,
+      refResolver: resolveRef,
+      maxRefDepth
+    });
+    let nodeCount2 = 0;
+    jsonSchemaTree.walker.hookInto("filter", (node) => {
+      if (shouldNodeBeIncluded(node, viewMode)) {
+        nodeCount2++;
+        return true;
+      }
+      return false;
+    });
+    jsonSchemaTree.populate();
+    return {
+      jsonSchemaTreeRoot: jsonSchemaTree.root,
+      nodeCount: nodeCount2
+    };
+  }, [schema, resolveRef, maxRefDepth, viewMode]);
+  React2.useEffect(() => {
+    onTreePopulated?.({
+      rootNode: jsonSchemaTreeRoot,
+      nodeCount
+    });
+  }, [jsonSchemaTreeRoot, onTreePopulated, nodeCount]);
+  const isEmpty2 = React2.useMemo(
+    () => jsonSchemaTreeRoot.children.every((node) => !isRegularNode(node) || node.unknown),
+    [jsonSchemaTreeRoot]
+  );
+  if (isEmpty2) {
+    return /* @__PURE__ */ jsx("div", { className: clsx("jsv-root", className), "data-test": "empty-text", "data-theme": dataTheme, children: emptyText });
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: clsx("jsv-root", className),
+      onMouseLeave,
+      style: { maxHeight, ...maxHeight ? { overflowY: "auto" } : {} },
+      "data-theme": dataTheme,
+      children: [
+        /* @__PURE__ */ jsx(PathCrumbs, { parentCrumbs }),
+        /* @__PURE__ */ jsx("div", { className: "jsv-content", children: /* @__PURE__ */ jsx(TopLevelSchemaRow, { schemaNode: jsonSchemaTreeRoot.children[0], skipDescription: skipTopLevelDescription }) })
+      ]
+    }
+  );
+};
+var JsonSchemaViewerErrorBoundary = class extends React2.Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false, error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  render() {
+    if (this.state.hasError) {
+      if (this.props.fallback) {
+        return this.props.fallback;
+      }
+      return /* @__PURE__ */ jsxs("div", { style: { padding: "1rem" }, children: [
+        /* @__PURE__ */ jsx("strong", { style: { color: "var(--jsv-color-danger, #ef4444)" }, children: "Error" }),
+        this.state.error !== null ? `: ${this.state.error.message}` : null
+      ] });
+    }
+    return this.props.children;
+  }
+};
+
+export { JsonSchemaViewer, JsonSchemaViewerErrorBoundary, Validations, getValidationsFromSchema, useChoices, visibleChildren };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map