docusaurus-theme-openapi-docs 0.0.0-1096 → 0.0.0-1098

package/lib/markdown/schema.js

@@ -11,6 +11,11 @@ exports.getQualifierMessage = getQualifierMessage;
 const Translate_1 = require("@docusaurus/Translate");
 const translationIds_1 = require("../theme/translationIds");
 function prettyName(schema, circular) {
+    // 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;
     }

package/lib/theme/ApiExplorer/Body/index.js

@@ -84,6 +84,7 @@ const createSchemaExample_1 = require("docusaurus-plugin-openapi-docs/src/openap
 const xml_formatter_1 = __importDefault(require("xml-formatter"));
 const slice_1 = require("./slice");
 const FormBodyItem_1 = __importDefault(require("./FormBodyItem"));
+const resolveSchemaWithSelections_1 = require("./resolveSchemaWithSelections");
 function BodyWrap({
   requestBodyMetadata,
   jsonRequestBodyExample,
@@ -114,6 +115,9 @@ function Body({
   const contentType = (0, hooks_1.useTypedSelector)(
     (state) => state.contentType.value
   );
+  const schemaSelections = (0, hooks_1.useTypedSelector)(
+    (state) => state.schemaSelection?.selections ?? {}
+  );
   const dispatch = (0, hooks_1.useTypedDispatch)();
   // Lot's of possible content-types:
   // - application/json
@@ -133,11 +137,200 @@ function Body({
   // Show form:
   // - multipart/form-data
   // - application/x-www-form-urlencoded
-  const schema = requestBodyMetadata?.content?.[contentType]?.schema;
+  const rawSchema = requestBodyMetadata?.content?.[contentType]?.schema;
   const example = requestBodyMetadata?.content?.[contentType]?.example;
   const examples = requestBodyMetadata?.content?.[contentType]?.examples;
+  // Resolve the schema based on user's anyOf/oneOf tab selections
+  const schema = (0, react_1.useMemo)(() => {
+    if (!rawSchema) return rawSchema;
+    return (0, resolveSchemaWithSelections_1.resolveSchemaWithSelections)(
+      rawSchema,
+      schemaSelections,
+      "requestBody"
+    );
+  }, [rawSchema, schemaSelections]);
   // OpenAPI 3.1 / JSON Schema: schema.examples is an array of example values
   const schemaExamples = schema?.examples;
+  // Compute the default body based on content type and schema
+  // This needs to be computed before early returns so the useEffect can use it
+  const { defaultBody, exampleBody, examplesBodies, language } = (0,
+  react_1.useMemo)(() => {
+    let lang = "plaintext";
+    let defBody = "";
+    let exBody;
+    let exBodies = [];
+    // Skip body generation for binary and form content types
+    if (schema?.format === "binary") {
+      return {
+        defaultBody: defBody,
+        exampleBody: exBody,
+        examplesBodies: exBodies,
+        language: lang,
+      };
+    }
+    if (
+      (contentType === "multipart/form-data" ||
+        contentType === "application/x-www-form-urlencoded") &&
+      schema?.type === "object"
+    ) {
+      return {
+        defaultBody: defBody,
+        exampleBody: exBody,
+        examplesBodies: exBodies,
+        language: lang,
+      };
+    }
+    // Generate example from the schema for the current content type
+    let contentTypeExample;
+    if (schema) {
+      contentTypeExample = (0, createSchemaExample_1.sampleFromSchema)(schema, {
+        type: "request",
+      });
+    } else if (jsonRequestBodyExample) {
+      // Fallback to the build-time generated example if no schema is available
+      contentTypeExample = jsonRequestBodyExample;
+    }
+    if (
+      contentType?.includes("application/json") ||
+      contentType?.endsWith("+json")
+    ) {
+      if (contentTypeExample) {
+        defBody = JSON.stringify(contentTypeExample, null, 2);
+      }
+      if (example) {
+        exBody = JSON.stringify(example, null, 2);
+      }
+      if (examples) {
+        for (const [key, ex] of Object.entries(examples)) {
+          let body = ex.value;
+          try {
+            // If the value is already valid JSON we shouldn't double encode the value
+            JSON.parse(ex.value);
+          } catch (e) {
+            body = JSON.stringify(ex.value, null, 2);
+          }
+          exBodies.push({
+            label: key,
+            body,
+            summary: ex.summary,
+          });
+        }
+      }
+      // OpenAPI 3.1: schema.examples is an array of example values
+      if (schemaExamples && Array.isArray(schemaExamples)) {
+        schemaExamples.forEach((schemaExample, index) => {
+          const body = JSON.stringify(schemaExample, null, 2);
+          exBodies.push({
+            label: `Example ${index + 1}`,
+            body,
+            summary: undefined,
+          });
+        });
+      }
+      lang = "json";
+    }
+    if (contentType === "application/xml" || contentType?.endsWith("+xml")) {
+      if (contentTypeExample) {
+        try {
+          defBody = (0, xml_formatter_1.default)(
+            (0, json2xml_1.default)(contentTypeExample, ""),
+            {
+              indentation: "  ",
+              lineSeparator: "\n",
+              collapseContent: true,
+            }
+          );
+        } catch {
+          defBody = (0, json2xml_1.default)(contentTypeExample);
+        }
+      }
+      if (example) {
+        try {
+          exBody = (0, xml_formatter_1.default)(
+            (0, json2xml_1.default)(example, ""),
+            {
+              indentation: "  ",
+              lineSeparator: "\n",
+              collapseContent: true,
+            }
+          );
+        } catch {
+          exBody = (0, json2xml_1.default)(example);
+        }
+      }
+      if (examples) {
+        for (const [key, ex] of Object.entries(examples)) {
+          let formattedXmlBody;
+          try {
+            formattedXmlBody = (0, xml_formatter_1.default)(ex.value, {
+              indentation: "  ",
+              lineSeparator: "\n",
+              collapseContent: true,
+            });
+          } catch {
+            formattedXmlBody = ex.value;
+          }
+          exBodies.push({
+            label: key,
+            body: formattedXmlBody,
+            summary: ex.summary,
+          });
+        }
+      }
+      // OpenAPI 3.1: schema.examples is an array of example values
+      if (schemaExamples && Array.isArray(schemaExamples)) {
+        schemaExamples.forEach((schemaExample, index) => {
+          let formattedXmlBody;
+          try {
+            formattedXmlBody = (0, xml_formatter_1.default)(
+              (0, json2xml_1.default)(schemaExample, ""),
+              {
+                indentation: "  ",
+                lineSeparator: "\n",
+                collapseContent: true,
+              }
+            );
+          } catch {
+            formattedXmlBody = (0, json2xml_1.default)(schemaExample);
+          }
+          exBodies.push({
+            label: `Example ${index + 1}`,
+            body: formattedXmlBody,
+            summary: undefined,
+          });
+        });
+      }
+      lang = "xml";
+    }
+    return {
+      defaultBody: defBody,
+      exampleBody: exBody,
+      examplesBodies: exBodies,
+      language: lang,
+    };
+  }, [
+    schema,
+    contentType,
+    example,
+    examples,
+    schemaExamples,
+    jsonRequestBodyExample,
+  ]);
+  // Create a stable key for the LiveApp component that changes when schema selection changes
+  // This forces the editor to remount and pick up the new defaultBody
+  const schemaSelectionKey = (0, react_1.useMemo)(
+    () => JSON.stringify(schemaSelections),
+    [schemaSelections]
+  );
+  // Update body in Redux when content type or schema selection changes
+  (0, react_1.useEffect)(() => {
+    if (defaultBody) {
+      dispatch((0, slice_1.setStringRawBody)(defaultBody));
+    }
+    // Re-run when contentType, schemaSelections, or defaultBody change
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [contentType, schemaSelections, defaultBody]);
+  // Now handle early returns after all hooks have been called
   if (schema?.format === "binary") {
     return react_1.default.createElement(
       FormItem_1.default,
@@ -190,140 +383,6 @@ function Body({
       })
     );
   }
-  let language = "plaintext";
-  let defaultBody = ""; //"body content";
-  let exampleBody;
-  let examplesBodies = [];
-  // Generate example from the schema for the current content type
-  let contentTypeExample;
-  if (schema) {
-    contentTypeExample = (0, createSchemaExample_1.sampleFromSchema)(schema, {
-      type: "request",
-    });
-  } else if (jsonRequestBodyExample) {
-    // Fallback to the build-time generated example if no schema is available
-    contentTypeExample = jsonRequestBodyExample;
-  }
-  if (
-    contentType.includes("application/json") ||
-    contentType.endsWith("+json")
-  ) {
-    if (contentTypeExample) {
-      defaultBody = JSON.stringify(contentTypeExample, null, 2);
-    }
-    if (example) {
-      exampleBody = JSON.stringify(example, null, 2);
-    }
-    if (examples) {
-      for (const [key, example] of Object.entries(examples)) {
-        let body = example.value;
-        try {
-          // If the value is already valid JSON we shouldn't double encode the value
-          JSON.parse(example.value);
-        } catch (e) {
-          body = JSON.stringify(example.value, null, 2);
-        }
-        examplesBodies.push({
-          label: key,
-          body,
-          summary: example.summary,
-        });
-      }
-    }
-    // OpenAPI 3.1: schema.examples is an array of example values
-    if (schemaExamples && Array.isArray(schemaExamples)) {
-      schemaExamples.forEach((schemaExample, index) => {
-        const body = JSON.stringify(schemaExample, null, 2);
-        examplesBodies.push({
-          label: `Example ${index + 1}`,
-          body,
-          summary: undefined,
-        });
-      });
-    }
-    language = "json";
-  }
-  if (contentType === "application/xml" || contentType.endsWith("+xml")) {
-    if (contentTypeExample) {
-      try {
-        defaultBody = (0, xml_formatter_1.default)(
-          (0, json2xml_1.default)(contentTypeExample, ""),
-          {
-            indentation: "  ",
-            lineSeparator: "\n",
-            collapseContent: true,
-          }
-        );
-      } catch {
-        defaultBody = (0, json2xml_1.default)(contentTypeExample);
-      }
-    }
-    if (example) {
-      try {
-        exampleBody = (0, xml_formatter_1.default)(
-          (0, json2xml_1.default)(example, ""),
-          {
-            indentation: "  ",
-            lineSeparator: "\n",
-            collapseContent: true,
-          }
-        );
-      } catch {
-        exampleBody = (0, json2xml_1.default)(example);
-      }
-    }
-    if (examples) {
-      for (const [key, example] of Object.entries(examples)) {
-        let formattedXmlBody;
-        try {
-          formattedXmlBody = (0, xml_formatter_1.default)(example.value, {
-            indentation: "  ",
-            lineSeparator: "\n",
-            collapseContent: true,
-          });
-        } catch {
-          formattedXmlBody = example.value;
-        }
-        examplesBodies.push({
-          label: key,
-          body: formattedXmlBody,
-          summary: example.summary,
-        });
-      }
-    }
-    // OpenAPI 3.1: schema.examples is an array of example values
-    if (schemaExamples && Array.isArray(schemaExamples)) {
-      schemaExamples.forEach((schemaExample, index) => {
-        let formattedXmlBody;
-        try {
-          formattedXmlBody = (0, xml_formatter_1.default)(
-            (0, json2xml_1.default)(schemaExample, ""),
-            {
-              indentation: "  ",
-              lineSeparator: "\n",
-              collapseContent: true,
-            }
-          );
-        } catch {
-          formattedXmlBody = (0, json2xml_1.default)(schemaExample);
-        }
-        examplesBodies.push({
-          label: `Example ${index + 1}`,
-          body: formattedXmlBody,
-          summary: undefined,
-        });
-      });
-    }
-    language = "xml";
-  }
-  // Update body in Redux when content type changes
-  (0, react_1.useEffect)(() => {
-    if (defaultBody) {
-      dispatch((0, slice_1.setStringRawBody)(defaultBody));
-    }
-    // Only re-run when contentType changes, not when defaultBody changes
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [contentType]);
   if (exampleBody) {
     return react_1.default.createElement(
       FormItem_1.default,
@@ -344,7 +403,7 @@ function Body({
           react_1.default.createElement(
             LiveEditor_1.default,
             {
-              key: contentType,
+              key: `${contentType}-${schemaSelectionKey}`,
               action: (code) => dispatch((0, slice_1.setStringRawBody)(code)),
               language: language,
               required: required,
@@ -365,7 +424,7 @@ function Body({
             react_1.default.createElement(
               LiveEditor_1.default,
               {
-                key: contentType,
+                key: `${contentType}-example`,
                 action: (code) => dispatch((0, slice_1.setStringRawBody)(code)),
                 language: language,
                 required: required,
@@ -396,7 +455,7 @@ function Body({
           react_1.default.createElement(
             LiveEditor_1.default,
             {
-              key: contentType,
+              key: `${contentType}-${schemaSelectionKey}`,
               action: (code) => dispatch((0, slice_1.setStringRawBody)(code)),
               language: language,
               required: required,
@@ -404,32 +463,28 @@ function Body({
             defaultBody
           )
         ),
-        examplesBodies.map((example) => {
+        examplesBodies.map((ex) => {
           return (
             // @ts-ignore
             react_1.default.createElement(
               TabItem_1.default,
-              {
-                label: example.label,
-                value: example.label,
-                key: example.label,
-              },
-              example.summary &&
+              { label: ex.label, value: ex.label, key: ex.label },
+              ex.summary &&
                 react_1.default.createElement(
                   Markdown_1.default,
                   null,
-                  example.summary
+                  ex.summary
                 ),
-              example.body &&
+              ex.body &&
                 react_1.default.createElement(
                   LiveEditor_1.default,
                   {
-                    key: `${contentType}-${example.label}`,
+                    key: `${contentType}-${ex.label}`,
                     action: (code) =>
                       dispatch((0, slice_1.setStringRawBody)(code)),
                     language: language,
                   },
-                  example.body
+                  ex.body
                 )
             )
           );
@@ -443,7 +498,7 @@ function Body({
     react_1.default.createElement(
       LiveEditor_1.default,
       {
-        key: contentType,
+        key: `${contentType}-${schemaSelectionKey}`,
         action: (code) => dispatch((0, slice_1.setStringRawBody)(code)),
         language: language,
         required: required,

package/lib/theme/ApiExplorer/Body/resolveSchemaWithSelections.d.ts

@@ -0,0 +1,13 @@
+import { SchemaObject } from "docusaurus-plugin-openapi-docs/src/openapi/types";
+export interface SchemaSelections {
+    [schemaPath: string]: number;
+}
+/**
+ * Resolves a schema by replacing anyOf/oneOf with the selected option based on user selections.
+ *
+ * @param schema - The original schema object
+ * @param selections - Map of schema paths to selected indices
+ * @param basePath - The base path for this schema (used for looking up selections)
+ * @returns A new schema with anyOf/oneOf resolved to selected options
+ */
+export declare function resolveSchemaWithSelections(schema: SchemaObject | undefined, selections: SchemaSelections, basePath?: string): SchemaObject | undefined;

package/lib/theme/ApiExplorer/Body/resolveSchemaWithSelections.js

@@ -0,0 +1,133 @@
+"use strict";
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSchemaWithSelections = resolveSchemaWithSelections;
+const merge_1 = __importDefault(require("lodash/merge"));
+/**
+ * Resolves a schema by replacing anyOf/oneOf with the selected option based on user selections.
+ *
+ * @param schema - The original schema object
+ * @param selections - Map of schema paths to selected indices
+ * @param basePath - The base path for this schema (used for looking up selections)
+ * @returns A new schema with anyOf/oneOf resolved to selected options
+ */
+function resolveSchemaWithSelections(
+  schema,
+  selections,
+  basePath = "requestBody"
+) {
+  if (!schema) {
+    return schema;
+  }
+  // Deep clone to avoid mutating the original schema
+  const schemaCopy = JSON.parse(JSON.stringify(schema));
+  return resolveSchemaRecursive(schemaCopy, selections, basePath);
+}
+function resolveSchemaRecursive(schema, selections, currentPath) {
+  // Handle oneOf
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    const selectedIndex = selections[currentPath] ?? 0;
+    const selectedSchema = schema.oneOf[selectedIndex];
+    if (selectedSchema) {
+      // If there are shared properties, merge them with the selected schema
+      if (schema.properties) {
+        const mergedSchema = (0, merge_1.default)({}, schema, selectedSchema);
+        delete mergedSchema.oneOf;
+        // Continue resolving nested schemas in the merged result
+        return resolveSchemaRecursive(
+          mergedSchema,
+          selections,
+          `${currentPath}.${selectedIndex}`
+        );
+      }
+      // No shared properties, just use the selected schema
+      // Continue resolving in case there are nested anyOf/oneOf
+      return resolveSchemaRecursive(
+        selectedSchema,
+        selections,
+        `${currentPath}.${selectedIndex}`
+      );
+    }
+  }
+  // Handle anyOf
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    const selectedIndex = selections[currentPath] ?? 0;
+    const selectedSchema = schema.anyOf[selectedIndex];
+    if (selectedSchema) {
+      // If there are shared properties, merge them with the selected schema
+      if (schema.properties) {
+        const mergedSchema = (0, merge_1.default)({}, schema, selectedSchema);
+        delete mergedSchema.anyOf;
+        // Continue resolving nested schemas in the merged result
+        return resolveSchemaRecursive(
+          mergedSchema,
+          selections,
+          `${currentPath}.${selectedIndex}`
+        );
+      }
+      // No shared properties, just use the selected schema
+      // Continue resolving in case there are nested anyOf/oneOf
+      return resolveSchemaRecursive(
+        selectedSchema,
+        selections,
+        `${currentPath}.${selectedIndex}`
+      );
+    }
+  }
+  // Handle allOf - merge all schemas and continue resolving
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    // Process each allOf item, resolving any anyOf/oneOf within them
+    const resolvedItems = schema.allOf.map((item, index) => {
+      return resolveSchemaRecursive(
+        item,
+        selections,
+        `${currentPath}.allOf.${index}`
+      );
+    });
+    // Merge all resolved items
+    const mergedSchema = resolvedItems.reduce(
+      (acc, item) => (0, merge_1.default)(acc, item),
+      {}
+    );
+    // Preserve any top-level properties from the original schema
+    if (schema.properties) {
+      mergedSchema.properties = (0, merge_1.default)(
+        {},
+        mergedSchema.properties,
+        schema.properties
+      );
+    }
+    return mergedSchema;
+  }
+  // Handle object properties recursively
+  if (schema.properties) {
+    const resolvedProperties = {};
+    for (const [propName, propSchema] of Object.entries(schema.properties)) {
+      resolvedProperties[propName] = resolveSchemaRecursive(
+        propSchema,
+        selections,
+        `${currentPath}.${propName}`
+      );
+    }
+    schema.properties = resolvedProperties;
+  }
+  // Handle array items recursively
+  if (schema.items) {
+    schema.items = resolveSchemaRecursive(
+      schema.items,
+      selections,
+      `${currentPath}.items`
+    );
+  }
+  return schema;
+}

package/lib/theme/ApiExplorer/SchemaSelection/index.d.ts

@@ -0,0 +1,2 @@
+export { default as schemaSelectionReducer, setSchemaSelection, clearSchemaSelections, } from "./slice";
+export type { SchemaSelectionState } from "./slice";

package/lib/theme/ApiExplorer/SchemaSelection/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearSchemaSelections =
+  exports.setSchemaSelection =
+  exports.schemaSelectionReducer =
+    void 0;
+var slice_1 = require("./slice");
+Object.defineProperty(exports, "schemaSelectionReducer", {
+  enumerable: true,
+  get: function () {
+    return __importDefault(slice_1).default;
+  },
+});
+Object.defineProperty(exports, "setSchemaSelection", {
+  enumerable: true,
+  get: function () {
+    return slice_1.setSchemaSelection;
+  },
+});
+Object.defineProperty(exports, "clearSchemaSelections", {
+  enumerable: true,
+  get: function () {
+    return slice_1.clearSchemaSelections;
+  },
+});

package/lib/theme/ApiExplorer/SchemaSelection/slice.d.ts

@@ -0,0 +1,37 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+export interface SchemaSelectionState {
+    /**
+     * Maps schema path (e.g., "requestBody", "requestBody.anyOf.0.layer3")
+     * to the selected anyOf/oneOf option index
+     */
+    selections: {
+        [schemaPath: string]: number;
+    };
+}
+export declare const slice: import("@reduxjs/toolkit").Slice<SchemaSelectionState, {
+    /**
+     * Set the selected index for a specific schema path
+     */
+    setSchemaSelection: (state: {
+        selections: {
+            [x: string]: number;
+        };
+    }, action: PayloadAction<{
+        path: string;
+        index: number;
+    }>) => void;
+    /**
+     * Clear all schema selections (useful when navigating to a new API endpoint)
+     */
+    clearSchemaSelections: (state: {
+        selections: {
+            [x: string]: number;
+        };
+    }) => void;
+}, "schemaSelection", "schemaSelection", import("@reduxjs/toolkit").SliceSelectors<SchemaSelectionState>>;
+export declare const setSchemaSelection: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    path: string;
+    index: number;
+}, "schemaSelection/setSchemaSelection">, clearSchemaSelections: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"schemaSelection/clearSchemaSelections">;
+declare const _default: import("redux").Reducer<SchemaSelectionState>;
+export default _default;