@kubb/agent 4.27.2 → 4.27.4

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

@@ -1,335 +0,0 @@
-import * as path from 'node:path';
-import * as url from 'node:url';
-import * as fs from 'node:fs';
-import module from 'node:module';
-import { isAbsoluteUrl } from '../ref-utils.js';
-import { isNotString } from '../utils/is-not-string.js';
-import { isString } from '../utils/is-string.js';
-import { isPlainObject } from '../utils/is-plain-object.js';
-import { isDefined } from '../utils/is-defined.js';
-import { resolveDocument, BaseResolver, Source } from '../resolve.js';
-import { defaultPlugin } from './builtIn.js';
-import { deepCloneMapWithJSON, isCommonJsPlugin, isDeprecatedPluginFormat, mergeExtends, parsePresetName, prefixRules, } from './utils.js';
-import { getResolveConfig } from './get-resolve-config.js';
-import { isBrowser } from '../env.js';
-import { colorize, logger } from '../logger.js';
-import { NormalizedConfigTypes } from '../types/redocly-yaml.js';
-import { bundleConfig, collectConfigPlugins } from '../bundle/bundle.js';
-import { CONFIG_FILE_NAME, DEFAULT_CONFIG, DEFAULT_PROJECT_PLUGIN_PATHS } from './constants.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

@@ -1,338 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { stringifyYaml } from '../js-yaml/index.js';
-import { slash } from '../utils/slash.js';
-import { isPlainObject } from '../utils/is-plain-object.js';
-import { specVersions } from '../detect-spec.js';
-import { getResolveConfig } from './get-resolve-config.js';
-import { isAbsoluteUrl } from '../ref-utils.js';
-import { groupAssertionRules } from './group-assertion-rules.js';
-import { IGNORE_BANNER, IGNORE_FILE } from './constants.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

@@ -1,13 +0,0 @@
-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