docusaurus-theme-openapi-docs 2.0.0-beta.2 → 2.0.0-beta.4

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@docusaurus/types";
+export default function docusaurusThemeOpenAPI(): Plugin<void>;

package/lib/index.js

@@ -1,64 +1,62 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = docusaurusThemeOpenAPI;
-var _path = _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /* ============================================================================
  * 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.
  * ========================================================================== */
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
 const NodePolyfillPlugin = require("node-polyfill-webpack-plugin");
 function docusaurusThemeOpenAPI() {
-  return {
-    name: "docusaurus-theme-openapi",
-    getClientModules() {
-      const modules = [require.resolve("./theme/styles.scss")];
-      return modules;
-    },
-    getThemePath() {
-      return _path.default.join(__dirname, "..", "lib-next", "theme");
-    },
-    getTypeScriptThemePath() {
-      return _path.default.resolve(__dirname, "..", "src", "theme");
-    },
-    configureWebpack(_, isServer, utils) {
-      const {
-        getStyleLoaders
-      } = utils;
-      const isProd = process.env.NODE_ENV === "production";
-      return {
-        plugins: [new NodePolyfillPlugin()],
-        module: {
-          rules: [{
-            test: /\.s[ca]ss$/,
-            oneOf: [{
-              test: /\.module\.s[ca]ss$/,
-              use: [...getStyleLoaders(isServer, {
-                modules: {
-                  localIdentName: isProd ? `[local]_[hash:base64:4]` : `[local]_[path][name]`,
-                  exportOnlyLocals: isServer
-                },
-                importLoaders: 2,
-                sourceMap: !isProd
-              }), {
-                loader: require.resolve("sass-loader"),
-                options: {}
-              }]
-            }, {
-              use: [...getStyleLoaders(isServer, {}), {
-                loader: require.resolve("sass-loader"),
-                options: {}
-              }]
-            }]
-          }]
-        }
-      };
-    }
-  };
-}
+    return {
+        name: "docusaurus-theme-openapi",
+        getClientModules() {
+            const modules = [
+                require.resolve(path_1.default.join(__dirname, "..", "lib", "theme", "styles.scss")),
+            ];
+            return modules;
+        },
+        getThemePath() {
+            return path_1.default.join(__dirname, "..", "lib", "theme");
+        },
+        getTypeScriptThemePath() {
+            return path_1.default.resolve(__dirname, "..", "src", "theme");
+        },
+        configureWebpack(_, isServer, utils) {
+            const rules = _.module?.rules ?? [];
+            const sassLoaderRule = rules.filter((r) => {
+                return String(r.test) === String(/\.s[ca]ss$/);
+            });
+            const { getStyleLoaders } = utils;
+            // Avoid conflicts with docusaurus-plugin-sass
+            if (sassLoaderRule.length === 0) {
+                return {
+                    plugins: [new NodePolyfillPlugin()],
+                    module: {
+                        rules: [
+                            {
+                                test: /\.s[ac]ss$/,
+                                include: path_1.default.resolve(__dirname, "..", "lib", "theme"),
+                                use: [
+                                    ...getStyleLoaders(isServer, {}),
+                                    {
+                                        loader: require.resolve("sass-loader"),
+                                        options: {},
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                };
+            }
+            return {
+                plugins: [new NodePolyfillPlugin()],
+            };
+        },
+    };
+}
+exports.default = docusaurusThemeOpenAPI;

package/lib/markdown/createDescription.d.ts

@@ -0,0 +1 @@
+export declare function createDescription(description: string | undefined): string;

package/lib/markdown/createDescription.js

@@ -1,19 +1,16 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createDescription = createDescription;
 /* ============================================================================
  * 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 });
+exports.createDescription = void 0;
 function createDescription(description) {
-  if (!description) {
-    return "";
-  }
-  return `\n\n${description}\n\n`;
-}
+    if (!description) {
+        return "";
+    }
+    return `\n\n${description}\n\n`;
+}
+exports.createDescription = createDescription;

package/lib/markdown/schema.d.ts

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

package/lib/markdown/schema.js

@@ -1,151 +1,150 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getQualifierMessage = getQualifierMessage;
-exports.getSchemaName = getSchemaName;
 /* ============================================================================
  * 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 });
+exports.getQualifierMessage = exports.getSchemaName = void 0;
 function prettyName(schema, circular) {
-  var _schema$title;
-  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") {
-    var _schema$xml$name, _schema$xml;
-    return (_schema$xml$name = (_schema$xml = schema.xml) === null || _schema$xml === void 0 ? void 0 : _schema$xml.name) !== null && _schema$xml$name !== void 0 ? _schema$xml$name : schema.type;
-    // return schema.type;
-  }
-
-  if (schema.type === "array") {
-    var _schema$xml$name2, _schema$xml2;
-    return (_schema$xml$name2 = (_schema$xml2 = schema.xml) === null || _schema$xml2 === void 0 ? void 0 : _schema$xml2.name) !== null && _schema$xml$name2 !== void 0 ? _schema$xml$name2 : schema.type;
-    // return schema.type;
-  }
-
-  return (_schema$title = schema.title) !== null && _schema$title !== void 0 ? _schema$title : schema.type;
+    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 schema.xml?.name ?? schema.type;
+        // return schema.type;
+    }
+    if (schema.type === "array") {
+        return schema.xml?.name ?? schema.type;
+        // return schema.type;
+    }
+    return schema.title ?? schema.type;
 }
 function getSchemaName(schema, circular) {
-  var _prettyName;
-  if (schema.items) {
-    return prettyName(schema.items, circular) + "[]";
-  }
-  return (_prettyName = prettyName(schema, circular)) !== null && _prettyName !== void 0 ? _prettyName : "";
+    if (schema.items) {
+        return prettyName(schema.items, circular) + "[]";
+    }
+    return prettyName(schema, circular) ?? "";
 }
+exports.getSchemaName = getSchemaName;
 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 || schema.maximum || 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 && !schema.exclusiveMinimum) {
-      minimum = `\`>= ${schema.minimum}\``;
-    } else if (schema.minimum && schema.exclusiveMinimum === true) {
-      minimum = `\`> ${schema.minimum}\``;
-    }
-    if (typeof schema.exclusiveMaximum === "number") {
-      maximum = `\`< ${schema.exclusiveMaximum}\``;
-    } else if (schema.maximum && !schema.exclusiveMaximum) {
-      maximum = `\`<= ${schema.maximum}\``;
-    } else if (schema.maximum && 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(", ");
-}
+    // 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 ||
+        schema.maximum ||
+        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 && !schema.exclusiveMinimum) {
+            minimum = `\`>= ${schema.minimum}\``;
+        }
+        else if (schema.minimum && schema.exclusiveMinimum === true) {
+            minimum = `\`> ${schema.minimum}\``;
+        }
+        if (typeof schema.exclusiveMaximum === "number") {
+            maximum = `\`< ${schema.exclusiveMaximum}\``;
+        }
+        else if (schema.maximum && !schema.exclusiveMaximum) {
+            maximum = `\`<= ${schema.maximum}\``;
+        }
+        else if (schema.maximum && 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(", ");
+}
+exports.getQualifierMessage = getQualifierMessage;

package/lib/markdown/utils.d.ts

@@ -0,0 +1,8 @@
+export declare type Children = string | undefined | (string | undefined)[];
+export declare type Props = Record<string, any> & {
+    children?: Children;
+};
+export declare function create(tag: string, props: Props): string;
+export declare function guard<T>(value: T | undefined | string, cb: (value: T) => Children): string;
+export declare function render(children: Children): string;
+export declare function toString(value: any): string | undefined;

package/lib/markdown/utils.js

@@ -1,56 +1,50 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.create = create;
-exports.guard = guard;
-exports.render = render;
-exports.toString = toString;
 /* ============================================================================
  * 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 });
+exports.toString = exports.render = exports.guard = exports.create = void 0;
 function create(tag, props) {
-  const {
-    children,
-    ...rest
-  } = props;
-  let propString = "";
-  for (const [key, value] of Object.entries(rest)) {
-    propString += ` ${key}={${JSON.stringify(value)}}`;
-  }
-  return `<${tag}${propString}>${render(children)}</${tag}>`;
+    const { children, ...rest } = props;
+    let propString = "";
+    for (const [key, value] of Object.entries(rest)) {
+        propString += ` ${key}={${JSON.stringify(value)}}`;
+    }
+    return `<${tag}${propString}>${render(children)}</${tag}>`;
 }
+exports.create = create;
 function guard(value, cb) {
-  if (!!value) {
-    const children = cb(value);
-    return render(children);
-  }
-  return "";
+    if (!!value) {
+        const children = cb(value);
+        return render(children);
+    }
+    return "";
 }
+exports.guard = guard;
 function render(children) {
-  if (Array.isArray(children)) {
-    return children.filter(c => c !== undefined).join("");
-  }
-  return children !== null && children !== void 0 ? children : "";
+    if (Array.isArray(children)) {
+        return children.filter((c) => c !== undefined).join("");
+    }
+    return children ?? "";
 }
+exports.render = render;
 function toString(value) {
-  // Return as-is if already string
-  if (typeof value === "string") {
-    return value;
-  }
-  // Return undefined if null or undefined
-  if (value == null) {
-    return undefined;
-  }
-  // Return formatted array if Array
-  if (Array.isArray(value)) {
-    return `[${value.join(", ")}]`;
-  }
-  // Coerce to string in all other cases,
-  return value + "";
-}
+    // Return as-is if already string
+    if (typeof value === "string") {
+        return value;
+    }
+    // Return undefined if null or undefined
+    if (value == null) {
+        return undefined;
+    }
+    // Return formatted array if Array
+    if (Array.isArray(value)) {
+        return `[${value.join(", ")}]`;
+    }
+    // Coerce to string in all other cases,
+    return value + "";
+}
+exports.toString = toString;