docusaurus-theme-openapi-docs 0.0.0-1068 → 0.0.0-1070

package/lib/theme/Schema/index.js

@@ -13,7 +13,6 @@ var __importDefault =
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importDefault(require("react"));
 const Translate_1 = require("@docusaurus/Translate");
-const translationIds_1 = require("@theme/translationIds");
 const ArrayBrackets_1 = require("@theme/ArrayBrackets");
 const Details_1 = __importDefault(require("@theme/Details"));
 const DiscriminatorTabs_1 = __importDefault(
@@ -23,6 +22,7 @@ const Markdown_1 = __importDefault(require("@theme/Markdown"));
 const SchemaItem_1 = __importDefault(require("@theme/SchemaItem"));
 const SchemaTabs_1 = __importDefault(require("@theme/SchemaTabs"));
 const TabItem_1 = __importDefault(require("@theme/TabItem"));
+const translationIds_1 = require("@theme/translationIds");
 // eslint-disable-next-line import/no-extraneous-dependencies
 const allof_merge_1 = require("allof-merge");
 const clsx_1 = __importDefault(require("clsx"));
@@ -116,6 +116,11 @@ const AnyOneOf = ({ schema, schemaType }) => {
         id: translationIds_1.OPENAPI_SCHEMA_ITEM.ANY_OF,
         message: "anyOf",
       });
+  // Generate a unique ID for this anyOf/oneOf to prevent tab value collisions
+  const uniqueId = react_1.default.useMemo(
+    () => Math.random().toString(36).substring(7),
+    []
+  );
   return react_1.default.createElement(
     react_1.default.Fragment,
     null,
@@ -126,14 +131,31 @@ const AnyOneOf = ({ schema, schemaType }) => {
     ),
     react_1.default.createElement(
       SchemaTabs_1.default,
-      null,
+      { groupId: `schema-${uniqueId}`, lazy: true },
       schema[key]?.map((anyOneSchema, index) => {
-        const label = anyOneSchema.title || anyOneSchema.type;
+        // Determine label for the tab
+        // If schema is just oneOf/anyOf without title/type, use a generic label
+        let label = anyOneSchema.title || anyOneSchema.type;
+        if (!label) {
+          if (anyOneSchema.oneOf) {
+            label = (0, Translate_1.translate)({
+              id: translationIds_1.OPENAPI_SCHEMA_ITEM.ONE_OF,
+              message: "oneOf",
+            });
+          } else if (anyOneSchema.anyOf) {
+            label = (0, Translate_1.translate)({
+              id: translationIds_1.OPENAPI_SCHEMA_ITEM.ANY_OF,
+              message: "anyOf",
+            });
+          } else {
+            label = `Option ${index + 1}`;
+          }
+        }
         return (
           // @ts-ignore
           react_1.default.createElement(
             TabItem_1.default,
-            { key: index, label: label, value: `${index}-item-properties` },
+            { key: index, label: label, value: `${uniqueId}-${index}-item` },
             (isPrimitive(anyOneSchema) || anyOneSchema.const) &&
               react_1.default.createElement(SchemaItem_1.default, {
                 collapsible: false,
@@ -162,7 +184,7 @@ const AnyOneOf = ({ schema, schemaType }) => {
                 discriminator: false,
                 children: null,
               }),
-            anyOneSchema.type === "object" &&
+            (anyOneSchema.type === "object" || !anyOneSchema.type) &&
               anyOneSchema.properties &&
               react_1.default.createElement(Properties, {
                 schema: anyOneSchema,
@@ -775,6 +797,47 @@ const SchemaNode = ({ schema, schemaType }) => {
   }
   // Handle allOf, oneOf, anyOf without discriminators
   if (schema.allOf) {
+    // Check if allOf contains multiple oneOf/anyOf items that should be rendered separately
+    const oneOfItems = schema.allOf.filter((item) => item.oneOf || item.anyOf);
+    const hasMultipleChoices = oneOfItems.length > 1;
+    if (hasMultipleChoices) {
+      // Render each oneOf/anyOf constraint first, then shared properties
+      const mergedSchemas = mergeAllOf(schema);
+      if (
+        (schemaType === "request" && mergedSchemas.readOnly) ||
+        (schemaType === "response" && mergedSchemas.writeOnly)
+      ) {
+        return null;
+      }
+      return react_1.default.createElement(
+        "div",
+        null,
+        schema.allOf.map((item, index) => {
+          if (item.oneOf || item.anyOf) {
+            return react_1.default.createElement(
+              "div",
+              { key: index },
+              react_1.default.createElement(AnyOneOf, {
+                schema: item,
+                schemaType: schemaType,
+              })
+            );
+          }
+          return null;
+        }),
+        mergedSchemas.properties &&
+          react_1.default.createElement(Properties, {
+            schema: mergedSchemas,
+            schemaType: schemaType,
+          }),
+        mergedSchemas.items &&
+          react_1.default.createElement(Items, {
+            schema: mergedSchemas,
+            schemaType: schemaType,
+          })
+      );
+    }
+    // For other allOf cases, use standard merge behavior
     const mergedSchemas = mergeAllOf(schema);
     if (
       (schemaType === "request" && mergedSchemas.readOnly) ||

package/lib/theme/SchemaTabs/index.js

@@ -141,7 +141,10 @@ function TabList({ className, block, selectedValue, selectValue, tabValues }) {
   };
   return react_1.default.createElement(
     "div",
-    { className: "openapi-tabs__schema-tabs-container" },
+    {
+      className: "openapi-tabs__schema-tabs-container",
+      style: { marginBottom: "1rem" },
+    },
     showTabArrows &&
       react_1.default.createElement("button", {
         className: "openapi-tabs__arrow left",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-theme-openapi-docs",
   "description": "OpenAPI theme for Docusaurus.",
-  "version": "0.0.0-1068",
+  "version": "0.0.0-1070",
   "license": "MIT",
   "keywords": [
     "openapi",
@@ -38,7 +38,7 @@
     "@types/postman-collection": "^3.5.11",
     "@types/react-modal": "^3.16.3",
     "concurrently": "^9.2.0",
-    "docusaurus-plugin-openapi-docs": "0.0.0-1068",
+    "docusaurus-plugin-openapi-docs": "0.0.0-1070",
     "docusaurus-plugin-sass": "^0.2.6",
     "eslint-plugin-prettier": "^5.5.1"
   },
@@ -81,5 +81,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "d18835ed938d31e72d4c57d272902a3818eac708"
+  "gitHead": "17e82a49d111895a400d787e51d081cdd60c7964"
 }

package/src/theme/Schema/index.tsx

@@ -8,8 +8,6 @@
 import React from "react";
 
 import { translate } from "@docusaurus/Translate";
-import { OPENAPI_SCHEMA_ITEM } from "@theme/translationIds";
-
 import { ClosingArrayBracket, OpeningArrayBracket } from "@theme/ArrayBrackets";
 import Details from "@theme/Details";
 import DiscriminatorTabs from "@theme/DiscriminatorTabs";
@@ -17,6 +15,7 @@ import Markdown from "@theme/Markdown";
 import SchemaItem from "@theme/SchemaItem";
 import SchemaTabs from "@theme/SchemaTabs";
 import TabItem from "@theme/TabItem";
+import { OPENAPI_SCHEMA_ITEM } from "@theme/translationIds";
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { merge } from "allof-merge";
 import clsx from "clsx";
@@ -132,20 +131,44 @@ const AnyOneOf: React.FC<SchemaProps> = ({ schema, schemaType }) => {
   const type = schema.oneOf
     ? translate({ id: OPENAPI_SCHEMA_ITEM.ONE_OF, message: "oneOf" })
     : translate({ id: OPENAPI_SCHEMA_ITEM.ANY_OF, message: "anyOf" });
+
+  // Generate a unique ID for this anyOf/oneOf to prevent tab value collisions
+  const uniqueId = React.useMemo(
+    () => Math.random().toString(36).substring(7),
+    []
+  );
+
   return (
     <>
       <span className="badge badge--info" style={{ marginBottom: "1rem" }}>
         {type}
       </span>
-      <SchemaTabs>
+      <SchemaTabs groupId={`schema-${uniqueId}`} lazy>
         {schema[key]?.map((anyOneSchema: any, index: number) => {
-          const label = anyOneSchema.title || anyOneSchema.type;
+          // Determine label for the tab
+          // If schema is just oneOf/anyOf without title/type, use a generic label
+          let label = anyOneSchema.title || anyOneSchema.type;
+          if (!label) {
+            if (anyOneSchema.oneOf) {
+              label = translate({
+                id: OPENAPI_SCHEMA_ITEM.ONE_OF,
+                message: "oneOf",
+              });
+            } else if (anyOneSchema.anyOf) {
+              label = translate({
+                id: OPENAPI_SCHEMA_ITEM.ANY_OF,
+                message: "anyOf",
+              });
+            } else {
+              label = `Option ${index + 1}`;
+            }
+          }
           return (
             // @ts-ignore
             <TabItem
               key={index}
               label={label}
-              value={`${index}-item-properties`}
+              value={`${uniqueId}-${index}-item`}
             >
               {/* Handle primitive types directly */}
               {(isPrimitive(anyOneSchema) || anyOneSchema.const) && (
@@ -178,9 +201,11 @@ const AnyOneOf: React.FC<SchemaProps> = ({ schema, schemaType }) => {
                 )}
 
               {/* Handle actual object types with properties or nested schemas */}
-              {anyOneSchema.type === "object" && anyOneSchema.properties && (
-                <Properties schema={anyOneSchema} schemaType={schemaType} />
-              )}
+              {/* Note: In OpenAPI, properties implies type: object even if not explicitly set */}
+              {(anyOneSchema.type === "object" || !anyOneSchema.type) &&
+                anyOneSchema.properties && (
+                  <Properties schema={anyOneSchema} schemaType={schemaType} />
+                )}
               {anyOneSchema.allOf && (
                 <SchemaNode schema={anyOneSchema} schemaType={schemaType} />
               )}
@@ -860,6 +885,48 @@ const SchemaNode: React.FC<SchemaProps> = ({ schema, schemaType }) => {
 
   // Handle allOf, oneOf, anyOf without discriminators
   if (schema.allOf) {
+    // Check if allOf contains multiple oneOf/anyOf items that should be rendered separately
+    const oneOfItems = schema.allOf.filter(
+      (item: any) => item.oneOf || item.anyOf
+    );
+    const hasMultipleChoices = oneOfItems.length > 1;
+
+    if (hasMultipleChoices) {
+      // Render each oneOf/anyOf constraint first, then shared properties
+      const mergedSchemas = mergeAllOf(schema) as SchemaObject;
+
+      if (
+        (schemaType === "request" && mergedSchemas.readOnly) ||
+        (schemaType === "response" && mergedSchemas.writeOnly)
+      ) {
+        return null;
+      }
+
+      return (
+        <div>
+          {/* Render all oneOf/anyOf constraints first */}
+          {schema.allOf.map((item: any, index: number) => {
+            if (item.oneOf || item.anyOf) {
+              return (
+                <div key={index}>
+                  <AnyOneOf schema={item} schemaType={schemaType} />
+                </div>
+              );
+            }
+            return null;
+          })}
+          {/* Then render shared properties from the merge */}
+          {mergedSchemas.properties && (
+            <Properties schema={mergedSchemas} schemaType={schemaType} />
+          )}
+          {mergedSchemas.items && (
+            <Items schema={mergedSchemas} schemaType={schemaType} />
+          )}
+        </div>
+      );
+    }
+
+    // For other allOf cases, use standard merge behavior
     const mergedSchemas = mergeAllOf(schema) as SchemaObject;
 
     if (

package/src/theme/SchemaTabs/index.tsx

@@ -115,7 +115,10 @@ function TabList({
   };
 
   return (
-    <div className="openapi-tabs__schema-tabs-container">
+    <div
+      className="openapi-tabs__schema-tabs-container"
+      style={{ marginBottom: "1rem" }}
+    >
       {showTabArrows && (
         <button
           className="openapi-tabs__arrow left"