docusaurus-plugin-openapi-docs 1.0.4 → 1.1.0

package/lib/markdown/utils.js

@@ -26,7 +26,10 @@ function guard(value, cb) {
 exports.guard = guard;
 function render(children) {
     if (Array.isArray(children)) {
-        return children.filter((c) => c !== undefined).join("");
+        const filteredChildren = children.filter((c) => c !== undefined);
+        return filteredChildren
+            .map((i) => (Array.isArray(i) ? i.join("") : i))
+            .join("");
     }
     return children !== null && children !== void 0 ? children : "";
 }

package/lib/openapi/openapi.d.ts

@@ -1,12 +1,12 @@
-import { ApiMetadata, SidebarOptions } from "../types";
-import { OpenApiObjectWithRef, TagObject } from "./types";
+import { ApiMetadata, APIOptions, SidebarOptions } from "../types";
+import { OpenApiObject, TagObject } from "./types";
 interface OpenApiFiles {
     source: string;
     sourceDirName: string;
-    data: OpenApiObjectWithRef;
+    data: OpenApiObject;
 }
-export declare function readOpenapiFiles(openapiPath: string, _options: {}): Promise<OpenApiFiles[]>;
+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)) {
@@ -188,7 +180,7 @@ function bindCollectionToApiItems(items, postmanCollection) {
         }
     });
 }
-async function readOpenapiFiles(openapiPath, _options) {
+async function readOpenapiFiles(openapiPath, options) {
     if (!(0, index_1.isURL)(openapiPath)) {
         const stat = await fs_extra_1.default.lstat(openapiPath);
         if (stat.isDirectory()) {
@@ -203,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));
+                const data = (await (0, loadAndResolveSpec_1.loadAndResolveSpec)(fullPath));
                 return {
                     source: fullPath,
                     sourceDirName: path_1.default.dirname(source),
@@ -212,7 +204,7 @@ async function readOpenapiFiles(openapiPath, _options) {
             }));
         }
     }
-    const data = (await (0, loadAndBundleSpec_1.loadAndBundleSpec)(openapiPath));
+    const data = (await (0, loadAndResolveSpec_1.loadAndResolveSpec)(openapiPath));
     return [
         {
             source: openapiPath,
@@ -224,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/openapi.test.js

@@ -15,7 +15,7 @@ const _1 = require(".");
 describe("openapi", () => {
     describe("readOpenapiFiles", () => {
         it("readOpenapiFiles", async () => {
-            const results = await (0, _1.readOpenapiFiles)(path_1.default.join(__dirname, "__fixtures__/examples"), {});
+            const results = await (0, _1.readOpenapiFiles)(path_1.default.join(__dirname, "__fixtures__/examples"), { specPath: "./", outputDir: "./" });
             const categoryMeta = results.find((x) => x.source.endsWith("_category_.json"));
             expect(categoryMeta).toBeFalsy();
             // console.log(results);

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;
@@ -255,7 +256,7 @@ export declare type SchemaObject = Omit<JSONSchema, "type" | "allOf" | "oneOf" |
     not?: SchemaObject;
     items?: SchemaObject;
     properties?: Map<SchemaObject>;
-    additionalProperties?: boolean | SchemaObject;
+    additionalProperties?: Map<SchemaObject>;
     nullable?: boolean;
     discriminator?: DiscriminatorObject;
     readOnly?: boolean;

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/loadAndResolveSpec.js

@@ -0,0 +1,112 @@
+"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.loadAndResolveSpec = exports.convertSwagger2OpenAPI = void 0;
+const json_schema_ref_parser_1 = __importDefault(require("@apidevtools/json-schema-ref-parser"));
+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: true,
+            },
+        });
+        return schema;
+    }
+    catch (err) {
+        console.error(chalk_1.default.yellow((_b = (_a = err.errors[0]) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : err));
+        return;
+    }
+}
+async function loadAndResolveSpec(specUrlOrObject) {
+    const config = new openapi_core_1.Config({});
+    const bundleOpts = {
+        config,
+        base: process.cwd(),
+    };
+    if (typeof specUrlOrObject === "object" && specUrlOrObject !== null) {
+        bundleOpts["doc"] = {
+            source: { absoluteRef: "" },
+            parsed: specUrlOrObject,
+        };
+    }
+    else {
+        bundleOpts["ref"] = specUrlOrObject;
+    }
+    // Force dereference ?
+    // bundleOpts["dereference"] = true;
+    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);
+    }
+    catch (err) {
+        console.error(chalk_1.default.yellow(err));
+    }
+    return decycled !== undefined && typeof decycled === "object"
+        ? decycled.swagger !== undefined
+            ? convertSwagger2OpenAPI(decycled)
+            : decycled
+        : resolved;
+}
+exports.loadAndResolveSpec = loadAndResolveSpec;

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

@@ -0,0 +1,52 @@
+import { OpenAPIRef, OpenAPISchema, OpenAPISpec, Referenced } from "../types";
+export declare type MergedOpenAPISchema = OpenAPISchema & {
+    parentRefs?: string[];
+};
+/**
+ * Loads and keeps spec. Provides raw spec operations
+ */
+export declare class OpenAPIParser {
+    private options;
+    specUrl?: string;
+    spec: OpenAPISpec;
+    private _refCounter;
+    private allowMergeRefs;
+    constructor(spec: OpenAPISpec, specUrl?: string, options?: {});
+    validate(spec: any): void;
+    /**
+     * get spec part by JsonPointer ($ref)
+     */
+    byRef: <T extends unknown = any>(ref: string) => T | undefined;
+    /**
+     * checks if the object is OpenAPI reference (contains $ref property)
+     */
+    isRef(obj: any): obj is OpenAPIRef;
+    /**
+     * resets visited endpoints. should be run after
+     */
+    resetVisited(): void;
+    exitRef<T>(ref: Referenced<T>): void;
+    /**
+     * Resolve given reference object or return as is if it is not a reference
+     * @param obj object to dereference
+     * @param forceCircular whether to dereference even if it is circular ref
+     */
+    deref<T extends object>(obj: OpenAPIRef | T, forceCircular?: boolean, mergeAsAllOf?: boolean): T;
+    shallowDeref<T extends unknown>(obj: OpenAPIRef | T): T;
+    mergeRefs(ref: any, resolved: any, mergeAsAllOf: boolean): any;
+    /**
+     * Merge allOf constraints.
+     * @param schema schema with allOF
+     * @param $ref pointer of the schema
+     * @param forceCircular whether to dereference children even if it is a circular ref
+     */
+    mergeAllOf(schema: OpenAPISchema, $ref?: string, forceCircular?: boolean, used$Refs?: Set<string>): MergedOpenAPISchema;
+    /**
+     * Find all derived definitions among #/components/schemas from any of $refs
+     * returns map of definition pointer to definition name
+     * @param $refs array of references to find derived from
+     */
+    findDerived($refs: string[]): Record<string, string[] | string>;
+    exitParents(shema: MergedOpenAPISchema): void;
+    private hoistOneOfs;
+}

package/lib/openapi/utils/services/OpenAPIParser.js

@@ -0,0 +1,342 @@
+"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.OpenAPIParser = void 0;
+const helpers_1 = require("../utils/helpers");
+const JsonPointer_1 = require("../utils/JsonPointer");
+const openapi_1 = require("../utils/openapi");
+const RedocNormalizedOptions_1 = require("./RedocNormalizedOptions");
+/**
+ * Helper class to keep track of visited references to avoid
+ * endless recursion because of circular refs
+ */
+class RefCounter {
+    constructor() {
+        this._counter = {};
+    }
+    reset() {
+        this._counter = {};
+    }
+    visit(ref) {
+        this._counter[ref] = this._counter[ref] ? this._counter[ref] + 1 : 1;
+    }
+    exit(ref) {
+        this._counter[ref] = this._counter[ref] && this._counter[ref] - 1;
+    }
+    visited(ref) {
+        return !!this._counter[ref];
+    }
+}
+/**
+ * Loads and keeps spec. Provides raw spec operations
+ */
+class OpenAPIParser {
+    constructor(spec, specUrl, options = new RedocNormalizedOptions_1.RedocNormalizedOptions()) {
+        this.options = options;
+        this._refCounter = new RefCounter();
+        this.allowMergeRefs = false;
+        /**
+         * get spec part by JsonPointer ($ref)
+         */
+        this.byRef = (ref) => {
+            let res;
+            if (!this.spec) {
+                return;
+            }
+            if (ref.charAt(0) !== "#") {
+                ref = "#" + ref;
+            }
+            ref = decodeURIComponent(ref);
+            try {
+                res = JsonPointer_1.JsonPointer.get(this.spec, ref);
+            }
+            catch (e) {
+                // do nothing
+            }
+            return res || {};
+        };
+        this.validate(spec);
+        this.spec = spec;
+        this.allowMergeRefs = spec.openapi.startsWith("3.1");
+        const href = undefined;
+        if (typeof specUrl === "string") {
+            this.specUrl = new URL(specUrl, href).href;
+        }
+    }
+    validate(spec) {
+        if (spec.openapi === undefined) {
+            throw new Error("Document must be valid OpenAPI 3.0.0 definition");
+        }
+    }
+    /**
+     * checks if the object is OpenAPI reference (contains $ref property)
+     */
+    isRef(obj) {
+        if (!obj) {
+            return false;
+        }
+        return obj.$ref !== undefined && obj.$ref !== null;
+    }
+    /**
+     * resets visited endpoints. should be run after
+     */
+    resetVisited() {
+        if (process.env.NODE_ENV !== "production") {
+            // check in dev mode
+            for (const k in this._refCounter._counter) {
+                if (this._refCounter._counter[k] > 0) {
+                    console.warn("Not exited reference: " + k);
+                }
+            }
+        }
+        this._refCounter = new RefCounter();
+    }
+    exitRef(ref) {
+        if (!this.isRef(ref)) {
+            return;
+        }
+        this._refCounter.exit(ref.$ref);
+    }
+    /**
+     * Resolve given reference object or return as is if it is not a reference
+     * @param obj object to dereference
+     * @param forceCircular whether to dereference even if it is circular ref
+     */
+    deref(obj, forceCircular = false, mergeAsAllOf = false) {
+        if (this.isRef(obj)) {
+            const schemaName = (0, openapi_1.getDefinitionName)(obj.$ref);
+            if (schemaName && this.options.ignoreNamedSchemas.has(schemaName)) {
+                return { type: "object", title: schemaName };
+            }
+            const resolved = this.byRef(obj.$ref);
+            const visited = this._refCounter.visited(obj.$ref);
+            this._refCounter.visit(obj.$ref);
+            if (visited && !forceCircular) {
+                // circular reference detected
+                // tslint:disable-next-line
+                return Object.assign({}, resolved, { "x-circular-ref": true });
+            }
+            // deref again in case one more $ref is here
+            let result = resolved;
+            if (this.isRef(resolved)) {
+                result = this.deref(resolved, false, mergeAsAllOf);
+                this.exitRef(resolved);
+            }
+            return this.allowMergeRefs
+                ? this.mergeRefs(obj, resolved, mergeAsAllOf)
+                : result;
+        }
+        return obj;
+    }
+    shallowDeref(obj) {
+        if (this.isRef(obj)) {
+            const schemaName = (0, openapi_1.getDefinitionName)(obj.$ref);
+            if (schemaName && this.options.ignoreNamedSchemas.has(schemaName)) {
+                return { type: "object", title: schemaName };
+            }
+            const resolved = this.byRef(obj.$ref);
+            return this.allowMergeRefs
+                ? this.mergeRefs(obj, resolved, false)
+                : resolved;
+        }
+        return obj;
+    }
+    mergeRefs(ref, resolved, mergeAsAllOf) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { $ref, ...rest } = ref;
+        const keys = Object.keys(rest);
+        if (keys.length === 0) {
+            if (this.isRef(resolved)) {
+                return this.shallowDeref(resolved);
+            }
+            return resolved;
+        }
+        if (mergeAsAllOf &&
+            keys.some((k) => k !== "description" && k !== "title" && k !== "externalDocs")) {
+            return {
+                allOf: [rest, resolved],
+            };
+        }
+        else {
+            // small optimization
+            return {
+                ...resolved,
+                ...rest,
+            };
+        }
+    }
+    /**
+     * Merge allOf constraints.
+     * @param schema schema with allOF
+     * @param $ref pointer of the schema
+     * @param forceCircular whether to dereference children even if it is a circular ref
+     */
+    mergeAllOf(schema, $ref, forceCircular = false, used$Refs = new Set()) {
+        if ($ref) {
+            used$Refs.add($ref);
+        }
+        schema = this.hoistOneOfs(schema);
+        if (schema.allOf === undefined) {
+            return schema;
+        }
+        let receiver = {
+            ...schema,
+            allOf: undefined,
+            parentRefs: [],
+            title: schema.title || (0, openapi_1.getDefinitionName)($ref),
+        };
+        // avoid mutating inner objects
+        if (receiver.properties !== undefined &&
+            typeof receiver.properties === "object") {
+            receiver.properties = { ...receiver.properties };
+        }
+        if (receiver.items !== undefined && typeof receiver.items === "object") {
+            receiver.items = { ...receiver.items };
+        }
+        const allOfSchemas = schema.allOf
+            .map((subSchema) => {
+            if (subSchema && subSchema.$ref && used$Refs.has(subSchema.$ref)) {
+                return undefined;
+            }
+            const resolved = this.deref(subSchema, forceCircular, true);
+            const subRef = subSchema.$ref || undefined;
+            const subMerged = this.mergeAllOf(resolved, subRef, forceCircular, used$Refs);
+            receiver.parentRefs.push(...(subMerged.parentRefs || []));
+            return {
+                $ref: subRef,
+                schema: subMerged,
+            };
+        })
+            .filter((child) => child !== undefined);
+        for (const { $ref: subSchemaRef, schema: subSchema } of allOfSchemas) {
+            const { type, enum: enumProperty, properties, items, required, oneOf, anyOf, title, ...otherConstraints } = subSchema;
+            if (receiver.type !== type &&
+                receiver.type !== undefined &&
+                type !== undefined) {
+                console.warn(`Incompatible types in allOf at "${$ref}": "${receiver.type}" and "${type}"`);
+            }
+            if (type !== undefined) {
+                if (Array.isArray(type) && Array.isArray(receiver.type)) {
+                    receiver.type = [...type, ...receiver.type];
+                }
+                else {
+                    receiver.type = type;
+                }
+            }
+            if (enumProperty !== undefined) {
+                if (Array.isArray(enumProperty) && Array.isArray(receiver.enum)) {
+                    receiver.enum = [...enumProperty, ...receiver.enum];
+                }
+                else {
+                    receiver.enum = enumProperty;
+                }
+            }
+            if (properties !== undefined) {
+                receiver.properties = receiver.properties || {};
+                for (const prop in properties) {
+                    if (!receiver.properties[prop]) {
+                        receiver.properties[prop] = properties[prop];
+                    }
+                    else {
+                        // merge inner properties
+                        const mergedProp = this.mergeAllOf({ allOf: [receiver.properties[prop], properties[prop]] }, $ref + "/properties/" + prop);
+                        receiver.properties[prop] = mergedProp;
+                        this.exitParents(mergedProp); // every prop resolution should have separate recursive stack
+                    }
+                }
+            }
+            if (items !== undefined) {
+                const receiverItems = (0, helpers_1.isBoolean)(receiver.items)
+                    ? { items: receiver.items }
+                    : receiver.items
+                        ? Object.assign({}, receiver.items)
+                        : {};
+                const subSchemaItems = (0, helpers_1.isBoolean)(items)
+                    ? { items }
+                    : Object.assign({}, items);
+                // merge inner properties
+                receiver.items = this.mergeAllOf({ allOf: [receiverItems, subSchemaItems] }, $ref + "/items");
+            }
+            if (required !== undefined) {
+                receiver.required = (receiver.required || []).concat(required);
+            }
+            if (oneOf !== undefined) {
+                receiver.oneOf = oneOf;
+            }
+            if (anyOf !== undefined) {
+                receiver.anyOf = anyOf;
+            }
+            // merge rest of constraints
+            // TODO: do more intelligent merge
+            receiver = {
+                ...receiver,
+                title: receiver.title || title,
+                ...otherConstraints,
+            };
+            if (subSchemaRef) {
+                receiver.parentRefs.push(subSchemaRef);
+                if (receiver.title === undefined && (0, openapi_1.isNamedDefinition)(subSchemaRef)) {
+                    // this is not so correct behaviour. commented out for now
+                    // ref: https://github.com/Redocly/redoc/issues/601
+                    // receiver.title = JsonPointer.baseName(subSchemaRef);
+                }
+            }
+        }
+        return receiver;
+    }
+    /**
+     * Find all derived definitions among #/components/schemas from any of $refs
+     * returns map of definition pointer to definition name
+     * @param $refs array of references to find derived from
+     */
+    findDerived($refs) {
+        const res = {};
+        const schemas = (this.spec.components && this.spec.components.schemas) || {};
+        for (const defName in schemas) {
+            const def = this.deref(schemas[defName]);
+            if (def.allOf !== undefined &&
+                def.allOf.find((obj) => obj.$ref !== undefined && $refs.indexOf(obj.$ref) > -1)) {
+                res["#/components/schemas/" + defName] = [
+                    def["x-discriminator-value"] || defName,
+                ];
+            }
+        }
+        return res;
+    }
+    exitParents(shema) {
+        for (const parent$ref of shema.parentRefs || []) {
+            this.exitRef({ $ref: parent$ref });
+        }
+    }
+    hoistOneOfs(schema) {
+        if (schema.allOf === undefined) {
+            return schema;
+        }
+        const allOf = schema.allOf;
+        for (let i = 0; i < allOf.length; i++) {
+            const sub = allOf[i];
+            if ((0, helpers_1.isArray)(sub.oneOf)) {
+                const beforeAllOf = allOf.slice(0, i);
+                const afterAllOf = allOf.slice(i + 1);
+                return {
+                    oneOf: sub.oneOf.map((part) => {
+                        const merged = this.mergeAllOf({
+                            allOf: [...beforeAllOf, part, ...afterAllOf],
+                        });
+                        // each oneOf should be independent so exiting all the parent refs
+                        // otherwise it will cause false-positive recursive detection
+                        this.exitParents(merged);
+                        return merged;
+                    }),
+                };
+            }
+        }
+        return schema;
+    }
+}
+exports.OpenAPIParser = OpenAPIParser;