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

package/src/markdown/createLicense.ts

@@ -10,7 +10,7 @@ import { LicenseObject } from "../openapi/types";
 
 export function createLicense(license: LicenseObject) {
   if (!license || !Object.keys(license).length) return "";
-  const { name, url } = license;
+  const { name, url, identifier } = license;
 
   return create("div", {
     style: {
@@ -29,6 +29,12 @@ export function createLicense(license: LicenseObject) {
           children: name ?? url,
         })
       ),
+      guard(identifier, () =>
+        create("a", {
+          href: `https://spdx.org/licenses/${identifier}.html`,
+          children: name ?? identifier,
+        })
+      ),
     ],
   });
 }

package/src/markdown/createSchema.ts

@@ -17,7 +17,7 @@ import {
 import { createDescription } from "./createDescription";
 import { createDetails } from "./createDetails";
 import { createDetailsSummary } from "./createDetailsSummary";
-import { getQualifierMessage, getSchemaName } from "./schema";
+import { getSchemaName } from "./schema";
 import { create, guard } from "./utils";
 import { SchemaObject } from "../openapi/types";
 
@@ -140,7 +140,6 @@ function createProperties(schema: SchemaObject) {
       name: "",
       required: false,
       schemaName: "object",
-      qualifierMessage: undefined,
       schema: {},
     });
   }
@@ -169,7 +168,6 @@ function createAdditionalProperties(schema: SchemaObject) {
       name: "property name*",
       required: false,
       schemaName: "any",
-      qualifierMessage: getQualifierMessage(schema),
       schema: schema,
       collapsible: false,
       discriminator: false,
@@ -209,7 +207,6 @@ function createAdditionalProperties(schema: SchemaObject) {
       name: "property name*",
       required: false,
       schemaName: schemaName,
-      qualifierMessage: getQualifierMessage(schema),
       schema: additionalProperties,
       collapsible: false,
       discriminator: false,
@@ -399,12 +396,6 @@ function createDetailsNode(
                   children: createDescription(description),
                 })
               ),
-              guard(getQualifierMessage(schema), (message) =>
-                create("div", {
-                  style: { marginTop: ".5rem", marginBottom: ".5rem" },
-                  children: createDescription(message),
-                })
-              ),
               createNodes(schema, SCHEMA_TYPE),
             ],
           }),
@@ -545,14 +536,6 @@ function createPropertyDiscriminator(
             children: createDescription(description),
           })
         ),
-        guard(getQualifierMessage(discriminator), (message) =>
-          create("div", {
-            style: {
-              paddingLeft: "1rem",
-            },
-            children: createDescription(message),
-          })
-        ),
         create("DiscriminatorTabs", {
           className: "openapi-tabs__discriminator",
           children: Object.keys(discriminator?.mapping!).map((key, index) => {
@@ -727,7 +710,6 @@ function createEdges({
       name,
       required: Array.isArray(required) ? required.includes(name) : required,
       schemaName: mergedSchemaName,
-      qualifierMessage: getQualifierMessage(mergedSchemas),
       schema: mergedSchemas,
     });
   }
@@ -738,7 +720,6 @@ function createEdges({
     name,
     required: Array.isArray(required) ? required.includes(name) : required,
     schemaName: schemaName,
-    qualifierMessage: getQualifierMessage(schema),
     schema: schema,
   });
 }
@@ -823,17 +804,7 @@ export function createNodes(
         marginTop: ".5rem",
         marginBottom: ".5rem",
       },
-      children: [
-        createDescription(schema.type),
-        guard(getQualifierMessage(schema), (message) =>
-          create("div", {
-            style: {
-              paddingTop: "1rem",
-            },
-            children: createDescription(message),
-          })
-        ),
-      ],
+      children: [createDescription(schema.type)],
     });
   }
 
@@ -844,17 +815,7 @@ export function createNodes(
         marginTop: ".5rem",
         marginBottom: ".5rem",
       },
-      children: [
-        createDescription(schema),
-        guard(getQualifierMessage(schema), (message) =>
-          create("div", {
-            style: {
-              paddingTop: "1rem",
-            },
-            children: createDescription(message),
-          })
-        ),
-      ],
+      children: [createDescription(schema)],
     });
   }
 

package/src/markdown/schema.ts

@@ -66,129 +66,3 @@ export function getSchemaName(
 
   return prettyName(schema, circular) ?? "";
 }
-
-export function getQualifierMessage(schema?: SchemaObject): string | undefined {
-  // 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 as any;
-  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/src/markdown/utils.ts

@@ -129,7 +129,9 @@ export function create(
   } 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)}}`;
+      }
     }
   }
 

package/src/openapi/types.ts

@@ -65,6 +65,7 @@ export interface ContactObject {
 export interface LicenseObject {
   name: string;
   url?: string;
+  identifier?: string;
 }
 
 export interface ServerObject {

package/src/openapi/utils/utils/openapi.ts

@@ -450,116 +450,6 @@ export function getDefinitionName(pointer?: string): string | undefined {
   return name;
 }
 
-function humanizeMultipleOfConstraint(
-  multipleOf: number | undefined
-): string | undefined {
-  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: string,
-  min: number | undefined,
-  max: number | undefined
-): string | undefined {
-  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;
-}
-
-export function humanizeNumberRange(schema: OpenAPISchema): string | undefined {
-  const minimum =
-    typeof schema.exclusiveMinimum === "number"
-      ? Math.min(schema.exclusiveMinimum, schema.minimum ?? Infinity)
-      : schema.minimum;
-  const maximum =
-    typeof schema.exclusiveMaximum === "number"
-      ? Math.max(schema.exclusiveMaximum, schema.maximum ?? -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}`;
-  }
-}
-
-export function humanizeConstraints(schema: OpenAPISchema): string[] {
-  const res: string[] = [];
-
-  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;
-}
-
 export function sortByRequired(fields: any[], order: string[] = []) {
   const unrequiredFields: any[] = [];
   const orderedFields: any[] = [];

package/lib/markdown/schema.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/markdown/schema.test.js

@@ -1,181 +0,0 @@
-"use strict";
-/* ============================================================================
- * Copyright (c) Palo Alto Networks
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- * ========================================================================== */
-Object.defineProperty(exports, "__esModule", { value: true });
-const schema_1 = require("./schema");
-describe("getQualifierMessage", () => {
-    it("should render nothing", () => {
-        const actual = (0, schema_1.getQualifierMessage)({});
-        expect(actual).toBeUndefined();
-    });
-    //
-    // minLength + maxLength
-    //
-    it("should render minLength", () => {
-        const expected = "**Possible values:** `non-empty`";
-        const actual = (0, schema_1.getQualifierMessage)({ minLength: 1 });
-        expect(actual).toBe(expected);
-    });
-    it("should render maxLength", () => {
-        const expected = "**Possible values:** `<= 40 characters`";
-        const actual = (0, schema_1.getQualifierMessage)({ maxLength: 40 });
-        expect(actual).toBe(expected);
-    });
-    it("should render minLength and maxLength", () => {
-        const expected = "**Possible values:** `non-empty` and `<= 40 characters`";
-        const actual = (0, schema_1.getQualifierMessage)({ minLength: 1, maxLength: 40 });
-        expect(actual).toBe(expected);
-    });
-    //
-    // pattern
-    //
-    it("should render pattern", () => {
-        const expected = "**Possible values:** Value must match regular expression `^[a-zA-Z0-9_-]*$`";
-        const actual = (0, schema_1.getQualifierMessage)({ pattern: "^[a-zA-Z0-9_-]*$" });
-        expect(actual).toBe(expected);
-    });
-    it("should render multiple string qualifiers", () => {
-        const expected = "**Possible values:** `non-empty` and `<= 40 characters`, Value must match regular expression `^[a-zA-Z0-9_-]*$`";
-        const actual = (0, schema_1.getQualifierMessage)({
-            minLength: 1,
-            maxLength: 40,
-            pattern: "^[a-zA-Z0-9_-]*$",
-        });
-        expect(actual).toBe(expected);
-    });
-    //
-    // enum
-    //
-    it("should render enum", () => {
-        const expected = "**Possible values:** [`cat`, `dog`, `mouse`]";
-        const actual = (0, schema_1.getQualifierMessage)({ enum: ["cat", "dog", "mouse"] });
-        expect(actual).toBe(expected);
-    });
-    //
-    // minimum + maximum + exclusiveMinimum + exclusiveMaximum
-    //
-    it("should render minimum", () => {
-        const expected = "**Possible values:** `>= 1`";
-        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1 });
-        expect(actual).toBe(expected);
-    });
-    it("should render maximum", () => {
-        const expected = "**Possible values:** `<= 40`";
-        const actual = (0, schema_1.getQualifierMessage)({ maximum: 40 });
-        expect(actual).toBe(expected);
-    });
-    it("should render numeric exclusiveMinimum", () => {
-        const expected = "**Possible values:** `> 1`";
-        const actual = (0, schema_1.getQualifierMessage)({ exclusiveMinimum: 1 });
-        expect(actual).toBe(expected);
-    });
-    it("should render numeric exclusiveMaximum", () => {
-        const expected = "**Possible values:** `< 40`";
-        const actual = (0, schema_1.getQualifierMessage)({ exclusiveMaximum: 40 });
-        expect(actual).toBe(expected);
-    });
-    it("should render boolean exclusiveMinimum", () => {
-        const expected = "**Possible values:** `> 1`";
-        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1, exclusiveMinimum: true });
-        expect(actual).toBe(expected);
-    });
-    it("should render boolean exclusiveMaximum", () => {
-        const expected = "**Possible values:** `< 40`";
-        const actual = (0, schema_1.getQualifierMessage)({ maximum: 40, exclusiveMaximum: true });
-        expect(actual).toBe(expected);
-    });
-    it("should render minimum when exclusiveMinimum is false", () => {
-        const expected = "**Possible values:** `>= 1`";
-        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1, exclusiveMinimum: false });
-        expect(actual).toBe(expected);
-    });
-    it("should render maximum when exclusiveMaximum is false", () => {
-        const expected = "**Possible values:** `<= 40`";
-        const actual = (0, schema_1.getQualifierMessage)({
-            maximum: 40,
-            exclusiveMaximum: false,
-        });
-        expect(actual).toBe(expected);
-    });
-    it("should render minimum and maximum", () => {
-        const expected = "**Possible values:** `>= 1` and `<= 40`";
-        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1, maximum: 40 });
-        expect(actual).toBe(expected);
-    });
-    it("should render 0 minimum and maximum", () => {
-        const expected = "**Possible values:** `>= 0` and `<= 40`";
-        const actual = (0, schema_1.getQualifierMessage)({ minimum: 0, maximum: 40 });
-        expect(actual).toBe(expected);
-    });
-    it("should render minimum and 0 maximum", () => {
-        const expected = "**Possible values:** `>= -10` and `<= 0`";
-        const actual = (0, schema_1.getQualifierMessage)({ minimum: -10, maximum: 0 });
-        expect(actual).toBe(expected);
-    });
-    it("should render boolean exclusiveMinimum and maximum", () => {
-        const expected = "**Possible values:** `> 1` and `<= 40`";
-        const actual = (0, schema_1.getQualifierMessage)({
-            minimum: 1,
-            maximum: 40,
-            exclusiveMinimum: true,
-        });
-        expect(actual).toBe(expected);
-    });
-    it("should render minimum and boolean exclusiveMaximum", () => {
-        const expected = "**Possible values:** `>= 1` and `< 40`";
-        const actual = (0, schema_1.getQualifierMessage)({
-            minimum: 1,
-            maximum: 40,
-            exclusiveMaximum: true,
-        });
-        expect(actual).toBe(expected);
-    });
-    it("should render numeric exclusiveMinimum and maximum", () => {
-        const expected = "**Possible values:** `> 1` and `<= 40`";
-        const actual = (0, schema_1.getQualifierMessage)({
-            exclusiveMinimum: 1,
-            maximum: 40,
-        });
-        expect(actual).toBe(expected);
-    });
-    it("should render minimum and numeric exclusiveMaximum", () => {
-        const expected = "**Possible values:** `>= 1` and `< 40`";
-        const actual = (0, schema_1.getQualifierMessage)({
-            minimum: 1,
-            exclusiveMaximum: 40,
-        });
-        expect(actual).toBe(expected);
-    });
-    it("should render numeric exclusiveMinimum and boolean exclusiveMaximum", () => {
-        const expected = "**Possible values:** `> 1` and `< 40`";
-        const actual = (0, schema_1.getQualifierMessage)({
-            exclusiveMinimum: 1,
-            maximum: 40,
-            exclusiveMaximum: true,
-        });
-        expect(actual).toBe(expected);
-    });
-    it("should render nothing with empty boolean exclusiveMinimum", () => {
-        const actual = (0, schema_1.getQualifierMessage)({
-            exclusiveMinimum: true,
-        });
-        expect(actual).toBeUndefined();
-    });
-    it("should render nothing with empty boolean exclusiveMaximum", () => {
-        const actual = (0, schema_1.getQualifierMessage)({
-            exclusiveMaximum: true,
-        });
-        expect(actual).toBeUndefined();
-    });
-    it("should render nothing with empty boolean exclusiveMinimum and exclusiveMaximum", () => {
-        const actual = (0, schema_1.getQualifierMessage)({
-            exclusiveMinimum: true,
-            exclusiveMaximum: true,
-        });
-        expect(actual).toBeUndefined();
-    });
-});