docusaurus-plugin-openapi-docs 0.0.0-395 → 0.0.0-396

package/lib/markdown/createAnyOneOf.js

@@ -9,14 +9,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAnyOneOf = void 0;
 const createSchemaDetails_1 = require("./createSchemaDetails");
 const utils_1 = require("./utils");
-// {
-//   'application/json': {
-//     schema: { properties: [Object], required: [Array], type: 'object' }
-//   }
-// }
-// {
-//   'application/json': { schema: { allOf: [Array], example: [Object] } }
-// }
 function createAnyOneOf(anyOneOf, type) {
     if (anyOneOf === undefined) {
         return undefined;
@@ -32,47 +24,19 @@ function createAnyOneOf(anyOneOf, type) {
             }),
             (0, utils_1.create)("SchemaTabs", {
                 children: anyOneOf.map((schema, index) => {
-                    // Prep schema details
-                    let schemaDetails = {};
-                    schemaDetails["application/json"] = {}; // Placeholder content type
-                    schemaDetails["application/json"].schema = {};
                     const label = schema.title ? schema.title : `MOD${index + 1}`;
                     if (schema.properties !== undefined) {
-                        schemaDetails["application/json"].schema.properties =
-                            schema.properties;
-                        schemaDetails["application/json"].schema.required = schema.required;
-                        schemaDetails["application/json"].schema.type = "object";
                         return (0, utils_1.create)("TabItem", {
                             label: label,
                             value: `${index}-properties`,
-                            children: [
-                                (0, utils_1.create)("div", {
-                                    children: (0, createSchemaDetails_1.createSchemaDetails)({
-                                        title: "Schema",
-                                        body: {
-                                            content: schemaDetails,
-                                        },
-                                    }),
-                                }),
-                            ],
+                            children: [(0, createSchemaDetails_1.createRows)({ schema: schema })],
                         });
                     }
                     if (schema.allOf !== undefined) {
-                        schemaDetails["application/json"].schema.allOf = schema.allOf;
-                        schemaDetails["application/json"].schema.example = schema.example;
                         return (0, utils_1.create)("TabItem", {
                             label: label,
                             value: `${index}-allOf`,
-                            children: [
-                                (0, utils_1.create)("div", {
-                                    children: (0, createSchemaDetails_1.createSchemaDetails)({
-                                        title: "Schema",
-                                        body: {
-                                            content: schemaDetails,
-                                        },
-                                    }),
-                                }),
-                            ],
+                            children: [(0, createSchemaDetails_1.createRows)({ schema: schema })],
                         });
                     }
                     return undefined;

package/lib/markdown/createSchemaDetails.d.ts

@@ -1,4 +1,8 @@
-import { MediaTypeObject } from "../openapi/types";
+import { MediaTypeObject, SchemaObject } from "../openapi/types";
+interface RowsProps {
+    schema: SchemaObject;
+}
+export declare function createRows({ schema }: RowsProps): string | undefined;
 interface Props {
     style?: any;
     title: string;

package/lib/markdown/createSchemaDetails.js

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  * ========================================================================== */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSchemaDetails = void 0;
+exports.createSchemaDetails = exports.createRows = void 0;
 const createAnyOneOf_1 = require("./createAnyOneOf");
 const createDescription_1 = require("./createDescription");
 const createDetails_1 = require("./createDetails");
@@ -16,7 +16,6 @@ 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, {
         resolvers: {
             readOnly: function () {
@@ -27,9 +26,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];
@@ -37,10 +33,55 @@ function resolveAllOf(allOf) {
         }
         return acc;
     }, []);
-    return { properties, required };
+    return { mergedSchemas, required };
 }
 function createRow({ name, schema, required }) {
-    const schemaName = (0, schema_1.getSchemaName)(schema, true);
+    const schemaName = (0, schema_1.getSchemaName)(schema);
+    // array
+    if (schema.type === "array" && schema.items) {
+        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.items }),
+                            ],
+                        }),
+                    ],
+                }),
+            ],
+        });
+    }
     if (schemaName && (schemaName === "object" || schemaName === "object[]")) {
         return (0, utils_1.create)("SchemaItem", {
             collapsible: true,
@@ -85,16 +126,25 @@ function createRow({ name, schema, required }) {
             ],
         });
     }
+    // primitive
     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 }) {
+    // oneOf
+    if (schema.oneOf !== undefined) {
+        return (0, createAnyOneOf_1.createAnyOneOf)(schema.oneOf, "oneOf");
+    }
+    // anyOf
+    if (schema.anyOf !== undefined) {
+        return (0, createAnyOneOf_1.createAnyOneOf)(schema.anyOf, "anyOf");
+    }
     // object
     if (schema.properties !== undefined) {
         return (0, utils_1.create)("ul", {
@@ -107,38 +157,43 @@ function createRows({ 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
+    // allOf
     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",
-                }),
-                Object.entries(properties).map(([key, val]) => createRow({
-                    name: key,
-                    schema: val,
-                    required: Array.isArray(required) ? required.includes(key) : false,
-                })),
-            ],
-        });
-    }
-    // Adds support one more level deep
-    if (schema.oneOf !== undefined) {
-        return (0, createAnyOneOf_1.createAnyOneOf)(schema.oneOf, "oneOf");
-    }
-    if (schema.anyOf !== undefined) {
-        return (0, createAnyOneOf_1.createAnyOneOf)(schema.anyOf, "anyOf");
-    }
-    // array
-    if (schema.items !== undefined) {
-        return createRows({ schema: schema.items });
+        const { mergedSchemas, required, } = resolveAllOf(schema.allOf);
+        // Adds support one more level deep
+        if (mergedSchemas.oneOf !== undefined) {
+            return (0, createAnyOneOf_1.createAnyOneOf)(mergedSchemas.oneOf, "oneOf");
+        }
+        if (mergedSchemas.anyOf !== undefined) {
+            return (0, createAnyOneOf_1.createAnyOneOf)(mergedSchemas.anyOf, "anyOf");
+        }
+        // array
+        if (mergedSchemas.items !== undefined) {
+            return createRows({ schema: schema.items });
+        }
+        if (mergedSchemas.properties !== undefined) {
+            return (0, utils_1.create)("div", {
+                children: [
+                    (0, utils_1.create)("span", {
+                        className: "badge badge--info",
+                        style: { marginBottom: "1rem" },
+                        children: "allOf",
+                    }),
+                    Object.entries(mergedSchemas.properties).map(([key, val]) => createRow({
+                        name: key,
+                        schema: val,
+                        required: Array.isArray(required)
+                            ? required.includes(key)
+                            : false,
+                    })),
+                ],
+            });
+        }
     }
     // primitive
     return undefined;
 }
+exports.createRows = createRows;
 function createRowsRoot({ schema }) {
     // object
     if (schema.properties !== undefined) {
@@ -150,9 +205,9 @@ function createRowsRoot({ schema }) {
                 : 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
+    // allOf
     if (schema.allOf !== undefined) {
-        const { properties, required } = resolveAllOf(schema.allOf);
+        const { mergedSchemas, required, } = resolveAllOf(schema.allOf);
         return (0, utils_1.create)("div", {
             children: [
                 (0, utils_1.create)("span", {
@@ -160,18 +215,21 @@ function createRowsRoot({ schema }) {
                     style: { marginBottom: "1rem" },
                     children: "allOf",
                 }),
-                Object.entries(properties).map(([key, val]) => createRow({
+                Object.entries(mergedSchemas.properties).map(([key, val]) => createRow({
                     name: key,
                     schema: val,
-                    required: Array.isArray(required) ? required.includes(key) : false,
+                    required: Array.isArray(required)
+                        ? required.includes(key)
+                        : false,
                 })),
             ],
         });
     }
-    // TODO: This is top-level only - add support for nested oneOf/anyOf
+    // oneOf
     if (schema.oneOf !== undefined) {
         return (0, createAnyOneOf_1.createAnyOneOf)(schema.oneOf, "oneOf");
     }
+    // anyOf
     if (schema.anyOf !== undefined) {
         return (0, createAnyOneOf_1.createAnyOneOf)(schema.anyOf, "anyOf");
     }

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;
     }
-    return (_c = schema.title) !== null && _c !== void 0 ? _c : 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 (_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
@@ -44,9 +54,10 @@ function getQualifierMessage(schema) {
     if (!schema) {
         return undefined;
     }
-    if (schema.items) {
-        return getQualifierMessage(schema.items);
-    }
+    // TODO: This doesn't seem right
+    // if (schema.items) {
+    //   return getQualifierMessage(schema.items);
+    // }
     let message = "**Possible values:** ";
     let qualifierGroups = [];
     if (schema.minLength || schema.maxLength) {
@@ -92,6 +103,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/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 {};

package/lib/openapi/openapi.js

@@ -16,18 +16,10 @@ const openapi_to_postmanv2_1 = __importDefault(require("@paloaltonetworks/openap
 const postman_collection_1 = __importDefault(require("@paloaltonetworks/postman-collection"));
 const chalk_1 = __importDefault(require("chalk"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
-const json_refs_1 = __importDefault(require("json-refs"));
 const lodash_1 = require("lodash");
 const index_1 = require("../index");
 const createExample_1 = require("./createExample");
-const loadAndBundleSpec_1 = require("./utils/loadAndBundleSpec");
-/**
- * Finds any reference objects in the OpenAPI definition and resolves them to a finalized value.
- */
-async function resolveRefs(openapiData) {
-    const { resolved } = await json_refs_1.default.resolveRefs(openapiData);
-    return resolved;
-}
+const loadAndResolveSpec_1 = require("./utils/loadAndResolveSpec");
 /**
  * Convenience function for converting raw JSON to a Postman Collection object.
  */
@@ -48,7 +40,7 @@ function jsonToCollection(data) {
  */
 async function createPostmanCollection(openapiData) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
-    const data = JSON.parse(JSON.stringify(openapiData));
+    const data = openapiData;
     // Including `servers` breaks postman, so delete all of them.
     delete data.servers;
     for (let pathItemObject of Object.values(data.paths)) {
@@ -189,9 +181,6 @@ function bindCollectionToApiItems(items, postmanCollection) {
     });
 }
 async function readOpenapiFiles(openapiPath, options) {
-    // TODO: determine if this should be an API option
-    // Forces the json-schema-ref-parser
-    const parseJsonRefs = true;
     if (!(0, index_1.isURL)(openapiPath)) {
         const stat = await fs_extra_1.default.lstat(openapiPath);
         if (stat.isDirectory()) {
@@ -206,7 +195,7 @@ async function readOpenapiFiles(openapiPath, options) {
             return Promise.all(sources.map(async (source) => {
                 // TODO: make a function for this
                 const fullPath = path_1.default.join(openapiPath, source);
-                const data = (await (0, loadAndBundleSpec_1.loadAndBundleSpec)(fullPath, parseJsonRefs));
+                const data = (await (0, loadAndResolveSpec_1.loadAndResolveSpec)(fullPath));
                 return {
                     source: fullPath,
                     sourceDirName: path_1.default.dirname(source),
@@ -215,7 +204,7 @@ async function readOpenapiFiles(openapiPath, options) {
             }));
         }
     }
-    const data = (await (0, loadAndBundleSpec_1.loadAndBundleSpec)(openapiPath, parseJsonRefs));
+    const data = (await (0, loadAndResolveSpec_1.loadAndResolveSpec)(openapiPath));
     return [
         {
             source: openapiPath,
@@ -227,27 +216,39 @@ async function readOpenapiFiles(openapiPath, options) {
 exports.readOpenapiFiles = readOpenapiFiles;
 async function processOpenapiFiles(files, sidebarOptions) {
     const promises = files.map(async (file) => {
-        const processedFile = await processOpenapiFile(file.data, sidebarOptions);
-        const itemsObjectsArray = processedFile[0].map((item) => ({
-            ...item,
-        }));
-        const tags = processedFile[1];
-        return [itemsObjectsArray, tags];
+        if (file.data !== undefined) {
+            const processedFile = await processOpenapiFile(file.data, sidebarOptions);
+            const itemsObjectsArray = processedFile[0].map((item) => ({
+                ...item,
+            }));
+            const tags = processedFile[1];
+            return [itemsObjectsArray, tags];
+        }
+        console.warn(chalk_1.default.yellow(`WARNING: the following OpenAPI spec returned undefined: ${file.source}`));
+        return [];
     });
     const metadata = await Promise.all(promises);
     const items = metadata
         .map(function (x) {
         return x[0];
     })
-        .flat();
-    const tags = metadata.map(function (x) {
+        .flat()
+        .filter(function (x) {
+        // Remove undefined items due to transient parsing errors
+        return x !== undefined;
+    });
+    const tags = metadata
+        .map(function (x) {
         return x[1];
+    })
+        .filter(function (x) {
+        // Remove undefined tags due to transient parsing errors
+        return x !== undefined;
     });
     return [items, tags];
 }
 exports.processOpenapiFiles = processOpenapiFiles;
-async function processOpenapiFile(openapiDataWithRefs, sidebarOptions) {
-    const openapiData = await resolveRefs(openapiDataWithRefs);
+async function processOpenapiFile(openapiData, sidebarOptions) {
     const postmanCollection = await createPostmanCollection(openapiData);
     const items = createItems(openapiData, sidebarOptions);
     bindCollectionToApiItems(items, postmanCollection);

package/lib/openapi/types.d.ts

@@ -11,6 +11,7 @@ export interface OpenApiObject {
     security?: SecurityRequirementObject[];
     tags?: TagObject[];
     externalDocs?: ExternalDocumentationObject;
+    swagger?: string;
 }
 export interface OpenApiObjectWithRef {
     openapi: string;

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

@@ -0,0 +1,2 @@
+export declare function convertSwagger2OpenAPI(spec: object): Promise<unknown>;
+export declare function loadAndResolveSpec(specUrlOrObject: object | string): Promise<any>;

package/lib/openapi/utils/{loadAndBundleSpec.js → loadAndResolveSpec.js}

@@ -9,25 +9,62 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertSwagger2OpenAPI = exports.loadAndBundleSpec = void 0;
-// @ts-nocheck
+exports.loadAndResolveSpec = exports.convertSwagger2OpenAPI = void 0;
 const json_schema_ref_parser_1 = __importDefault(require("@apidevtools/json-schema-ref-parser"));
-const bundle_1 = require("@redocly/openapi-core/lib/bundle");
-const config_1 = require("@redocly/openapi-core/lib/config/config");
+const openapi_core_1 = require("@redocly/openapi-core");
 const chalk_1 = __importDefault(require("chalk"));
+// @ts-ignore
 const swagger2openapi_1 = require("swagger2openapi");
+function serializer(replacer, cycleReplacer) {
+    var stack = [], keys = [];
+    if (cycleReplacer === undefined)
+        cycleReplacer = function (key, value) {
+            if (stack[0] === value)
+                return "circular()";
+            return value.title ? `circular(${value.title})` : "circular()";
+        };
+    return function (key, value) {
+        if (stack.length > 0) {
+            // @ts-ignore
+            var thisPos = stack.indexOf(this);
+            // @ts-ignore
+            ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+            ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+            // @ts-ignore
+            if (~stack.indexOf(value))
+                value = cycleReplacer.call(this, key, value);
+        }
+        else
+            stack.push(value);
+        // @ts-ignore
+        return replacer === undefined ? value : replacer.call(this, key, value);
+    };
+}
+function convertSwagger2OpenAPI(spec) {
+    console.warn("[ReDoc Compatibility mode]: Converting OpenAPI 2.0 to OpenAPI 3.0");
+    return new Promise((resolve, reject) => (0, swagger2openapi_1.convertObj)(spec, { patch: true, warnOnly: true, text: "{}", anchors: true }, (err, res) => {
+        // TODO: log any warnings
+        if (err) {
+            return reject(err);
+        }
+        resolve(res && res.openapi);
+    }));
+}
+exports.convertSwagger2OpenAPI = convertSwagger2OpenAPI;
 async function resolveJsonRefs(specUrlOrObject) {
     var _a, _b;
     try {
         let schema = await json_schema_ref_parser_1.default.dereference(specUrlOrObject, {
             continueOnError: true,
             resolve: {
+                file: true,
+                external: true,
                 http: {
                     timeout: 15000, // 15 sec timeout
                 },
             },
             dereference: {
-                circular: "ignore",
+                circular: true,
             },
         });
         return schema;
@@ -37,8 +74,8 @@ async function resolveJsonRefs(specUrlOrObject) {
         return;
     }
 }
-async function loadAndBundleSpec(specUrlOrObject, parseJsonRefs) {
-    const config = new config_1.Config({});
+async function loadAndResolveSpec(specUrlOrObject) {
+    const config = new openapi_core_1.Config({});
     const bundleOpts = {
         config,
         base: process.cwd(),
@@ -54,26 +91,22 @@ async function loadAndBundleSpec(specUrlOrObject, parseJsonRefs) {
     }
     // Force dereference ?
     // bundleOpts["dereference"] = true;
-    const { bundle: { parsed }, } = await (0, bundle_1.bundle)(bundleOpts);
-    if (parseJsonRefs) {
-        const resolved = await resolveJsonRefs(parsed);
-        return typeof resolved === Object
-            ? resolved.swagger !== undefined
-                ? convertSwagger2OpenAPI(resolved)
-                : resolved
-            : parsed;
+    const { bundle: { parsed }, } = await (0, openapi_core_1.bundle)(bundleOpts);
+    const resolved = await resolveJsonRefs(parsed);
+    // Force serialization and replace circular $ref pointers
+    // @ts-ignore
+    const serialized = JSON.stringify(resolved, serializer());
+    let decycled;
+    try {
+        decycled = JSON.parse(serialized);
     }
-    return parsed.swagger !== undefined ? convertSwagger2OpenAPI(parsed) : parsed;
-}
-exports.loadAndBundleSpec = loadAndBundleSpec;
-function convertSwagger2OpenAPI(spec) {
-    console.warn("[ReDoc Compatibility mode]: Converting OpenAPI 2.0 to OpenAPI 3.0");
-    return new Promise((resolve, reject) => (0, swagger2openapi_1.convertObj)(spec, { patch: true, warnOnly: true, text: "{}", anchors: true }, (err, res) => {
-        // TODO: log any warnings
-        if (err) {
-            return reject(err);
-        }
-        resolve(res && res.openapi);
-    }));
+    catch (err) {
+        console.error(chalk_1.default.yellow(err));
+    }
+    return decycled !== undefined && typeof decycled === "object"
+        ? decycled.swagger !== undefined
+            ? convertSwagger2OpenAPI(decycled)
+            : decycled
+        : resolved;
 }
-exports.convertSwagger2OpenAPI = convertSwagger2OpenAPI;
+exports.loadAndResolveSpec = loadAndResolveSpec;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-plugin-openapi-docs",
   "description": "OpenAPI plugin for Docusaurus.",
-  "version": "0.0.0-395",
+  "version": "0.0.0-396",
   "license": "MIT",
   "keywords": [
     "openapi",
@@ -67,5 +67,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "6b0d77e35b366bb8418b6f9523b29e5c137a7464"
+  "gitHead": "958b9c6e0b370afe79572dfea950d2be33f41cc0"
 }