@alexlit/lint-kit 117.3.1 → 117.4.0

package/packages/config-eslint/node_modules/@eslint/eslintrc/lib/flat-compat.js

@@ -1,318 +0,0 @@
-/**
- * @fileoverview Compatibility class for flat config.
- * @author Nicholas C. Zakas
- */
-
-//-----------------------------------------------------------------------------
-// Requirements
-//-----------------------------------------------------------------------------
-
-import createDebug from "debug";
-import path from "path";
-
-import environments from "../conf/environments.js";
-import { ConfigArrayFactory } from "./config-array-factory.js";
-
-//-----------------------------------------------------------------------------
-// Helpers
-//-----------------------------------------------------------------------------
-
-/** @typedef {import("../../shared/types").Environment} Environment */
-/** @typedef {import("../../shared/types").Processor} Processor */
-
-const debug = createDebug("eslintrc:flat-compat");
-const cafactory = Symbol("cafactory");
-
-/**
- * Translates an ESLintRC-style config object into a flag-config-style config
- * object.
- * @param {Object} eslintrcConfig An ESLintRC-style config object.
- * @param {Object} options Options to help translate the config.
- * @param {string} options.resolveConfigRelativeTo To the directory to resolve
- *      configs from.
- * @param {string} options.resolvePluginsRelativeTo The directory to resolve
- *      plugins from.
- * @param {ReadOnlyMap<string,Environment>} options.pluginEnvironments A map of plugin environment
- *      names to objects.
- * @param {ReadOnlyMap<string,Processor>} options.pluginProcessors A map of plugin processor
- *      names to objects.
- * @returns {Object} A flag-config-style config object.
- */
-function translateESLintRC(eslintrcConfig, {
-    resolveConfigRelativeTo,
-    resolvePluginsRelativeTo,
-    pluginEnvironments,
-    pluginProcessors
-}) {
-
-    const flatConfig = {};
-    const configs = [];
-    const languageOptions = {};
-    const linterOptions = {};
-    const keysToCopy = ["settings", "rules", "processor"];
-    const languageOptionsKeysToCopy = ["globals", "parser", "parserOptions"];
-    const linterOptionsKeysToCopy = ["noInlineConfig", "reportUnusedDisableDirectives"];
-
-    // copy over simple translations
-    for (const key of keysToCopy) {
-        if (key in eslintrcConfig && typeof eslintrcConfig[key] !== "undefined") {
-            flatConfig[key] = eslintrcConfig[key];
-        }
-    }
-
-    // copy over languageOptions
-    for (const key of languageOptionsKeysToCopy) {
-        if (key in eslintrcConfig && typeof eslintrcConfig[key] !== "undefined") {
-
-            // create the languageOptions key in the flat config
-            flatConfig.languageOptions = languageOptions;
-
-            if (key === "parser") {
-                debug(`Resolving parser '${languageOptions[key]}' relative to ${resolveConfigRelativeTo}`);
-
-                if (eslintrcConfig[key].error) {
-                    throw eslintrcConfig[key].error;
-                }
-
-                languageOptions[key] = eslintrcConfig[key].definition;
-                continue;
-            }
-
-            // clone any object values that are in the eslintrc config
-            if (eslintrcConfig[key] && typeof eslintrcConfig[key] === "object") {
-                languageOptions[key] = {
-                    ...eslintrcConfig[key]
-                };
-            } else {
-                languageOptions[key] = eslintrcConfig[key];
-            }
-        }
-    }
-
-    // copy over linterOptions
-    for (const key of linterOptionsKeysToCopy) {
-        if (key in eslintrcConfig && typeof eslintrcConfig[key] !== "undefined") {
-            flatConfig.linterOptions = linterOptions;
-            linterOptions[key] = eslintrcConfig[key];
-        }
-    }
-
-    // move ecmaVersion a level up
-    if (languageOptions.parserOptions) {
-
-        if ("ecmaVersion" in languageOptions.parserOptions) {
-            languageOptions.ecmaVersion = languageOptions.parserOptions.ecmaVersion;
-            delete languageOptions.parserOptions.ecmaVersion;
-        }
-
-        if ("sourceType" in languageOptions.parserOptions) {
-            languageOptions.sourceType = languageOptions.parserOptions.sourceType;
-            delete languageOptions.parserOptions.sourceType;
-        }
-
-        // check to see if we even need parserOptions anymore and remove it if not
-        if (Object.keys(languageOptions.parserOptions).length === 0) {
-            delete languageOptions.parserOptions;
-        }
-    }
-
-    // overrides
-    if (eslintrcConfig.criteria) {
-        flatConfig.files = [absoluteFilePath => eslintrcConfig.criteria.test(absoluteFilePath)];
-    }
-
-    // translate plugins
-    if (eslintrcConfig.plugins && typeof eslintrcConfig.plugins === "object") {
-        debug(`Translating plugins: ${eslintrcConfig.plugins}`);
-
-        flatConfig.plugins = {};
-
-        for (const pluginName of Object.keys(eslintrcConfig.plugins)) {
-
-            debug(`Translating plugin: ${pluginName}`);
-            debug(`Resolving plugin '${pluginName} relative to ${resolvePluginsRelativeTo}`);
-
-            const { original: plugin, error } = eslintrcConfig.plugins[pluginName];
-
-            if (error) {
-                throw error;
-            }
-
-            flatConfig.plugins[pluginName] = plugin;
-
-            // create a config for any processors
-            if (plugin.processors) {
-                for (const processorName of Object.keys(plugin.processors)) {
-                    if (processorName.startsWith(".")) {
-                        debug(`Assigning processor: ${pluginName}/${processorName}`);
-
-                        configs.unshift({
-                            files: [`**/*${processorName}`],
-                            processor: pluginProcessors.get(`${pluginName}/${processorName}`)
-                        });
-                    }
-
-                }
-            }
-        }
-    }
-
-    // translate env - must come after plugins
-    if (eslintrcConfig.env && typeof eslintrcConfig.env === "object") {
-        for (const envName of Object.keys(eslintrcConfig.env)) {
-
-            // only add environments that are true
-            if (eslintrcConfig.env[envName]) {
-                debug(`Translating environment: ${envName}`);
-
-                if (environments.has(envName)) {
-
-                    // built-in environments should be defined first
-                    configs.unshift(...translateESLintRC({
-                        criteria: eslintrcConfig.criteria,
-                        ...environments.get(envName)
-                    }, {
-                        resolveConfigRelativeTo,
-                        resolvePluginsRelativeTo
-                    }));
-                } else if (pluginEnvironments.has(envName)) {
-
-                    // if the environment comes from a plugin, it should come after the plugin config
-                    configs.push(...translateESLintRC({
-                        criteria: eslintrcConfig.criteria,
-                        ...pluginEnvironments.get(envName)
-                    }, {
-                        resolveConfigRelativeTo,
-                        resolvePluginsRelativeTo
-                    }));
-                }
-            }
-        }
-    }
-
-    // only add if there are actually keys in the config
-    if (Object.keys(flatConfig).length > 0) {
-        configs.push(flatConfig);
-    }
-
-    return configs;
-}
-
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-/**
- * A compatibility class for working with configs.
- */
-class FlatCompat {
-
-    constructor({
-        baseDirectory = process.cwd(),
-        resolvePluginsRelativeTo = baseDirectory,
-        recommendedConfig,
-        allConfig
-    } = {}) {
-        this.baseDirectory = baseDirectory;
-        this.resolvePluginsRelativeTo = resolvePluginsRelativeTo;
-        this[cafactory] = new ConfigArrayFactory({
-            cwd: baseDirectory,
-            resolvePluginsRelativeTo,
-            getEslintAllConfig: () => {
-
-                if (!allConfig) {
-                    throw new TypeError("Missing parameter 'allConfig' in FlatCompat constructor.");
-                }
-
-                return allConfig;
-            },
-            getEslintRecommendedConfig: () => {
-
-                if (!recommendedConfig) {
-                    throw new TypeError("Missing parameter 'recommendedConfig' in FlatCompat constructor.");
-                }
-
-                return recommendedConfig;
-            }
-        });
-    }
-
-    /**
-     * Translates an ESLintRC-style config into a flag-config-style config.
-     * @param {Object} eslintrcConfig The ESLintRC-style config object.
-     * @returns {Object} A flag-config-style config object.
-     */
-    config(eslintrcConfig) {
-        const eslintrcArray = this[cafactory].create(eslintrcConfig, {
-            basePath: this.baseDirectory
-        });
-
-        const flatArray = [];
-        let hasIgnorePatterns = false;
-
-        eslintrcArray.forEach(configData => {
-            if (configData.type === "config") {
-                hasIgnorePatterns = hasIgnorePatterns || configData.ignorePattern;
-                flatArray.push(...translateESLintRC(configData, {
-                    resolveConfigRelativeTo: path.join(this.baseDirectory, "__placeholder.js"),
-                    resolvePluginsRelativeTo: path.join(this.resolvePluginsRelativeTo, "__placeholder.js"),
-                    pluginEnvironments: eslintrcArray.pluginEnvironments,
-                    pluginProcessors: eslintrcArray.pluginProcessors
-                }));
-            }
-        });
-
-        // combine ignorePatterns to emulate ESLintRC behavior better
-        if (hasIgnorePatterns) {
-            flatArray.unshift({
-                ignores: [filePath => {
-
-                    // Compute the final config for this file.
-                    // This filters config array elements by `files`/`excludedFiles` then merges the elements.
-                    const finalConfig = eslintrcArray.extractConfig(filePath);
-
-                    // Test the `ignorePattern` properties of the final config.
-                    return Boolean(finalConfig.ignores) && finalConfig.ignores(filePath);
-                }]
-            });
-        }
-
-        return flatArray;
-    }
-
-    /**
-     * Translates the `env` section of an ESLintRC-style config.
-     * @param {Object} envConfig The `env` section of an ESLintRC config.
-     * @returns {Object[]} An array of flag-config objects representing the environments.
-     */
-    env(envConfig) {
-        return this.config({
-            env: envConfig
-        });
-    }
-
-    /**
-     * Translates the `extends` section of an ESLintRC-style config.
-     * @param {...string} configsToExtend The names of the configs to load.
-     * @returns {Object[]} An array of flag-config objects representing the config.
-     */
-    extends(...configsToExtend) {
-        return this.config({
-            extends: configsToExtend
-        });
-    }
-
-    /**
-     * Translates the `plugins` section of an ESLintRC-style config.
-     * @param {...string} plugins The names of the plugins to load.
-     * @returns {Object[]} An array of flag-config objects representing the plugins.
-     */
-    plugins(...plugins) {
-        return this.config({
-            plugins
-        });
-    }
-}
-
-export { FlatCompat };

package/packages/config-eslint/node_modules/@eslint/eslintrc/lib/index-universal.js

@@ -1,29 +0,0 @@
-/**
- * @fileoverview Package exports for @eslint/eslintrc
- * @author Nicholas C. Zakas
- */
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-import * as ConfigOps from "./shared/config-ops.js";
-import ConfigValidator from "./shared/config-validator.js";
-import * as naming from "./shared/naming.js";
-import environments from "../conf/environments.js";
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-const Legacy = {
-    environments,
-
-    // shared
-    ConfigOps,
-    ConfigValidator,
-    naming
-};
-
-export {
-    Legacy
-};

package/packages/config-eslint/node_modules/@eslint/eslintrc/lib/index.js

@@ -1,58 +0,0 @@
-/**
- * @fileoverview Package exports for @eslint/eslintrc
- * @author Nicholas C. Zakas
- */
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-import {
-    ConfigArrayFactory,
-    createContext as createConfigArrayFactoryContext,
-    loadConfigFile
-} from "./config-array-factory.js";
-
-import { CascadingConfigArrayFactory } from "./cascading-config-array-factory.js";
-import * as ModuleResolver from "./shared/relative-module-resolver.js";
-import { ConfigArray, getUsedExtractedConfigs } from "./config-array/index.js";
-import { ConfigDependency } from "./config-array/config-dependency.js";
-import { ExtractedConfig } from "./config-array/extracted-config.js";
-import { IgnorePattern } from "./config-array/ignore-pattern.js";
-import { OverrideTester } from "./config-array/override-tester.js";
-import * as ConfigOps from "./shared/config-ops.js";
-import ConfigValidator from "./shared/config-validator.js";
-import * as naming from "./shared/naming.js";
-import { FlatCompat } from "./flat-compat.js";
-import environments from "../conf/environments.js";
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-const Legacy = {
-    ConfigArray,
-    createConfigArrayFactoryContext,
-    CascadingConfigArrayFactory,
-    ConfigArrayFactory,
-    ConfigDependency,
-    ExtractedConfig,
-    IgnorePattern,
-    OverrideTester,
-    getUsedExtractedConfigs,
-    environments,
-    loadConfigFile,
-
-    // shared
-    ConfigOps,
-    ConfigValidator,
-    ModuleResolver,
-    naming
-};
-
-export {
-
-    Legacy,
-
-    FlatCompat
-
-};

package/packages/config-eslint/node_modules/@eslint/eslintrc/lib/shared/ajv.js

@@ -1,191 +0,0 @@
-/**
- * @fileoverview The instance of Ajv validator.
- * @author Evgeny Poberezkin
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-import Ajv from "ajv";
-
-//-----------------------------------------------------------------------------
-// Helpers
-//-----------------------------------------------------------------------------
-
-/*
- * Copied from ajv/lib/refs/json-schema-draft-04.json
- * The MIT License (MIT)
- * Copyright (c) 2015-2017 Evgeny Poberezkin
- */
-const metaSchema = {
-    id: "http://json-schema.org/draft-04/schema#",
-    $schema: "http://json-schema.org/draft-04/schema#",
-    description: "Core schema meta-schema",
-    definitions: {
-        schemaArray: {
-            type: "array",
-            minItems: 1,
-            items: { $ref: "#" }
-        },
-        positiveInteger: {
-            type: "integer",
-            minimum: 0
-        },
-        positiveIntegerDefault0: {
-            allOf: [{ $ref: "#/definitions/positiveInteger" }, { default: 0 }]
-        },
-        simpleTypes: {
-            enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
-        },
-        stringArray: {
-            type: "array",
-            items: { type: "string" },
-            minItems: 1,
-            uniqueItems: true
-        }
-    },
-    type: "object",
-    properties: {
-        id: {
-            type: "string"
-        },
-        $schema: {
-            type: "string"
-        },
-        title: {
-            type: "string"
-        },
-        description: {
-            type: "string"
-        },
-        default: { },
-        multipleOf: {
-            type: "number",
-            minimum: 0,
-            exclusiveMinimum: true
-        },
-        maximum: {
-            type: "number"
-        },
-        exclusiveMaximum: {
-            type: "boolean",
-            default: false
-        },
-        minimum: {
-            type: "number"
-        },
-        exclusiveMinimum: {
-            type: "boolean",
-            default: false
-        },
-        maxLength: { $ref: "#/definitions/positiveInteger" },
-        minLength: { $ref: "#/definitions/positiveIntegerDefault0" },
-        pattern: {
-            type: "string",
-            format: "regex"
-        },
-        additionalItems: {
-            anyOf: [
-                { type: "boolean" },
-                { $ref: "#" }
-            ],
-            default: { }
-        },
-        items: {
-            anyOf: [
-                { $ref: "#" },
-                { $ref: "#/definitions/schemaArray" }
-            ],
-            default: { }
-        },
-        maxItems: { $ref: "#/definitions/positiveInteger" },
-        minItems: { $ref: "#/definitions/positiveIntegerDefault0" },
-        uniqueItems: {
-            type: "boolean",
-            default: false
-        },
-        maxProperties: { $ref: "#/definitions/positiveInteger" },
-        minProperties: { $ref: "#/definitions/positiveIntegerDefault0" },
-        required: { $ref: "#/definitions/stringArray" },
-        additionalProperties: {
-            anyOf: [
-                { type: "boolean" },
-                { $ref: "#" }
-            ],
-            default: { }
-        },
-        definitions: {
-            type: "object",
-            additionalProperties: { $ref: "#" },
-            default: { }
-        },
-        properties: {
-            type: "object",
-            additionalProperties: { $ref: "#" },
-            default: { }
-        },
-        patternProperties: {
-            type: "object",
-            additionalProperties: { $ref: "#" },
-            default: { }
-        },
-        dependencies: {
-            type: "object",
-            additionalProperties: {
-                anyOf: [
-                    { $ref: "#" },
-                    { $ref: "#/definitions/stringArray" }
-                ]
-            }
-        },
-        enum: {
-            type: "array",
-            minItems: 1,
-            uniqueItems: true
-        },
-        type: {
-            anyOf: [
-                { $ref: "#/definitions/simpleTypes" },
-                {
-                    type: "array",
-                    items: { $ref: "#/definitions/simpleTypes" },
-                    minItems: 1,
-                    uniqueItems: true
-                }
-            ]
-        },
-        format: { type: "string" },
-        allOf: { $ref: "#/definitions/schemaArray" },
-        anyOf: { $ref: "#/definitions/schemaArray" },
-        oneOf: { $ref: "#/definitions/schemaArray" },
-        not: { $ref: "#" }
-    },
-    dependencies: {
-        exclusiveMaximum: ["maximum"],
-        exclusiveMinimum: ["minimum"]
-    },
-    default: { }
-};
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-export default (additionalOptions = {}) => {
-    const ajv = new Ajv({
-        meta: false,
-        useDefaults: true,
-        validateSchema: false,
-        missingRefs: "ignore",
-        verbose: true,
-        schemaId: "auto",
-        ...additionalOptions
-    });
-
-    ajv.addMetaSchema(metaSchema);
-    // eslint-disable-next-line no-underscore-dangle
-    ajv._opts.defaultMeta = metaSchema.id;
-
-    return ajv;
-};