@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/camelcase.js

@@ -1,397 +0,0 @@
-/**
- * @fileoverview Rule to flag non-camelcased identifiers
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce camelcase naming convention",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/camelcase"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    ignoreDestructuring: {
-                        type: "boolean",
-                        default: false
-                    },
-                    ignoreImports: {
-                        type: "boolean",
-                        default: false
-                    },
-                    ignoreGlobals: {
-                        type: "boolean",
-                        default: false
-                    },
-                    properties: {
-                        enum: ["always", "never"]
-                    },
-                    allow: {
-                        type: "array",
-                        items: {
-                            type: "string"
-                        },
-                        minItems: 0,
-                        uniqueItems: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            notCamelCase: "Identifier '{{name}}' is not in camel case.",
-            notCamelCasePrivate: "#{{name}} is not in camel case."
-        }
-    },
-
-    create(context) {
-        const options = context.options[0] || {};
-        const properties = options.properties === "never" ? "never" : "always";
-        const ignoreDestructuring = options.ignoreDestructuring;
-        const ignoreImports = options.ignoreImports;
-        const ignoreGlobals = options.ignoreGlobals;
-        const allow = options.allow || [];
-        const sourceCode = context.sourceCode;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        // contains reported nodes to avoid reporting twice on destructuring with shorthand notation
-        const reported = new Set();
-
-        /**
-         * Checks if a string contains an underscore and isn't all upper-case
-         * @param {string} name The string to check.
-         * @returns {boolean} if the string is underscored
-         * @private
-         */
-        function isUnderscored(name) {
-            const nameBody = name.replace(/^_+|_+$/gu, "");
-
-            // if there's an underscore, it might be A_CONSTANT, which is okay
-            return nameBody.includes("_") && nameBody !== nameBody.toUpperCase();
-        }
-
-        /**
-         * Checks if a string match the ignore list
-         * @param {string} name The string to check.
-         * @returns {boolean} if the string is ignored
-         * @private
-         */
-        function isAllowed(name) {
-            return allow.some(
-                entry => name === entry || name.match(new RegExp(entry, "u"))
-            );
-        }
-
-        /**
-         * Checks if a given name is good or not.
-         * @param {string} name The name to check.
-         * @returns {boolean} `true` if the name is good.
-         * @private
-         */
-        function isGoodName(name) {
-            return !isUnderscored(name) || isAllowed(name);
-        }
-
-        /**
-         * Checks if a given identifier reference or member expression is an assignment
-         * target.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} `true` if the node is an assignment target.
-         */
-        function isAssignmentTarget(node) {
-            const parent = node.parent;
-
-            switch (parent.type) {
-                case "AssignmentExpression":
-                case "AssignmentPattern":
-                    return parent.left === node;
-
-                case "Property":
-                    return (
-                        parent.parent.type === "ObjectPattern" &&
-                        parent.value === node
-                    );
-                case "ArrayPattern":
-                case "RestElement":
-                    return true;
-
-                default:
-                    return false;
-            }
-        }
-
-        /**
-         * Checks if a given binding identifier uses the original name as-is.
-         * - If it's in object destructuring or object expression, the original name is its property name.
-         * - If it's in import declaration, the original name is its exported name.
-         * @param {ASTNode} node The `Identifier` node to check.
-         * @returns {boolean} `true` if the identifier uses the original name as-is.
-         */
-        function equalsToOriginalName(node) {
-            const localName = node.name;
-            const valueNode = node.parent.type === "AssignmentPattern"
-                ? node.parent
-                : node;
-            const parent = valueNode.parent;
-
-            switch (parent.type) {
-                case "Property":
-                    return (
-                        (parent.parent.type === "ObjectPattern" || parent.parent.type === "ObjectExpression") &&
-                        parent.value === valueNode &&
-                        !parent.computed &&
-                        parent.key.type === "Identifier" &&
-                        parent.key.name === localName
-                    );
-
-                case "ImportSpecifier":
-                    return (
-                        parent.local === node &&
-                        astUtils.getModuleExportName(parent.imported) === localName
-                    );
-
-                default:
-                    return false;
-            }
-        }
-
-        /**
-         * Reports an AST node as a rule violation.
-         * @param {ASTNode} node The node to report.
-         * @returns {void}
-         * @private
-         */
-        function report(node) {
-            if (reported.has(node.range[0])) {
-                return;
-            }
-            reported.add(node.range[0]);
-
-            // Report it.
-            context.report({
-                node,
-                messageId: node.type === "PrivateIdentifier"
-                    ? "notCamelCasePrivate"
-                    : "notCamelCase",
-                data: { name: node.name }
-            });
-        }
-
-        /**
-         * Reports an identifier reference or a binding identifier.
-         * @param {ASTNode} node The `Identifier` node to report.
-         * @returns {void}
-         */
-        function reportReferenceId(node) {
-
-            /*
-             * For backward compatibility, if it's in callings then ignore it.
-             * Not sure why it is.
-             */
-            if (
-                node.parent.type === "CallExpression" ||
-                node.parent.type === "NewExpression"
-            ) {
-                return;
-            }
-
-            /*
-             * For backward compatibility, if it's a default value of
-             * destructuring/parameters then ignore it.
-             * Not sure why it is.
-             */
-            if (
-                node.parent.type === "AssignmentPattern" &&
-                node.parent.right === node
-            ) {
-                return;
-            }
-
-            /*
-             * The `ignoreDestructuring` flag skips the identifiers that uses
-             * the property name as-is.
-             */
-            if (ignoreDestructuring && equalsToOriginalName(node)) {
-                return;
-            }
-
-            report(node);
-        }
-
-        return {
-
-            // Report camelcase of global variable references ------------------
-            Program(node) {
-                const scope = sourceCode.getScope(node);
-
-                if (!ignoreGlobals) {
-
-                    // Defined globals in config files or directive comments.
-                    for (const variable of scope.variables) {
-                        if (
-                            variable.identifiers.length > 0 ||
-                            isGoodName(variable.name)
-                        ) {
-                            continue;
-                        }
-                        for (const reference of variable.references) {
-
-                            /*
-                             * For backward compatibility, this rule reports read-only
-                             * references as well.
-                             */
-                            reportReferenceId(reference.identifier);
-                        }
-                    }
-                }
-
-                // Undefined globals.
-                for (const reference of scope.through) {
-                    const id = reference.identifier;
-
-                    if (isGoodName(id.name)) {
-                        continue;
-                    }
-
-                    /*
-                     * For backward compatibility, this rule reports read-only
-                     * references as well.
-                     */
-                    reportReferenceId(id);
-                }
-            },
-
-            // Report camelcase of declared variables --------------------------
-            [[
-                "VariableDeclaration",
-                "FunctionDeclaration",
-                "FunctionExpression",
-                "ArrowFunctionExpression",
-                "ClassDeclaration",
-                "ClassExpression",
-                "CatchClause"
-            ]](node) {
-                for (const variable of sourceCode.getDeclaredVariables(node)) {
-                    if (isGoodName(variable.name)) {
-                        continue;
-                    }
-                    const id = variable.identifiers[0];
-
-                    // Report declaration.
-                    if (!(ignoreDestructuring && equalsToOriginalName(id))) {
-                        report(id);
-                    }
-
-                    /*
-                     * For backward compatibility, report references as well.
-                     * It looks unnecessary because declarations are reported.
-                     */
-                    for (const reference of variable.references) {
-                        if (reference.init) {
-                            continue; // Skip the write references of initializers.
-                        }
-                        reportReferenceId(reference.identifier);
-                    }
-                }
-            },
-
-            // Report camelcase in properties ----------------------------------
-            [[
-                "ObjectExpression > Property[computed!=true] > Identifier.key",
-                "MethodDefinition[computed!=true] > Identifier.key",
-                "PropertyDefinition[computed!=true] > Identifier.key",
-                "MethodDefinition > PrivateIdentifier.key",
-                "PropertyDefinition > PrivateIdentifier.key"
-            ]](node) {
-                if (properties === "never" || isGoodName(node.name)) {
-                    return;
-                }
-                report(node);
-            },
-            "MemberExpression[computed!=true] > Identifier.property"(node) {
-                if (
-                    properties === "never" ||
-                    !isAssignmentTarget(node.parent) || // ← ignore read-only references.
-                    isGoodName(node.name)
-                ) {
-                    return;
-                }
-                report(node);
-            },
-
-            // Report camelcase in import --------------------------------------
-            ImportDeclaration(node) {
-                for (const variable of sourceCode.getDeclaredVariables(node)) {
-                    if (isGoodName(variable.name)) {
-                        continue;
-                    }
-                    const id = variable.identifiers[0];
-
-                    // Report declaration.
-                    if (!(ignoreImports && equalsToOriginalName(id))) {
-                        report(id);
-                    }
-
-                    /*
-                     * For backward compatibility, report references as well.
-                     * It looks unnecessary because declarations are reported.
-                     */
-                    for (const reference of variable.references) {
-                        reportReferenceId(reference.identifier);
-                    }
-                }
-            },
-
-            // Report camelcase in re-export -----------------------------------
-            [[
-                "ExportAllDeclaration > Identifier.exported",
-                "ExportSpecifier > Identifier.exported"
-            ]](node) {
-                if (isGoodName(node.name)) {
-                    return;
-                }
-                report(node);
-            },
-
-            // Report camelcase in labels --------------------------------------
-            [[
-                "LabeledStatement > Identifier.label",
-
-                /*
-                 * For backward compatibility, report references as well.
-                 * It looks unnecessary because declarations are reported.
-                 */
-                "BreakStatement > Identifier.label",
-                "ContinueStatement > Identifier.label"
-            ]](node) {
-                if (isGoodName(node.name)) {
-                    return;
-                }
-                report(node);
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/capitalized-comments.js

@@ -1,303 +0,0 @@
-/**
- * @fileoverview enforce or disallow capitalization of the first letter of a comment
- * @author Kevin Partington
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const DEFAULT_IGNORE_PATTERN = astUtils.COMMENTS_IGNORE_PATTERN,
-    WHITESPACE = /\s/gu,
-    MAYBE_URL = /^\s*[^:/?#\s]+:\/\/[^?#]/u, // TODO: Combine w/ max-len pattern?
-    LETTER_PATTERN = /\p{L}/u;
-
-/*
- * Base schema body for defining the basic capitalization rule, ignorePattern,
- * and ignoreInlineComments values.
- * This can be used in a few different ways in the actual schema.
- */
-const SCHEMA_BODY = {
-    type: "object",
-    properties: {
-        ignorePattern: {
-            type: "string"
-        },
-        ignoreInlineComments: {
-            type: "boolean"
-        },
-        ignoreConsecutiveComments: {
-            type: "boolean"
-        }
-    },
-    additionalProperties: false
-};
-const DEFAULTS = {
-    ignorePattern: "",
-    ignoreInlineComments: false,
-    ignoreConsecutiveComments: false
-};
-
-/**
- * Get normalized options for either block or line comments from the given
- * user-provided options.
- * - If the user-provided options is just a string, returns a normalized
- *   set of options using default values for all other options.
- * - If the user-provided options is an object, then a normalized option
- *   set is returned. Options specified in overrides will take priority
- *   over options specified in the main options object, which will in
- *   turn take priority over the rule's defaults.
- * @param {Object|string} rawOptions The user-provided options.
- * @param {string} which Either "line" or "block".
- * @returns {Object} The normalized options.
- */
-function getNormalizedOptions(rawOptions, which) {
-    return Object.assign({}, DEFAULTS, rawOptions[which] || rawOptions);
-}
-
-/**
- * Get normalized options for block and line comments.
- * @param {Object|string} rawOptions The user-provided options.
- * @returns {Object} An object with "Line" and "Block" keys and corresponding
- * normalized options objects.
- */
-function getAllNormalizedOptions(rawOptions = {}) {
-    return {
-        Line: getNormalizedOptions(rawOptions, "line"),
-        Block: getNormalizedOptions(rawOptions, "block")
-    };
-}
-
-/**
- * Creates a regular expression for each ignorePattern defined in the rule
- * options.
- *
- * This is done in order to avoid invoking the RegExp constructor repeatedly.
- * @param {Object} normalizedOptions The normalized rule options.
- * @returns {void}
- */
-function createRegExpForIgnorePatterns(normalizedOptions) {
-    Object.keys(normalizedOptions).forEach(key => {
-        const ignorePatternStr = normalizedOptions[key].ignorePattern;
-
-        if (ignorePatternStr) {
-            const regExp = RegExp(`^\\s*(?:${ignorePatternStr})`, "u");
-
-            normalizedOptions[key].ignorePatternRegExp = regExp;
-        }
-    });
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce or disallow capitalization of the first letter of a comment",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/capitalized-comments"
-        },
-
-        fixable: "code",
-
-        schema: [
-            { enum: ["always", "never"] },
-            {
-                oneOf: [
-                    SCHEMA_BODY,
-                    {
-                        type: "object",
-                        properties: {
-                            line: SCHEMA_BODY,
-                            block: SCHEMA_BODY
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
-
-        messages: {
-            unexpectedLowercaseComment: "Comments should not begin with a lowercase character.",
-            unexpectedUppercaseComment: "Comments should not begin with an uppercase character."
-        }
-    },
-
-    create(context) {
-
-        const capitalize = context.options[0] || "always",
-            normalizedOptions = getAllNormalizedOptions(context.options[1]),
-            sourceCode = context.sourceCode;
-
-        createRegExpForIgnorePatterns(normalizedOptions);
-
-        //----------------------------------------------------------------------
-        // Helpers
-        //----------------------------------------------------------------------
-
-        /**
-         * Checks whether a comment is an inline comment.
-         *
-         * For the purpose of this rule, a comment is inline if:
-         * 1. The comment is preceded by a token on the same line; and
-         * 2. The command is followed by a token on the same line.
-         *
-         * Note that the comment itself need not be single-line!
-         *
-         * Also, it follows from this definition that only block comments can
-         * be considered as possibly inline. This is because line comments
-         * would consume any following tokens on the same line as the comment.
-         * @param {ASTNode} comment The comment node to check.
-         * @returns {boolean} True if the comment is an inline comment, false
-         * otherwise.
-         */
-        function isInlineComment(comment) {
-            const previousToken = sourceCode.getTokenBefore(comment, { includeComments: true }),
-                nextToken = sourceCode.getTokenAfter(comment, { includeComments: true });
-
-            return Boolean(
-                previousToken &&
-                nextToken &&
-                comment.loc.start.line === previousToken.loc.end.line &&
-                comment.loc.end.line === nextToken.loc.start.line
-            );
-        }
-
-        /**
-         * Determine if a comment follows another comment.
-         * @param {ASTNode} comment The comment to check.
-         * @returns {boolean} True if the comment follows a valid comment.
-         */
-        function isConsecutiveComment(comment) {
-            const previousTokenOrComment = sourceCode.getTokenBefore(comment, { includeComments: true });
-
-            return Boolean(
-                previousTokenOrComment &&
-                ["Block", "Line"].includes(previousTokenOrComment.type)
-            );
-        }
-
-        /**
-         * Check a comment to determine if it is valid for this rule.
-         * @param {ASTNode} comment The comment node to process.
-         * @param {Object} options The options for checking this comment.
-         * @returns {boolean} True if the comment is valid, false otherwise.
-         */
-        function isCommentValid(comment, options) {
-
-            // 1. Check for default ignore pattern.
-            if (DEFAULT_IGNORE_PATTERN.test(comment.value)) {
-                return true;
-            }
-
-            // 2. Check for custom ignore pattern.
-            const commentWithoutAsterisks = comment.value
-                .replace(/\*/gu, "");
-
-            if (options.ignorePatternRegExp && options.ignorePatternRegExp.test(commentWithoutAsterisks)) {
-                return true;
-            }
-
-            // 3. Check for inline comments.
-            if (options.ignoreInlineComments && isInlineComment(comment)) {
-                return true;
-            }
-
-            // 4. Is this a consecutive comment (and are we tolerating those)?
-            if (options.ignoreConsecutiveComments && isConsecutiveComment(comment)) {
-                return true;
-            }
-
-            // 5. Does the comment start with a possible URL?
-            if (MAYBE_URL.test(commentWithoutAsterisks)) {
-                return true;
-            }
-
-            // 6. Is the initial word character a letter?
-            const commentWordCharsOnly = commentWithoutAsterisks
-                .replace(WHITESPACE, "");
-
-            if (commentWordCharsOnly.length === 0) {
-                return true;
-            }
-
-            // Get the first Unicode character (1 or 2 code units).
-            const [firstWordChar] = commentWordCharsOnly;
-
-            if (!LETTER_PATTERN.test(firstWordChar)) {
-                return true;
-            }
-
-            // 7. Check the case of the initial word character.
-            const isUppercase = firstWordChar !== firstWordChar.toLocaleLowerCase(),
-                isLowercase = firstWordChar !== firstWordChar.toLocaleUpperCase();
-
-            if (capitalize === "always" && isLowercase) {
-                return false;
-            }
-            if (capitalize === "never" && isUppercase) {
-                return false;
-            }
-
-            return true;
-        }
-
-        /**
-         * Process a comment to determine if it needs to be reported.
-         * @param {ASTNode} comment The comment node to process.
-         * @returns {void}
-         */
-        function processComment(comment) {
-            const options = normalizedOptions[comment.type],
-                commentValid = isCommentValid(comment, options);
-
-            if (!commentValid) {
-                const messageId = capitalize === "always"
-                    ? "unexpectedLowercaseComment"
-                    : "unexpectedUppercaseComment";
-
-                context.report({
-                    node: null, // Intentionally using loc instead
-                    loc: comment.loc,
-                    messageId,
-                    fix(fixer) {
-                        const match = comment.value.match(LETTER_PATTERN);
-                        const char = match[0];
-
-                        // Offset match.index by 2 to account for the first 2 characters that start the comment (// or /*)
-                        const charIndex = comment.range[0] + match.index + 2;
-
-                        return fixer.replaceTextRange(
-                            [charIndex, charIndex + char.length],
-                            capitalize === "always" ? char.toLocaleUpperCase() : char.toLocaleLowerCase()
-                        );
-                    }
-                });
-            }
-        }
-
-        //----------------------------------------------------------------------
-        // Public
-        //----------------------------------------------------------------------
-
-        return {
-            Program() {
-                const comments = sourceCode.getAllComments();
-
-                comments.filter(token => token.type !== "Shebang").forEach(processComment);
-            }
-        };
-    }
-};