docusaurus-plugin-openapi-docs 0.0.0-1155 → 0.0.0-1156

package/lib/markdown/createSchema.js

@@ -122,7 +122,6 @@ function createProperties(schema) {
             name: "",
             required: false,
             schemaName: "object",
-            qualifierMessage: undefined,
             schema: {},
         });
     }
@@ -151,7 +150,6 @@ function createAdditionalProperties(schema) {
             name: "property name*",
             required: false,
             schemaName: "any",
-            qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
             schema: schema,
             collapsible: false,
             discriminator: false,
@@ -179,7 +177,6 @@ function createAdditionalProperties(schema) {
             name: "property name*",
             required: false,
             schemaName: schemaName,
-            qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
             schema: additionalProperties,
             collapsible: false,
             discriminator: false,
@@ -336,10 +333,6 @@ function createDetailsNode(name, schemaName, schema, required, nullable) {
                                 style: { marginTop: ".5rem", marginBottom: ".5rem" },
                                 children: (0, createDescription_1.createDescription)(description),
                             })),
-                            (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),
-                            })),
                             createNodes(schema, SCHEMA_TYPE),
                         ],
                     }),
@@ -465,12 +458,6 @@ function createPropertyDiscriminator(name, schemaName, schema, discriminator, re
                     },
                     children: (0, createDescription_1.createDescription)(description),
                 })),
-                (0, utils_1.guard)((0, schema_1.getQualifierMessage)(discriminator), (message) => (0, utils_1.create)("div", {
-                    style: {
-                        paddingLeft: "1rem",
-                    },
-                    children: (0, createDescription_1.createDescription)(message),
-                })),
                 (0, utils_1.create)("DiscriminatorTabs", {
                     className: "openapi-tabs__discriminator",
                     children: Object.keys(discriminator === null || discriminator === void 0 ? void 0 : discriminator.mapping).map((key, index) => {
@@ -554,7 +541,6 @@ function createEdges({ name, schema, required, discriminator, }) {
             name,
             required: Array.isArray(required) ? required.includes(name) : required,
             schemaName: mergedSchemaName,
-            qualifierMessage: (0, schema_1.getQualifierMessage)(mergedSchemas),
             schema: mergedSchemas,
         });
     }
@@ -564,7 +550,6 @@ function createEdges({ name, schema, required, discriminator, }) {
         name,
         required: Array.isArray(required) ? required.includes(name) : required,
         schemaName: schemaName,
-        qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
         schema: schema,
     });
 }
@@ -633,15 +618,7 @@ function createNodes(schema, schemaType) {
                 marginTop: ".5rem",
                 marginBottom: ".5rem",
             },
-            children: [
-                (0, createDescription_1.createDescription)(schema.type),
-                (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema), (message) => (0, utils_1.create)("div", {
-                    style: {
-                        paddingTop: "1rem",
-                    },
-                    children: (0, createDescription_1.createDescription)(message),
-                })),
-            ],
+            children: [(0, createDescription_1.createDescription)(schema.type)],
         });
     }
     // handle circular references
@@ -651,15 +628,7 @@ function createNodes(schema, schemaType) {
                 marginTop: ".5rem",
                 marginBottom: ".5rem",
             },
-            children: [
-                (0, createDescription_1.createDescription)(schema),
-                (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema), (message) => (0, utils_1.create)("div", {
-                    style: {
-                        paddingTop: "1rem",
-                    },
-                    children: (0, createDescription_1.createDescription)(message),
-                })),
-            ],
+            children: [(0, createDescription_1.createDescription)(schema)],
         });
     }
     // Unknown node/schema type should return undefined

package/lib/markdown/schema.d.ts

@@ -1,3 +1,2 @@
 import { SchemaObject } from "../openapi/types";
 export declare function getSchemaName(schema: SchemaObject, circular?: boolean): string;
-export declare function getQualifierMessage(schema?: SchemaObject): string | undefined;

package/lib/markdown/schema.js

@@ -7,7 +7,6 @@
  * ========================================================================== */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSchemaName = getSchemaName;
-exports.getQualifierMessage = getQualifierMessage;
 function prettyName(schema, circular) {
     var _a, _b, _c, _d, _e;
     // Handle enum-only schemas (valid in JSON Schema)
@@ -56,107 +55,3 @@ function getSchemaName(schema, circular) {
     }
     return (_a = prettyName(schema, circular)) !== null && _a !== void 0 ? _a : "";
 }
-function getQualifierMessage(schema) {
-    // TODO:
-    // - uniqueItems
-    // - maxProperties
-    // - minProperties
-    // - multipleOf
-    if (!schema) {
-        return undefined;
-    }
-    if (schema.items &&
-        schema.minItems === undefined &&
-        schema.maxItems === undefined) {
-        return getQualifierMessage(schema.items);
-    }
-    let message = "**Possible values:** ";
-    let qualifierGroups = [];
-    if (schema.items && schema.items.enum) {
-        if (schema.items.enum) {
-            qualifierGroups.push(`[${schema.items.enum.map((e) => `\`${e}\``).join(", ")}]`);
-        }
-    }
-    if (schema.minLength || schema.maxLength) {
-        let lengthQualifier = "";
-        let minLength;
-        let maxLength;
-        if (schema.minLength && schema.minLength > 1) {
-            minLength = `\`>= ${schema.minLength} characters\``;
-        }
-        if (schema.minLength && schema.minLength === 1) {
-            minLength = `\`non-empty\``;
-        }
-        if (schema.maxLength) {
-            maxLength = `\`<= ${schema.maxLength} characters\``;
-        }
-        if (minLength && !maxLength) {
-            lengthQualifier += minLength;
-        }
-        if (maxLength && !minLength) {
-            lengthQualifier += maxLength;
-        }
-        if (minLength && maxLength) {
-            lengthQualifier += `${minLength} and ${maxLength}`;
-        }
-        qualifierGroups.push(lengthQualifier);
-    }
-    if (schema.minimum != null ||
-        schema.maximum != null ||
-        typeof schema.exclusiveMinimum === "number" ||
-        typeof schema.exclusiveMaximum === "number") {
-        let minmaxQualifier = "";
-        let minimum;
-        let maximum;
-        if (typeof schema.exclusiveMinimum === "number") {
-            minimum = `\`> ${schema.exclusiveMinimum}\``;
-        }
-        else if (schema.minimum != null && !schema.exclusiveMinimum) {
-            minimum = `\`>= ${schema.minimum}\``;
-        }
-        else if (schema.minimum != null && schema.exclusiveMinimum === true) {
-            minimum = `\`> ${schema.minimum}\``;
-        }
-        if (typeof schema.exclusiveMaximum === "number") {
-            maximum = `\`< ${schema.exclusiveMaximum}\``;
-        }
-        else if (schema.maximum != null && !schema.exclusiveMaximum) {
-            maximum = `\`<= ${schema.maximum}\``;
-        }
-        else if (schema.maximum != null && schema.exclusiveMaximum === true) {
-            maximum = `\`< ${schema.maximum}\``;
-        }
-        if (minimum && !maximum) {
-            minmaxQualifier += minimum;
-        }
-        if (maximum && !minimum) {
-            minmaxQualifier += maximum;
-        }
-        if (minimum && maximum) {
-            minmaxQualifier += `${minimum} and ${maximum}`;
-        }
-        qualifierGroups.push(minmaxQualifier);
-    }
-    if (schema.pattern) {
-        qualifierGroups.push(`Value must match regular expression \`${schema.pattern}\``);
-    }
-    // Check if discriminator mapping
-    const discriminator = schema;
-    if (discriminator.mapping) {
-        const values = Object.keys(discriminator.mapping);
-        qualifierGroups.push(`[${values.map((e) => `\`${e}\``).join(", ")}]`);
-    }
-    if (schema.enum) {
-        qualifierGroups.push(`[${schema.enum.map((e) => `\`${e}\``).join(", ")}]`);
-    }
-    if (schema.minItems) {
-        qualifierGroups.push(`\`>= ${schema.minItems}\``);
-    }
-    if (schema.maxItems) {
-        qualifierGroups.push(`\`<= ${schema.maxItems}\``);
-    }
-    if (qualifierGroups.length === 0) {
-        return undefined;
-    }
-    return message + qualifierGroups.join(", ");
-}

package/lib/markdown/utils.js

@@ -81,7 +81,9 @@ function create(tag, props, options = {}) {
     else {
         // Inline props as usual
         for (const [key, value] of Object.entries(rest)) {
-            propString += `\n  ${key}={${JSON.stringify(value)}}`;
+            if (value !== undefined) {
+                propString += `\n  ${key}={${JSON.stringify(value)}}`;
+            }
         }
     }
     let indentedChildren = render(children).replace(/^/gm, "  ");

package/lib/openapi/utils/utils/openapi.d.ts

@@ -19,8 +19,6 @@ export declare function getSerializedValue(field: any, example: any): any;
 export declare function langFromMime(contentType: string): string;
 export declare function isNamedDefinition(pointer?: string): boolean;
 export declare function getDefinitionName(pointer?: string): string | undefined;
-export declare function humanizeNumberRange(schema: OpenAPISchema): string | undefined;
-export declare function humanizeConstraints(schema: OpenAPISchema): string[];
 export declare function sortByRequired(fields: any[], order?: string[]): any[];
 export declare function sortByField(fields: any[], param: "name" | "description" | "kind"): any[];
 export declare function mergeParams(parser: OpenAPIParser, pathParams?: Array<Referenced<OpenAPIParameter>>, operationParams?: Array<Referenced<OpenAPIParameter>>): Array<Referenced<OpenAPIParameter>>;

package/lib/openapi/utils/utils/openapi.js

@@ -22,8 +22,6 @@ exports.getSerializedValue = getSerializedValue;
 exports.langFromMime = langFromMime;
 exports.isNamedDefinition = isNamedDefinition;
 exports.getDefinitionName = getDefinitionName;
-exports.humanizeNumberRange = humanizeNumberRange;
-exports.humanizeConstraints = humanizeConstraints;
 exports.sortByRequired = sortByRequired;
 exports.sortByField = sortByField;
 exports.mergeParams = mergeParams;
@@ -366,86 +364,6 @@ function getDefinitionName(pointer) {
     const [name] = ((_a = pointer === null || pointer === void 0 ? void 0 : pointer.match(DEFINITION_NAME_REGEX)) === null || _a === void 0 ? void 0 : _a.reverse()) || [];
     return name;
 }
-function humanizeMultipleOfConstraint(multipleOf) {
-    if (multipleOf === undefined) {
-        return;
-    }
-    const strigifiedMultipleOf = multipleOf.toString(10);
-    if (!/^0\.0*1$/.test(strigifiedMultipleOf)) {
-        return `multiple of ${strigifiedMultipleOf}`;
-    }
-    return `decimal places <= ${strigifiedMultipleOf.split(".")[1].length}`;
-}
-function humanizeRangeConstraint(description, min, max) {
-    let stringRange;
-    if (min !== undefined && max !== undefined) {
-        if (min === max) {
-            stringRange = `= ${min} ${description}`;
-        }
-        else {
-            stringRange = `[ ${min} .. ${max} ] ${description}`;
-        }
-    }
-    else if (max !== undefined) {
-        stringRange = `<= ${max} ${description}`;
-    }
-    else if (min !== undefined) {
-        if (min === 1) {
-            stringRange = "non-empty";
-        }
-        else {
-            stringRange = `>= ${min} ${description}`;
-        }
-    }
-    return stringRange;
-}
-function humanizeNumberRange(schema) {
-    var _a, _b;
-    const minimum = typeof schema.exclusiveMinimum === "number"
-        ? Math.min(schema.exclusiveMinimum, (_a = schema.minimum) !== null && _a !== void 0 ? _a : Infinity)
-        : schema.minimum;
-    const maximum = typeof schema.exclusiveMaximum === "number"
-        ? Math.max(schema.exclusiveMaximum, (_b = schema.maximum) !== null && _b !== void 0 ? _b : -Infinity)
-        : schema.maximum;
-    const exclusiveMinimum = typeof schema.exclusiveMinimum === "number" || schema.exclusiveMinimum;
-    const exclusiveMaximum = typeof schema.exclusiveMaximum === "number" || schema.exclusiveMaximum;
-    if (minimum !== undefined && maximum !== undefined) {
-        return `${exclusiveMinimum ? "( " : "[ "}${minimum} .. ${maximum}${exclusiveMaximum ? " )" : " ]"}`;
-    }
-    else if (maximum !== undefined) {
-        return `${exclusiveMaximum ? "< " : "<= "}${maximum}`;
-    }
-    else if (minimum !== undefined) {
-        return `${exclusiveMinimum ? "> " : ">= "}${minimum}`;
-    }
-}
-function humanizeConstraints(schema) {
-    const res = [];
-    const stringRange = humanizeRangeConstraint("characters", schema.minLength, schema.maxLength);
-    if (stringRange !== undefined) {
-        res.push(stringRange);
-    }
-    const arrayRange = humanizeRangeConstraint("items", schema.minItems, schema.maxItems);
-    if (arrayRange !== undefined) {
-        res.push(arrayRange);
-    }
-    const propertiesRange = humanizeRangeConstraint("properties", schema.minProperties, schema.maxProperties);
-    if (propertiesRange !== undefined) {
-        res.push(propertiesRange);
-    }
-    const multipleOfConstraint = humanizeMultipleOfConstraint(schema.multipleOf);
-    if (multipleOfConstraint !== undefined) {
-        res.push(multipleOfConstraint);
-    }
-    const numberRange = humanizeNumberRange(schema);
-    if (numberRange !== undefined) {
-        res.push(numberRange);
-    }
-    if (schema.uniqueItems) {
-        res.push("unique");
-    }
-    return res;
-}
 function sortByRequired(fields, order = []) {
     const unrequiredFields = [];
     const orderedFields = [];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-plugin-openapi-docs",
   "description": "OpenAPI plugin for Docusaurus.",
-  "version": "0.0.0-1155",
+  "version": "0.0.0-1156",
   "license": "MIT",
   "keywords": [
     "openapi",
@@ -65,5 +65,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "388036c8328b54f841365688b671422a418098bb"
+  "gitHead": "15f538e349ea6e12482cb5a53dea9c349fd9157e"
 }