docusaurus-theme-openapi-docs 4.5.1 → 4.7.0

package/lib/theme/Schema/index.js

@@ -5,13 +5,72 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  * ========================================================================== */
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (
+          !desc ||
+          ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)
+        ) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o["default"] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  (function () {
+    var ownKeys = function (o) {
+      ownKeys =
+        Object.getOwnPropertyNames ||
+        function (o) {
+          var ar = [];
+          for (var k in o)
+            if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          return ar;
+        };
+      return ownKeys(o);
+    };
+    return function (mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null)
+        for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+          if (k[i] !== "default") __createBinding(result, mod, k[i]);
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  })();
 var __importDefault =
   (this && this.__importDefault) ||
   function (mod) {
     return mod && mod.__esModule ? mod : { default: mod };
   };
 Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importDefault(require("react"));
+const react_1 = __importStar(require("react"));
+const Translate_1 = require("@docusaurus/Translate");
+const slice_1 = require("@theme/ApiExplorer/SchemaSelection/slice");
+const hooks_1 = require("@theme/ApiItem/hooks");
 const ArrayBrackets_1 = require("@theme/ArrayBrackets");
 const Details_1 = __importDefault(require("@theme/Details"));
 const DiscriminatorTabs_1 = __importDefault(
@@ -21,6 +80,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"));
@@ -77,25 +137,66 @@ const Summary = ({ name, schemaName, schema, required }) => {
         react_1.default.createElement(
           "span",
           { className: "openapi-schema__nullable" },
-          "nullable"
+          (0, Translate_1.translate)({
+            id: translationIds_1.OPENAPI_SCHEMA_ITEM.NULLABLE,
+            message: "nullable",
+          })
         ),
       isRequired &&
         react_1.default.createElement(
           "span",
           { className: "openapi-schema__required" },
-          "required"
+          (0, Translate_1.translate)({
+            id: translationIds_1.OPENAPI_SCHEMA_ITEM.REQUIRED,
+            message: "required",
+          })
         ),
       deprecated &&
         react_1.default.createElement(
           "span",
           { className: "openapi-schema__deprecated" },
-          "deprecated"
+          (0, Translate_1.translate)({
+            id: translationIds_1.OPENAPI_SCHEMA_ITEM.DEPRECATED,
+            message: "deprecated",
+          })
         )
     )
   );
 };
-const AnyOneOf = ({ schema, schemaType }) => {
-  const type = schema.oneOf ? "oneOf" : "anyOf";
+const AnyOneOf = ({ schema, schemaType, schemaPath }) => {
+  const key = schema.oneOf ? "oneOf" : "anyOf";
+  const type = schema.oneOf
+    ? (0, Translate_1.translate)({
+        id: translationIds_1.OPENAPI_SCHEMA_ITEM.ONE_OF,
+        message: "oneOf",
+      })
+    : (0, Translate_1.translate)({
+        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),
+    []
+  );
+  // Try to get Redux dispatch - will be undefined if not inside a Provider
+  let dispatch;
+  try {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    dispatch = (0, hooks_1.useTypedDispatch)();
+  } catch {
+    // Not inside a Redux Provider, which is fine for response schemas
+    dispatch = undefined;
+  }
+  // Handle tab change - dispatch to Redux if schemaPath is provided
+  const handleTabChange = (0, react_1.useCallback)(
+    (index) => {
+      if (schemaPath && dispatch) {
+        dispatch((0, slice_1.setSchemaSelection)({ path: schemaPath, index }));
+      }
+    },
+    [schemaPath, dispatch]
+  );
   return react_1.default.createElement(
     react_1.default.Fragment,
     null,
@@ -106,19 +207,43 @@ const AnyOneOf = ({ schema, schemaType }) => {
     ),
     react_1.default.createElement(
       SchemaTabs_1.default,
-      null,
-      schema[type]?.map((anyOneSchema, index) => {
-        const label = anyOneSchema.title || anyOneSchema.type;
+      { groupId: `schema-${uniqueId}`, lazy: true, onChange: handleTabChange },
+      schema[key]?.map((anyOneSchema, index) => {
+        // Use getSchemaName to include format info (e.g., "string<date-time>")
+        const computedSchemaName = (0, schema_1.getSchemaName)(anyOneSchema);
+        // Determine label for the tab
+        // Prefer explicit title, then computed schema name, then raw type
+        let label =
+          anyOneSchema.title || computedSchemaName || 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}`;
+          }
+        }
+        // Build the nested schemaPath for child anyOf/oneOf
+        const childSchemaPath = schemaPath
+          ? `${schemaPath}.${index}`
+          : undefined;
         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,
                 name: undefined,
-                schemaName: anyOneSchema.type,
+                schemaName: computedSchemaName,
                 qualifierMessage: (0, schema_1.getQualifierMessage)(
                   anyOneSchema
                 ),
@@ -134,7 +259,7 @@ const AnyOneOf = ({ schema, schemaType }) => {
               react_1.default.createElement(SchemaItem_1.default, {
                 collapsible: false,
                 name: undefined,
-                schemaName: anyOneSchema.type,
+                schemaName: computedSchemaName,
                 qualifierMessage: (0, schema_1.getQualifierMessage)(
                   anyOneSchema
                 ),
@@ -142,31 +267,36 @@ 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,
                 schemaType: schemaType,
+                schemaPath: childSchemaPath,
               }),
             anyOneSchema.allOf &&
               react_1.default.createElement(SchemaNode, {
                 schema: anyOneSchema,
                 schemaType: schemaType,
+                schemaPath: childSchemaPath,
               }),
             anyOneSchema.oneOf &&
               react_1.default.createElement(SchemaNode, {
                 schema: anyOneSchema,
                 schemaType: schemaType,
+                schemaPath: childSchemaPath,
               }),
             anyOneSchema.anyOf &&
               react_1.default.createElement(SchemaNode, {
                 schema: anyOneSchema,
                 schemaType: schemaType,
+                schemaPath: childSchemaPath,
               }),
             anyOneSchema.items &&
               react_1.default.createElement(Items, {
                 schema: anyOneSchema,
                 schemaType: schemaType,
+                schemaPath: childSchemaPath,
               })
           )
         );
@@ -174,7 +304,7 @@ const AnyOneOf = ({ schema, schemaType }) => {
     )
   );
 };
-const Properties = ({ schema, schemaType }) => {
+const Properties = ({ schema, schemaType, schemaPath }) => {
   const discriminator = schema.discriminator;
   if (discriminator && !discriminator.mapping) {
     const anyOneOf = schema.oneOf ?? schema.anyOf ?? {};
@@ -213,6 +343,7 @@ const Properties = ({ schema, schemaType }) => {
           : false,
         discriminator: discriminator,
         schemaType: schemaType,
+        schemaPath: schemaPath ? `${schemaPath}.${key}` : undefined,
       })
     )
   );
@@ -262,7 +393,10 @@ const PropertyDiscriminator = ({
             react_1.default.createElement(
               "span",
               { className: "openapi-schema__required" },
-              "required"
+              (0, Translate_1.translate)({
+                id: translationIds_1.OPENAPI_SCHEMA_ITEM.REQUIRED,
+                message: "required",
+              })
             )
         ),
         react_1.default.createElement(
@@ -446,6 +580,7 @@ const SchemaNodeDetails = ({
   schema,
   required,
   schemaType,
+  schemaPath,
 }) => {
   return react_1.default.createElement(
     SchemaItem_1.default,
@@ -475,12 +610,13 @@ const SchemaNodeDetails = ({
         react_1.default.createElement(SchemaNode, {
           schema: schema,
           schemaType: schemaType,
+          schemaPath: schemaPath,
         })
       )
     )
   );
 };
-const Items = ({ schema, schemaType }) => {
+const Items = ({ schema, schemaType, schemaPath }) => {
   // Process schema.items to handle allOf merging
   let itemsSchema = schema.items;
   if (schema.items?.allOf) {
@@ -490,6 +626,8 @@ const Items = ({ schema, schemaType }) => {
   const hasOneOfAnyOf = itemsSchema?.oneOf || itemsSchema?.anyOf;
   const hasProperties = itemsSchema?.properties;
   const hasAdditionalProperties = itemsSchema?.additionalProperties;
+  // Build the items schema path
+  const itemsSchemaPath = schemaPath ? `${schemaPath}.items` : undefined;
   if (hasOneOfAnyOf || hasProperties || hasAdditionalProperties) {
     return react_1.default.createElement(
       react_1.default.Fragment,
@@ -499,11 +637,13 @@ const Items = ({ schema, schemaType }) => {
         react_1.default.createElement(AnyOneOf, {
           schema: itemsSchema,
           schemaType: schemaType,
+          schemaPath: itemsSchemaPath,
         }),
       hasProperties &&
         react_1.default.createElement(Properties, {
           schema: itemsSchema,
           schemaType: schemaType,
+          schemaPath: itemsSchemaPath,
         }),
       hasAdditionalProperties &&
         react_1.default.createElement(AdditionalProperties, {
@@ -556,7 +696,14 @@ const Items = ({ schema, schemaType }) => {
     react_1.default.createElement(ArrayBrackets_1.ClosingArrayBracket, null)
   );
 };
-const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
+const SchemaEdge = ({
+  name,
+  schema,
+  required,
+  discriminator,
+  schemaType,
+  schemaPath,
+}) => {
   if (
     (schemaType === "request" && schema.readOnly) ||
     (schemaType === "response" && schema.writeOnly)
@@ -583,6 +730,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       required: required,
       schema: schema,
       nullable: schema.nullable,
+      schemaPath: schemaPath,
     });
   }
   if (schema.properties) {
@@ -593,6 +741,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       required: required,
       schema: schema,
       nullable: schema.nullable,
+      schemaPath: schemaPath,
     });
   }
   if (schema.additionalProperties) {
@@ -603,6 +752,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       required: required,
       schema: schema,
       nullable: schema.nullable,
+      schemaPath: schemaPath,
     });
   }
   if (schema.items?.properties) {
@@ -613,9 +763,10 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       nullable: schema.nullable,
       schema: schema,
       schemaType: schemaType,
+      schemaPath: schemaPath,
     });
   }
-  if (schema.items?.anyOf || schema.items?.oneOf) {
+  if (schema.items?.anyOf || schema.items?.oneOf || schema.items?.allOf) {
     return react_1.default.createElement(SchemaNodeDetails, {
       name: name,
       schemaName: schemaName,
@@ -623,6 +774,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       nullable: schema.nullable,
       schema: schema,
       schemaType: schemaType,
+      schemaPath: schemaPath,
     });
   }
   if (schema.allOf) {
@@ -656,36 +808,33 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       return react_1.default.createElement(SchemaNodeDetails, {
         name: name,
         schemaName: mergedSchemaName,
-        required: Array.isArray(mergedSchemas.required)
-          ? mergedSchemas.required.includes(name)
-          : mergedSchemas.required,
+        required: Array.isArray(required) ? required.includes(name) : required,
         nullable: mergedSchemas.nullable,
         schema: mergedSchemas,
         schemaType: schemaType,
+        schemaPath: schemaPath,
       });
     }
     if (mergedSchemas.properties !== undefined) {
       return react_1.default.createElement(SchemaNodeDetails, {
         name: name,
         schemaName: mergedSchemaName,
-        required: Array.isArray(mergedSchemas.required)
-          ? mergedSchemas.required.includes(name)
-          : mergedSchemas.required,
+        required: Array.isArray(required) ? required.includes(name) : required,
         nullable: mergedSchemas.nullable,
         schema: mergedSchemas,
         schemaType: schemaType,
+        schemaPath: schemaPath,
       });
     }
     if (mergedSchemas.items?.properties) {
-      react_1.default.createElement(SchemaNodeDetails, {
+      return react_1.default.createElement(SchemaNodeDetails, {
         name: name,
         schemaName: mergedSchemaName,
-        required: Array.isArray(mergedSchemas.required)
-          ? mergedSchemas.required.includes(name)
-          : mergedSchemas.required,
+        required: Array.isArray(required) ? required.includes(name) : required,
         nullable: mergedSchemas.nullable,
         schema: mergedSchemas,
         schemaType: schemaType,
+        schemaPath: schemaPath,
       });
     }
     return react_1.default.createElement(SchemaItem_1.default, {
@@ -710,7 +859,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
     children: null,
   });
 };
-function renderChildren(schema, schemaType) {
+function renderChildren(schema, schemaType, schemaPath) {
   return react_1.default.createElement(
     react_1.default.Fragment,
     null,
@@ -718,16 +867,19 @@ function renderChildren(schema, schemaType) {
       react_1.default.createElement(AnyOneOf, {
         schema: schema,
         schemaType: schemaType,
+        schemaPath: schemaPath,
       }),
     schema.anyOf &&
       react_1.default.createElement(AnyOneOf, {
         schema: schema,
         schemaType: schemaType,
+        schemaPath: schemaPath,
       }),
     schema.properties &&
       react_1.default.createElement(Properties, {
         schema: schema,
         schemaType: schemaType,
+        schemaPath: schemaPath,
       }),
     schema.additionalProperties &&
       react_1.default.createElement(AdditionalProperties, {
@@ -738,10 +890,11 @@ function renderChildren(schema, schemaType) {
       react_1.default.createElement(Items, {
         schema: schema,
         schemaType: schemaType,
+        schemaPath: schemaPath,
       })
   );
 }
-const SchemaNode = ({ schema, schemaType }) => {
+const SchemaNode = ({ schema, schemaType, schemaPath }) => {
   if (
     (schemaType === "request" && schema.readOnly) ||
     (schemaType === "response" && schema.writeOnly)
@@ -758,6 +911,53 @@ 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) {
+            const itemSchemaPath = schemaPath
+              ? `${schemaPath}.allOf.${index}`
+              : undefined;
+            return react_1.default.createElement(
+              "div",
+              { key: index },
+              react_1.default.createElement(AnyOneOf, {
+                schema: item,
+                schemaType: schemaType,
+                schemaPath: itemSchemaPath,
+              })
+            );
+          }
+          return null;
+        }),
+        mergedSchemas.properties &&
+          react_1.default.createElement(Properties, {
+            schema: mergedSchemas,
+            schemaType: schemaType,
+            schemaPath: schemaPath,
+          }),
+        mergedSchemas.items &&
+          react_1.default.createElement(Items, {
+            schema: mergedSchemas,
+            schemaType: schemaType,
+            schemaPath: schemaPath,
+          })
+      );
+    }
+    // For other allOf cases, use standard merge behavior
     const mergedSchemas = mergeAllOf(schema);
     if (
       (schemaType === "request" && mergedSchemas.readOnly) ||
@@ -772,21 +972,25 @@ const SchemaNode = ({ schema, schemaType }) => {
         react_1.default.createElement(AnyOneOf, {
           schema: mergedSchemas,
           schemaType: schemaType,
+          schemaPath: schemaPath,
         }),
       mergedSchemas.anyOf &&
         react_1.default.createElement(AnyOneOf, {
           schema: mergedSchemas,
           schemaType: schemaType,
+          schemaPath: schemaPath,
         }),
       mergedSchemas.properties &&
         react_1.default.createElement(Properties, {
           schema: mergedSchemas,
           schemaType: schemaType,
+          schemaPath: schemaPath,
         }),
       mergedSchemas.items &&
         react_1.default.createElement(Items, {
           schema: mergedSchemas,
           schemaType: schemaType,
+          schemaPath: schemaPath,
         })
     );
   }
@@ -812,7 +1016,7 @@ const SchemaNode = ({ schema, schemaType }) => {
       children: null,
     });
   }
-  return renderChildren(schema, schemaType);
+  return renderChildren(schema, schemaType, schemaPath);
 };
 exports.default = SchemaNode;
 const PRIMITIVE_TYPES = {
@@ -823,5 +1027,10 @@ const PRIMITIVE_TYPES = {
   null: true,
 };
 const isPrimitive = (schema) => {
+  // Enum-only schemas (without explicit type) should be treated as primitives
+  // This is valid JSON Schema where enum values define the constraints
+  if (schema.enum && !schema.type) {
+    return true;
+  }
   return PRIMITIVE_TYPES[schema.type];
 };