@redocly/openapi-core 1.0.0-beta.100

package/lib/config/config.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { NormalizedProblem } from '../walk';
+import { OasVersion, OasMajorVersion, Oas2RuleSet, Oas3RuleSet } from '../oas-types';
+import type { NodeType } from '../types';
+import type { DecoratorConfig, Plugin, PreprocessorConfig, Region, ResolveConfig, ResolvedApi, ResolvedConfig, ResolvedLintConfig, RuleConfig } from './types';
+export declare const env: NodeJS.ProcessEnv;
+export declare const IGNORE_FILE = ".redocly.lint-ignore.yaml";
+export declare const DEFAULT_REGION = "us";
+export declare const DOMAINS: {
+    us: string;
+    eu: string;
+};
+export declare const AVAILABLE_REGIONS: Region[];
+export declare class LintConfig {
+    rawConfig: ResolvedLintConfig;
+    configFile?: string | undefined;
+    plugins: Plugin[];
+    ignore: Record<string, Record<string, Set<string>>>;
+    doNotResolveExamples: boolean;
+    rules: Record<OasVersion, Record<string, RuleConfig>>;
+    preprocessors: Record<OasVersion, Record<string, PreprocessorConfig>>;
+    decorators: Record<OasVersion, Record<string, DecoratorConfig>>;
+    private _usedRules;
+    private _usedVersions;
+    recommendedFallback: boolean;
+    extendPaths: string[];
+    pluginPaths: string[];
+    constructor(rawConfig: ResolvedLintConfig, configFile?: string | undefined);
+    saveIgnore(): void;
+    addIgnore(problem: NormalizedProblem): void;
+    addProblemToIgnore(problem: NormalizedProblem): NormalizedProblem;
+    extendTypes(types: Record<string, NodeType>, version: OasVersion): Record<string, NodeType>;
+    getRuleSettings(ruleId: string, oasVersion: OasVersion): {
+        severity: import("../walk").ProblemSeverity | "off";
+    };
+    getPreprocessorSettings(ruleId: string, oasVersion: OasVersion): {
+        severity: import("../walk").ProblemSeverity | "off";
+    };
+    getDecoratorSettings(ruleId: string, oasVersion: OasVersion): {
+        severity: import("../walk").ProblemSeverity | "off";
+    };
+    getUnusedRules(): {
+        rules: string[];
+        preprocessors: string[];
+        decorators: string[];
+    };
+    getRulesForOasVersion(version: OasMajorVersion): Oas3RuleSet[] | Oas2RuleSet[];
+    skipRules(rules?: string[]): void;
+    skipPreprocessors(preprocessors?: string[]): void;
+    skipDecorators(decorators?: string[]): void;
+}
+export declare class Config {
+    rawConfig: ResolvedConfig;
+    configFile?: string | undefined;
+    apis: Record<string, ResolvedApi>;
+    lint: LintConfig;
+    resolve: ResolveConfig;
+    licenseKey?: string;
+    region?: Region;
+    'features.openapi': Record<string, any>;
+    'features.mockServer'?: Record<string, any>;
+    organization?: string;
+    constructor(rawConfig: ResolvedConfig, configFile?: string | undefined);
+}

package/lib/config/config.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.LintConfig = exports.AVAILABLE_REGIONS = exports.DOMAINS = exports.DEFAULT_REGION = exports.IGNORE_FILE = exports.env = void 0;
+const fs = require("fs");
+const path = require("path");
+const js_yaml_1 = require("../js-yaml");
+const utils_1 = require("../utils");
+const oas_types_1 = require("../oas-types");
+const utils_2 = require("./utils");
+// Alias environment here so this file can work in browser environments too.
+exports.env = typeof process !== 'undefined' ? process.env || {} : {};
+exports.IGNORE_FILE = '.redocly.lint-ignore.yaml';
+const IGNORE_BANNER = `# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API.\n` +
+    `# See https://redoc.ly/docs/cli/ for more information.\n`;
+exports.DEFAULT_REGION = 'us';
+function getDomains() {
+    const domains = {
+        us: 'redocly.com',
+        eu: 'eu.redocly.com',
+    };
+    // FIXME: temporary fix for our lab environments
+    const domain = exports.env.REDOCLY_DOMAIN;
+    if (domain === null || domain === void 0 ? void 0 : domain.endsWith('.redocly.host')) {
+        domains[domain.split('.')[0]] = domain;
+    }
+    if (domain === 'redoc.online') {
+        domains[domain] = domain;
+    }
+    return domains;
+}
+exports.DOMAINS = getDomains();
+exports.AVAILABLE_REGIONS = Object.keys(exports.DOMAINS);
+class LintConfig {
+    constructor(rawConfig, configFile) {
+        this.rawConfig = rawConfig;
+        this.configFile = configFile;
+        this.ignore = {};
+        this._usedRules = new Set();
+        this._usedVersions = new Set();
+        this.plugins = rawConfig.plugins || [];
+        this.doNotResolveExamples = !!rawConfig.doNotResolveExamples;
+        this.recommendedFallback = rawConfig.recommendedFallback || false;
+        this.rules = {
+            [oas_types_1.OasVersion.Version2]: Object.assign(Object.assign({}, rawConfig.rules), rawConfig.oas2Rules),
+            [oas_types_1.OasVersion.Version3_0]: Object.assign(Object.assign({}, rawConfig.rules), rawConfig.oas3_0Rules),
+            [oas_types_1.OasVersion.Version3_1]: Object.assign(Object.assign({}, rawConfig.rules), rawConfig.oas3_1Rules),
+        };
+        this.preprocessors = {
+            [oas_types_1.OasVersion.Version2]: Object.assign(Object.assign({}, rawConfig.preprocessors), rawConfig.oas2Preprocessors),
+            [oas_types_1.OasVersion.Version3_0]: Object.assign(Object.assign({}, rawConfig.preprocessors), rawConfig.oas3_0Preprocessors),
+            [oas_types_1.OasVersion.Version3_1]: Object.assign(Object.assign({}, rawConfig.preprocessors), rawConfig.oas3_1Preprocessors),
+        };
+        this.decorators = {
+            [oas_types_1.OasVersion.Version2]: Object.assign(Object.assign({}, rawConfig.decorators), rawConfig.oas2Decorators),
+            [oas_types_1.OasVersion.Version3_0]: Object.assign(Object.assign({}, rawConfig.decorators), rawConfig.oas3_0Decorators),
+            [oas_types_1.OasVersion.Version3_1]: Object.assign(Object.assign({}, rawConfig.decorators), rawConfig.oas3_1Decorators),
+        };
+        this.extendPaths = rawConfig.extendPaths || [];
+        this.pluginPaths = rawConfig.pluginPaths || [];
+        const dir = this.configFile
+            ? path.dirname(this.configFile)
+            : (typeof process !== 'undefined' && process.cwd()) || '';
+        const ignoreFile = path.join(dir, exports.IGNORE_FILE);
+        /* no crash when using it on the client */
+        if (fs.hasOwnProperty('existsSync') && fs.existsSync(ignoreFile)) {
+            // TODO: parse errors
+            this.ignore =
+                js_yaml_1.parseYaml(fs.readFileSync(ignoreFile, 'utf-8')) || {};
+            // resolve ignore paths
+            for (const fileName of Object.keys(this.ignore)) {
+                this.ignore[path.resolve(path.dirname(ignoreFile), fileName)] = this.ignore[fileName];
+                for (const ruleId of Object.keys(this.ignore[fileName])) {
+                    this.ignore[fileName][ruleId] = new Set(this.ignore[fileName][ruleId]);
+                }
+                delete this.ignore[fileName];
+            }
+        }
+    }
+    saveIgnore() {
+        const dir = this.configFile ? path.dirname(this.configFile) : process.cwd();
+        const ignoreFile = path.join(dir, exports.IGNORE_FILE);
+        const mapped = {};
+        for (const absFileName of Object.keys(this.ignore)) {
+            const ignoredRules = (mapped[utils_1.slash(path.relative(dir, absFileName))] =
+                this.ignore[absFileName]);
+            for (const ruleId of Object.keys(ignoredRules)) {
+                ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]);
+            }
+        }
+        fs.writeFileSync(ignoreFile, IGNORE_BANNER + js_yaml_1.stringifyYaml(mapped));
+    }
+    addIgnore(problem) {
+        const ignore = this.ignore;
+        const loc = problem.location[0];
+        if (loc.pointer === undefined)
+            return;
+        const fileIgnore = (ignore[loc.source.absoluteRef] = ignore[loc.source.absoluteRef] || {});
+        const ruleIgnore = (fileIgnore[problem.ruleId] = fileIgnore[problem.ruleId] || new Set());
+        ruleIgnore.add(loc.pointer);
+    }
+    addProblemToIgnore(problem) {
+        const loc = problem.location[0];
+        if (loc.pointer === undefined)
+            return problem;
+        const fileIgnore = this.ignore[loc.source.absoluteRef] || {};
+        const ruleIgnore = fileIgnore[problem.ruleId];
+        const ignored = ruleIgnore && ruleIgnore.has(loc.pointer);
+        return ignored
+            ? Object.assign(Object.assign({}, problem), { ignored }) : problem;
+    }
+    extendTypes(types, version) {
+        let extendedTypes = types;
+        for (const plugin of this.plugins) {
+            if (plugin.typeExtension !== undefined) {
+                switch (version) {
+                    case oas_types_1.OasVersion.Version3_0:
+                    case oas_types_1.OasVersion.Version3_1:
+                        if (!plugin.typeExtension.oas3)
+                            continue;
+                        extendedTypes = plugin.typeExtension.oas3(extendedTypes, version);
+                    case oas_types_1.OasVersion.Version2:
+                        if (!plugin.typeExtension.oas2)
+                            continue;
+                        extendedTypes = plugin.typeExtension.oas2(extendedTypes, version);
+                    default:
+                        throw new Error('Not implemented');
+                }
+            }
+        }
+        return extendedTypes;
+    }
+    getRuleSettings(ruleId, oasVersion) {
+        this._usedRules.add(ruleId);
+        this._usedVersions.add(oasVersion);
+        const settings = this.rules[oasVersion][ruleId] || 'off';
+        if (typeof settings === 'string') {
+            return {
+                severity: settings,
+            };
+        }
+        else {
+            return Object.assign({ severity: 'error' }, settings);
+        }
+    }
+    getPreprocessorSettings(ruleId, oasVersion) {
+        this._usedRules.add(ruleId);
+        this._usedVersions.add(oasVersion);
+        const settings = this.preprocessors[oasVersion][ruleId] || 'off';
+        if (typeof settings === 'string') {
+            return {
+                severity: settings === 'on' ? 'error' : settings,
+            };
+        }
+        else {
+            return Object.assign({ severity: 'error' }, settings);
+        }
+    }
+    getDecoratorSettings(ruleId, oasVersion) {
+        this._usedRules.add(ruleId);
+        this._usedVersions.add(oasVersion);
+        const settings = this.decorators[oasVersion][ruleId] || 'off';
+        if (typeof settings === 'string') {
+            return {
+                severity: settings === 'on' ? 'error' : settings,
+            };
+        }
+        else {
+            return Object.assign({ severity: 'error' }, settings);
+        }
+    }
+    getUnusedRules() {
+        const rules = [];
+        const decorators = [];
+        const preprocessors = [];
+        for (const usedVersion of Array.from(this._usedVersions)) {
+            rules.push(...Object.keys(this.rules[usedVersion]).filter((name) => !this._usedRules.has(name)));
+            decorators.push(...Object.keys(this.decorators[usedVersion]).filter((name) => !this._usedRules.has(name)));
+            preprocessors.push(...Object.keys(this.preprocessors[usedVersion]).filter((name) => !this._usedRules.has(name)));
+        }
+        return {
+            rules,
+            preprocessors,
+            decorators,
+        };
+    }
+    getRulesForOasVersion(version) {
+        switch (version) {
+            case oas_types_1.OasMajorVersion.Version3:
+                const oas3Rules = []; // default ruleset
+                this.plugins.forEach((p) => { var _a; return ((_a = p.preprocessors) === null || _a === void 0 ? void 0 : _a.oas3) && oas3Rules.push(p.preprocessors.oas3); });
+                this.plugins.forEach((p) => { var _a; return ((_a = p.rules) === null || _a === void 0 ? void 0 : _a.oas3) && oas3Rules.push(p.rules.oas3); });
+                this.plugins.forEach((p) => { var _a; return ((_a = p.decorators) === null || _a === void 0 ? void 0 : _a.oas3) && oas3Rules.push(p.decorators.oas3); });
+                return oas3Rules;
+            case oas_types_1.OasMajorVersion.Version2:
+                const oas2Rules = []; // default ruleset
+                this.plugins.forEach((p) => { var _a; return ((_a = p.preprocessors) === null || _a === void 0 ? void 0 : _a.oas2) && oas2Rules.push(p.preprocessors.oas2); });
+                this.plugins.forEach((p) => { var _a; return ((_a = p.rules) === null || _a === void 0 ? void 0 : _a.oas2) && oas2Rules.push(p.rules.oas2); });
+                this.plugins.forEach((p) => { var _a; return ((_a = p.decorators) === null || _a === void 0 ? void 0 : _a.oas2) && oas2Rules.push(p.decorators.oas2); });
+                return oas2Rules;
+        }
+    }
+    skipRules(rules) {
+        for (const ruleId of rules || []) {
+            for (const version of Object.values(oas_types_1.OasVersion)) {
+                if (this.rules[version][ruleId]) {
+                    this.rules[version][ruleId] = 'off';
+                }
+            }
+        }
+    }
+    skipPreprocessors(preprocessors) {
+        for (const preprocessorId of preprocessors || []) {
+            for (const version of Object.values(oas_types_1.OasVersion)) {
+                if (this.preprocessors[version][preprocessorId]) {
+                    this.preprocessors[version][preprocessorId] = 'off';
+                }
+            }
+        }
+    }
+    skipDecorators(decorators) {
+        for (const decoratorId of decorators || []) {
+            for (const version of Object.values(oas_types_1.OasVersion)) {
+                if (this.decorators[version][decoratorId]) {
+                    this.decorators[version][decoratorId] = 'off';
+                }
+            }
+        }
+    }
+}
+exports.LintConfig = LintConfig;
+class Config {
+    constructor(rawConfig, configFile) {
+        this.rawConfig = rawConfig;
+        this.configFile = configFile;
+        this.apis = rawConfig.apis || {};
+        this.lint = new LintConfig(rawConfig.lint || {}, configFile);
+        this['features.openapi'] = rawConfig['features.openapi'] || {};
+        this['features.mockServer'] = rawConfig['features.mockServer'] || {};
+        this.resolve = utils_2.getResolveConfig(rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.resolve);
+        this.region = rawConfig.region;
+        this.organization = rawConfig.organization;
+    }
+}
+exports.Config = Config;

package/lib/config/index.d.ts

@@ -0,0 +1,7 @@
+export * from './config';
+export * from './types';
+export * from './rules';
+export * from './builtIn';
+export * from './load';
+export * from './utils';
+export * from './config-resolvers';

package/lib/config/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./rules"), exports);
+__exportStar(require("./builtIn"), exports);
+__exportStar(require("./load"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./config-resolvers"), exports);

package/lib/config/load.d.ts

@@ -0,0 +1,6 @@
+import { Config } from './config';
+import type { RawConfig } from './types';
+export declare function loadConfig(configPath?: string | undefined, customExtends?: string[]): Promise<Config>;
+export declare const CONFIG_FILE_NAMES: string[];
+export declare function findConfig(dir?: string): string | undefined;
+export declare function getConfig(configPath?: string | undefined): Promise<RawConfig>;

package/lib/config/load.js

@@ -0,0 +1,93 @@
+"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.getConfig = exports.findConfig = exports.CONFIG_FILE_NAMES = exports.loadConfig = void 0;
+const fs = require("fs");
+const path = require("path");
+const redocly_1 = require("../redocly");
+const utils_1 = require("../utils");
+const config_1 = require("./config");
+const utils_2 = require("./utils");
+const config_resolvers_1 = require("./config-resolvers");
+function loadConfig(configPath = findConfig(), customExtends) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const rawConfig = yield getConfig(configPath);
+        if (customExtends !== undefined) {
+            rawConfig.lint = rawConfig.lint || {};
+            rawConfig.lint.extends = customExtends;
+        }
+        else if (utils_1.isEmptyObject(rawConfig)) {
+            // TODO: check if we can add recommended here. add message here?
+            // rawConfig.lint = { extends: ['recommended'], recommendedFallback: true };
+        }
+        const redoclyClient = new redocly_1.RedoclyClient();
+        const tokens = yield redoclyClient.getTokens();
+        if (tokens.length) {
+            if (!rawConfig.resolve)
+                rawConfig.resolve = {};
+            if (!rawConfig.resolve.http)
+                rawConfig.resolve.http = {};
+            rawConfig.resolve.http.headers = [...((_a = rawConfig.resolve.http.headers) !== null && _a !== void 0 ? _a : [])];
+            for (const item of tokens) {
+                const domain = config_1.DOMAINS[item.region];
+                rawConfig.resolve.http.headers.push({
+                    matches: `https://api.${domain}/registry/**`,
+                    name: 'Authorization',
+                    envVariable: undefined,
+                    value: item.token,
+                }, 
+                //support redocly.com domain for future compatibility
+                ...(item.region === 'us'
+                    ? [
+                        {
+                            matches: `https://api.redoc.ly/registry/**`,
+                            name: 'Authorization',
+                            envVariable: undefined,
+                            value: item.token,
+                        },
+                    ]
+                    : []));
+            }
+        }
+        return config_resolvers_1.resolveConfig(rawConfig, configPath);
+    });
+}
+exports.loadConfig = loadConfig;
+exports.CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
+function findConfig(dir) {
+    if (!fs.hasOwnProperty('existsSync'))
+        return;
+    const existingConfigFiles = exports.CONFIG_FILE_NAMES.map((name) => dir ? path.resolve(dir, name) : name).filter(fs.existsSync);
+    if (existingConfigFiles.length > 1) {
+        throw new Error(`
+      Multiple configuration files are not allowed. 
+      Found the following files: ${existingConfigFiles.join(', ')}. 
+      Please use 'redocly.yaml' instead.
+    `);
+    }
+    return existingConfigFiles[0];
+}
+exports.findConfig = findConfig;
+function getConfig(configPath = findConfig()) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!configPath)
+            return {};
+        try {
+            const rawConfig = ((yield utils_1.loadYaml(configPath)) || {});
+            return utils_2.transformConfig(rawConfig);
+        }
+        catch (e) {
+            throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);
+        }
+    });
+}
+exports.getConfig = getConfig;

package/lib/config/minimal.d.ts

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

package/lib/config/minimal.js

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

package/lib/config/recommended.d.ts

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

package/lib/config/recommended.js

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

package/lib/config/rules.d.ts

@@ -0,0 +1,7 @@
+import { RuleSet, OasVersion } from '../oas-types';
+import { LintConfig } from './config';
+export declare function initRules<T extends Function, P extends RuleSet<T>>(rules: P[], config: LintConfig, type: 'rules' | 'preprocessors' | 'decorators', oasVersion: OasVersion): {
+    severity: import("..").ProblemSeverity | "off";
+    ruleId: string;
+    visitor: any;
+}[];

package/lib/config/rules.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initRules = void 0;
+const utils_1 = require("../utils");
+function initRules(rules, config, type, oasVersion) {
+    return rules
+        .flatMap((ruleset) => Object.keys(ruleset).map((ruleId) => {
+        const rule = ruleset[ruleId];
+        const ruleSettings = type === 'rules'
+            ? config.getRuleSettings(ruleId, oasVersion)
+            : type === 'preprocessors'
+                ? config.getPreprocessorSettings(ruleId, oasVersion)
+                : config.getDecoratorSettings(ruleId, oasVersion);
+        if (ruleSettings.severity === 'off') {
+            return undefined;
+        }
+        const visitors = rule(ruleSettings);
+        if (Array.isArray(visitors)) {
+            return visitors.map((visitor) => ({
+                severity: ruleSettings.severity,
+                ruleId,
+                visitor: visitor,
+            }));
+        }
+        return {
+            severity: ruleSettings.severity,
+            ruleId,
+            visitor: visitors, // note: actually it is only one visitor object
+        };
+    }))
+        .flatMap(visitor => visitor)
+        .filter(utils_1.notUndefined);
+}
+exports.initRules = initRules;