eslint 8.57.1 → 9.39.1

package/lib/cli-engine/formatters/tap.js

@@ -1,95 +0,0 @@
-/**
- * @fileoverview TAP reporter
- * @author Jonathan Kingston
- */
-"use strict";
-
-const yaml = require("js-yaml");
-
-//------------------------------------------------------------------------------
-// Helper Functions
-//------------------------------------------------------------------------------
-
-/**
- * Returns a canonical error level string based upon the error message passed in.
- * @param {Object} message Individual error message provided by eslint
- * @returns {string} Error level string
- */
-function getMessageType(message) {
-    if (message.fatal || message.severity === 2) {
-        return "error";
-    }
-    return "warning";
-}
-
-/**
- * Takes in a JavaScript object and outputs a TAP diagnostics string
- * @param {Object} diagnostic JavaScript object to be embedded as YAML into output.
- * @returns {string} diagnostics string with YAML embedded - TAP version 13 compliant
- */
-function outputDiagnostics(diagnostic) {
-    const prefix = "  ";
-    let output = `${prefix}---\n`;
-
-    output += prefix + yaml.dump(diagnostic).split("\n").join(`\n${prefix}`);
-    output += "...\n";
-    return output;
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = function(results) {
-    let output = `TAP version 13\n1..${results.length}\n`;
-
-    results.forEach((result, id) => {
-        const messages = result.messages;
-        let testResult = "ok";
-        let diagnostics = {};
-
-        if (messages.length > 0) {
-            messages.forEach(message => {
-                const severity = getMessageType(message);
-                const diagnostic = {
-                    message: message.message,
-                    severity,
-                    data: {
-                        line: message.line || 0,
-                        column: message.column || 0,
-                        ruleId: message.ruleId || ""
-                    }
-                };
-
-                // This ensures a warning message is not flagged as error
-                if (severity === "error") {
-                    testResult = "not ok";
-                }
-
-                /*
-                 * If we have multiple messages place them under a messages key
-                 * The first error will be logged as message key
-                 * This is to adhere to TAP 13 loosely defined specification of having a message key
-                 */
-                if ("message" in diagnostics) {
-                    if (typeof diagnostics.messages === "undefined") {
-                        diagnostics.messages = [];
-                    }
-                    diagnostics.messages.push(diagnostic);
-                } else {
-                    diagnostics = diagnostic;
-                }
-            });
-        }
-
-        output += `${testResult} ${id + 1} - ${result.filePath}\n`;
-
-        // If we have an error include diagnostics
-        if (messages.length > 0) {
-            output += outputDiagnostics(diagnostics);
-        }
-
-    });
-
-    return output;
-};

package/lib/cli-engine/formatters/unix.js

@@ -1,58 +0,0 @@
-/**
- * @fileoverview unix-style formatter.
- * @author oshi-shinobu
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helper Functions
-//------------------------------------------------------------------------------
-
-/**
- * Returns a canonical error level string based upon the error message passed in.
- * @param {Object} message Individual error message provided by eslint
- * @returns {string} Error level string
- */
-function getMessageType(message) {
-    if (message.fatal || message.severity === 2) {
-        return "Error";
-    }
-    return "Warning";
-
-}
-
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = function(results) {
-
-    let output = "",
-        total = 0;
-
-    results.forEach(result => {
-
-        const messages = result.messages;
-
-        total += messages.length;
-
-        messages.forEach(message => {
-
-            output += `${result.filePath}:`;
-            output += `${message.line || 0}:`;
-            output += `${message.column || 0}:`;
-            output += ` ${message.message} `;
-            output += `[${getMessageType(message)}${message.ruleId ? `/${message.ruleId}` : ""}]`;
-            output += "\n";
-
-        });
-
-    });
-
-    if (total > 0) {
-        output += `\n${total} problem${total !== 1 ? "s" : ""}`;
-    }
-
-    return output;
-};

package/lib/cli-engine/formatters/visualstudio.js

@@ -1,63 +0,0 @@
-/**
- * @fileoverview Visual Studio compatible formatter
- * @author Ronald Pijnacker
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helper Functions
-//------------------------------------------------------------------------------
-
-/**
- * Returns the severity of warning or error
- * @param {Object} message message object to examine
- * @returns {string} severity level
- * @private
- */
-function getMessageType(message) {
-    if (message.fatal || message.severity === 2) {
-        return "error";
-    }
-    return "warning";
-
-}
-
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = function(results) {
-
-    let output = "",
-        total = 0;
-
-    results.forEach(result => {
-
-        const messages = result.messages;
-
-        total += messages.length;
-
-        messages.forEach(message => {
-
-            output += result.filePath;
-            output += `(${message.line || 0}`;
-            output += message.column ? `,${message.column}` : "";
-            output += `): ${getMessageType(message)}`;
-            output += message.ruleId ? ` ${message.ruleId}` : "";
-            output += ` : ${message.message}`;
-            output += "\n";
-
-        });
-
-    });
-
-    if (total === 0) {
-        output += "no problems";
-    } else {
-        output += `\n${total} problem${total !== 1 ? "s" : ""}`;
-    }
-
-    return output;
-};

package/lib/cli-engine/xml-escape.js

@@ -1,34 +0,0 @@
-/**
- * @fileoverview XML character escaper
- * @author George Chung
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * Returns the escaped value for a character
- * @param {string} s string to examine
- * @returns {string} severity level
- * @private
- */
-module.exports = function(s) {
-    return (`${s}`).replace(/[<>&"'\x00-\x1F\x7F\u0080-\uFFFF]/gu, c => { // eslint-disable-line no-control-regex -- Converting controls to entities
-        switch (c) {
-            case "<":
-                return "&lt;";
-            case ">":
-                return "&gt;";
-            case "&":
-                return "&amp;";
-            case "\"":
-                return "&quot;";
-            case "'":
-                return "&apos;";
-            default:
-                return `&#${c.charCodeAt(0)};`;
-        }
-    });
-};

package/lib/config/flat-config-helpers.js

@@ -1,111 +0,0 @@
-/**
- * @fileoverview Shared functions to work with configs.
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Functions
-//-----------------------------------------------------------------------------
-
-/**
- * Parses a ruleId into its plugin and rule parts.
- * @param {string} ruleId The rule ID to parse.
- * @returns {{pluginName:string,ruleName:string}} The plugin and rule
- *      parts of the ruleId;
- */
-function parseRuleId(ruleId) {
-    let pluginName, ruleName;
-
-    // distinguish between core rules and plugin rules
-    if (ruleId.includes("/")) {
-
-        // mimic scoped npm packages
-        if (ruleId.startsWith("@")) {
-            pluginName = ruleId.slice(0, ruleId.lastIndexOf("/"));
-        } else {
-            pluginName = ruleId.slice(0, ruleId.indexOf("/"));
-        }
-
-        ruleName = ruleId.slice(pluginName.length + 1);
-    } else {
-        pluginName = "@";
-        ruleName = ruleId;
-    }
-
-    return {
-        pluginName,
-        ruleName
-    };
-}
-
-/**
- * Retrieves a rule instance from a given config based on the ruleId.
- * @param {string} ruleId The rule ID to look for.
- * @param {FlatConfig} config The config to search.
- * @returns {import("../shared/types").Rule|undefined} The rule if found
- *      or undefined if not.
- */
-function getRuleFromConfig(ruleId, config) {
-
-    const { pluginName, ruleName } = parseRuleId(ruleId);
-
-    const plugin = config.plugins && config.plugins[pluginName];
-    let rule = plugin && plugin.rules && plugin.rules[ruleName];
-
-
-    // normalize function rules into objects
-    if (rule && typeof rule === "function") {
-        rule = {
-            create: rule
-        };
-    }
-
-    return rule;
-}
-
-/**
- * Gets a complete options schema for a rule.
- * @param {{create: Function, schema: (Array|null)}} rule A new-style rule object
- * @returns {Object} JSON Schema for the rule's options.
- */
-function getRuleOptionsSchema(rule) {
-
-    if (!rule) {
-        return null;
-    }
-
-    const schema = rule.schema || rule.meta && rule.meta.schema;
-
-    if (Array.isArray(schema)) {
-        if (schema.length) {
-            return {
-                type: "array",
-                items: schema,
-                minItems: 0,
-                maxItems: schema.length
-            };
-        }
-        return {
-            type: "array",
-            minItems: 0,
-            maxItems: 0
-        };
-
-    }
-
-    // Given a full schema, leave it alone
-    return schema || null;
-}
-
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-module.exports = {
-    parseRuleId,
-    getRuleFromConfig,
-    getRuleOptionsSchema
-};

package/lib/config/rule-validator.js

@@ -1,158 +0,0 @@
-/**
- * @fileoverview Rule Validator
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Requirements
-//-----------------------------------------------------------------------------
-
-const ajvImport = require("../shared/ajv");
-const ajv = ajvImport();
-const {
-    parseRuleId,
-    getRuleFromConfig,
-    getRuleOptionsSchema
-} = require("./flat-config-helpers");
-const ruleReplacements = require("../../conf/replacements.json");
-
-//-----------------------------------------------------------------------------
-// Helpers
-//-----------------------------------------------------------------------------
-
-/**
- * Throws a helpful error when a rule cannot be found.
- * @param {Object} ruleId The rule identifier.
- * @param {string} ruleId.pluginName The ID of the rule to find.
- * @param {string} ruleId.ruleName The ID of the rule to find.
- * @param {Object} config The config to search in.
- * @throws {TypeError} For missing plugin or rule.
- * @returns {void}
- */
-function throwRuleNotFoundError({ pluginName, ruleName }, config) {
-
-    const ruleId = pluginName === "@" ? ruleName : `${pluginName}/${ruleName}`;
-
-    const errorMessageHeader = `Key "rules": Key "${ruleId}"`;
-    let errorMessage = `${errorMessageHeader}: Could not find plugin "${pluginName}".`;
-
-    // if the plugin exists then we need to check if the rule exists
-    if (config.plugins && config.plugins[pluginName]) {
-        const replacementRuleName = ruleReplacements.rules[ruleName];
-
-        if (pluginName === "@" && replacementRuleName) {
-
-            errorMessage = `${errorMessageHeader}: Rule "${ruleName}" was removed and replaced by "${replacementRuleName}".`;
-
-        } else {
-
-            errorMessage = `${errorMessageHeader}: Could not find "${ruleName}" in plugin "${pluginName}".`;
-
-            // otherwise, let's see if we can find the rule name elsewhere
-            for (const [otherPluginName, otherPlugin] of Object.entries(config.plugins)) {
-                if (otherPlugin.rules && otherPlugin.rules[ruleName]) {
-                    errorMessage += ` Did you mean "${otherPluginName}/${ruleName}"?`;
-                    break;
-                }
-            }
-
-        }
-
-        // falls through to throw error
-    }
-
-    throw new TypeError(errorMessage);
-}
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-/**
- * Implements validation functionality for the rules portion of a config.
- */
-class RuleValidator {
-
-    /**
-     * Creates a new instance.
-     */
-    constructor() {
-
-        /**
-         * A collection of compiled validators for rules that have already
-         * been validated.
-         * @type {WeakMap}
-         */
-        this.validators = new WeakMap();
-    }
-
-    /**
-     * Validates all of the rule configurations in a config against each
-     * rule's schema.
-     * @param {Object} config The full config to validate. This object must
-     *      contain both the rules section and the plugins section.
-     * @returns {void}
-     * @throws {Error} If a rule's configuration does not match its schema.
-     */
-    validate(config) {
-
-        if (!config.rules) {
-            return;
-        }
-
-        for (const [ruleId, ruleOptions] of Object.entries(config.rules)) {
-
-            // check for edge case
-            if (ruleId === "__proto__") {
-                continue;
-            }
-
-            /*
-             * If a rule is disabled, we don't do any validation. This allows
-             * users to safely set any value to 0 or "off" without worrying
-             * that it will cause a validation error.
-             *
-             * Note: ruleOptions is always an array at this point because
-             * this validation occurs after FlatConfigArray has merged and
-             * normalized values.
-             */
-            if (ruleOptions[0] === 0) {
-                continue;
-            }
-
-            const rule = getRuleFromConfig(ruleId, config);
-
-            if (!rule) {
-                throwRuleNotFoundError(parseRuleId(ruleId), config);
-            }
-
-            // Precompile and cache validator the first time
-            if (!this.validators.has(rule)) {
-                const schema = getRuleOptionsSchema(rule);
-
-                if (schema) {
-                    this.validators.set(rule, ajv.compile(schema));
-                }
-            }
-
-            const validateRule = this.validators.get(rule);
-
-            if (validateRule) {
-
-                validateRule(ruleOptions.slice(1));
-
-                if (validateRule.errors) {
-                    throw new Error(`Key "rules": Key "${ruleId}": ${
-                        validateRule.errors.map(
-                            error => `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`
-                        ).join("")
-                    }`);
-                }
-            }
-        }
-    }
-}
-
-exports.RuleValidator = RuleValidator;