docusaurus-plugin-openapi-docs 1.0.6 → 1.1.2

package/README.md

@@ -121,7 +121,6 @@ The `docusaurus-plugin-openapi-docs` plugin can be configured with the following
 | ---------------- | -------- | ------- | --------------------------------------------------------------------------------------------------------------------------- |
 | `specPath`       | `string` | `null`  | Designated URL or path to the source of an OpenAPI specification file or directory of multiple OpenAPI specification files. |
 | `ouputDir`       | `string` | `null`  | Desired output path for generated MDX files.                                                                                |
-| `ouputDir`       | `string` | `null`  | Desired output path for generated MDX files.                                                                                |
 | `template`       | `string` | `null`  | _Optional:_ Customize MDX content with a desired template.                                                                  |
 | `sidebarOptions` | `object` | `null`  | _Optional:_ Set of options for sidebar configuration. See below for a list of supported options.                            |
 | `version`        | `string` | `null`  | _Optional:_ Version assigned to single or micro-spec API specified in `specPath`.                                           |
@@ -247,7 +246,7 @@ yarn docusaurus gen-api-docs:version petstore:all
 Run the following to bootstrap a Docsaurus v2 site (classic theme) with `docusaurus-openapi-docs`:
 
 ```bash
-npx create-docusaurus@2.0.0-beta.21 my-website --package-manager yarn
+npx create-docusaurus@2.0.0-rc.1 my-website --package-manager yarn
 ```
 
 > When prompted to select a template choose `Git repository`.

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;
 };

package/lib/markdown/utils.js

@@ -26,7 +26,10 @@ function guard(value, cb) {
 exports.guard = guard;
 function render(children) {
     if (Array.isArray(children)) {
-        return children.filter((c) => c !== undefined).join("");
+        const filteredChildren = children.filter((c) => c !== undefined);
+        return filteredChildren
+            .map((i) => (Array.isArray(i) ? i.join("") : i))
+            .join("");
     }
     return children !== null && children !== void 0 ? children : "";
 }

package/lib/openapi/openapi.d.ts

@@ -1,12 +1,12 @@
 import { ApiMetadata, APIOptions, SidebarOptions } from "../types";
-import { OpenApiObjectWithRef, TagObject } from "./types";
+import { OpenApiObject, TagObject } from "./types";
 interface OpenApiFiles {
     source: string;
     sourceDirName: string;
-    data: OpenApiObjectWithRef;
+    data: OpenApiObject;
 }
 export declare function readOpenapiFiles(openapiPath: string, options: APIOptions): Promise<OpenApiFiles[]>;
 export declare function processOpenapiFiles(files: OpenApiFiles[], sidebarOptions: SidebarOptions): Promise<[ApiMetadata[], TagObject[]]>;
-export declare function processOpenapiFile(openapiDataWithRefs: OpenApiObjectWithRef, sidebarOptions: SidebarOptions): Promise<[ApiMetadata[], TagObject[]]>;
+export declare function processOpenapiFile(openapiData: OpenApiObject, sidebarOptions: SidebarOptions): Promise<[ApiMetadata[], TagObject[]]>;
 export declare function getTagDisplayName(tagName: string, tags: TagObject[]): string;
 export {};