docusaurus-plugin-openapi-docs 1.0.4 → 1.1.0

package/README.md

@@ -81,6 +81,7 @@ Here is an example of properly configuring your `docusaurus.config.js` file for
       'docusaurus-plugin-openapi-docs',
       {
         id: "apiDocs",
+        docsPluginId: "classic",
         config: {
           petstore: { // Note: petstore key is treated as the <id> and can be used to specify an API doc instance when using CLI commands
             specPath: "examples/petstore.yaml", // Path to designated spec file
@@ -107,10 +108,10 @@ Here is an example of properly configuring your `docusaurus.config.js` file for
 
 The `docusaurus-plugin-openapi-docs` plugin can be configured with the following options:
 
-| Name          | Type     | Default | Description                                                                                                                                          |
-| ------------- | -------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `id`          | `string` | `null`  | A unique document id.                                                                                                                                |
-| `docPluginId` | `string` | `null`  | The ID associated with the `plugin-content-docs` or `preset` instance used to render the OpenAPI docs (e.g. "your-plugin-id", "classic", "default"). |
+| Name           | Type     | Default | Description                                                                                                                                          |
+| -------------- | -------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `id`           | `string` | `null`  | A unique document id.                                                                                                                                |
+| `docsPluginId` | `string` | `null`  | The ID associated with the `plugin-content-docs` or `preset` instance used to render the OpenAPI docs (e.g. "your-plugin-id", "classic", "default"). |
 
 ### config
 

package/lib/index.js

@@ -54,13 +54,13 @@ function getDocsData(dataArray, filter) {
 }
 exports.getDocsData = getDocsData;
 function pluginOpenAPIDocs(context, options) {
-    const { config, docPluginId } = options;
+    const { config, docsPluginId } = options;
     const { siteDir, siteConfig } = context;
     // Get routeBasePath and path from plugin-content-docs or preset
     const presets = siteConfig.presets;
     const plugins = siteConfig.plugins;
     const presetsPlugins = presets.concat(plugins);
-    const docData = getDocsData(presetsPlugins, docPluginId);
+    const docData = getDocsData(presetsPlugins, docsPluginId);
     const docRouteBasePath = docData ? docData.routeBasePath : undefined;
     const docPath = docData ? (docData.path ? docData.path : "docs") : undefined;
     async function generateApiDocs(options) {
@@ -69,7 +69,7 @@ function pluginOpenAPIDocs(context, options) {
             ? specPath
             : path_1.default.resolve(siteDir, specPath);
         try {
-            const openapiFiles = await (0, openapi_1.readOpenapiFiles)(contentPath, {});
+            const openapiFiles = await (0, openapi_1.readOpenapiFiles)(contentPath, options);
             const [loadedApi, tags] = await (0, openapi_1.processOpenapiFiles)(openapiFiles, sidebarOptions);
             if (!fs_1.default.existsSync(outputDir)) {
                 try {

package/lib/markdown/createSchemaDetails.js

@@ -12,11 +12,12 @@ const createDetails_1 = require("./createDetails");
 const createDetailsSummary_1 = require("./createDetailsSummary");
 const schema_1 = require("./schema");
 const utils_1 = require("./utils");
-const mergeAllOf = require("json-schema-merge-allof");
-function resolveAllOf(allOf) {
-    // Use external library to resolve and merge nested allOf schemas
-    let properties = {};
-    const mergedSchemas = mergeAllOf(allOf, {
+const jsonSchemaMergeAllOf = require("json-schema-merge-allof");
+/**
+ * Returns a merged representation of allOf array of schemas.
+ */
+function mergeAllOf(allOf) {
+    const mergedSchemas = jsonSchemaMergeAllOf(allOf, {
         resolvers: {
             readOnly: function () {
                 return true;
@@ -26,9 +27,6 @@ function resolveAllOf(allOf) {
             },
         },
     });
-    if (mergedSchemas.properties) {
-        properties = mergedSchemas.properties;
-    }
     const required = allOf.reduce((acc, cur) => {
         if (Array.isArray(cur.required)) {
             const next = [...acc, ...cur.required];
@@ -36,153 +34,344 @@ function resolveAllOf(allOf) {
         }
         return acc;
     }, []);
-    return { properties, required };
+    return { mergedSchemas, required };
 }
-function createRow({ name, schema, required }) {
-    const schemaName = (0, schema_1.getSchemaName)(schema, true);
-    if (schemaName && (schemaName === "object" || schemaName === "object[]")) {
-        return (0, utils_1.create)("SchemaItem", {
-            collapsible: true,
-            className: "schemaItem",
-            children: [
-                (0, createDetails_1.createDetails)({
-                    children: [
-                        (0, createDetailsSummary_1.createDetailsSummary)({
-                            children: [
-                                (0, utils_1.create)("strong", { children: name }),
-                                (0, utils_1.create)("span", {
-                                    style: { opacity: "0.6" },
-                                    children: ` ${schemaName}`,
-                                }),
-                                (0, utils_1.guard)(required, () => [
-                                    (0, utils_1.create)("strong", {
-                                        style: {
-                                            fontSize: "var(--ifm-code-font-size)",
-                                            color: "var(--openapi-required)",
-                                        },
-                                        children: " required",
-                                    }),
-                                ]),
-                            ],
-                        }),
-                        (0, utils_1.create)("div", {
-                            style: { marginLeft: "1rem" },
-                            children: [
-                                (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema), (message) => (0, utils_1.create)("div", {
-                                    style: { marginTop: ".5rem", marginBottom: ".5rem" },
-                                    children: (0, createDescription_1.createDescription)(message),
-                                })),
-                                (0, utils_1.guard)(schema.description, (description) => (0, utils_1.create)("div", {
-                                    style: { marginTop: ".5rem", marginBottom: ".5rem" },
-                                    children: (0, createDescription_1.createDescription)(description),
-                                })),
-                                createRows({ schema: schema }),
-                            ],
+/**
+ * For handling nested anyOf/oneOf.
+ */
+function createAnyOneOf(schema) {
+    const type = schema.oneOf ? "oneOf" : "anyOf";
+    return (0, utils_1.create)("li", {
+        children: [
+            (0, utils_1.create)("div", {
+                children: [
+                    (0, utils_1.create)("span", {
+                        className: "badge badge--info",
+                        children: type,
+                    }),
+                    (0, utils_1.create)("SchemaTabs", {
+                        children: schema[type].map((anyOneSchema, index) => {
+                            const label = anyOneSchema.title
+                                ? anyOneSchema.title
+                                : `MOD${index + 1}`;
+                            const anyOneChildren = [];
+                            if (anyOneSchema.properties !== undefined) {
+                                anyOneChildren.push(createProperties(anyOneSchema));
+                            }
+                            if (anyOneSchema.allOf !== undefined) {
+                                anyOneChildren.push(createNodes(anyOneSchema));
+                            }
+                            if (anyOneSchema.items !== undefined) {
+                                anyOneChildren.push(createItems(anyOneSchema));
+                            }
+                            if (anyOneSchema.type === "string" ||
+                                anyOneSchema.type === "number" ||
+                                anyOneSchema.type === "integer" ||
+                                anyOneSchema.type === "boolean") {
+                                anyOneChildren.push(createNodes(anyOneSchema));
+                            }
+                            if (anyOneChildren.length) {
+                                return (0, utils_1.create)("TabItem", {
+                                    label: label,
+                                    value: `${index}-item-properties`,
+                                    children: anyOneChildren,
+                                });
+                            }
+                            return undefined;
                         }),
+                    }),
+                ],
+            }),
+        ],
+    });
+}
+function createProperties(schema) {
+    return Object.entries(schema.properties).map(([key, val]) => createEdges({
+        name: key,
+        schema: val,
+        required: Array.isArray(schema.required)
+            ? schema.required.includes(key)
+            : false,
+    }));
+}
+function createAdditionalProperties(schema) {
+    // TODO?:
+    //   {
+    //   description: 'Integration configuration. See \n' +
+    //     '[Integration Configurations](https://prisma.pan.dev/api/cloud/api-integration-config/).\n',
+    //   example: { webhookUrl: 'https://hooks.slack.com/abcdef' },
+    //   externalDocs: { url: 'https://prisma.pan.dev/api/cloud/api-integration-config' },
+    //   type: 'object'
+    // }
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    // TODO?:
+    // {
+    // items: {
+    //     properties: {
+    //       aliasField: [Object],
+    //       displayName: [Object],
+    //       fieldName: [Object],
+    //       maxLength: [Object],
+    //       options: [Object],
+    //       redlockMapping: [Object],
+    //       required: [Object],
+    //       type: [Object],
+    //       typeaheadUri: [Object],
+    //       value: [Object]
+    //     },
+    //     type: 'object'
+    //   },
+    //   type: 'array'
+    // }
+    if (((_a = schema.additionalProperties) === null || _a === void 0 ? void 0 : _a.type) === "string" ||
+        ((_b = schema.additionalProperties) === null || _b === void 0 ? void 0 : _b.type) === "object" ||
+        ((_c = schema.additionalProperties) === null || _c === void 0 ? void 0 : _c.type) === "boolean" ||
+        ((_d = schema.additionalProperties) === null || _d === void 0 ? void 0 : _d.type) === "integer" ||
+        ((_e = schema.additionalProperties) === null || _e === void 0 ? void 0 : _e.type) === "number") {
+        const type = (_f = schema.additionalProperties) === null || _f === void 0 ? void 0 : _f.type;
+        const additionalProperties = (_g = schema.additionalProperties) === null || _g === void 0 ? void 0 : _g.additionalProperties;
+        if (additionalProperties !== undefined) {
+            const type = (_j = (_h = schema.additionalProperties) === null || _h === void 0 ? void 0 : _h.additionalProperties) === null || _j === void 0 ? void 0 : _j.type;
+            const format = (_l = (_k = schema.additionalProperties) === null || _k === void 0 ? void 0 : _k.additionalProperties) === null || _l === void 0 ? void 0 : _l.format;
+            return (0, utils_1.create)("li", {
+                children: (0, utils_1.create)("div", {
+                    children: [
+                        (0, utils_1.create)("code", { children: `property name*` }),
+                        (0, utils_1.guard)(type, (type) => (0, utils_1.create)("span", {
+                            style: { opacity: "0.6" },
+                            children: ` ${type}`,
+                        })),
+                        (0, utils_1.guard)(format, (format) => (0, utils_1.create)("span", {
+                            style: { opacity: "0.6" },
+                            children: ` (${format})`,
+                        })),
+                        (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema.additionalProperties), (message) => (0, utils_1.create)("div", {
+                            style: { marginTop: "var(--ifm-table-cell-padding)" },
+                            children: (0, createDescription_1.createDescription)(message),
+                        })),
                     ],
                 }),
-            ],
+            });
+        }
+        return (0, utils_1.create)("li", {
+            children: (0, utils_1.create)("div", {
+                children: [
+                    (0, utils_1.create)("code", { children: `property name*` }),
+                    (0, utils_1.guard)(type, (type) => (0, utils_1.create)("span", {
+                        style: { opacity: "0.6" },
+                        children: ` ${type}`,
+                    })),
+                    (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema.additionalProperties), (message) => (0, utils_1.create)("div", {
+                        style: { marginTop: "var(--ifm-table-cell-padding)" },
+                        children: (0, createDescription_1.createDescription)(message),
+                    })),
+                ],
+            }),
         });
     }
+    return Object.entries(schema.additionalProperties).map(([key, val]) => createEdges({
+        name: key,
+        schema: val,
+        required: Array.isArray(schema.required)
+            ? schema.required.includes(key)
+            : false,
+    }));
+}
+// TODO: figure out how to handle array of objects
+function createItems(schema) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    if (((_a = schema.items) === null || _a === void 0 ? void 0 : _a.properties) !== undefined) {
+        return createProperties(schema.items);
+    }
+    if (((_b = schema.items) === null || _b === void 0 ? void 0 : _b.additionalProperties) !== undefined) {
+        return createAdditionalProperties(schema.items);
+    }
+    if (((_c = schema.items) === null || _c === void 0 ? void 0 : _c.oneOf) !== undefined || ((_d = schema.items) === null || _d === void 0 ? void 0 : _d.anyOf) !== undefined) {
+        return createAnyOneOf(schema.items);
+    }
+    if (((_e = schema.items) === null || _e === void 0 ? void 0 : _e.allOf) !== undefined) {
+        const { mergedSchemas } = mergeAllOf((_f = schema.items) === null || _f === void 0 ? void 0 : _f.allOf);
+        // Handles combo anyOf/oneOf + properties
+        if ((mergedSchemas.oneOf !== undefined ||
+            mergedSchemas.anyOf !== undefined) &&
+            mergedSchemas.properties) {
+            return (0, utils_1.create)("div", {
+                children: [
+                    createAnyOneOf(mergedSchemas),
+                    createProperties(mergedSchemas),
+                ],
+            });
+        }
+        // Handles only anyOf/oneOf
+        if (mergedSchemas.oneOf !== undefined ||
+            mergedSchemas.anyOf !== undefined) {
+            return (0, utils_1.create)("div", {
+                children: [
+                    createAnyOneOf(mergedSchemas),
+                    createProperties(mergedSchemas),
+                ],
+            });
+        }
+    }
+    if (((_g = schema.items) === null || _g === void 0 ? void 0 : _g.type) === "string" ||
+        ((_h = schema.items) === null || _h === void 0 ? void 0 : _h.type) === "number" ||
+        ((_j = schema.items) === null || _j === void 0 ? void 0 : _j.type) === "integer" ||
+        ((_k = schema.items) === null || _k === void 0 ? void 0 : _k.type) === "boolean") {
+        return createNodes(schema.items);
+    }
+    // TODO: clean this up or eliminate it?
+    return Object.entries(schema.items).map(([key, val]) => createEdges({
+        name: key,
+        schema: val,
+        required: Array.isArray(schema.required)
+            ? schema.required.includes(key)
+            : false,
+    }));
+}
+function createDetailsNode(name, schemaName, schema, required) {
+    return (0, utils_1.create)("SchemaItem", {
+        collapsible: true,
+        className: "schemaItem",
+        children: [
+            (0, createDetails_1.createDetails)({
+                children: [
+                    (0, createDetailsSummary_1.createDetailsSummary)({
+                        children: [
+                            (0, utils_1.create)("strong", { children: name }),
+                            (0, utils_1.create)("span", {
+                                style: { opacity: "0.6" },
+                                children: ` ${schemaName}`,
+                            }),
+                            (0, utils_1.guard)(required, () => [
+                                (0, utils_1.create)("strong", {
+                                    style: {
+                                        fontSize: "var(--ifm-code-font-size)",
+                                        color: "var(--openapi-required)",
+                                    },
+                                    children: " required",
+                                }),
+                            ]),
+                        ],
+                    }),
+                    (0, utils_1.create)("div", {
+                        style: { marginLeft: "1rem" },
+                        children: [
+                            (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema), (message) => (0, utils_1.create)("div", {
+                                style: { marginTop: ".5rem", marginBottom: ".5rem" },
+                                children: (0, createDescription_1.createDescription)(message),
+                            })),
+                            (0, utils_1.guard)(schema.description, (description) => (0, utils_1.create)("div", {
+                                style: { marginTop: ".5rem", marginBottom: ".5rem" },
+                                children: (0, createDescription_1.createDescription)(description),
+                            })),
+                            createNodes(schema),
+                        ],
+                    }),
+                ],
+            }),
+        ],
+    });
+}
+/**
+ * Creates the edges or "leaves" of a schema tree. Edges can branch into sub-nodes with createDetails().
+ */
+function createEdges({ name, schema, required }) {
+    var _a;
+    const schemaName = (0, schema_1.getSchemaName)(schema);
+    if (schema.oneOf !== undefined || schema.anyOf !== undefined) {
+        return createDetailsNode(name, schemaName, schema, required);
+    }
+    if (schema.allOf !== undefined) {
+        const { mergedSchemas, required, } = mergeAllOf(schema.allOf);
+        const mergedSchemaName = (0, schema_1.getSchemaName)(mergedSchemas);
+        if (mergedSchemas.oneOf !== undefined ||
+            mergedSchemas.anyOf !== undefined) {
+            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required);
+        }
+        if (mergedSchemas.properties !== undefined) {
+            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required);
+        }
+        if (mergedSchemas.additionalProperties !== undefined) {
+            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required);
+        }
+        return (0, utils_1.create)("SchemaItem", {
+            collapsible: false,
+            name,
+            required,
+            schemaDescription: mergedSchemas.description,
+            schemaName: schemaName,
+            qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
+        });
+    }
+    if (schema.properties !== undefined) {
+        return createDetailsNode(name, schemaName, schema, required);
+    }
+    if (schema.additionalProperties !== undefined) {
+        return createDetailsNode(name, schemaName, schema, required);
+    }
+    // array of objects
+    if (((_a = schema.items) === null || _a === void 0 ? void 0 : _a.properties) !== undefined) {
+        return createDetailsNode(name, schemaName, schema, required);
+    }
+    // primitives and array of non-objects
     return (0, utils_1.create)("SchemaItem", {
         collapsible: false,
         name,
         required,
         schemaDescription: schema.description,
-        schemaName: (0, schema_1.getSchemaName)(schema, true),
+        schemaName: schemaName,
         qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
     });
 }
-function createRows({ schema }) {
-    // object
-    if (schema.properties !== undefined) {
-        return (0, utils_1.create)("ul", {
-            children: Object.entries(schema.properties).map(([key, val]) => createRow({
-                name: key,
-                schema: val,
-                required: Array.isArray(schema.required)
-                    ? schema.required.includes(key)
-                    : false,
-            })),
-        });
+/**
+ * Creates a hierarchical level of a schema tree. Nodes produce edges that can branch into sub-nodes with edges, recursively.
+ */
+function createNodes(schema) {
+    if (schema.oneOf !== undefined || schema.anyOf !== undefined) {
+        return createAnyOneOf(schema);
     }
-    // TODO: This can be a bit complicated types can be missmatched and there can be nested allOfs which need to be resolved before merging properties
     if (schema.allOf !== undefined) {
-        const { properties, required } = resolveAllOf(schema.allOf);
-        return (0, utils_1.create)("div", {
-            children: [
-                (0, utils_1.create)("span", {
-                    className: "badge badge--info",
-                    style: { marginBottom: "1rem" },
-                    children: "allOf",
-                }),
-                (0, utils_1.create)("ul", {
-                    className: "allOf",
-                    children: Object.entries(properties).map(([key, val]) => createRow({
-                        name: key,
-                        schema: val,
-                        required: Array.isArray(required)
-                            ? required.includes(key)
-                            : false,
-                    })),
-                }),
-            ],
-        });
+        const { mergedSchemas } = mergeAllOf(schema.allOf);
+        // allOf seems to always result in properties
+        if (mergedSchemas.properties !== undefined) {
+            return createProperties(mergedSchemas);
+        }
+    }
+    if (schema.properties !== undefined) {
+        return createProperties(schema);
+    }
+    if (schema.additionalProperties !== undefined) {
+        return createAdditionalProperties(schema);
     }
-    // array
+    // TODO: figure out how to handle array of objects
     if (schema.items !== undefined) {
-        return createRows({ schema: schema.items });
+        return createItems(schema);
     }
     // primitive
-    return undefined;
-}
-function createRowsRoot({ schema }) {
-    // object
-    if (schema.properties !== undefined) {
-        return Object.entries(schema.properties).map(([key, val]) => createRow({
-            name: key,
-            schema: val,
-            required: Array.isArray(schema.required)
-                ? schema.required.includes(key)
-                : false,
-        }));
-    }
-    // TODO: This can be a bit complicated types can be missmatched and there can be nested allOfs which need to be resolved before merging properties
-    if (schema.allOf !== undefined) {
-        const { properties, required } = resolveAllOf(schema.allOf);
-        return Object.entries(properties).map(([key, val]) => createRow({
-            name: key,
-            schema: val,
-            required: Array.isArray(required) ? required.includes(key) : false,
-        }));
-    }
-    // array
-    if (schema.items !== undefined) {
+    if (schema.type !== undefined) {
         return (0, utils_1.create)("li", {
             children: (0, utils_1.create)("div", {
-                children: [createRows({ schema: schema.items })],
+                children: [
+                    (0, utils_1.create)("strong", { children: schema.type }),
+                    (0, utils_1.guard)(schema.format, (format) => (0, utils_1.create)("span", {
+                        style: { opacity: "0.6" },
+                        children: ` ${format}`,
+                    })),
+                    (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema), (message) => (0, utils_1.create)("div", {
+                        style: { marginTop: "var(--ifm-table-cell-padding)" },
+                        children: (0, createDescription_1.createDescription)(message),
+                    })),
+                    (0, utils_1.guard)(schema.description, (description) => (0, utils_1.create)("div", {
+                        style: { marginTop: "var(--ifm-table-cell-padding)" },
+                        children: (0, createDescription_1.createDescription)(description),
+                    })),
+                ],
             }),
         });
     }
-    // primitive
-    return (0, utils_1.create)("li", {
-        children: (0, utils_1.create)("div", {
-            children: [
-                (0, utils_1.create)("span", {
-                    style: { opacity: "0.6" },
-                    children: ` ${schema.type}`,
-                }),
-                (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema), (message) => (0, utils_1.create)("div", {
-                    style: { marginTop: "var(--ifm-table-cell-padding)" },
-                    children: (0, createDescription_1.createDescription)(message),
-                })),
-                (0, utils_1.guard)(schema.description, (description) => (0, utils_1.create)("div", {
-                    style: { marginTop: "var(--ifm-table-cell-padding)" },
-                    children: (0, createDescription_1.createDescription)(description),
-                })),
-            ],
-        }),
-    });
+    // Unknown node/schema type should return undefined
+    // So far, haven't seen this hit in testing
+    return undefined;
 }
 function createSchemaDetails({ title, body, ...rest }) {
     if (body === undefined ||
@@ -191,7 +380,6 @@ function createSchemaDetails({ title, body, ...rest }) {
         Object.keys(body.content).length === 0) {
         return undefined;
     }
-    // TODO:
     // NOTE: We just pick a random content-type.
     // How common is it to have multiple?
     const randomFirstKey = Object.keys(body.content)[0];
@@ -205,6 +393,7 @@ function createSchemaDetails({ title, body, ...rest }) {
             return undefined;
         }
     }
+    // Root-level schema dropdown
     return (0, createDetails_1.createDetails)({
         "data-collapsed": false,
         open: true,
@@ -214,6 +403,10 @@ function createSchemaDetails({ title, body, ...rest }) {
                 style: { textAlign: "left" },
                 children: [
                     (0, utils_1.create)("strong", { children: `${title}` }),
+                    (0, utils_1.guard)(firstBody.type === "array", (format) => (0, utils_1.create)("span", {
+                        style: { opacity: "0.6" },
+                        children: ` array`,
+                    })),
                     (0, utils_1.guard)(body.required, () => [
                         (0, utils_1.create)("strong", {
                             style: {
@@ -238,7 +431,7 @@ function createSchemaDetails({ title, body, ...rest }) {
             }),
             (0, utils_1.create)("ul", {
                 style: { marginLeft: "1rem" },
-                children: createRowsRoot({ schema: firstBody }),
+                children: createNodes(firstBody),
             }),
         ],
     });

package/lib/markdown/index.js

@@ -24,6 +24,7 @@ function createApiPageMD({ title, api: { deprecated, "x-deprecated-description":
         `import ParamsItem from "@theme/ParamsItem";\n`,
         `import SchemaItem from "@theme/SchemaItem"\n`,
         `import ApiTabs from "@theme/ApiTabs";\n`,
+        `import SchemaTabs from "@theme/SchemaTabs";\n`,
         `import TabItem from "@theme/TabItem";\n\n`,
         `## ${(0, lodash_1.escape)(title)}\n\n`,
         (0, createDeprecationNotice_1.createDeprecationNotice)({ deprecated, description: deprecatedDescription }),

package/lib/markdown/schema.js

@@ -8,22 +8,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getQualifierMessage = exports.getSchemaName = void 0;
 function prettyName(schema, circular) {
-    var _a, _b, _c;
-    if (schema.$ref) {
-        return schema.$ref.replace("#/components/schemas/", "") + circular
-            ? " (circular)"
-            : "";
-    }
+    var _a, _b, _c, _d, _e;
     if (schema.format) {
         return schema.format;
     }
     if (schema.allOf) {
+        if (typeof schema.allOf[0] === "string") {
+            // @ts-ignore
+            if (schema.allOf[0].includes("circular")) {
+                return schema.allOf[0];
+            }
+        }
+        return "object";
+    }
+    if (schema.oneOf) {
+        return "object";
+    }
+    if (schema.anyOf) {
         return "object";
     }
     if (schema.type === "object") {
         return (_b = (_a = schema.xml) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : schema.type;
+        // return schema.type;
+    }
+    if (schema.type === "array") {
+        return (_d = (_c = schema.xml) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : schema.type;
+        // return schema.type;
     }
-    return (_c = schema.title) !== null && _c !== void 0 ? _c : schema.type;
+    return (_e = schema.title) !== null && _e !== void 0 ? _e : schema.type;
 }
 function getSchemaName(schema, circular) {
     var _a;
@@ -35,8 +47,6 @@ function getSchemaName(schema, circular) {
 exports.getSchemaName = getSchemaName;
 function getQualifierMessage(schema) {
     // TODO:
-    // - maxItems
-    // - minItems
     // - uniqueItems
     // - maxProperties
     // - minProperties
@@ -92,6 +102,12 @@ function getQualifierMessage(schema) {
     if (schema.enum) {
         qualifierGroups.push(`[${schema.enum.map((e) => `\`${e}\``).join(", ")}]`);
     }
+    if (schema.minItems) {
+        qualifierGroups.push(`items >= ${schema.minItems}`);
+    }
+    if (schema.maxItems) {
+        qualifierGroups.push(`items <= ${schema.maxItems}`);
+    }
     if (qualifierGroups.length === 0) {
         return undefined;
     }

package/lib/markdown/utils.d.ts

@@ -1,4 +1,4 @@
-export declare type Children = string | undefined | (string | undefined)[];
+export declare type Children = string | undefined | (string | string[] | undefined)[];
 export declare type Props = Record<string, any> & {
     children?: Children;
 };