docusaurus-plugin-openapi-docs 0.0.0-348 → 0.0.0-351

package/lib/markdown/schema.test.js

@@ -0,0 +1,171 @@
+"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:** 1 ≤ length";
+        const actual = (0, schema_1.getQualifierMessage)({ minLength: 1 });
+        expect(actual).toBe(expected);
+    });
+    it("should render maxLength", () => {
+        const expected = "**Possible values:** length ≤ 40";
+        const actual = (0, schema_1.getQualifierMessage)({ maxLength: 40 });
+        expect(actual).toBe(expected);
+    });
+    it("should render minLength and maxLength", () => {
+        const expected = "**Possible values:** 1 ≤ length ≤ 40";
+        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:** 1 ≤ length ≤ 40, 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 ≤ value";
+        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1 });
+        expect(actual).toBe(expected);
+    });
+    it("should render maximum", () => {
+        const expected = "**Possible values:** value ≤ 40";
+        const actual = (0, schema_1.getQualifierMessage)({ maximum: 40 });
+        expect(actual).toBe(expected);
+    });
+    it("should render numeric exclusiveMinimum", () => {
+        const expected = "**Possible values:** 1 < value";
+        const actual = (0, schema_1.getQualifierMessage)({ exclusiveMinimum: 1 });
+        expect(actual).toBe(expected);
+    });
+    it("should render numeric exclusiveMaximum", () => {
+        const expected = "**Possible values:** value < 40";
+        const actual = (0, schema_1.getQualifierMessage)({ exclusiveMaximum: 40 });
+        expect(actual).toBe(expected);
+    });
+    it("should render boolean exclusiveMinimum", () => {
+        const expected = "**Possible values:** 1 < value";
+        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1, exclusiveMinimum: true });
+        expect(actual).toBe(expected);
+    });
+    it("should render boolean exclusiveMaximum", () => {
+        const expected = "**Possible values:** value < 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 ≤ value";
+        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:** value ≤ 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 ≤ value ≤ 40";
+        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1, maximum: 40 });
+        expect(actual).toBe(expected);
+    });
+    it("should render boolean exclusiveMinimum and maximum", () => {
+        const expected = "**Possible values:** 1 < value ≤ 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 ≤ value < 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 < value ≤ 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 ≤ value < 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 < value < 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();
+    });
+});

package/lib/markdown/utils.d.ts

@@ -0,0 +1,7 @@
+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, cb: (value: T) => Children): string;
+export declare function render(children: Children): string;

package/lib/markdown/utils.js

@@ -0,0 +1,33 @@
+"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 });
+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}>`;
+}
+exports.create = create;
+function guard(value, cb) {
+    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 : "";
+}
+exports.render = render;

package/lib/openapi/createExample.d.ts

@@ -0,0 +1,2 @@
+import { SchemaObject } from "./types";
+export declare const sampleFromSchema: (schema?: SchemaObject) => any;

package/lib/openapi/createExample.js

@@ -0,0 +1,113 @@
+"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 });
+exports.sampleFromSchema = void 0;
+const primitives = {
+    string: {
+        default: () => "string",
+        email: () => "user@example.com",
+        date: () => new Date().toISOString().substring(0, 10),
+        uuid: () => "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+        hostname: () => "example.com",
+        ipv4: () => "198.51.100.42",
+        ipv6: () => "2001:0db8:5b96:0000:0000:426f:8e17:642a",
+    },
+    number: {
+        default: () => 0,
+        float: () => 0.0,
+    },
+    integer: {
+        default: () => 0,
+    },
+    boolean: {
+        default: (schema) => typeof schema.default === "boolean" ? schema.default : true,
+    },
+    object: {},
+    array: {},
+};
+const sampleFromSchema = (schema = {}) => {
+    let { type, example, allOf, properties, items } = schema;
+    if (example !== undefined) {
+        return example;
+    }
+    if (allOf) {
+        // TODO: We are just assuming it will always be an object for now
+        let obj = {
+            type: "object",
+            properties: {},
+            required: [], // NOTE: We shouldn't need to worry about required
+        };
+        for (let item of allOf) {
+            if (item.properties) {
+                obj.properties = {
+                    ...obj.properties,
+                    ...item.properties,
+                };
+            }
+        }
+        return (0, exports.sampleFromSchema)(obj);
+    }
+    if (!type) {
+        if (properties) {
+            type = "object";
+        }
+        else if (items) {
+            type = "array";
+        }
+        else {
+            return;
+        }
+    }
+    if (type === "object") {
+        let obj = {};
+        for (let [name, prop] of Object.entries(properties !== null && properties !== void 0 ? properties : {})) {
+            if (prop.deprecated) {
+                continue;
+            }
+            obj[name] = (0, exports.sampleFromSchema)(prop);
+        }
+        return obj;
+    }
+    if (type === "array") {
+        if (Array.isArray(items === null || items === void 0 ? void 0 : items.anyOf)) {
+            return items === null || items === void 0 ? void 0 : items.anyOf.map((item) => (0, exports.sampleFromSchema)(item));
+        }
+        if (Array.isArray(items === null || items === void 0 ? void 0 : items.oneOf)) {
+            return items === null || items === void 0 ? void 0 : items.oneOf.map((item) => (0, exports.sampleFromSchema)(item));
+        }
+        return [(0, exports.sampleFromSchema)(items)];
+    }
+    if (schema.enum) {
+        if (schema.default) {
+            return schema.default;
+        }
+        return normalizeArray(schema.enum)[0];
+    }
+    return primitive(schema);
+};
+exports.sampleFromSchema = sampleFromSchema;
+function primitive(schema = {}) {
+    let { type, format } = schema;
+    if (type === undefined) {
+        return;
+    }
+    let fn = primitives[type].default;
+    if (format !== undefined) {
+        fn = primitives[type][format] || fn;
+    }
+    if (fn) {
+        return fn(schema);
+    }
+    return "Unknown Type: " + schema.type;
+}
+function normalizeArray(arr) {
+    if (Array.isArray(arr)) {
+        return arr;
+    }
+    return [arr];
+}

package/lib/openapi/index.d.ts

@@ -0,0 +1 @@
+export { readOpenapiFiles, processOpenapiFiles } from "./openapi";

package/lib/openapi/index.js

@@ -0,0 +1,12 @@
+"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 });
+exports.processOpenapiFiles = exports.readOpenapiFiles = void 0;
+var openapi_1 = require("./openapi");
+Object.defineProperty(exports, "readOpenapiFiles", { enumerable: true, get: function () { return openapi_1.readOpenapiFiles; } });
+Object.defineProperty(exports, "processOpenapiFiles", { enumerable: true, get: function () { return openapi_1.processOpenapiFiles; } });

package/lib/openapi/openapi.d.ts

@@ -0,0 +1,11 @@
+import { ApiMetadata } from "../types";
+import { OpenApiObjectWithRef } from "./types";
+interface OpenApiFiles {
+    source: string;
+    sourceDirName: string;
+    data: OpenApiObjectWithRef;
+}
+export declare function readOpenapiFiles(openapiPath: string, _options: {}): Promise<OpenApiFiles[]>;
+export declare function processOpenapiFiles(files: OpenApiFiles[]): Promise<ApiMetadata[]>;
+export declare function processOpenapiFile(openapiDataWithRefs: OpenApiObjectWithRef): Promise<ApiMetadata[]>;
+export {};

package/lib/openapi/openapi.js

@@ -0,0 +1,231 @@
+"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.
+ * ========================================================================== */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processOpenapiFile = exports.processOpenapiFiles = exports.readOpenapiFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@docusaurus/utils");
+const openapi_to_postmanv2_1 = __importDefault(require("@paloaltonetworks/openapi-to-postmanv2"));
+const postman_collection_1 = __importDefault(require("@paloaltonetworks/postman-collection"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const json_refs_1 = __importDefault(require("json-refs"));
+const lodash_1 = require("lodash");
+const createExample_1 = require("./createExample");
+/**
+ * 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;
+}
+/**
+ * Convenience function for converting raw JSON to a Postman Collection object.
+ */
+function jsonToCollection(data) {
+    return new Promise((resolve, reject) => {
+        let schemaPack = new openapi_to_postmanv2_1.default.SchemaPack({ type: "json", data }, { schemaFaker: false });
+        schemaPack.computedOptions.schemaFaker = false;
+        schemaPack.convert((_err, conversionResult) => {
+            if (!conversionResult.result) {
+                return reject(conversionResult.reason);
+            }
+            return resolve(new postman_collection_1.default.Collection(conversionResult.output[0].data));
+        });
+    });
+}
+/**
+ * Creates a Postman Collection object from an OpenAPI definition.
+ */
+async function createPostmanCollection(openapiData) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const data = JSON.parse(JSON.stringify(openapiData));
+    // Including `servers` breaks postman, so delete all of them.
+    delete data.servers;
+    for (let pathItemObject of Object.values(data.paths)) {
+        delete pathItemObject.servers;
+        (_a = pathItemObject.get) === null || _a === void 0 ? true : delete _a.servers;
+        (_b = pathItemObject.put) === null || _b === void 0 ? true : delete _b.servers;
+        (_c = pathItemObject.post) === null || _c === void 0 ? true : delete _c.servers;
+        (_d = pathItemObject.delete) === null || _d === void 0 ? true : delete _d.servers;
+        (_e = pathItemObject.options) === null || _e === void 0 ? true : delete _e.servers;
+        (_f = pathItemObject.head) === null || _f === void 0 ? true : delete _f.servers;
+        (_g = pathItemObject.patch) === null || _g === void 0 ? true : delete _g.servers;
+        (_h = pathItemObject.trace) === null || _h === void 0 ? true : delete _h.servers;
+    }
+    return await jsonToCollection(data);
+}
+function createItems(openapiData) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    // TODO: Find a better way to handle this
+    let items = [];
+    // Only create an info page if we have a description.
+    if (openapiData.info.description) {
+        const infoPage = {
+            type: "info",
+            id: "introduction",
+            unversionedId: "introduction",
+            title: "Introduction",
+            description: openapiData.info.description,
+            slug: "/introduction",
+            frontMatter: {},
+            info: {
+                ...openapiData.info,
+                title: (_a = openapiData.info.title) !== null && _a !== void 0 ? _a : "Introduction",
+            },
+        };
+        items.push(infoPage);
+    }
+    for (let [path, pathObject] of Object.entries(openapiData.paths)) {
+        const { $ref, description, parameters, servers, summary, ...rest } = pathObject;
+        for (let [method, operationObject] of Object.entries({ ...rest })) {
+            const title = (_c = (_b = operationObject.summary) !== null && _b !== void 0 ? _b : operationObject.operationId) !== null && _c !== void 0 ? _c : "Missing summary";
+            if (operationObject.description === undefined) {
+                operationObject.description =
+                    (_e = (_d = operationObject.summary) !== null && _d !== void 0 ? _d : operationObject.operationId) !== null && _e !== void 0 ? _e : "";
+            }
+            const baseId = (0, lodash_1.kebabCase)(title);
+            const servers = (_g = (_f = operationObject.servers) !== null && _f !== void 0 ? _f : pathObject.servers) !== null && _g !== void 0 ? _g : openapiData.servers;
+            const security = (_h = operationObject.security) !== null && _h !== void 0 ? _h : openapiData.security;
+            // Add security schemes so we know how to handle security.
+            const securitySchemes = (_j = openapiData.components) === null || _j === void 0 ? void 0 : _j.securitySchemes;
+            // Make sure schemes are lowercase. See: https://github.com/cloud-annotations/docusaurus-plugin-openapi/issues/79
+            if (securitySchemes) {
+                for (let securityScheme of Object.values(securitySchemes)) {
+                    if (securityScheme.type === "http") {
+                        securityScheme.scheme = securityScheme.scheme.toLowerCase();
+                    }
+                }
+            }
+            let jsonRequestBodyExample;
+            const body = (_l = (_k = operationObject.requestBody) === null || _k === void 0 ? void 0 : _k.content) === null || _l === void 0 ? void 0 : _l["application/json"];
+            if (body === null || body === void 0 ? void 0 : body.schema) {
+                jsonRequestBodyExample = (0, createExample_1.sampleFromSchema)(body.schema);
+            }
+            // TODO: Don't include summary temporarilly
+            const { summary, ...defaults } = operationObject;
+            const apiPage = {
+                type: "api",
+                id: baseId,
+                unversionedId: baseId,
+                title: title,
+                description: description !== null && description !== void 0 ? description : "",
+                slug: "/" + baseId,
+                frontMatter: {},
+                api: {
+                    ...defaults,
+                    tags: (_m = operationObject.tags) === null || _m === void 0 ? void 0 : _m.map((tagName) => { var _a; return getTagDisplayName(tagName, (_a = openapiData.tags) !== null && _a !== void 0 ? _a : []); }),
+                    method,
+                    path,
+                    servers,
+                    security,
+                    securitySchemes,
+                    jsonRequestBodyExample,
+                    info: openapiData.info,
+                },
+            };
+            items.push(apiPage);
+        }
+    }
+    return items;
+}
+/**
+ * Attach Postman Request objects to the corresponding ApiItems.
+ */
+function bindCollectionToApiItems(items, postmanCollection) {
+    postmanCollection.forEachItem((item) => {
+        const method = item.request.method.toLowerCase();
+        const path = item.request.url
+            .getPath({ unresolved: true }) // unresolved returns "/:variableName" instead of "/<type>"
+            .replace(/:([a-z0-9-_]+)/gi, "{$1}"); // replace "/:variableName" with "/{variableName}"
+        const apiItem = items.find((item) => {
+            if (item.type === "info") {
+                return false;
+            }
+            return item.api.path === path && item.api.method === method;
+        });
+        if ((apiItem === null || apiItem === void 0 ? void 0 : apiItem.type) === "api") {
+            apiItem.api.postman = item.request;
+        }
+    });
+}
+async function readOpenapiFiles(openapiPath, _options) {
+    const stat = await fs_extra_1.default.lstat(openapiPath);
+    if (stat.isDirectory()) {
+        console.warn(chalk_1.default.yellow("WARNING: Loading a directory of OpenAPI definitions is experimental and subject to unannounced breaking changes."));
+        // TODO: Add config for inlcude/ignore
+        const allFiles = await (0, utils_1.Globby)(["**/*.{json,yaml,yml}"], {
+            cwd: openapiPath,
+            ignore: utils_1.GlobExcludeDefault,
+        });
+        const sources = allFiles.filter((x) => !x.includes("_category_")); // todo: regex exclude?
+        return Promise.all(sources.map(async (source) => {
+            // TODO: make a function for this
+            const fullPath = path_1.default.join(openapiPath, source);
+            const openapiString = await fs_extra_1.default.readFile(fullPath, "utf-8");
+            const data = js_yaml_1.default.load(openapiString);
+            return {
+                source: fullPath,
+                sourceDirName: path_1.default.dirname(source),
+                data,
+            };
+        }));
+    }
+    const openapiString = await fs_extra_1.default.readFile(openapiPath, "utf-8");
+    const data = js_yaml_1.default.load(openapiString);
+    return [
+        {
+            source: openapiPath,
+            sourceDirName: ".",
+            data,
+        },
+    ];
+}
+exports.readOpenapiFiles = readOpenapiFiles;
+async function processOpenapiFiles(files) {
+    const promises = files.map(async (file) => {
+        const items = await processOpenapiFile(file.data);
+        return items.map((item) => ({
+            ...item,
+        }));
+    });
+    const metadata = await Promise.all(promises);
+    const items = metadata.flat();
+    return items;
+}
+exports.processOpenapiFiles = processOpenapiFiles;
+async function processOpenapiFile(openapiDataWithRefs) {
+    const openapiData = await resolveRefs(openapiDataWithRefs);
+    const postmanCollection = await createPostmanCollection(openapiData);
+    const items = createItems(openapiData);
+    bindCollectionToApiItems(items, postmanCollection);
+    return items;
+}
+exports.processOpenapiFile = processOpenapiFile;
+// order for picking items as a display name of tags
+const tagDisplayNameProperties = ["x-displayName", "name"];
+function getTagDisplayName(tagName, tags) {
+    var _a;
+    // find the very own tagObject
+    const tagObject = (_a = tags.find((tagObject) => tagObject.name === tagName)) !== null && _a !== void 0 ? _a : {
+        // if none found, just fake one
+        name: tagName,
+    };
+    // return the first found and filled value from the property list
+    for (const property of tagDisplayNameProperties) {
+        const displayName = tagObject[property];
+        if (typeof displayName === "string") {
+            return displayName;
+        }
+    }
+    // always default to the tagName
+    return tagName;
+}

package/lib/openapi/openapi.test.d.ts

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

package/lib/openapi/openapi.test.js

@@ -0,0 +1,33 @@
+"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.
+ * ========================================================================== */
+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 _1 = require(".");
+// npx jest packages/docusaurus-plugin-openapi/src/openapi/openapi.test.ts --watch
+describe("openapi", () => {
+    describe("readOpenapiFiles", () => {
+        it("readOpenapiFiles", async () => {
+            const results = await (0, _1.readOpenapiFiles)(path_1.default.join(__dirname, "__fixtures__/examples"), {});
+            const categoryMeta = results.find((x) => x.source.endsWith("_category_.json"));
+            expect(categoryMeta).toBeFalsy();
+            // console.log(results);
+            const yaml = results.find((x) => x.source.endsWith("openapi.yaml"));
+            expect(yaml).toBeTruthy();
+            expect(yaml === null || yaml === void 0 ? void 0 : yaml.sourceDirName).toBe(".");
+            const froyo = results.find((x) => x.source.endsWith("froyo.yaml"));
+            expect(froyo).toBeTruthy();
+            expect(froyo === null || froyo === void 0 ? void 0 : froyo.sourceDirName).toBe("yogurtstore");
+            const nested = results.find((x) => x.source.endsWith("nested.yaml"));
+            expect(nested).toBeTruthy();
+            expect(nested === null || nested === void 0 ? void 0 : nested.sourceDirName).toBe("yogurtstore/nested");
+        });
+    });
+});