@redocly/openapi-core 1.0.0-beta.100

package/lib/bundle.js

@@ -0,0 +1,291 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapTypeToComponent = exports.bundleDocument = exports.bundle = exports.OasVersion = void 0;
+const isEqual = require("lodash.isequal");
+const resolve_1 = require("./resolve");
+const visitors_1 = require("./visitors");
+const oas3_1 = require("./types/oas3");
+const oas2_1 = require("./types/oas2");
+const oas3_1_1 = require("./types/oas3_1");
+const types_1 = require("./types");
+const walk_1 = require("./walk");
+const oas_types_1 = require("./oas-types");
+const ref_utils_1 = require("./ref-utils");
+const rules_1 = require("./config/rules");
+const no_unresolved_refs_1 = require("./rules/no-unresolved-refs");
+const utils_1 = require("./utils");
+const redocly_1 = require("./redocly");
+const remove_unused_components_1 = require("./rules/oas2/remove-unused-components");
+const remove_unused_components_2 = require("./rules/oas3/remove-unused-components");
+var OasVersion;
+(function (OasVersion) {
+    OasVersion["Version2"] = "oas2";
+    OasVersion["Version3_0"] = "oas3_0";
+    OasVersion["Version3_1"] = "oas3_1";
+})(OasVersion = exports.OasVersion || (exports.OasVersion = {}));
+function bundle(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { ref, doc, externalRefResolver = new resolve_1.BaseResolver(opts.config.resolve), base = null, } = opts;
+        if (!(ref || doc)) {
+            throw new Error('Document or reference is required.\n');
+        }
+        const document = doc !== undefined ? doc : yield externalRefResolver.resolveDocument(base, ref, true);
+        if (document instanceof Error) {
+            throw document;
+        }
+        return bundleDocument(Object.assign(Object.assign({ document }, opts), { config: opts.config.lint, externalRefResolver }));
+    });
+}
+exports.bundle = bundle;
+function bundleDocument(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { document, config, customTypes, externalRefResolver, dereference = false, skipRedoclyRegistryRefs = false, removeUnusedComponents = false, keepUrlRefs = false, } = opts;
+        const oasVersion = oas_types_1.detectOpenAPI(document.parsed);
+        const oasMajorVersion = oas_types_1.openAPIMajor(oasVersion);
+        const rules = config.getRulesForOasVersion(oasMajorVersion);
+        const types = types_1.normalizeTypes(config.extendTypes((customTypes !== null && customTypes !== void 0 ? customTypes : oasMajorVersion === oas_types_1.OasMajorVersion.Version3)
+            ? oasVersion === OasVersion.Version3_1
+                ? oas3_1_1.Oas3_1Types
+                : oas3_1.Oas3Types
+            : oas2_1.Oas2Types, oasVersion), config);
+        const preprocessors = rules_1.initRules(rules, config, 'preprocessors', oasVersion);
+        const decorators = rules_1.initRules(rules, config, 'decorators', oasVersion);
+        const ctx = {
+            problems: [],
+            oasVersion: oasVersion,
+            refTypes: new Map(),
+            visitorsData: {},
+        };
+        if (removeUnusedComponents) {
+            decorators.push({
+                severity: 'error',
+                ruleId: 'remove-unused-components',
+                visitor: oasMajorVersion === oas_types_1.OasMajorVersion.Version2
+                    ? remove_unused_components_1.RemoveUnusedComponents({})
+                    : remove_unused_components_2.RemoveUnusedComponents({})
+            });
+        }
+        const resolvedRefMap = yield resolve_1.resolveDocument({
+            rootDocument: document,
+            rootType: types.DefinitionRoot,
+            externalRefResolver,
+        });
+        const bundleVisitor = visitors_1.normalizeVisitors([
+            ...preprocessors,
+            {
+                severity: 'error',
+                ruleId: 'bundler',
+                visitor: makeBundleVisitor(oasMajorVersion, dereference, skipRedoclyRegistryRefs, document, resolvedRefMap, keepUrlRefs),
+            },
+            ...decorators,
+        ], types);
+        walk_1.walkDocument({
+            document,
+            rootType: types.DefinitionRoot,
+            normalizedVisitors: bundleVisitor,
+            resolvedRefMap,
+            ctx,
+        });
+        return {
+            bundle: document,
+            problems: ctx.problems.map((problem) => config.addProblemToIgnore(problem)),
+            fileDependencies: externalRefResolver.getFiles(),
+            rootType: types.DefinitionRoot,
+            refTypes: ctx.refTypes,
+            visitorsData: ctx.visitorsData,
+        };
+    });
+}
+exports.bundleDocument = bundleDocument;
+function mapTypeToComponent(typeName, version) {
+    switch (version) {
+        case oas_types_1.OasMajorVersion.Version3:
+            switch (typeName) {
+                case 'Schema':
+                    return 'schemas';
+                case 'Parameter':
+                    return 'parameters';
+                case 'Response':
+                    return 'responses';
+                case 'Example':
+                    return 'examples';
+                case 'RequestBody':
+                    return 'requestBodies';
+                case 'Header':
+                    return 'headers';
+                case 'SecuritySchema':
+                    return 'securitySchemes';
+                case 'Link':
+                    return 'links';
+                case 'Callback':
+                    return 'callbacks';
+                default:
+                    return null;
+            }
+        case oas_types_1.OasMajorVersion.Version2:
+            switch (typeName) {
+                case 'Schema':
+                    return 'definitions';
+                case 'Parameter':
+                    return 'parameters';
+                case 'Response':
+                    return 'responses';
+                default:
+                    return null;
+            }
+    }
+}
+exports.mapTypeToComponent = mapTypeToComponent;
+// function oas3Move
+function makeBundleVisitor(version, dereference, skipRedoclyRegistryRefs, rootDocument, resolvedRefMap, keepUrlRefs) {
+    let components;
+    const visitor = {
+        ref: {
+            leave(node, ctx, resolved) {
+                if (!resolved.location || resolved.node === undefined) {
+                    no_unresolved_refs_1.reportUnresolvedRef(resolved, ctx.report, ctx.location);
+                    return;
+                }
+                if (resolved.location.source === rootDocument.source &&
+                    resolved.location.source === ctx.location.source &&
+                    ctx.type.name !== 'scalar' &&
+                    !dereference) {
+                    return;
+                }
+                // do not bundle registry URL before push, otherwise we can't record dependencies
+                if (skipRedoclyRegistryRefs && redocly_1.isRedoclyRegistryURL(node.$ref)) {
+                    return;
+                }
+                if (keepUrlRefs && ref_utils_1.isAbsoluteUrl(node.$ref)) {
+                    return;
+                }
+                const componentType = mapTypeToComponent(ctx.type.name, version);
+                if (!componentType) {
+                    replaceRef(node, resolved, ctx);
+                }
+                else {
+                    if (dereference) {
+                        saveComponent(componentType, resolved, ctx);
+                        replaceRef(node, resolved, ctx);
+                    }
+                    else {
+                        node.$ref = saveComponent(componentType, resolved, ctx);
+                        resolveBundledComponent(node, resolved, ctx);
+                    }
+                }
+            },
+        },
+        DefinitionRoot: {
+            enter(root) {
+                if (version === oas_types_1.OasMajorVersion.Version3) {
+                    components = root.components = root.components || {};
+                }
+                else if (version === oas_types_1.OasMajorVersion.Version2) {
+                    components = root;
+                }
+            },
+        },
+    };
+    if (version === oas_types_1.OasMajorVersion.Version3) {
+        visitor.DiscriminatorMapping = {
+            leave(mapping, ctx) {
+                for (const name of Object.keys(mapping)) {
+                    const $ref = mapping[name];
+                    const resolved = ctx.resolve({ $ref });
+                    if (!resolved.location || resolved.node === undefined) {
+                        no_unresolved_refs_1.reportUnresolvedRef(resolved, ctx.report, ctx.location.child(name));
+                        return;
+                    }
+                    const componentType = mapTypeToComponent('Schema', version);
+                    if (dereference) {
+                        saveComponent(componentType, resolved, ctx);
+                    }
+                    else {
+                        mapping[name] = saveComponent(componentType, resolved, ctx);
+                    }
+                }
+            },
+        };
+    }
+    function resolveBundledComponent(node, resolved, ctx) {
+        const newRefId = resolve_1.makeRefId(ctx.location.source.absoluteRef, node.$ref);
+        resolvedRefMap.set(newRefId, {
+            document: rootDocument,
+            isRemote: false,
+            node: resolved.node,
+            nodePointer: node.$ref,
+            resolved: true,
+        });
+    }
+    function replaceRef(ref, resolved, ctx) {
+        if (!utils_1.isPlainObject(resolved.node)) {
+            ctx.parent[ctx.key] = resolved.node;
+        }
+        else {
+            // @ts-ignore
+            delete ref.$ref;
+            Object.assign(ref, resolved.node);
+        }
+    }
+    function saveComponent(componentType, target, ctx) {
+        components[componentType] = components[componentType] || {};
+        const name = getComponentName(target, componentType, ctx);
+        components[componentType][name] = target.node;
+        if (version === oas_types_1.OasMajorVersion.Version3) {
+            return `#/components/${componentType}/${name}`;
+        }
+        else {
+            return `#/${componentType}/${name}`;
+        }
+    }
+    function isEqualOrEqualRef(node, target, ctx) {
+        var _a;
+        if (ref_utils_1.isRef(node) &&
+            ((_a = ctx.resolve(node).location) === null || _a === void 0 ? void 0 : _a.absolutePointer) === target.location.absolutePointer) {
+            return true;
+        }
+        return isEqual(node, target.node);
+    }
+    function getComponentName(target, componentType, ctx) {
+        const [fileRef, pointer] = [target.location.source.absoluteRef, target.location.pointer];
+        const componentsGroup = components[componentType];
+        let name = '';
+        const refParts = pointer.slice(2).split('/').filter(Boolean); // slice(2) removes "#/"
+        while (refParts.length > 0) {
+            name = refParts.pop() + (name ? `-${name}` : '');
+            if (!componentsGroup ||
+                !componentsGroup[name] ||
+                isEqualOrEqualRef(componentsGroup[name], target, ctx)) {
+                return name;
+            }
+        }
+        name = ref_utils_1.refBaseName(fileRef) + (name ? `_${name}` : '');
+        if (!componentsGroup[name] || isEqualOrEqualRef(componentsGroup[name], target, ctx)) {
+            return name;
+        }
+        const prevName = name;
+        let serialId = 2;
+        while (componentsGroup[name] && !isEqualOrEqualRef(componentsGroup[name], target, ctx)) {
+            name = `${prevName}-${serialId}`;
+            serialId++;
+        }
+        if (!componentsGroup[name]) {
+            ctx.report({
+                message: `Two schemas are referenced with the same name but different content. Renamed ${prevName} to ${name}.`,
+                location: ctx.location,
+                forceSeverity: 'warn',
+            });
+        }
+        return name;
+    }
+    return visitor;
+}

package/lib/config/all.d.ts

@@ -0,0 +1,3 @@
+import type { PluginLintConfig } from "./types";
+declare const _default: PluginLintConfig;
+export default _default;

package/lib/config/all.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    rules: {
+        'info-description': 'error',
+        'info-contact': 'error',
+        'info-license': 'error',
+        'info-license-url': 'error',
+        'tag-description': 'error',
+        'tags-alphabetical': 'error',
+        'parameter-description': 'error',
+        'no-identical-paths': 'error',
+        'no-ambiguous-paths': 'error',
+        'no-path-trailing-slash': 'error',
+        'path-segment-plural': 'error',
+        'path-declaration-must-exist': 'error',
+        'path-not-include-query': 'error',
+        'path-parameters-defined': 'error',
+        'operation-description': 'error',
+        'operation-2xx-response': 'error',
+        'operation-4xx-response': 'error',
+        'assertions': 'error',
+        'operation-operationId': 'error',
+        'operation-summary': 'error',
+        'operation-operationId-unique': 'error',
+        'operation-operationId-url-safe': 'error',
+        'operation-parameters-unique': 'error',
+        'operation-tag-defined': 'error',
+        'operation-security-defined': 'error',
+        'operation-singular-tag': 'error',
+        'no-unresolved-refs': 'error',
+        'no-enum-type-mismatch': 'error',
+        'boolean-parameter-prefixes': 'error',
+        'paths-kebab-case': 'error',
+        'no-http-verbs-in-paths': 'error',
+        'path-excludes-patterns': {
+            severity: 'error',
+            patterns: [],
+        },
+        'request-mime-type': 'error',
+        spec: 'error',
+        'no-invalid-schema-examples': 'error',
+        'no-invalid-parameter-examples': 'error',
+        'scalar-property-missing-example': 'error',
+    },
+    oas3_0Rules: {
+        'no-invalid-media-type-examples': 'error',
+        'no-server-example.com': 'error',
+        'no-server-trailing-slash': 'error',
+        'no-empty-servers': 'error',
+        'no-example-value-and-externalValue': 'error',
+        'no-unused-components': 'error',
+        'no-undefined-server-variable': 'error',
+        'no-servers-empty-enum': 'error',
+    },
+    oas3_1Rules: {
+        'no-server-example.com': 'error',
+        'no-server-trailing-slash': 'error',
+        'no-empty-servers': 'error',
+        'no-example-value-and-externalValue': 'error',
+        'no-unused-components': 'error',
+        'no-undefined-server-variable': 'error',
+        'no-servers-empty-enum': 'error',
+    },
+};

package/lib/config/builtIn.d.ts

@@ -0,0 +1,3 @@
+import type { LintRawConfig, Plugin } from './types';
+export declare const builtInConfigs: Record<string, LintRawConfig>;
+export declare const defaultPlugin: Plugin;

package/lib/config/builtIn.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPlugin = exports.builtInConfigs = void 0;
+const recommended_1 = require("./recommended");
+const all_1 = require("./all");
+const minimal_1 = require("./minimal");
+const oas3_1 = require("../rules/oas3");
+const oas2_1 = require("../rules/oas2");
+const oas3_2 = require("../rules/oas3");
+const oas2_2 = require("../rules/oas2");
+const oas3_3 = require("../decorators/oas3");
+const oas2_3 = require("../decorators/oas2");
+exports.builtInConfigs = {
+    recommended: recommended_1.default,
+    minimal: minimal_1.default,
+    all: all_1.default,
+    'redocly-registry': {
+        decorators: { 'registry-dependencies': 'on' }
+    }
+};
+exports.defaultPlugin = {
+    id: '',
+    rules: {
+        oas3: oas3_1.rules,
+        oas2: oas2_1.rules,
+    },
+    preprocessors: {
+        oas3: oas3_2.preprocessors,
+        oas2: oas2_2.preprocessors,
+    },
+    decorators: {
+        oas3: oas3_3.decorators,
+        oas2: oas2_3.decorators,
+    },
+    configs: exports.builtInConfigs,
+};

package/lib/config/config-resolvers.d.ts

@@ -0,0 +1,16 @@
+import { BaseResolver } from '../resolve';
+import type { LintRawConfig, Plugin, RawConfig, ResolvedApi, ResolvedLintConfig } from './types';
+import { Config } from './config';
+export declare function resolveConfig(rawConfig: RawConfig, configPath?: string): Promise<Config>;
+export declare function resolvePlugins(plugins: (string | Plugin)[] | null, configPath?: string): Plugin[];
+export declare function resolveApis({ rawConfig, configPath, resolver, }: {
+    rawConfig: RawConfig;
+    configPath?: string;
+    resolver?: BaseResolver;
+}): Promise<Record<string, ResolvedApi>>;
+export declare function resolveLint(lintOpts: {
+    lintConfig?: LintRawConfig;
+    configPath?: string;
+    resolver?: BaseResolver;
+}, parentConfigPaths?: string[], extendPaths?: string[]): Promise<ResolvedLintConfig>;
+export declare function resolvePreset(presetName: string, plugins: Plugin[]): ResolvedLintConfig;

package/lib/config/config-resolvers.js

@@ -0,0 +1,242 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePreset = exports.resolveLint = exports.resolveApis = exports.resolvePlugins = exports.resolveConfig = void 0;
+const path = require("path");
+const colorette_1 = require("colorette");
+const ref_utils_1 = require("../ref-utils");
+const resolve_1 = require("../resolve");
+const builtIn_1 = require("./builtIn");
+const utils_1 = require("./utils");
+const utils_2 = require("../utils");
+const config_1 = require("./config");
+function resolveConfig(rawConfig, configPath) {
+    var _a, _b, _c, _d, _e;
+    return __awaiter(this, void 0, void 0, function* () {
+        if ((_b = (_a = rawConfig.lint) === null || _a === void 0 ? void 0 : _a.extends) === null || _b === void 0 ? void 0 : _b.some(utils_2.isNotString)) {
+            throw new Error(`Error configuration format not detected in extends value must contain strings`);
+        }
+        const resolver = new resolve_1.BaseResolver(utils_1.getResolveConfig(rawConfig.resolve));
+        const configExtends = (_d = (_c = rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.lint) === null || _c === void 0 ? void 0 : _c.extends) !== null && _d !== void 0 ? _d : ['recommended'];
+        const recommendedFallback = !((_e = rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.lint) === null || _e === void 0 ? void 0 : _e.extends);
+        const lintConfig = Object.assign(Object.assign({}, rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.lint), { extends: configExtends, recommendedFallback });
+        const apis = yield resolveApis({
+            rawConfig: Object.assign(Object.assign({}, rawConfig), { lint: lintConfig }),
+            configPath,
+            resolver,
+        });
+        const lint = yield resolveLint({
+            lintConfig,
+            configPath,
+            resolver,
+        });
+        return new config_1.Config(Object.assign(Object.assign({}, rawConfig), { apis,
+            lint }), configPath);
+    });
+}
+exports.resolveConfig = resolveConfig;
+function resolvePlugins(plugins, configPath = '') {
+    if (!plugins)
+        return [];
+    // @ts-ignore
+    const requireFunc = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require;
+    const seenPluginIds = new Map();
+    return plugins
+        .map((p) => {
+        if (utils_2.isString(p) && ref_utils_1.isAbsoluteUrl(p)) {
+            throw new Error(colorette_1.red(`We don't support remote plugins yet.`));
+        }
+        // TODO: resolve npm packages similar to eslint
+        const pluginModule = utils_2.isString(p)
+            ? requireFunc(path.resolve(path.dirname(configPath), p))
+            : p;
+        const id = pluginModule.id;
+        if (typeof id !== 'string') {
+            throw new Error(colorette_1.red(`Plugin must define \`id\` property in ${colorette_1.blue(p.toString())}.`));
+        }
+        if (seenPluginIds.has(id)) {
+            const pluginPath = seenPluginIds.get(id);
+            throw new Error(colorette_1.red(`Plugin "id" must be unique. Plugin ${colorette_1.blue(p.toString())} uses id "${colorette_1.blue(id)}" already seen in ${colorette_1.blue(pluginPath)}`));
+        }
+        seenPluginIds.set(id, p.toString());
+        const plugin = Object.assign(Object.assign({ id }, (pluginModule.configs ? { configs: pluginModule.configs } : {})), (pluginModule.typeExtension ? { typeExtension: pluginModule.typeExtension } : {}));
+        if (pluginModule.rules) {
+            if (!pluginModule.rules.oas3 && !pluginModule.rules.oas2) {
+                throw new Error(`Plugin rules must have \`oas3\` or \`oas2\` rules "${p}.`);
+            }
+            plugin.rules = {};
+            if (pluginModule.rules.oas3) {
+                plugin.rules.oas3 = utils_1.prefixRules(pluginModule.rules.oas3, id);
+            }
+            if (pluginModule.rules.oas2) {
+                plugin.rules.oas2 = utils_1.prefixRules(pluginModule.rules.oas2, id);
+            }
+        }
+        if (pluginModule.preprocessors) {
+            if (!pluginModule.preprocessors.oas3 && !pluginModule.preprocessors.oas2) {
+                throw new Error(`Plugin \`preprocessors\` must have \`oas3\` or \`oas2\` preprocessors "${p}.`);
+            }
+            plugin.preprocessors = {};
+            if (pluginModule.preprocessors.oas3) {
+                plugin.preprocessors.oas3 = utils_1.prefixRules(pluginModule.preprocessors.oas3, id);
+            }
+            if (pluginModule.preprocessors.oas2) {
+                plugin.preprocessors.oas2 = utils_1.prefixRules(pluginModule.preprocessors.oas2, id);
+            }
+        }
+        if (pluginModule.decorators) {
+            if (!pluginModule.decorators.oas3 && !pluginModule.decorators.oas2) {
+                throw new Error(`Plugin \`decorators\` must have \`oas3\` or \`oas2\` decorators "${p}.`);
+            }
+            plugin.decorators = {};
+            if (pluginModule.decorators.oas3) {
+                plugin.decorators.oas3 = utils_1.prefixRules(pluginModule.decorators.oas3, id);
+            }
+            if (pluginModule.decorators.oas2) {
+                plugin.decorators.oas2 = utils_1.prefixRules(pluginModule.decorators.oas2, id);
+            }
+        }
+        return plugin;
+    })
+        .filter(utils_2.notUndefined);
+}
+exports.resolvePlugins = resolvePlugins;
+function resolveApis({ rawConfig, configPath = '', resolver, }) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { apis = {}, lint: lintConfig = {} } = rawConfig;
+        let resolvedApis = {};
+        for (const [apiName, apiContent] of Object.entries(apis || {})) {
+            if ((_b = (_a = apiContent.lint) === null || _a === void 0 ? void 0 : _a.extends) === null || _b === void 0 ? void 0 : _b.some(utils_2.isNotString)) {
+                throw new Error(`Error configuration format not detected in extends value must contain strings`);
+            }
+            const rawLintConfig = getMergedLintRawConfig(lintConfig, apiContent.lint);
+            const apiLint = yield resolveLint({
+                lintConfig: rawLintConfig,
+                configPath,
+                resolver,
+            });
+            resolvedApis[apiName] = Object.assign(Object.assign({}, apiContent), { lint: apiLint });
+        }
+        return resolvedApis;
+    });
+}
+exports.resolveApis = resolveApis;
+function resolveAndMergeNestedLint({ lintConfig, configPath = '', resolver = new resolve_1.BaseResolver(), }, parentConfigPaths = [], extendPaths = []) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (parentConfigPaths.includes(configPath)) {
+            throw new Error(`Circular dependency in config file: "${configPath}"`);
+        }
+        const plugins = utils_1.getUniquePlugins(resolvePlugins([...((lintConfig === null || lintConfig === void 0 ? void 0 : lintConfig.plugins) || []), builtIn_1.defaultPlugin], configPath));
+        const pluginPaths = (_a = lintConfig === null || lintConfig === void 0 ? void 0 : lintConfig.plugins) === null || _a === void 0 ? void 0 : _a.filter(utils_2.isString).map((p) => path.resolve(path.dirname(configPath), p));
+        const resolvedConfigPath = ref_utils_1.isAbsoluteUrl(configPath)
+            ? configPath
+            : configPath && path.resolve(configPath);
+        const extendConfigs = yield Promise.all(((_b = lintConfig === null || lintConfig === void 0 ? void 0 : lintConfig.extends) === null || _b === void 0 ? void 0 : _b.map((presetItem) => __awaiter(this, void 0, void 0, function* () {
+            if (!ref_utils_1.isAbsoluteUrl(presetItem) && !path.extname(presetItem)) {
+                return resolvePreset(presetItem, plugins);
+            }
+            const pathItem = ref_utils_1.isAbsoluteUrl(presetItem)
+                ? presetItem
+                : ref_utils_1.isAbsoluteUrl(configPath)
+                    ? new URL(presetItem, configPath).href
+                    : path.resolve(path.dirname(configPath), presetItem);
+            const extendedLintConfig = yield loadExtendLintConfig(pathItem, resolver);
+            return yield resolveAndMergeNestedLint({
+                lintConfig: extendedLintConfig,
+                configPath: pathItem,
+                resolver: resolver,
+            }, [...parentConfigPaths, resolvedConfigPath], extendPaths);
+        }))) || []);
+        const _d = utils_1.mergeExtends([
+            ...extendConfigs,
+            Object.assign(Object.assign({}, lintConfig), { plugins, extends: undefined, extendPaths: [...parentConfigPaths, resolvedConfigPath], pluginPaths }),
+        ]), { plugins: mergedPlugins = [] } = _d, lint = __rest(_d, ["plugins"]);
+        return Object.assign(Object.assign({}, lint), { extendPaths: (_c = lint.extendPaths) === null || _c === void 0 ? void 0 : _c.filter((path) => path && !ref_utils_1.isAbsoluteUrl(path)), plugins: utils_1.getUniquePlugins(mergedPlugins), recommendedFallback: lintConfig === null || lintConfig === void 0 ? void 0 : lintConfig.recommendedFallback, doNotResolveExamples: lintConfig === null || lintConfig === void 0 ? void 0 : lintConfig.doNotResolveExamples });
+    });
+}
+function resolveLint(lintOpts, parentConfigPaths = [], extendPaths = []) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resolvedLint = yield resolveAndMergeNestedLint(lintOpts, parentConfigPaths, extendPaths);
+        return Object.assign(Object.assign({}, resolvedLint), { rules: resolvedLint.rules && groupLintAssertionRules(resolvedLint.rules) });
+    });
+}
+exports.resolveLint = resolveLint;
+function resolvePreset(presetName, plugins) {
+    var _a;
+    const { pluginId, configName } = utils_1.parsePresetName(presetName);
+    const plugin = plugins.find((p) => p.id === pluginId);
+    if (!plugin) {
+        throw new Error(`Invalid config ${colorette_1.red(presetName)}: plugin ${pluginId} is not included.`);
+    }
+    const preset = (_a = plugin.configs) === null || _a === void 0 ? void 0 : _a[configName];
+    if (!preset) {
+        throw new Error(pluginId
+            ? `Invalid config ${colorette_1.red(presetName)}: plugin ${pluginId} doesn't export config with name ${configName}.`
+            : `Invalid config ${colorette_1.red(presetName)}: there is no such built-in config.`);
+    }
+    return preset;
+}
+exports.resolvePreset = resolvePreset;
+function loadExtendLintConfig(filePath, resolver) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const fileSource = yield resolver.loadExternalRef(filePath);
+            const rawConfig = utils_1.transformConfig(utils_2.parseYaml(fileSource.body));
+            if (!rawConfig.lint) {
+                throw new Error(`Lint configuration format not detected: "${filePath}"`);
+            }
+            return rawConfig.lint;
+        }
+        catch (error) {
+            throw new Error(`Failed to load "${filePath}": ${error.message}`);
+        }
+    });
+}
+function getMergedLintRawConfig(configLint, apiLint) {
+    const resultLint = Object.assign(Object.assign(Object.assign({}, configLint), apiLint), { rules: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.rules), apiLint === null || apiLint === void 0 ? void 0 : apiLint.rules), oas2Rules: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.oas2Rules), apiLint === null || apiLint === void 0 ? void 0 : apiLint.oas2Rules), oas3_0Rules: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.oas3_0Rules), apiLint === null || apiLint === void 0 ? void 0 : apiLint.oas3_0Rules), oas3_1Rules: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.oas3_1Rules), apiLint === null || apiLint === void 0 ? void 0 : apiLint.oas3_1Rules), preprocessors: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.preprocessors), apiLint === null || apiLint === void 0 ? void 0 : apiLint.preprocessors), oas2Preprocessors: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.oas2Preprocessors), apiLint === null || apiLint === void 0 ? void 0 : apiLint.oas2Preprocessors), oas3_0Preprocessors: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.oas3_0Preprocessors), apiLint === null || apiLint === void 0 ? void 0 : apiLint.oas3_0Preprocessors), oas3_1Preprocessors: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.oas3_1Preprocessors), apiLint === null || apiLint === void 0 ? void 0 : apiLint.oas3_1Preprocessors), decorators: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.decorators), apiLint === null || apiLint === void 0 ? void 0 : apiLint.decorators), oas2Decorators: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.oas2Decorators), apiLint === null || apiLint === void 0 ? void 0 : apiLint.oas2Decorators), oas3_0Decorators: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.oas3_0Decorators), apiLint === null || apiLint === void 0 ? void 0 : apiLint.oas3_0Decorators), oas3_1Decorators: Object.assign(Object.assign({}, configLint === null || configLint === void 0 ? void 0 : configLint.oas3_1Decorators), apiLint === null || apiLint === void 0 ? void 0 : apiLint.oas3_1Decorators), recommendedFallback: (apiLint === null || apiLint === void 0 ? void 0 : apiLint.extends) ? false : configLint.recommendedFallback });
+    return resultLint;
+}
+function groupLintAssertionRules(rules) {
+    if (!rules) {
+        return rules;
+    }
+    // Create a new record to avoid mutating original
+    const transformedRules = {};
+    // Collect assertion rules
+    const assertions = [];
+    for (const [ruleKey, rule] of Object.entries(rules)) {
+        if (ruleKey.startsWith('assert/') && typeof rule === 'object' && rule !== null) {
+            const assertion = rule;
+            assertions.push(Object.assign(Object.assign({}, assertion), { assertionId: ruleKey.replace('assert/', '') }));
+        }
+        else {
+            // If it's not an assertion, keep it as is
+            transformedRules[ruleKey] = rule;
+        }
+    }
+    if (assertions.length > 0) {
+        transformedRules.assertions = assertions;
+    }
+    return transformedRules;
+}