@camunda8/docusaurus-plugin-openapi-docs 4.5.1

package/lib/openapi/sdkExamples.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Configuration for a single SDK example source.
+ */
+export interface SdkExampleSource {
+    /** Language label shown in the code sample tab (e.g. "TypeScript", "Python", "C#"). */
+    lang: string;
+    /** Syntax highlight mode (e.g. "typescript", "python", "csharp"). */
+    highlight?: string;
+    /** Path to the operation-map.json file (relative to site root or absolute). */
+    operationMapPath: string;
+}
+/**
+ * A single entry in operation-map.json for one operationId.
+ */
+interface OperationMapEntry {
+    file: string;
+    region: string;
+    label?: string;
+}
+/**
+ * Shape of operation-map.json: operationId -> entries[].
+ */
+type OperationMap = Record<string, OperationMapEntry[]>;
+/**
+ * Build x-codeSamples entries for a given operationId from all configured SDK sources.
+ *
+ * @param operationId - The OpenAPI operationId to look up.
+ * @param sdkExamples - Array of SDK example source configurations.
+ * @param siteDir - The Docusaurus site root directory (for resolving relative paths).
+ * @param fileCache - Shared cache to avoid re-reading the same source files.
+ * @param mapCache - Shared cache for parsed operation-map.json files.
+ * @returns Array of x-codeSamples entries, or empty array if none found.
+ */
+export declare function buildCodeSamples(operationId: string, sdkExamples: SdkExampleSource[], siteDir: string, fileCache: Map<string, string>, mapCache: Map<string, OperationMap>): {
+    lang: string;
+    label: string;
+    source: string;
+}[];
+export {};

package/lib/openapi/sdkExamples.js

@@ -0,0 +1,141 @@
+"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.buildCodeSamples = buildCodeSamples;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+// Region marker patterns for supported languages.
+// Each pattern matches the start/end of a named region.
+const REGION_PATTERNS = [
+    // TypeScript/JavaScript: //#region Name  ...  //#endregion [Name]
+    {
+        start: /^\s*\/\/#region\s+(.+?)\s*$/,
+        end: /^\s*\/\/#endregion(?:\s+(.+?))?\s*$/,
+    },
+    // C#: #region Name  ...  #endregion [Name]
+    {
+        start: /^\s*#region\s+(.+?)\s*$/,
+        end: /^\s*#endregion(?:\s+(.+?))?\s*$/,
+    },
+    // XML-style: // <RegionName>  ...  // </RegionName>
+    {
+        start: /^\s*\/\/\s*<([A-Za-z]\w*)>\s*$/,
+        end: /^\s*\/\/\s*<\/([A-Za-z]\w*)>\s*$/,
+    },
+    // Python: # region Name  ...  # endregion [Name]
+    {
+        start: /^\s*#\s*region\s+(.+?)\s*$/,
+        end: /^\s*#\s*endregion(?:\s+(.+?))?\s*$/,
+    },
+];
+/**
+ * Extract the code between region markers from a source file's content.
+ * Returns the trimmed code block or undefined if the region is not found.
+ */
+function extractRegion(content, regionName) {
+    const lines = content.split(/\r?\n/);
+    let capturing = false;
+    let capturedLines = [];
+    for (const line of lines) {
+        if (capturing) {
+            // Check if this line is an end marker for our region
+            for (const pattern of REGION_PATTERNS) {
+                const endMatch = line.match(pattern.end);
+                if (endMatch &&
+                    (!endMatch[1] || endMatch[1].trim() === regionName)) {
+                    // Found end marker — return captured content
+                    return trimIndentation(capturedLines);
+                }
+            }
+            capturedLines.push(line);
+        }
+        else {
+            // Check if this line is a start marker for our region
+            for (const pattern of REGION_PATTERNS) {
+                const startMatch = line.match(pattern.start);
+                if (startMatch && startMatch[1].trim() === regionName) {
+                    capturing = true;
+                    capturedLines = [];
+                    break;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Remove the common leading whitespace from all non-empty lines.
+ */
+function trimIndentation(lines) {
+    const nonEmptyLines = lines.filter((l) => l.trim().length > 0);
+    if (nonEmptyLines.length === 0)
+        return "";
+    const minIndent = Math.min(...nonEmptyLines.map((l) => {
+        const match = l.match(/^(\s*)/);
+        return match ? match[1].length : 0;
+    }));
+    return lines
+        .map((l) => (l.trim().length === 0 ? "" : l.slice(minIndent)))
+        .join("\n")
+        .trim();
+}
+/**
+ * Build x-codeSamples entries for a given operationId from all configured SDK sources.
+ *
+ * @param operationId - The OpenAPI operationId to look up.
+ * @param sdkExamples - Array of SDK example source configurations.
+ * @param siteDir - The Docusaurus site root directory (for resolving relative paths).
+ * @param fileCache - Shared cache to avoid re-reading the same source files.
+ * @param mapCache - Shared cache for parsed operation-map.json files.
+ * @returns Array of x-codeSamples entries, or empty array if none found.
+ */
+function buildCodeSamples(operationId, sdkExamples, siteDir, fileCache, mapCache) {
+    const samples = [];
+    for (const sdk of sdkExamples) {
+        const mapPath = path_1.default.resolve(siteDir, sdk.operationMapPath);
+        let operationMap = mapCache.get(mapPath);
+        if (!operationMap) {
+            if (!fs_extra_1.default.existsSync(mapPath)) {
+                console.warn(`SDK examples: operation-map not found at ${mapPath}`);
+                continue;
+            }
+            operationMap = fs_extra_1.default.readJSONSync(mapPath);
+            mapCache.set(mapPath, operationMap);
+        }
+        const entries = operationMap[operationId];
+        if (!entries || entries.length === 0)
+            continue;
+        const mapDir = path_1.default.dirname(mapPath);
+        for (const entry of entries) {
+            const filePath = path_1.default.resolve(mapDir, entry.file);
+            let fileContent = fileCache.get(filePath);
+            if (fileContent === undefined) {
+                if (!fs_extra_1.default.existsSync(filePath)) {
+                    console.warn(`SDK examples: source file not found at ${filePath} (referenced by ${sdk.lang} operation-map for ${operationId})`);
+                    continue;
+                }
+                fileContent = fs_extra_1.default.readFileSync(filePath, "utf-8");
+                fileCache.set(filePath, fileContent);
+            }
+            const code = extractRegion(fileContent, entry.region);
+            if (!code) {
+                console.warn(`SDK examples: region "${entry.region}" not found in ${filePath} (${sdk.lang}, ${operationId})`);
+                continue;
+            }
+            samples.push({
+                lang: sdk.lang,
+                label: "SDK",
+                source: code,
+            });
+        }
+    }
+    return samples;
+}

package/lib/openapi/types.d.ts

@@ -0,0 +1,352 @@
+import type { JSONSchema4, JSONSchema6, JSONSchema7, JSONSchema7TypeName } from "json-schema";
+export interface OpenApiObject {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+    swagger?: string;
+    webhooks?: PathsObject;
+    "x-webhooks"?: PathsObject;
+    "x-tagGroups"?: TagGroupObject[];
+}
+export interface OpenApiObjectWithRef {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObjectWithRef;
+    components?: ComponentsObjectWithRef;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+}
+export interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+    tags?: TagObject[];
+    "x-logo"?: LogoObject;
+    "x-dark-logo"?: LogoObject;
+    logo?: LogoObject;
+    darkLogo?: LogoObject;
+}
+export interface LogoObject {
+    url?: string;
+}
+export interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface LicenseObject {
+    name: string;
+    url?: string;
+}
+export interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: Record<string, ServerVariable>;
+}
+export interface ServerVariable {
+    enum?: string[];
+    default: string;
+    description?: string;
+}
+export interface ComponentsObject {
+    schemas?: Record<string, SchemaObject>;
+    responses?: Record<string, ResponseObject>;
+    parameters?: Record<string, ParameterObject>;
+    examples?: Record<string, ExampleObject>;
+    requestBodies?: Record<string, RequestBodyObject>;
+    headers?: Record<string, HeaderObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject>;
+    links?: Record<string, LinkObject>;
+    callbacks?: Record<string, CallbackObject>;
+}
+export interface ComponentsObjectWithRef {
+    schemas?: Record<string, SchemaObjectWithRef | ReferenceObject>;
+    responses?: Record<string, ResponseObjectWithRef | ReferenceObject>;
+    parameters?: Record<string, ParameterObjectWithRef | ReferenceObject>;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    requestBodies?: Record<string, RequestBodyObjectWithRef | ReferenceObject>;
+    headers?: Record<string, HeaderObjectWithRef | ReferenceObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject>;
+    links?: Record<string, LinkObject | ReferenceObject>;
+    callbacks?: Record<string, CallbackObjectWithRef | ReferenceObject>;
+}
+export type PathsObject = Record<string, PathItemObject>;
+export type PathsObjectWithRef = Record<string, PathItemObjectWithRef>;
+export interface PathItemObject {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObject;
+    put?: OperationObject;
+    post?: OperationObject;
+    delete?: OperationObject;
+    options?: OperationObject;
+    head?: OperationObject;
+    patch?: OperationObject;
+    trace?: OperationObject;
+    servers?: ServerObject[];
+    parameters?: ParameterObject[];
+}
+export interface PathItemObjectWithRef {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObjectWithRef;
+    put?: OperationObjectWithRef;
+    post?: OperationObjectWithRef;
+    delete?: OperationObjectWithRef;
+    options?: OperationObjectWithRef;
+    head?: OperationObjectWithRef;
+    patch?: OperationObjectWithRef;
+    trace?: OperationObjectWithRef;
+    servers?: ServerObject[];
+    parameters?: (ParameterObjectWithRef | ReferenceObject)[];
+}
+export interface OperationObject {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: ParameterObject[];
+    requestBody?: RequestBodyObject;
+    responses: ResponsesObject;
+    callbacks?: Record<string, CallbackObject>;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+    "x-position"?: number;
+    "x-deprecated-description"?: string;
+}
+export interface OperationObjectWithRef {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ParameterObjectWithRef | ReferenceObject)[];
+    requestBody?: RequestBodyObjectWithRef | ReferenceObject;
+    responses: ResponsesObjectWithRef;
+    callbacks?: Record<string, CallbackObjectWithRef | ReferenceObject>;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+    "x-deprecated-description"?: string;
+}
+export interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+}
+export interface ParameterObject {
+    name: string;
+    in: "query" | "header" | "path" | "cookie";
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: string;
+    explode?: string;
+    allowReserved?: boolean;
+    schema?: SchemaObject;
+    example?: any;
+    examples?: Record<string, ExampleObject>;
+    content?: Record<string, MediaTypeObject>;
+    param?: Object;
+    "x-enumDescriptions"?: Record<string, string>;
+}
+export interface ParameterObjectWithRef {
+    name: string;
+    in: string;
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: string;
+    explode?: string;
+    allowReserved?: boolean;
+    schema?: SchemaObjectWithRef | ReferenceObject;
+    example?: any;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    content?: Record<string, MediaTypeObjectWithRef>;
+}
+export interface RequestBodyObject {
+    description?: string;
+    content: Record<string, MediaTypeObject>;
+    required?: boolean;
+}
+export interface RequestBodyObjectWithRef {
+    description?: string;
+    content: Record<string, MediaTypeObjectWithRef>;
+    required?: boolean;
+}
+export interface MediaTypeObject {
+    schema?: SchemaObject;
+    example?: any;
+    examples?: Record<string, ExampleObject>;
+    encoding?: Record<string, EncodingObject>;
+    type?: any;
+}
+export interface MediaTypeObjectWithRef {
+    schema?: SchemaObjectWithRef | ReferenceObject;
+    example?: any;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    encoding?: Record<string, EncodingObjectWithRef>;
+}
+export interface EncodingObject {
+    contentType?: string;
+    headers?: Record<string, HeaderObject>;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+export interface EncodingObjectWithRef {
+    contentType?: string;
+    headers?: Record<string, HeaderObjectWithRef | ReferenceObject>;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+export type ResponsesObject = Record<string, ResponseObject>;
+export type ResponsesObjectWithRef = Record<string, ResponseObjectWithRef | ReferenceObject>;
+export interface ResponseObject {
+    description: string;
+    headers?: Record<string, HeaderObject>;
+    content?: Record<string, MediaTypeObject>;
+    links?: Record<string, LinkObject>;
+}
+export interface ResponseObjectWithRef {
+    description: string;
+    headers?: Record<string, HeaderObjectWithRef | ReferenceObject>;
+    content?: Record<string, MediaTypeObjectWithRef>;
+    links?: Record<string, LinkObject | ReferenceObject>;
+}
+export type CallbackObject = Record<string, PathItemObject>;
+export type CallbackObjectWithRef = Record<string, PathItemObjectWithRef>;
+export interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+}
+export interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: Record<string, any>;
+    requestBody?: any;
+    description?: string;
+    server?: ServerObject;
+}
+export type HeaderObject = Omit<ParameterObject, "name" | "in">;
+export type HeaderObjectWithRef = Omit<ParameterObjectWithRef, "name" | "in">;
+export interface TagObject {
+    name?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    "x-displayName"?: string;
+}
+export interface TagGroupObject {
+    name: string;
+    tags: string[];
+}
+export interface ReferenceObject {
+    $ref: string;
+}
+export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
+export type SchemaType = JSONSchema7TypeName;
+export type SchemaObject = Omit<JSONSchema, "type" | "allOf" | "oneOf" | "anyOf" | "not" | "items" | "properties" | "additionalProperties"> & {
+    type?: SchemaType;
+    allOf?: SchemaObject[];
+    oneOf?: SchemaObject[];
+    anyOf?: SchemaObject[];
+    not?: SchemaObject;
+    items?: SchemaObject;
+    properties?: Record<string, SchemaObject>;
+    additionalProperties?: boolean | SchemaObject;
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+    "x-tags"?: string[];
+    "x-enumDescriptions"?: Record<string, string>;
+};
+export type SchemaObjectWithRef = Omit<JSONSchema, "type" | "allOf" | "oneOf" | "anyOf" | "not" | "items" | "properties" | "additionalProperties"> & {
+    type?: SchemaType;
+    allOf?: (SchemaObject | ReferenceObject)[];
+    oneOf?: (SchemaObject | ReferenceObject)[];
+    anyOf?: (SchemaObject | ReferenceObject)[];
+    not?: SchemaObject | ReferenceObject;
+    items?: SchemaObject | ReferenceObject;
+    properties?: Record<string, SchemaObject | ReferenceObject>;
+    additionalProperties?: boolean | SchemaObject | ReferenceObject;
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+};
+export interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: Record<string, string>;
+}
+export interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+export type SecuritySchemeObject = ApiKeySecuritySchemeObject | HttpSecuritySchemeObject | Oauth2SecuritySchemeObject | OpenIdConnectSecuritySchemeObject;
+export interface ApiKeySecuritySchemeObject {
+    type: "apiKey";
+    description?: string;
+    name: string;
+    in: "query" | "header" | "cookie";
+}
+export interface HttpSecuritySchemeObject {
+    type: "http";
+    description?: string;
+    scheme: string;
+    bearerFormat?: string;
+    name?: string;
+    in?: string;
+}
+export interface Oauth2SecuritySchemeObject {
+    type: "oauth2";
+    description?: string;
+    flows: OAuthFlowsObject;
+}
+export interface OpenIdConnectSecuritySchemeObject {
+    type: "openIdConnect";
+    description?: string;
+    openIdConnectUrl: string;
+}
+export interface OAuthFlowsObject {
+    implicit?: OAuthFlowObject;
+    password?: OAuthFlowObject;
+    clientCredentials?: OAuthFlowObject;
+    authorizationCode?: OAuthFlowObject;
+}
+export interface OAuthFlowObject {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: Record<string, string>;
+}
+export type SecurityRequirementObject = Record<string, string[]>;

package/lib/openapi/types.js

@@ -0,0 +1,8 @@
+"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 });

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,153 @@
+"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.convertSwagger2OpenAPI = convertSwagger2OpenAPI;
+exports.loadAndResolveSpec = loadAndResolveSpec;
+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");
+const OpenAPIParser_1 = require("./services/OpenAPIParser");
+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) {
+        // Resolve discriminator ref pointers
+        if ((value === null || value === void 0 ? void 0 : value.discriminator) !== undefined) {
+            const parser = new OpenAPIParser_1.OpenAPIParser(stack[0]);
+            if (value.discriminator.mapping &&
+                typeof value.discriminator.mapping === "object") {
+                for (let [k, v] of Object.entries(value.discriminator.mapping)) {
+                    const discriminator = k;
+                    if (typeof v === "string" && v.charAt(0) === "#") {
+                        const ref = v;
+                        const resolvedRef = parser.byRef(ref);
+                        value.discriminator.mapping[discriminator] = resolvedRef;
+                    }
+                }
+            }
+        }
+        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,
+        resolveInternal: true,
+    }, (err, res) => {
+        // TODO: log any warnings
+        if (err) {
+            return reject(err);
+        }
+        resolve(res && res.openapi);
+    }));
+}
+async function resolveJsonRefs(specUrlOrObject) {
+    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) {
+        let errorMsg = "";
+        if (err.errors[0] !== undefined) {
+            const error = err.errors[0];
+            errorMsg = `Error: [${error.message}] with footprint [${error.footprint}]`;
+        }
+        else {
+            errorMsg = err;
+        }
+        console.error(chalk_1.default.yellow(errorMsg));
+        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);
+    //Pre-processing before resolving JSON refs
+    if (parsed.components) {
+        for (let [component, type] of Object.entries(parsed.components)) {
+            if (component === "schemas") {
+                for (let [schemaKey, schemaValue] of Object.entries(type)) {
+                    const title = schemaValue["title"];
+                    if (!title) {
+                        schemaValue.title = schemaKey;
+                    }
+                }
+            }
+        }
+    }
+    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;
+}