docusaurus-theme-openapi-docs 4.6.0 → 4.7.0

package/lib/theme/Schema/index.js

@@ -5,14 +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(
@@ -105,7 +163,7 @@ const Summary = ({ name, schemaName, schema, required }) => {
     )
   );
 };
-const AnyOneOf = ({ schema, schemaType }) => {
+const AnyOneOf = ({ schema, schemaType, schemaPath }) => {
   const key = schema.oneOf ? "oneOf" : "anyOf";
   const type = schema.oneOf
     ? (0, Translate_1.translate)({
@@ -121,6 +179,24 @@ const AnyOneOf = ({ schema, schemaType }) => {
     () => 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,
@@ -131,7 +207,7 @@ const AnyOneOf = ({ schema, schemaType }) => {
     ),
     react_1.default.createElement(
       SchemaTabs_1.default,
-      { groupId: `schema-${uniqueId}`, lazy: true },
+      { 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);
@@ -154,6 +230,10 @@ const AnyOneOf = ({ schema, schemaType }) => {
             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(
@@ -192,26 +272,31 @@ const AnyOneOf = ({ schema, schemaType }) => {
               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,
               })
           )
         );
@@ -219,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 ?? {};
@@ -258,6 +343,7 @@ const Properties = ({ schema, schemaType }) => {
           : false,
         discriminator: discriminator,
         schemaType: schemaType,
+        schemaPath: schemaPath ? `${schemaPath}.${key}` : undefined,
       })
     )
   );
@@ -494,6 +580,7 @@ const SchemaNodeDetails = ({
   schema,
   required,
   schemaType,
+  schemaPath,
 }) => {
   return react_1.default.createElement(
     SchemaItem_1.default,
@@ -523,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) {
@@ -538,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,
@@ -547,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, {
@@ -604,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)
@@ -631,6 +730,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       required: required,
       schema: schema,
       nullable: schema.nullable,
+      schemaPath: schemaPath,
     });
   }
   if (schema.properties) {
@@ -641,6 +741,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       required: required,
       schema: schema,
       nullable: schema.nullable,
+      schemaPath: schemaPath,
     });
   }
   if (schema.additionalProperties) {
@@ -651,6 +752,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       required: required,
       schema: schema,
       nullable: schema.nullable,
+      schemaPath: schemaPath,
     });
   }
   if (schema.items?.properties) {
@@ -661,6 +763,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       nullable: schema.nullable,
       schema: schema,
       schemaType: schemaType,
+      schemaPath: schemaPath,
     });
   }
   if (schema.items?.anyOf || schema.items?.oneOf || schema.items?.allOf) {
@@ -671,6 +774,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
       nullable: schema.nullable,
       schema: schema,
       schemaType: schemaType,
+      schemaPath: schemaPath,
     });
   }
   if (schema.allOf) {
@@ -708,6 +812,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
         nullable: mergedSchemas.nullable,
         schema: mergedSchemas,
         schemaType: schemaType,
+        schemaPath: schemaPath,
       });
     }
     if (mergedSchemas.properties !== undefined) {
@@ -718,6 +823,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
         nullable: mergedSchemas.nullable,
         schema: mergedSchemas,
         schemaType: schemaType,
+        schemaPath: schemaPath,
       });
     }
     if (mergedSchemas.items?.properties) {
@@ -728,6 +834,7 @@ const SchemaEdge = ({ name, schema, required, discriminator, schemaType }) => {
         nullable: mergedSchemas.nullable,
         schema: mergedSchemas,
         schemaType: schemaType,
+        schemaPath: schemaPath,
       });
     }
     return react_1.default.createElement(SchemaItem_1.default, {
@@ -752,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,
@@ -760,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, {
@@ -780,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)
@@ -817,12 +928,16 @@ const SchemaNode = ({ schema, schemaType }) => {
         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,
               })
             );
           }
@@ -832,11 +947,13 @@ const SchemaNode = ({ schema, schemaType }) => {
           react_1.default.createElement(Properties, {
             schema: mergedSchemas,
             schemaType: schemaType,
+            schemaPath: schemaPath,
           }),
         mergedSchemas.items &&
           react_1.default.createElement(Items, {
             schema: mergedSchemas,
             schemaType: schemaType,
+            schemaPath: schemaPath,
           })
       );
     }
@@ -855,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,
         })
     );
   }
@@ -895,7 +1016,7 @@ const SchemaNode = ({ schema, schemaType }) => {
       children: null,
     });
   }
-  return renderChildren(schema, schemaType);
+  return renderChildren(schema, schemaType, schemaPath);
 };
 exports.default = SchemaNode;
 const PRIMITIVE_TYPES = {
@@ -906,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];
 };

package/lib/theme/SchemaTabs/index.d.ts

@@ -1,3 +1,10 @@
 import React from "react";
 import { TabProps } from "@docusaurus/theme-common/internal";
-export default function SchemaTabs(props: TabProps): React.JSX.Element;
+export interface SchemaTabsProps extends TabProps {
+    /**
+     * Optional callback fired when the selected tab changes.
+     * Receives the index of the newly selected tab.
+     */
+    onChange?: (index: number) => void;
+}
+export default function SchemaTabs(props: SchemaTabsProps): React.JSX.Element;

package/lib/theme/SchemaTabs/index.js

@@ -73,7 +73,14 @@ const internal_1 = require("@docusaurus/theme-common/internal");
 const useIsBrowser_1 = __importDefault(require("@docusaurus/useIsBrowser"));
 const clsx_1 = __importDefault(require("clsx"));
 const flatten_1 = __importDefault(require("lodash/flatten"));
-function TabList({ className, block, selectedValue, selectValue, tabValues }) {
+function TabList({
+  className,
+  block,
+  selectedValue,
+  selectValue,
+  tabValues,
+  onChange,
+}) {
   const tabRefs = [];
   const { blockElementScrollPositionUntilNextRender } = (0,
   internal_1.useScrollPositionBlocker)();
@@ -84,6 +91,8 @@ function TabList({ className, block, selectedValue, selectValue, tabValues }) {
     if (newTabValue !== selectedValue) {
       blockElementScrollPositionUntilNextRender(newTab);
       selectValue(newTabValue);
+      // Notify parent component of the tab change
+      onChange?.(newTabIndex);
     }
   };
   const handleKeydown = (event) => {

package/lib/theme/StatusCodes/index.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { ApiItem } from "docusaurus-plugin-openapi-docs/lib/types";
+import { ApiItem } from "docusaurus-plugin-openapi-docs/src/types";
 interface Props {
     id?: string;
     label?: string;

package/lib/theme/styles.scss

@@ -166,6 +166,16 @@
   border-right: thin solid var(--ifm-toc-border-color);
 }
 
+@media (min-width: 997px) {
+  .openapi-right-panel__container {
+    position: sticky;
+    top: calc(var(--ifm-navbar-height) + 1rem);
+    max-height: calc(100vh - var(--ifm-navbar-height) - 2rem);
+    overflow-y: auto;
+    align-self: flex-start;
+  }
+}
+
 @media (max-width: 997px) {
   .schema {
     margin-bottom: 1rem;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-theme-openapi-docs",
   "description": "OpenAPI theme for Docusaurus.",
-  "version": "4.6.0",
+  "version": "4.7.0",
   "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": "^4.6.0",
+    "docusaurus-plugin-openapi-docs": "^4.7.0",
     "docusaurus-plugin-sass": "^0.2.6",
     "eslint-plugin-prettier": "^5.5.1"
   },
@@ -81,5 +81,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "c7c5ca9934031d166faa0740746ef1a39e72982d"
+  "gitHead": "f5829b8e478b0ee76344ba31edd67efdfea18990"
 }

package/src/markdown/schema.ts

@@ -11,6 +11,12 @@ import { OPENAPI_SCHEMA_ITEM } from "../theme/translationIds";
 import { SchemaObject } from "../types";
 
 function prettyName(schema: SchemaObject, circular?: boolean) {
+  // Handle enum-only schemas (valid in JSON Schema)
+  // When enum is present without explicit type, treat as string
+  if (schema.enum && !schema.type) {
+    return "string";
+  }
+
   if (schema.format) {
     return schema.format;
   }