eslint 8.57.1 → 9.39.1

package/lib/linter/config-comment-parser.js

@@ -1,185 +0,0 @@
-/**
- * @fileoverview Config Comment Parser
- * @author Nicholas C. Zakas
- */
-
-/* eslint class-methods-use-this: off -- Methods desired on instance */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const levn = require("levn"),
-    {
-        Legacy: {
-            ConfigOps
-        }
-    } = require("@eslint/eslintrc/universal"),
-    {
-        directivesPattern
-    } = require("../shared/directives");
-
-const debug = require("debug")("eslint:config-comment-parser");
-
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/** @typedef {import("../shared/types").LintMessage} LintMessage */
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * Object to parse ESLint configuration comments inside JavaScript files.
- * @name ConfigCommentParser
- */
-module.exports = class ConfigCommentParser {
-
-    /**
-     * Parses a list of "name:string_value" or/and "name" options divided by comma or
-     * whitespace. Used for "global" and "exported" comments.
-     * @param {string} string The string to parse.
-     * @param {Comment} comment The comment node which has the string.
-     * @returns {Object} Result map object of names and string values, or null values if no value was provided
-     */
-    parseStringConfig(string, comment) {
-        debug("Parsing String config");
-
-        const items = {};
-
-        // Collapse whitespace around `:` and `,` to make parsing easier
-        const trimmedString = string.replace(/\s*([:,])\s*/gu, "$1");
-
-        trimmedString.split(/\s|,+/u).forEach(name => {
-            if (!name) {
-                return;
-            }
-
-            // value defaults to null (if not provided), e.g: "foo" => ["foo", null]
-            const [key, value = null] = name.split(":");
-
-            items[key] = { value, comment };
-        });
-        return items;
-    }
-
-    /**
-     * Parses a JSON-like config.
-     * @param {string} string The string to parse.
-     * @param {Object} location Start line and column of comments for potential error message.
-     * @returns {({success: true, config: Object}|{success: false, error: LintMessage})} Result map object
-     */
-    parseJsonConfig(string, location) {
-        debug("Parsing JSON config");
-
-        let items = {};
-
-        // Parses a JSON-like comment by the same way as parsing CLI option.
-        try {
-            items = levn.parse("Object", string) || {};
-
-            // Some tests say that it should ignore invalid comments such as `/*eslint no-alert:abc*/`.
-            // Also, commaless notations have invalid severity:
-            //     "no-alert: 2 no-console: 2" --> {"no-alert": "2 no-console: 2"}
-            // Should ignore that case as well.
-            if (ConfigOps.isEverySeverityValid(items)) {
-                return {
-                    success: true,
-                    config: items
-                };
-            }
-        } catch {
-
-            debug("Levn parsing failed; falling back to manual parsing.");
-
-            // ignore to parse the string by a fallback.
-        }
-
-        /*
-         * Optionator cannot parse commaless notations.
-         * But we are supporting that. So this is a fallback for that.
-         */
-        items = {};
-        const normalizedString = string.replace(/([-a-zA-Z0-9/]+):/gu, "\"$1\":").replace(/(\]|[0-9])\s+(?=")/u, "$1,");
-
-        try {
-            items = JSON.parse(`{${normalizedString}}`);
-        } catch (ex) {
-            debug("Manual parsing failed.");
-
-            return {
-                success: false,
-                error: {
-                    ruleId: null,
-                    fatal: true,
-                    severity: 2,
-                    message: `Failed to parse JSON from '${normalizedString}': ${ex.message}`,
-                    line: location.start.line,
-                    column: location.start.column + 1,
-                    nodeType: null
-                }
-            };
-
-        }
-
-        return {
-            success: true,
-            config: items
-        };
-    }
-
-    /**
-     * Parses a config of values separated by comma.
-     * @param {string} string The string to parse.
-     * @returns {Object} Result map of values and true values
-     */
-    parseListConfig(string) {
-        debug("Parsing list config");
-
-        const items = {};
-
-        string.split(",").forEach(name => {
-            const trimmedName = name.trim().replace(/^(?<quote>['"]?)(?<ruleId>.*)\k<quote>$/us, "$<ruleId>");
-
-            if (trimmedName) {
-                items[trimmedName] = true;
-            }
-        });
-        return items;
-    }
-
-    /**
-     * Extract the directive and the justification from a given directive comment and trim them.
-     * @param {string} value The comment text to extract.
-     * @returns {{directivePart: string, justificationPart: string}} The extracted directive and justification.
-     */
-    extractDirectiveComment(value) {
-        const match = /\s-{2,}\s/u.exec(value);
-
-        if (!match) {
-            return { directivePart: value.trim(), justificationPart: "" };
-        }
-
-        const directive = value.slice(0, match.index).trim();
-        const justification = value.slice(match.index + match[0].length).trim();
-
-        return { directivePart: directive, justificationPart: justification };
-    }
-
-    /**
-     * Parses a directive comment into directive text and value.
-     * @param {Comment} comment The comment node with the directive to be parsed.
-     * @returns {{directiveText: string, directiveValue: string}} The directive text and value.
-     */
-    parseDirective(comment) {
-        const { directivePart } = this.extractDirectiveComment(comment.value);
-        const match = directivesPattern.exec(directivePart);
-        const directiveText = match[1];
-        const directiveValue = directivePart.slice(match.index + directiveText.length);
-
-        return { directiveText, directiveValue };
-    }
-};

package/lib/linter/node-event-generator.js

@@ -1,354 +0,0 @@
-/**
- * @fileoverview The event generator for AST nodes.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const esquery = require("esquery");
-
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/**
- * An object describing an AST selector
- * @typedef {Object} ASTSelector
- * @property {string} rawSelector The string that was parsed into this selector
- * @property {boolean} isExit `true` if this should be emitted when exiting the node rather than when entering
- * @property {Object} parsedSelector An object (from esquery) describing the matching behavior of the selector
- * @property {string[]|null} listenerTypes A list of node types that could possibly cause the selector to match,
- * or `null` if all node types could cause a match
- * @property {number} attributeCount The total number of classes, pseudo-classes, and attribute queries in this selector
- * @property {number} identifierCount The total number of identifier queries in this selector
- */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Computes the union of one or more arrays
- * @param {...any[]} arrays One or more arrays to union
- * @returns {any[]} The union of the input arrays
- */
-function union(...arrays) {
-    return [...new Set(arrays.flat())];
-}
-
-/**
- * Computes the intersection of one or more arrays
- * @param {...any[]} arrays One or more arrays to intersect
- * @returns {any[]} The intersection of the input arrays
- */
-function intersection(...arrays) {
-    if (arrays.length === 0) {
-        return [];
-    }
-
-    let result = [...new Set(arrays[0])];
-
-    for (const array of arrays.slice(1)) {
-        result = result.filter(x => array.includes(x));
-    }
-    return result;
-}
-
-/**
- * Gets the possible types of a selector
- * @param {Object} parsedSelector An object (from esquery) describing the matching behavior of the selector
- * @returns {string[]|null} The node types that could possibly trigger this selector, or `null` if all node types could trigger it
- */
-function getPossibleTypes(parsedSelector) {
-    switch (parsedSelector.type) {
-        case "identifier":
-            return [parsedSelector.value];
-
-        case "matches": {
-            const typesForComponents = parsedSelector.selectors.map(getPossibleTypes);
-
-            if (typesForComponents.every(Boolean)) {
-                return union(...typesForComponents);
-            }
-            return null;
-        }
-
-        case "compound": {
-            const typesForComponents = parsedSelector.selectors.map(getPossibleTypes).filter(typesForComponent => typesForComponent);
-
-            // If all of the components could match any type, then the compound could also match any type.
-            if (!typesForComponents.length) {
-                return null;
-            }
-
-            /*
-             * If at least one of the components could only match a particular type, the compound could only match
-             * the intersection of those types.
-             */
-            return intersection(...typesForComponents);
-        }
-
-        case "child":
-        case "descendant":
-        case "sibling":
-        case "adjacent":
-            return getPossibleTypes(parsedSelector.right);
-
-        case "class":
-            if (parsedSelector.name === "function") {
-                return ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"];
-            }
-
-            return null;
-
-        default:
-            return null;
-
-    }
-}
-
-/**
- * Counts the number of class, pseudo-class, and attribute queries in this selector
- * @param {Object} parsedSelector An object (from esquery) describing the selector's matching behavior
- * @returns {number} The number of class, pseudo-class, and attribute queries in this selector
- */
-function countClassAttributes(parsedSelector) {
-    switch (parsedSelector.type) {
-        case "child":
-        case "descendant":
-        case "sibling":
-        case "adjacent":
-            return countClassAttributes(parsedSelector.left) + countClassAttributes(parsedSelector.right);
-
-        case "compound":
-        case "not":
-        case "matches":
-            return parsedSelector.selectors.reduce((sum, childSelector) => sum + countClassAttributes(childSelector), 0);
-
-        case "attribute":
-        case "field":
-        case "nth-child":
-        case "nth-last-child":
-            return 1;
-
-        default:
-            return 0;
-    }
-}
-
-/**
- * Counts the number of identifier queries in this selector
- * @param {Object} parsedSelector An object (from esquery) describing the selector's matching behavior
- * @returns {number} The number of identifier queries
- */
-function countIdentifiers(parsedSelector) {
-    switch (parsedSelector.type) {
-        case "child":
-        case "descendant":
-        case "sibling":
-        case "adjacent":
-            return countIdentifiers(parsedSelector.left) + countIdentifiers(parsedSelector.right);
-
-        case "compound":
-        case "not":
-        case "matches":
-            return parsedSelector.selectors.reduce((sum, childSelector) => sum + countIdentifiers(childSelector), 0);
-
-        case "identifier":
-            return 1;
-
-        default:
-            return 0;
-    }
-}
-
-/**
- * Compares the specificity of two selector objects, with CSS-like rules.
- * @param {ASTSelector} selectorA An AST selector descriptor
- * @param {ASTSelector} selectorB Another AST selector descriptor
- * @returns {number}
- * a value less than 0 if selectorA is less specific than selectorB
- * a value greater than 0 if selectorA is more specific than selectorB
- * a value less than 0 if selectorA and selectorB have the same specificity, and selectorA <= selectorB alphabetically
- * a value greater than 0 if selectorA and selectorB have the same specificity, and selectorA > selectorB alphabetically
- */
-function compareSpecificity(selectorA, selectorB) {
-    return selectorA.attributeCount - selectorB.attributeCount ||
-        selectorA.identifierCount - selectorB.identifierCount ||
-        (selectorA.rawSelector <= selectorB.rawSelector ? -1 : 1);
-}
-
-/**
- * Parses a raw selector string, and throws a useful error if parsing fails.
- * @param {string} rawSelector A raw AST selector
- * @returns {Object} An object (from esquery) describing the matching behavior of this selector
- * @throws {Error} An error if the selector is invalid
- */
-function tryParseSelector(rawSelector) {
-    try {
-        return esquery.parse(rawSelector.replace(/:exit$/u, ""));
-    } catch (err) {
-        if (err.location && err.location.start && typeof err.location.start.offset === "number") {
-            throw new SyntaxError(`Syntax error in selector "${rawSelector}" at position ${err.location.start.offset}: ${err.message}`);
-        }
-        throw err;
-    }
-}
-
-const selectorCache = new Map();
-
-/**
- * Parses a raw selector string, and returns the parsed selector along with specificity and type information.
- * @param {string} rawSelector A raw AST selector
- * @returns {ASTSelector} A selector descriptor
- */
-function parseSelector(rawSelector) {
-    if (selectorCache.has(rawSelector)) {
-        return selectorCache.get(rawSelector);
-    }
-
-    const parsedSelector = tryParseSelector(rawSelector);
-
-    const result = {
-        rawSelector,
-        isExit: rawSelector.endsWith(":exit"),
-        parsedSelector,
-        listenerTypes: getPossibleTypes(parsedSelector),
-        attributeCount: countClassAttributes(parsedSelector),
-        identifierCount: countIdentifiers(parsedSelector)
-    };
-
-    selectorCache.set(rawSelector, result);
-    return result;
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * The event generator for AST nodes.
- * This implements below interface.
- *
- * ```ts
- * interface EventGenerator {
- *     emitter: SafeEmitter;
- *     enterNode(node: ASTNode): void;
- *     leaveNode(node: ASTNode): void;
- * }
- * ```
- */
-class NodeEventGenerator {
-
-    /**
-     * @param {SafeEmitter} emitter
-     * An SafeEmitter which is the destination of events. This emitter must already
-     * have registered listeners for all of the events that it needs to listen for.
-     * (See lib/linter/safe-emitter.js for more details on `SafeEmitter`.)
-     * @param {ESQueryOptions} esqueryOptions `esquery` options for traversing custom nodes.
-     * @returns {NodeEventGenerator} new instance
-     */
-    constructor(emitter, esqueryOptions) {
-        this.emitter = emitter;
-        this.esqueryOptions = esqueryOptions;
-        this.currentAncestry = [];
-        this.enterSelectorsByNodeType = new Map();
-        this.exitSelectorsByNodeType = new Map();
-        this.anyTypeEnterSelectors = [];
-        this.anyTypeExitSelectors = [];
-
-        emitter.eventNames().forEach(rawSelector => {
-            const selector = parseSelector(rawSelector);
-
-            if (selector.listenerTypes) {
-                const typeMap = selector.isExit ? this.exitSelectorsByNodeType : this.enterSelectorsByNodeType;
-
-                selector.listenerTypes.forEach(nodeType => {
-                    if (!typeMap.has(nodeType)) {
-                        typeMap.set(nodeType, []);
-                    }
-                    typeMap.get(nodeType).push(selector);
-                });
-                return;
-            }
-            const selectors = selector.isExit ? this.anyTypeExitSelectors : this.anyTypeEnterSelectors;
-
-            selectors.push(selector);
-        });
-
-        this.anyTypeEnterSelectors.sort(compareSpecificity);
-        this.anyTypeExitSelectors.sort(compareSpecificity);
-        this.enterSelectorsByNodeType.forEach(selectorList => selectorList.sort(compareSpecificity));
-        this.exitSelectorsByNodeType.forEach(selectorList => selectorList.sort(compareSpecificity));
-    }
-
-    /**
-     * Checks a selector against a node, and emits it if it matches
-     * @param {ASTNode} node The node to check
-     * @param {ASTSelector} selector An AST selector descriptor
-     * @returns {void}
-     */
-    applySelector(node, selector) {
-        if (esquery.matches(node, selector.parsedSelector, this.currentAncestry, this.esqueryOptions)) {
-            this.emitter.emit(selector.rawSelector, node);
-        }
-    }
-
-    /**
-     * Applies all appropriate selectors to a node, in specificity order
-     * @param {ASTNode} node The node to check
-     * @param {boolean} isExit `false` if the node is currently being entered, `true` if it's currently being exited
-     * @returns {void}
-     */
-    applySelectors(node, isExit) {
-        const selectorsByNodeType = (isExit ? this.exitSelectorsByNodeType : this.enterSelectorsByNodeType).get(node.type) || [];
-        const anyTypeSelectors = isExit ? this.anyTypeExitSelectors : this.anyTypeEnterSelectors;
-
-        /*
-         * selectorsByNodeType and anyTypeSelectors were already sorted by specificity in the constructor.
-         * Iterate through each of them, applying selectors in the right order.
-         */
-        let selectorsByTypeIndex = 0;
-        let anyTypeSelectorsIndex = 0;
-
-        while (selectorsByTypeIndex < selectorsByNodeType.length || anyTypeSelectorsIndex < anyTypeSelectors.length) {
-            if (
-                selectorsByTypeIndex >= selectorsByNodeType.length ||
-                anyTypeSelectorsIndex < anyTypeSelectors.length &&
-                compareSpecificity(anyTypeSelectors[anyTypeSelectorsIndex], selectorsByNodeType[selectorsByTypeIndex]) < 0
-            ) {
-                this.applySelector(node, anyTypeSelectors[anyTypeSelectorsIndex++]);
-            } else {
-                this.applySelector(node, selectorsByNodeType[selectorsByTypeIndex++]);
-            }
-        }
-    }
-
-    /**
-     * Emits an event of entering AST node.
-     * @param {ASTNode} node A node which was entered.
-     * @returns {void}
-     */
-    enterNode(node) {
-        if (node.parent) {
-            this.currentAncestry.unshift(node.parent);
-        }
-        this.applySelectors(node, false);
-    }
-
-    /**
-     * Emits an event of leaving AST node.
-     * @param {ASTNode} node A node which was left.
-     * @returns {void}
-     */
-    leaveNode(node) {
-        this.applySelectors(node, true);
-        this.currentAncestry.shift();
-    }
-}
-
-module.exports = NodeEventGenerator;