@kubb/agent 4.33.1 → 4.33.3

package/.output/server/node_modules/@redocly/openapi-core/lib/config/config-resolvers.js

@@ -0,0 +1,335 @@
+import * as fs from 'node:fs';
+import module from 'node:module';
+import * as path from 'node:path';
+import * as url from 'node:url';
+import { bundleConfig, collectConfigPlugins } from '../bundle/bundle.js';
+import { isBrowser } from '../env.js';
+import { colorize, logger } from '../logger.js';
+import { isAbsoluteUrl } from '../ref-utils.js';
+import { resolveDocument, BaseResolver, Source } from '../resolve.js';
+import { NormalizedConfigTypes } from '../types/redocly-yaml.js';
+import { isDefined } from '../utils/is-defined.js';
+import { isNotString } from '../utils/is-not-string.js';
+import { isPlainObject } from '../utils/is-plain-object.js';
+import { isString } from '../utils/is-string.js';
+import { defaultPlugin } from './builtIn.js';
+import { CONFIG_FILE_NAME, DEFAULT_CONFIG, DEFAULT_PROJECT_PLUGIN_PATHS } from './constants.js';
+import { getResolveConfig } from './get-resolve-config.js';
+import { deepCloneMapWithJSON, isCommonJsPlugin, isDeprecatedPluginFormat, mergeExtends, parsePresetName, prefixRules, } from './utils.js';
+// Cache instantiated plugins during a single execution
+const pluginsCache = new Map();
+export async function resolveConfig({ rawConfigDocument, configPath, externalRefResolver, customExtends, }) {
+    const config = rawConfigDocument === undefined ? DEFAULT_CONFIG : rawConfigDocument.parsed;
+    if (customExtends !== undefined && isPlainObject(config)) {
+        config.extends = customExtends;
+    }
+    if (isPlainObject(config) && config?.extends?.some(isNotString)) {
+        throw new Error(`Configuration format not detected in extends: values must be strings.`);
+    }
+    const rootDocument = rawConfigDocument ?? {
+        source: new Source(configPath ?? '', JSON.stringify(config)),
+        parsed: config,
+    };
+    const resolvedRefMap = await resolveDocument({
+        rootDocument,
+        rootType: NormalizedConfigTypes.ConfigRoot,
+        externalRefResolver: externalRefResolver ??
+            new BaseResolver(getResolveConfig(config?.resolve)),
+    });
+    let pluginsOrPaths = [];
+    let resolvedPlugins;
+    let rootConfigDir = '';
+    if (isBrowser) {
+        // In browser, we don't support plugins from config file yet
+        const instantiatedPlugins = (config?.plugins || []).filter((p) => !isString(p));
+        resolvedPlugins = [...instantiatedPlugins, defaultPlugin];
+    }
+    else {
+        rootConfigDir = path.dirname(configPath ?? '');
+        pluginsOrPaths = collectConfigPlugins(rootDocument, resolvedRefMap, rootConfigDir);
+        const plugins = await resolvePlugins(pluginsOrPaths.map((p) => (isPluginResolveInfo(p) ? p.absolutePath : p)), rootConfigDir);
+        resolvedPlugins = [...plugins, defaultPlugin];
+    }
+    const bundledConfig = bundleConfig(rootDocument, deepCloneMapWithJSON(resolvedRefMap), resolvedPlugins);
+    if (bundledConfig.apis) {
+        bundledConfig.apis = Object.fromEntries(Object.entries(bundledConfig.apis).map(([key, apiConfig]) => {
+            const mergedConfig = mergeExtends([bundledConfig, apiConfig]);
+            return [key, { ...apiConfig, ...mergedConfig }];
+        }));
+    }
+    const pluginPaths = pluginsOrPaths.length
+        ? pluginsOrPaths
+            .map((p) => isPluginResolveInfo(p) && p.isModule
+            ? p.rawPath
+            : p.absolutePath && path.relative(rootConfigDir, p.absolutePath))
+            .filter(isDefined)
+        : undefined;
+    return {
+        resolvedConfig: {
+            ...bundledConfig,
+            plugins: pluginPaths,
+        },
+        resolvedRefMap,
+        plugins: resolvedPlugins,
+    };
+}
+function getDefaultPluginPath(configDir) {
+    for (const pluginPath of DEFAULT_PROJECT_PLUGIN_PATHS) {
+        const absolutePluginPath = path.resolve(configDir, pluginPath);
+        if (fs.existsSync(absolutePluginPath)) {
+            return pluginPath;
+        }
+    }
+    return;
+}
+function isPluginResolveInfo(plugin) {
+    return 'isModule' in plugin;
+}
+export const preResolvePluginPath = (plugin, base, rootConfigDir) => {
+    if (!isString(plugin)) {
+        return plugin;
+    }
+    const maybeAbsolutePluginPath = path.resolve(path.dirname(base), plugin);
+    return fs.existsSync(maybeAbsolutePluginPath)
+        ? { absolutePath: maybeAbsolutePluginPath, rawPath: plugin, isModule: false }
+        : {
+            absolutePath: module.createRequire(import.meta.url ?? __dirname).resolve(plugin, {
+                paths: [
+                    // Plugins imported from the node_modules in the project directory
+                    rootConfigDir,
+                    // Plugins imported from the node_modules in the package install directory (for example, npx cache directory)
+                    import.meta.url ? path.dirname(url.fileURLToPath(import.meta.url)) : __dirname,
+                ],
+            }),
+            isModule: true,
+            rawPath: plugin,
+        };
+};
+export async function resolvePlugins(plugins, configDir) {
+    if (!plugins)
+        return [];
+    // TODO: implement or reuse Resolver approach so it will work in node and browser envs
+    const requireFunc = async (plugin) => {
+        if (!isString(plugin)) {
+            return plugin;
+        }
+        try {
+            const absolutePluginPath = path.isAbsolute(plugin)
+                ? plugin
+                : preResolvePluginPath(plugin, path.join(configDir, CONFIG_FILE_NAME), configDir).absolutePath;
+            if (!pluginsCache.has(absolutePluginPath)) {
+                let requiredPlugin;
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore FIXME: investigate if we still need this (2.0)
+                if (typeof __webpack_require__ === 'function') {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore FIXME: investigate if we still need this (2.0)
+                    requiredPlugin = __non_webpack_require__(absolutePluginPath);
+                }
+                else {
+                    const mod = await import(url.pathToFileURL(absolutePluginPath).pathname);
+                    requiredPlugin = mod.default || mod;
+                }
+                const pluginCreatorOptions = { contentDir: configDir };
+                const requiredPluginInstances = Array.isArray(requiredPlugin)
+                    ? requiredPlugin
+                    : [requiredPlugin];
+                for (const requiredPluginInstance of requiredPluginInstances) {
+                    if (requiredPluginInstance?.id && isDeprecatedPluginFormat(requiredPluginInstance)) {
+                        logger.info(`Deprecated plugin format detected: ${requiredPluginInstance.id}\n`);
+                    }
+                }
+                const pluginModule = isDeprecatedPluginFormat(requiredPlugin)
+                    ? requiredPlugin
+                    : isCommonJsPlugin(requiredPlugin)
+                        ? await requiredPlugin(pluginCreatorOptions)
+                        : await requiredPlugin?.default?.(pluginCreatorOptions);
+                const pluginInstances = Array.isArray(pluginModule) ? pluginModule : [pluginModule];
+                if (pluginModule) {
+                    pluginsCache.set(absolutePluginPath, pluginInstances.map((p) => ({
+                        ...p,
+                        path: plugin,
+                        absolutePath: absolutePluginPath,
+                    })));
+                }
+            }
+            return pluginsCache.get(absolutePluginPath);
+        }
+        catch (e) {
+            throw new Error(`Failed to load plugin "${plugin}": ${e.message}\n\n${e.stack}`);
+        }
+    };
+    const seenPluginIds = new Map();
+    /**
+     * Include the default plugin automatically if it's not in configuration
+     */
+    const defaultPluginPath = getDefaultPluginPath(configDir);
+    if (defaultPluginPath) {
+        plugins.push(defaultPluginPath);
+    }
+    const resolvedPlugins = new Set();
+    const instances = await Promise.all(plugins.map(async (p) => {
+        if (isString(p)) {
+            if (isAbsoluteUrl(p)) {
+                throw new Error(colorize.red(`We don't support remote plugins yet.`));
+            }
+            if (resolvedPlugins.has(p)) {
+                return;
+            }
+            resolvedPlugins.add(p);
+        }
+        const pluginInstanceOrInstances = await requireFunc(p);
+        if (!pluginInstanceOrInstances) {
+            return;
+        }
+        const pluginInstances = Array.isArray(pluginInstanceOrInstances)
+            ? pluginInstanceOrInstances
+            : [pluginInstanceOrInstances];
+        return (await Promise.all(pluginInstances.map(async (pluginInstance) => {
+            if (!pluginInstance)
+                return;
+            const id = pluginInstance.id;
+            if (typeof id !== 'string') {
+                throw new Error(colorize.red(`Plugin must define \`id\` property in ${colorize.blue(p.toString())}.`));
+            }
+            const pluginPath = pluginInstance.absolutePath ?? p.toString();
+            const existingPluginPath = seenPluginIds.get(id);
+            if (existingPluginPath) {
+                if (pluginPath !== existingPluginPath) {
+                    throw new Error(colorize.red(`Plugin "id" must be unique. Plugin ${colorize.blue(pluginPath)} uses id "${colorize.blue(id)}" already seen in ${colorize.blue(pluginPath)}`));
+                }
+                return undefined;
+            }
+            seenPluginIds.set(id, pluginPath);
+            const plugin = {
+                id,
+                ...(pluginInstance.configs ? { configs: pluginInstance.configs } : {}),
+                ...(pluginInstance.typeExtension
+                    ? { typeExtension: pluginInstance.typeExtension }
+                    : {}),
+            };
+            if (pluginInstance.rules) {
+                if (!pluginInstance.rules.oas3 &&
+                    !pluginInstance.rules.oas2 &&
+                    !pluginInstance.rules.async2 &&
+                    !pluginInstance.rules.async3 &&
+                    !pluginInstance.rules.arazzo1 &&
+                    !pluginInstance.rules.overlay1 &&
+                    !pluginInstance.rules.openrpc1) {
+                    throw new Error(`Plugin rules must have \`oas3\`, \`oas2\`, \`async2\`, \`async3\`, \`arazzo\`, \`overlay1\`, or \`openrpc1\` rules "${p}.`);
+                }
+                plugin.rules = {};
+                if (pluginInstance.rules.oas3) {
+                    plugin.rules.oas3 = prefixRules(pluginInstance.rules.oas3, id);
+                }
+                if (pluginInstance.rules.oas2) {
+                    plugin.rules.oas2 = prefixRules(pluginInstance.rules.oas2, id);
+                }
+                if (pluginInstance.rules.async2) {
+                    plugin.rules.async2 = prefixRules(pluginInstance.rules.async2, id);
+                }
+                if (pluginInstance.rules.async3) {
+                    plugin.rules.async3 = prefixRules(pluginInstance.rules.async3, id);
+                }
+                if (pluginInstance.rules.arazzo1) {
+                    plugin.rules.arazzo1 = prefixRules(pluginInstance.rules.arazzo1, id);
+                }
+                if (pluginInstance.rules.overlay1) {
+                    plugin.rules.overlay1 = prefixRules(pluginInstance.rules.overlay1, id);
+                }
+                if (pluginInstance.rules.openrpc1) {
+                    plugin.rules.openrpc1 = prefixRules(pluginInstance.rules.openrpc1, id);
+                }
+            }
+            if (pluginInstance.preprocessors) {
+                if (!pluginInstance.preprocessors.oas3 &&
+                    !pluginInstance.preprocessors.oas2 &&
+                    !pluginInstance.preprocessors.async2 &&
+                    !pluginInstance.preprocessors.async3 &&
+                    !pluginInstance.preprocessors.arazzo1 &&
+                    !pluginInstance.preprocessors.overlay1 &&
+                    !pluginInstance.preprocessors.openrpc1) {
+                    throw new Error(`Plugin \`preprocessors\` must have \`oas3\`, \`oas2\`, \`async2\`, \`async3\`, \`arazzo1\`, \`overlay1\`, or \`openrpc1\` preprocessors "${p}.`);
+                }
+                plugin.preprocessors = {};
+                if (pluginInstance.preprocessors.oas3) {
+                    plugin.preprocessors.oas3 = prefixRules(pluginInstance.preprocessors.oas3, id);
+                }
+                if (pluginInstance.preprocessors.oas2) {
+                    plugin.preprocessors.oas2 = prefixRules(pluginInstance.preprocessors.oas2, id);
+                }
+                if (pluginInstance.preprocessors.async2) {
+                    plugin.preprocessors.async2 = prefixRules(pluginInstance.preprocessors.async2, id);
+                }
+                if (pluginInstance.preprocessors.async3) {
+                    plugin.preprocessors.async3 = prefixRules(pluginInstance.preprocessors.async3, id);
+                }
+                if (pluginInstance.preprocessors.arazzo1) {
+                    plugin.preprocessors.arazzo1 = prefixRules(pluginInstance.preprocessors.arazzo1, id);
+                }
+                if (pluginInstance.preprocessors.overlay1) {
+                    plugin.preprocessors.overlay1 = prefixRules(pluginInstance.preprocessors.overlay1, id);
+                }
+                if (pluginInstance.preprocessors.openrpc1) {
+                    plugin.preprocessors.openrpc1 = prefixRules(pluginInstance.preprocessors.openrpc1, id);
+                }
+            }
+            if (pluginInstance.decorators) {
+                if (!pluginInstance.decorators.oas3 &&
+                    !pluginInstance.decorators.oas2 &&
+                    !pluginInstance.decorators.async2 &&
+                    !pluginInstance.decorators.async3 &&
+                    !pluginInstance.decorators.arazzo1 &&
+                    !pluginInstance.decorators.overlay1 &&
+                    !pluginInstance.decorators.openrpc1) {
+                    throw new Error(`Plugin \`decorators\` must have \`oas3\`, \`oas2\`, \`async2\`, \`async3\`, \`arazzo1\`, \`overlay1\`, or \`openrpc1\` decorators "${p}.`);
+                }
+                plugin.decorators = {};
+                if (pluginInstance.decorators.oas3) {
+                    plugin.decorators.oas3 = prefixRules(pluginInstance.decorators.oas3, id);
+                }
+                if (pluginInstance.decorators.oas2) {
+                    plugin.decorators.oas2 = prefixRules(pluginInstance.decorators.oas2, id);
+                }
+                if (pluginInstance.decorators.async2) {
+                    plugin.decorators.async2 = prefixRules(pluginInstance.decorators.async2, id);
+                }
+                if (pluginInstance.decorators.async3) {
+                    plugin.decorators.async3 = prefixRules(pluginInstance.decorators.async3, id);
+                }
+                if (pluginInstance.decorators.arazzo1) {
+                    plugin.decorators.arazzo1 = prefixRules(pluginInstance.decorators.arazzo1, id);
+                }
+                if (pluginInstance.decorators.overlay1) {
+                    plugin.decorators.overlay1 = prefixRules(pluginInstance.decorators.overlay1, id);
+                }
+                if (pluginInstance.decorators.openrpc1) {
+                    plugin.decorators.openrpc1 = prefixRules(pluginInstance.decorators.openrpc1, id);
+                }
+            }
+            if (pluginInstance.assertions) {
+                plugin.assertions = pluginInstance.assertions;
+            }
+            return {
+                ...pluginInstance,
+                ...plugin,
+            };
+        }))).filter(isDefined);
+    }));
+    return instances.filter(isDefined).flat();
+}
+export function resolvePreset(presetName, plugins) {
+    const { pluginId, configName } = parsePresetName(presetName);
+    const plugin = plugins.find((p) => p.id === pluginId);
+    if (!plugin) {
+        throw new Error(`Invalid config ${colorize.red(presetName)}: plugin ${pluginId} is not included.`);
+    }
+    const preset = plugin.configs?.[configName];
+    if (!preset) {
+        throw new Error(pluginId
+            ? `Invalid config ${colorize.red(presetName)}: plugin ${pluginId} doesn't export config with name ${configName}.`
+            : `Invalid config ${colorize.red(presetName)}: there is no such built-in config.`);
+    }
+    return preset;
+}
+//# sourceMappingURL=config-resolvers.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/config/config.js

@@ -0,0 +1,338 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { specVersions } from '../detect-spec.js';
+import { stringifyYaml } from '../js-yaml/index.js';
+import { isAbsoluteUrl } from '../ref-utils.js';
+import { isPlainObject } from '../utils/is-plain-object.js';
+import { slash } from '../utils/slash.js';
+import { IGNORE_BANNER, IGNORE_FILE } from './constants.js';
+import { getResolveConfig } from './get-resolve-config.js';
+import { groupAssertionRules } from './group-assertion-rules.js';
+export class Config {
+    constructor(resolvedConfig, opts = {}) {
+        this.ignore = {};
+        this._usedRules = new Set();
+        this._usedVersions = new Set();
+        this.resolvedConfig = resolvedConfig;
+        this.configPath = opts.configPath;
+        this.document = opts.document;
+        this.resolvedRefMap = opts.resolvedRefMap;
+        this.resolve = getResolveConfig(this.resolvedConfig.resolve);
+        this._alias = opts.alias;
+        this.plugins = opts.plugins || [];
+        this.doNotResolveExamples = !!resolvedConfig.resolve?.doNotResolveExamples;
+        const group = (rules) => {
+            return groupAssertionRules({ rules }, this.plugins);
+        };
+        this.rules = {
+            oas2: group({ ...resolvedConfig.rules, ...resolvedConfig.oas2Rules }),
+            oas3_0: group({ ...resolvedConfig.rules, ...resolvedConfig.oas3_0Rules }),
+            oas3_1: group({ ...resolvedConfig.rules, ...resolvedConfig.oas3_1Rules }),
+            oas3_2: group({ ...resolvedConfig.rules, ...resolvedConfig.oas3_2Rules }),
+            async2: group({ ...resolvedConfig.rules, ...resolvedConfig.async2Rules }),
+            async3: group({ ...resolvedConfig.rules, ...resolvedConfig.async3Rules }),
+            arazzo1: group({ ...resolvedConfig.rules, ...resolvedConfig.arazzo1Rules }),
+            overlay1: group({ ...resolvedConfig.rules, ...resolvedConfig.overlay1Rules }),
+            openrpc1: group({ ...resolvedConfig.rules, ...resolvedConfig.openrpc1Rules }),
+        };
+        this.preprocessors = {
+            oas2: { ...resolvedConfig.preprocessors, ...resolvedConfig.oas2Preprocessors },
+            oas3_0: {
+                ...resolvedConfig.preprocessors,
+                ...resolvedConfig.oas3_0Preprocessors,
+            },
+            oas3_1: {
+                ...resolvedConfig.preprocessors,
+                ...resolvedConfig.oas3_1Preprocessors,
+            },
+            oas3_2: {
+                ...resolvedConfig.preprocessors,
+                ...resolvedConfig.oas3_2Preprocessors,
+            },
+            async2: {
+                ...resolvedConfig.preprocessors,
+                ...resolvedConfig.async2Preprocessors,
+            },
+            async3: {
+                ...resolvedConfig.preprocessors,
+                ...resolvedConfig.async3Preprocessors,
+            },
+            arazzo1: {
+                ...resolvedConfig.preprocessors,
+                ...resolvedConfig.arazzo1Preprocessors,
+            },
+            overlay1: {
+                ...resolvedConfig.preprocessors,
+                ...resolvedConfig.overlay1Preprocessors,
+            },
+            openrpc1: {
+                ...resolvedConfig.preprocessors,
+                ...resolvedConfig.openrpc1Preprocessors,
+            },
+        };
+        this.decorators = {
+            oas2: { ...resolvedConfig.decorators, ...resolvedConfig.oas2Decorators },
+            oas3_0: { ...resolvedConfig.decorators, ...resolvedConfig.oas3_0Decorators },
+            oas3_1: { ...resolvedConfig.decorators, ...resolvedConfig.oas3_1Decorators },
+            oas3_2: { ...resolvedConfig.decorators, ...resolvedConfig.oas3_2Decorators },
+            async2: { ...resolvedConfig.decorators, ...resolvedConfig.async2Decorators },
+            async3: { ...resolvedConfig.decorators, ...resolvedConfig.async3Decorators },
+            arazzo1: { ...resolvedConfig.decorators, ...resolvedConfig.arazzo1Decorators },
+            overlay1: {
+                ...resolvedConfig.decorators,
+                ...resolvedConfig.overlay1Decorators,
+            },
+            openrpc1: {
+                ...resolvedConfig.decorators,
+                ...resolvedConfig.openrpc1Decorators,
+            },
+        };
+        this.ignore = opts.ignore ?? {};
+    }
+    forAlias(alias) {
+        if (alias === undefined || !isPlainObject(this.resolvedConfig?.apis?.[alias])) {
+            return this;
+        }
+        const { apis, ...rest } = this.resolvedConfig;
+        const { root: _root, output: _output, ...aliasConfig } = apis[alias];
+        return new Config({ ...rest, ...aliasConfig }, {
+            configPath: this.configPath,
+            document: this.document,
+            resolvedRefMap: this.resolvedRefMap,
+            alias,
+            plugins: this.plugins,
+            ignore: this.ignore,
+        });
+    }
+    saveIgnore() {
+        const dir = this.configPath ? path.dirname(this.configPath) : process.cwd();
+        const ignoreFile = path.join(dir, IGNORE_FILE);
+        const mapped = {};
+        for (const absFileName of Object.keys(this.ignore)) {
+            const mappedDefinitionName = isAbsoluteUrl(absFileName)
+                ? absFileName
+                : slash(path.relative(dir, absFileName));
+            const ignoredRules = (mapped[mappedDefinitionName] = this.ignore[absFileName]);
+            for (const ruleId of Object.keys(ignoredRules)) {
+                ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]);
+            }
+        }
+        fs.writeFileSync(ignoreFile, IGNORE_BANNER + 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
+            ? {
+                ...problem,
+                ignored,
+            }
+            : problem;
+    }
+    extendTypes(types, version) {
+        let extendedTypes = types;
+        for (const plugin of this.plugins) {
+            if (plugin.typeExtension !== undefined) {
+                switch (version) {
+                    case 'oas3_0':
+                    case 'oas3_1':
+                    case 'oas3_2':
+                        if (!plugin.typeExtension.oas3)
+                            continue;
+                        extendedTypes = plugin.typeExtension.oas3(extendedTypes, version);
+                        break;
+                    case 'oas2':
+                        if (!plugin.typeExtension.oas2)
+                            continue;
+                        extendedTypes = plugin.typeExtension.oas2(extendedTypes, version);
+                        break;
+                    case 'async2':
+                        if (!plugin.typeExtension.async2)
+                            continue;
+                        extendedTypes = plugin.typeExtension.async2(extendedTypes, version);
+                        break;
+                    case 'async3':
+                        if (!plugin.typeExtension.async3)
+                            continue;
+                        extendedTypes = plugin.typeExtension.async3(extendedTypes, version);
+                        break;
+                    case 'arazzo1':
+                        if (!plugin.typeExtension.arazzo1)
+                            continue;
+                        extendedTypes = plugin.typeExtension.arazzo1(extendedTypes, version);
+                        break;
+                    case 'overlay1':
+                        if (!plugin.typeExtension.overlay1)
+                            continue;
+                        extendedTypes = plugin.typeExtension.overlay1(extendedTypes, version);
+                        break;
+                    case 'openrpc1':
+                        if (!plugin.typeExtension.openrpc1)
+                            continue;
+                        extendedTypes = plugin.typeExtension.openrpc1(extendedTypes, version);
+                        break;
+                    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 { 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 { 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 { 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,
+        };
+    }
+    // TODO: add default case for redocly.yaml
+    getRulesForSpecVersion(version) {
+        switch (version) {
+            case 'oas3':
+                // eslint-disable-next-line no-case-declarations
+                const oas3Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.oas3 && oas3Rules.push(p.preprocessors.oas3));
+                this.plugins.forEach((p) => p.rules?.oas3 && oas3Rules.push(p.rules.oas3));
+                this.plugins.forEach((p) => p.decorators?.oas3 && oas3Rules.push(p.decorators.oas3));
+                return oas3Rules;
+            case 'oas2':
+                // eslint-disable-next-line no-case-declarations
+                const oas2Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.oas2 && oas2Rules.push(p.preprocessors.oas2));
+                this.plugins.forEach((p) => p.rules?.oas2 && oas2Rules.push(p.rules.oas2));
+                this.plugins.forEach((p) => p.decorators?.oas2 && oas2Rules.push(p.decorators.oas2));
+                return oas2Rules;
+            case 'async2':
+                // eslint-disable-next-line no-case-declarations
+                const asyncApi2Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.async2 && asyncApi2Rules.push(p.preprocessors.async2));
+                this.plugins.forEach((p) => p.rules?.async2 && asyncApi2Rules.push(p.rules.async2));
+                this.plugins.forEach((p) => p.decorators?.async2 && asyncApi2Rules.push(p.decorators.async2));
+                return asyncApi2Rules;
+            case 'async3':
+                // eslint-disable-next-line no-case-declarations
+                const asyncApi3Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.async3 && asyncApi3Rules.push(p.preprocessors.async3));
+                this.plugins.forEach((p) => p.rules?.async3 && asyncApi3Rules.push(p.rules.async3));
+                this.plugins.forEach((p) => p.decorators?.async3 && asyncApi3Rules.push(p.decorators.async3));
+                return asyncApi3Rules;
+            case 'arazzo1':
+                // eslint-disable-next-line no-case-declarations
+                const arazzo1Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.arazzo1 && arazzo1Rules.push(p.preprocessors.arazzo1));
+                this.plugins.forEach((p) => p.rules?.arazzo1 && arazzo1Rules.push(p.rules.arazzo1));
+                this.plugins.forEach((p) => p.decorators?.arazzo1 && arazzo1Rules.push(p.decorators.arazzo1));
+                return arazzo1Rules;
+            case 'overlay1':
+                // eslint-disable-next-line no-case-declarations
+                const overlay1Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.overlay1 && overlay1Rules.push(p.preprocessors.overlay1));
+                this.plugins.forEach((p) => p.rules?.overlay1 && overlay1Rules.push(p.rules.overlay1));
+                this.plugins.forEach((p) => p.decorators?.overlay1 && overlay1Rules.push(p.decorators.overlay1));
+                return overlay1Rules;
+            case 'openrpc1':
+                // eslint-disable-next-line no-case-declarations
+                const openrpc1Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.openrpc1 && openrpc1Rules.push(p.preprocessors.openrpc1));
+                this.plugins.forEach((p) => p.rules?.openrpc1 && openrpc1Rules.push(p.rules.openrpc1));
+                this.plugins.forEach((p) => p.decorators?.openrpc1 && openrpc1Rules.push(p.decorators.openrpc1));
+                return openrpc1Rules;
+        }
+    }
+    skipRules(rules) {
+        for (const ruleId of rules || []) {
+            for (const version of specVersions) {
+                if (this.rules[version][ruleId]) {
+                    this.rules[version][ruleId] = 'off';
+                }
+                else if (Array.isArray(this.rules[version].assertions)) {
+                    // skip assertions
+                    for (const configurableRule of this.rules[version].assertions) {
+                        if (configurableRule.assertionId === ruleId) {
+                            configurableRule.severity = 'off';
+                        }
+                    }
+                }
+            }
+        }
+    }
+    skipPreprocessors(preprocessors) {
+        for (const preprocessorId of preprocessors || []) {
+            for (const version of specVersions) {
+                if (this.preprocessors[version][preprocessorId]) {
+                    this.preprocessors[version][preprocessorId] = 'off';
+                }
+            }
+        }
+    }
+    skipDecorators(decorators) {
+        for (const decoratorId of decorators || []) {
+            for (const version of specVersions) {
+                if (this.decorators[version][decoratorId]) {
+                    this.decorators[version][decoratorId] = 'off';
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=config.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/config/constants.js

@@ -0,0 +1,13 @@
+export const CONFIG_FILE_NAME = 'redocly.yaml';
+export const DEFAULT_CONFIG = { extends: ['recommended'] };
+export const IGNORE_FILE = '.redocly.lint-ignore.yaml';
+export const IGNORE_BANNER = `# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API.\n` +
+    `# See https://redocly.com/docs/cli/ for more information.\n`;
+export const CONFIG_BUNDLER_VISITOR_ID = 'configBundler';
+export const PLUGINS_COLLECTOR_VISITOR_ID = 'pluginsCollector';
+export const DEFAULT_PROJECT_PLUGIN_PATHS = [
+    '@theme/plugin.js',
+    '@theme/plugin.cjs',
+    '@theme/plugin.mjs',
+];
+//# sourceMappingURL=constants.js.map