docusaurus-theme-openapi-docs 0.0.0-940 → 0.0.0-941

package/lib/theme/ApiTabs/_ApiTabs.scss

@@ -6,7 +6,6 @@
  * ========================================================================== */
 .openapi-tabs__container {
   margin-left: -1px;
-  margin-bottom: var(--ifm-leading);
 }
 
 .openapi-tabs__response-header {

package/lib/theme/Schema/index.js

@@ -183,6 +183,20 @@ const AnyOneOf = ({ schema, schemaType }) => {
 };
 const Properties = ({ schema, schemaType }) => {
   const discriminator = schema.discriminator;
+  if (discriminator && !discriminator.mapping) {
+    const anyOneOf = schema.oneOf ?? schema.anyOf ?? {};
+    const inferredMapping = {};
+    Object.entries(anyOneOf).map(([_, anyOneSchema]) => {
+      // ensure discriminated property only renders once
+      if (
+        schema.properties[discriminator.propertyName] &&
+        anyOneSchema.properties[discriminator.propertyName]
+      )
+        delete anyOneSchema.properties[discriminator.propertyName];
+      return (inferredMapping[anyOneSchema.title] = anyOneSchema);
+    });
+    discriminator["mapping"] = inferredMapping;
+  }
   if (Object.keys(schema.properties).length === 0) {
     return react_1.default.createElement(SchemaItem_1.default, {
       collapsible: false,
@@ -221,71 +235,143 @@ const PropertyDiscriminator = ({
   if (!schema) {
     return null;
   }
-  if (discriminator.mapping === undefined) {
-    return react_1.default.createElement(SchemaEdge, {
-      name: name,
-      schema: schema,
-      required: required,
-      schemaName: schemaName,
-      schemaType: schemaType,
-    });
-  }
   return react_1.default.createElement(
-    "div",
-    { className: "openapi-discriminator__item openapi-schema__list-item" },
+    react_1.default.Fragment,
+    null,
     react_1.default.createElement(
       "div",
-      null,
+      { className: "openapi-discriminator__item openapi-schema__list-item" },
       react_1.default.createElement(
-        "span",
-        { className: "openapi-schema__container" },
+        "div",
+        null,
         react_1.default.createElement(
-          "strong",
-          { className: "openapi-discriminator__name openapi-schema__property" },
-          name
-        ),
-        schemaName &&
+          "span",
+          { className: "openapi-schema__container" },
           react_1.default.createElement(
-            "span",
-            { className: "openapi-schema__name" },
-            " ",
-            schemaName
+            "strong",
+            {
+              className: "openapi-discriminator__name openapi-schema__property",
+            },
+            name
           ),
-        required &&
-          react_1.default.createElement(
-            "span",
-            { className: "openapi-schema__required" },
-            "required"
-          )
-      ),
-      react_1.default.createElement(
-        "div",
-        { style: { marginLeft: "1rem" } },
-        schema.description &&
-          react_1.default.createElement(Markdown, { text: schema.description }),
-        (0, schema_1.getQualifierMessage)(discriminator) &&
-          react_1.default.createElement(Markdown, {
-            text: (0, schema_1.getQualifierMessage)(discriminator),
-          })
-      ),
-      react_1.default.createElement(
-        DiscriminatorTabs_1.default,
-        { className: "openapi-tabs__discriminator" },
-        Object.keys(discriminator.mapping).map((key, index) =>
-          // @ts-ignore
-          react_1.default.createElement(
-            TabItem_1.default,
-            { key: index, label: key, value: `${index}-item-discriminator` },
-            react_1.default.createElement(SchemaNode, {
-              schema: discriminator.mapping[key],
-              schemaType: schemaType,
+          schemaName &&
+            react_1.default.createElement(
+              "span",
+              { className: "openapi-schema__name" },
+              " ",
+              schemaName
+            ),
+          required &&
+            react_1.default.createElement("span", {
+              className: "openapi-schema__divider",
+            }),
+          required &&
+            react_1.default.createElement(
+              "span",
+              { className: "openapi-schema__required" },
+              "required"
+            )
+        ),
+        react_1.default.createElement(
+          "div",
+          { style: { marginLeft: "1rem" } },
+          schema.description &&
+            react_1.default.createElement(Markdown, {
+              text: schema.description,
+            }),
+          (0, schema_1.getQualifierMessage)(discriminator) &&
+            react_1.default.createElement(Markdown, {
+              text: (0, schema_1.getQualifierMessage)(discriminator),
             })
+        ),
+        react_1.default.createElement(
+          DiscriminatorTabs_1.default,
+          { className: "openapi-tabs__discriminator" },
+          Object.keys(discriminator.mapping).map((key, index) =>
+            // @ts-ignore
+            react_1.default.createElement(
+              TabItem_1.default,
+              { key: index, label: key, value: `${index}-item-discriminator` },
+              react_1.default.createElement(SchemaNode, {
+                schema: discriminator.mapping[key],
+                schemaType: schemaType,
+              })
+            )
           )
         )
       )
-    )
+    ),
+    schema.properties &&
+      Object.entries(schema.properties).map(
+        ([key, val]) =>
+          key !== discriminator.propertyName &&
+          react_1.default.createElement(SchemaEdge, {
+            key: key,
+            name: key,
+            schema: val,
+            required: Array.isArray(schema.required)
+              ? schema.required.includes(key)
+              : false,
+            discriminator: false,
+            schemaType: schemaType,
+          })
+      )
   );
 };
+const DiscriminatorNode = ({ discriminator, schema, schemaType }) => {
+  let discriminatedSchemas = {};
+  let inferredMapping = {};
+  const discriminatorProperty = schema.properties[discriminator.propertyName];
+  if (schema.allOf) {
+    const mergedSchemas = mergeAllOf(schema);
+    if (mergedSchemas.oneOf || mergedSchemas.anyOf) {
+      discriminatedSchemas = mergedSchemas.oneOf || mergedSchemas.anyOf;
+    }
+  } else if (schema.oneOf || schema.anyOf) {
+    discriminatedSchemas = schema.oneOf || schema.anyOf;
+  }
+  // Handle case where no mapping is defined
+  if (!discriminator.mapping) {
+    Object.entries(discriminatedSchemas).forEach(([_, subschema], index) => {
+      inferredMapping[subschema.title ?? `PROP${index}`] = subschema;
+    });
+    discriminator.mapping = inferredMapping;
+  }
+  // Merge sub schema discriminator property with parent
+  Object.keys(discriminator.mapping).forEach((key) => {
+    const subSchema = discriminator.mapping[key];
+    // Handle discriminated schema with allOf
+    let mergedSubSchema = {};
+    if (subSchema.allOf) {
+      mergedSubSchema = mergeAllOf(subSchema);
+    }
+    const subProperties = subSchema.properties || mergedSubSchema.properties;
+    if (subProperties[discriminator.propertyName]) {
+      schema.properties[discriminator.propertyName] = {
+        ...schema.properties[discriminator.propertyName],
+        ...subProperties[discriminator.propertyName],
+      };
+      if (subSchema.required && !schema.required) {
+        schema.required = subSchema.required;
+      }
+      // Avoid duplicating property
+      delete subProperties[discriminator.propertyName];
+    }
+  });
+  const name = discriminator.propertyName;
+  const schemaName = (0, schema_1.getSchemaName)(discriminatorProperty);
+  // Default case for discriminator without oneOf/anyOf/allOf
+  return react_1.default.createElement(PropertyDiscriminator, {
+    name: name,
+    schemaName: schemaName,
+    schema: schema,
+    schemaType: schemaType,
+    discriminator: discriminator,
+    required: Array.isArray(schema.required)
+      ? schema.required.includes(name)
+      : schema.required,
+  });
+};
 const AdditionalProperties = ({ schema, schemaType }) => {
   const additionalProperties = schema.additionalProperties;
   if (!additionalProperties) return null;
@@ -690,6 +776,15 @@ const SchemaNode = ({ schema, schemaType }) => {
   ) {
     return null;
   }
+  if (schema.discriminator) {
+    const { discriminator } = schema;
+    return react_1.default.createElement(DiscriminatorNode, {
+      discriminator: discriminator,
+      schema: schema,
+      schemaType: schemaType,
+    });
+  }
+  // Handle allOf, oneOf, anyOf without discriminators
   if (schema.allOf) {
     const mergedSchemas = mergeAllOf(schema);
     if (
@@ -723,6 +818,12 @@ const SchemaNode = ({ schema, schemaType }) => {
         })
     );
   }
+  if (schema.oneOf || schema.anyOf) {
+    return react_1.default.createElement(AnyOneOf, {
+      schema: schema,
+      schemaType: schemaType,
+    });
+  }
   // Handle primitives
   if (
     schema.type &&

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-theme-openapi-docs",
   "description": "OpenAPI theme for Docusaurus.",
-  "version": "0.0.0-940",
+  "version": "0.0.0-941",
   "license": "MIT",
   "keywords": [
     "openapi",
@@ -43,7 +43,7 @@
     "clsx": "^1.1.1",
     "copy-text-to-clipboard": "^3.1.0",
     "crypto-js": "^4.1.1",
-    "docusaurus-plugin-openapi-docs": "0.0.0-940",
+    "docusaurus-plugin-openapi-docs": "0.0.0-941",
     "docusaurus-plugin-sass": "^0.2.3",
     "file-saver": "^2.0.5",
     "lodash": "^4.17.20",
@@ -71,5 +71,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "73fe6a842a36f1da27cb0c22d2fa260b268739d6"
+  "gitHead": "64f0f2dd6de011ae7970b6340fa63e41d79a9232"
 }

package/src/theme/ApiTabs/_ApiTabs.scss

@@ -6,7 +6,6 @@
  * ========================================================================== */
 .openapi-tabs__container {
   margin-left: -1px;
-  margin-bottom: var(--ifm-leading);
 }
 
 .openapi-tabs__response-header {

package/src/theme/Schema/index.tsx

@@ -184,6 +184,20 @@ const AnyOneOf: React.FC<SchemaProps> = ({ schema, schemaType }) => {
 
 const Properties: React.FC<SchemaProps> = ({ schema, schemaType }) => {
   const discriminator = schema.discriminator;
+  if (discriminator && !discriminator.mapping) {
+    const anyOneOf = schema.oneOf ?? schema.anyOf ?? {};
+    const inferredMapping = {} as any;
+    Object.entries(anyOneOf).map(([_, anyOneSchema]: [string, any]) => {
+      // ensure discriminated property only renders once
+      if (
+        schema.properties![discriminator.propertyName] &&
+        anyOneSchema.properties[discriminator.propertyName]
+      )
+        delete anyOneSchema.properties[discriminator.propertyName];
+      return (inferredMapping[anyOneSchema.title] = anyOneSchema);
+    });
+    discriminator["mapping"] = inferredMapping;
+  }
   if (Object.keys(schema.properties as {}).length === 0) {
     return (
       <SchemaItem
@@ -196,6 +210,7 @@ const Properties: React.FC<SchemaProps> = ({ schema, schemaType }) => {
       />
     );
   }
+
   return (
     <>
       {Object.entries(schema.properties as {}).map(
@@ -230,55 +245,143 @@ const PropertyDiscriminator: React.FC<SchemaEdgeProps> = ({
     return null;
   }
 
-  if (discriminator.mapping === undefined) {
-    return (
-      <SchemaEdge
-        name={name}
-        schema={schema}
-        required={required}
-        schemaName={schemaName}
-        schemaType={schemaType}
-      />
-    );
-  }
-
   return (
-    <div className="openapi-discriminator__item openapi-schema__list-item">
-      <div>
-        <span className="openapi-schema__container">
-          <strong className="openapi-discriminator__name openapi-schema__property">
-            {name}
-          </strong>
-          {schemaName && (
-            <span className="openapi-schema__name"> {schemaName}</span>
-          )}
-          {required && (
-            <span className="openapi-schema__required">required</span>
-          )}
-        </span>
-        <div style={{ marginLeft: "1rem" }}>
-          {schema.description && <Markdown text={schema.description} />}
-          {getQualifierMessage(discriminator) && (
-            <Markdown text={getQualifierMessage(discriminator)} />
-          )}
+    <>
+      <div className="openapi-discriminator__item openapi-schema__list-item">
+        <div>
+          <span className="openapi-schema__container">
+            <strong className="openapi-discriminator__name openapi-schema__property">
+              {name}
+            </strong>
+            {schemaName && (
+              <span className="openapi-schema__name"> {schemaName}</span>
+            )}
+            {required && <span className="openapi-schema__divider"></span>}
+            {required && (
+              <span className="openapi-schema__required">required</span>
+            )}
+          </span>
+          <div style={{ marginLeft: "1rem" }}>
+            {schema.description && <Markdown text={schema.description} />}
+            {getQualifierMessage(discriminator) && (
+              <Markdown text={getQualifierMessage(discriminator)} />
+            )}
+          </div>
+          <DiscriminatorTabs className="openapi-tabs__discriminator">
+            {Object.keys(discriminator.mapping).map((key, index) => (
+              // @ts-ignore
+              <TabItem
+                key={index}
+                label={key}
+                value={`${index}-item-discriminator`}
+              >
+                <SchemaNode
+                  schema={discriminator.mapping[key]}
+                  schemaType={schemaType}
+                />
+              </TabItem>
+            ))}
+          </DiscriminatorTabs>
         </div>
-        <DiscriminatorTabs className="openapi-tabs__discriminator">
-          {Object.keys(discriminator.mapping).map((key, index) => (
-            // @ts-ignore
-            <TabItem
-              key={index}
-              label={key}
-              value={`${index}-item-discriminator`}
-            >
-              <SchemaNode
-                schema={discriminator.mapping[key]}
+      </div>
+      {schema.properties &&
+        Object.entries(schema.properties as {}).map(
+          ([key, val]: [string, any]) =>
+            key !== discriminator.propertyName && (
+              <SchemaEdge
+                key={key}
+                name={key}
+                schema={val}
+                required={
+                  Array.isArray(schema.required)
+                    ? schema.required.includes(key)
+                    : false
+                }
+                discriminator={false}
                 schemaType={schemaType}
               />
-            </TabItem>
-          ))}
-        </DiscriminatorTabs>
-      </div>
-    </div>
+            )
+        )}
+    </>
+  );
+};
+
+interface DiscriminatorNodeProps {
+  discriminator: any;
+  schema: SchemaObject;
+  schemaType: "request" | "response";
+}
+
+const DiscriminatorNode: React.FC<DiscriminatorNodeProps> = ({
+  discriminator,
+  schema,
+  schemaType,
+}) => {
+  let discriminatedSchemas: any = {};
+  let inferredMapping: any = {};
+
+  const discriminatorProperty = schema.properties![discriminator.propertyName];
+
+  if (schema.allOf) {
+    const mergedSchemas = mergeAllOf(schema) as SchemaObject;
+    if (mergedSchemas.oneOf || mergedSchemas.anyOf) {
+      discriminatedSchemas = mergedSchemas.oneOf || mergedSchemas.anyOf;
+    }
+  } else if (schema.oneOf || schema.anyOf) {
+    discriminatedSchemas = schema.oneOf || schema.anyOf;
+  }
+
+  // Handle case where no mapping is defined
+  if (!discriminator.mapping) {
+    Object.entries(discriminatedSchemas).forEach(
+      ([_, subschema]: [string, any], index) => {
+        inferredMapping[subschema.title ?? `PROP${index}`] = subschema;
+      }
+    );
+    discriminator.mapping = inferredMapping;
+  }
+
+  // Merge sub schema discriminator property with parent
+  Object.keys(discriminator.mapping).forEach((key) => {
+    const subSchema = discriminator.mapping[key];
+
+    // Handle discriminated schema with allOf
+    let mergedSubSchema = {} as SchemaObject;
+    if (subSchema.allOf) {
+      mergedSubSchema = mergeAllOf(subSchema) as SchemaObject;
+    }
+
+    const subProperties = subSchema.properties || mergedSubSchema.properties;
+    if (subProperties[discriminator.propertyName]) {
+      schema.properties![discriminator.propertyName] = {
+        ...schema.properties![discriminator.propertyName],
+        ...subProperties[discriminator.propertyName],
+      };
+      if (subSchema.required && !schema.required) {
+        schema.required = subSchema.required;
+      }
+      // Avoid duplicating property
+      delete subProperties[discriminator.propertyName];
+    }
+  });
+
+  const name = discriminator.propertyName;
+  const schemaName = getSchemaName(discriminatorProperty);
+
+  // Default case for discriminator without oneOf/anyOf/allOf
+  return (
+    <PropertyDiscriminator
+      name={name}
+      schemaName={schemaName}
+      schema={schema}
+      schemaType={schemaType}
+      discriminator={discriminator}
+      required={
+        Array.isArray(schema.required)
+          ? schema.required.includes(name)
+          : schema.required
+      }
+    />
   );
 };
 
@@ -738,6 +841,18 @@ const SchemaNode: React.FC<SchemaProps> = ({ schema, schemaType }) => {
     return null;
   }
 
+  if (schema.discriminator) {
+    const { discriminator } = schema;
+    return (
+      <DiscriminatorNode
+        discriminator={discriminator}
+        schema={schema}
+        schemaType={schemaType}
+      />
+    );
+  }
+
+  // Handle allOf, oneOf, anyOf without discriminators
   if (schema.allOf) {
     const mergedSchemas = mergeAllOf(schema) as SchemaObject;
 
@@ -766,6 +881,10 @@ const SchemaNode: React.FC<SchemaProps> = ({ schema, schemaType }) => {
     );
   }
 
+  if (schema.oneOf || schema.anyOf) {
+    return <AnyOneOf schema={schema} schemaType={schemaType} />;
+  }
+
   // Handle primitives
   if (
     schema.type &&