@alexlit/lint-kit 127.0.0 → 127.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/for-direction.js

@@ -1,140 +0,0 @@
-/**
- * @fileoverview enforce "for" loop update clause moving the counter in the right direction.(for-direction)
- * @author Aladdin-ADD<hh_2013@foxmail.com>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { getStaticValue } = require("@eslint-community/eslint-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Enforce \"for\" loop update clause moving the counter in the right direction",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/for-direction"
-        },
-
-        fixable: null,
-        schema: [],
-
-        messages: {
-            incorrectDirection: "The update clause in this loop moves the variable in the wrong direction."
-        }
-    },
-
-    create(context) {
-        const { sourceCode } = context;
-
-        /**
-         * report an error.
-         * @param {ASTNode} node the node to report.
-         * @returns {void}
-         */
-        function report(node) {
-            context.report({
-                node,
-                messageId: "incorrectDirection"
-            });
-        }
-
-        /**
-         * check the right side of the assignment
-         * @param {ASTNode} update UpdateExpression to check
-         * @param {int} dir expected direction that could either be turned around or invalidated
-         * @returns {int} return dir, the negated dir, or zero if the counter does not change or the direction is not clear
-         */
-        function getRightDirection(update, dir) {
-            const staticValue = getStaticValue(update.right, sourceCode.getScope(update));
-
-            if (staticValue && ["bigint", "boolean", "number"].includes(typeof staticValue.value)) {
-                const sign = Math.sign(Number(staticValue.value)) || 0; // convert NaN to 0
-
-                return dir * sign;
-            }
-            return 0;
-        }
-
-        /**
-         * check UpdateExpression add/sub the counter
-         * @param {ASTNode} update UpdateExpression to check
-         * @param {string} counter variable name to check
-         * @returns {int} if add return 1, if sub return -1, if nochange, return 0
-         */
-        function getUpdateDirection(update, counter) {
-            if (update.argument.type === "Identifier" && update.argument.name === counter) {
-                if (update.operator === "++") {
-                    return 1;
-                }
-                if (update.operator === "--") {
-                    return -1;
-                }
-            }
-            return 0;
-        }
-
-        /**
-         * check AssignmentExpression add/sub the counter
-         * @param {ASTNode} update AssignmentExpression to check
-         * @param {string} counter variable name to check
-         * @returns {int} if add return 1, if sub return -1, if nochange, return 0
-         */
-        function getAssignmentDirection(update, counter) {
-            if (update.left.name === counter) {
-                if (update.operator === "+=") {
-                    return getRightDirection(update, 1);
-                }
-                if (update.operator === "-=") {
-                    return getRightDirection(update, -1);
-                }
-            }
-            return 0;
-        }
-
-        return {
-            ForStatement(node) {
-
-                if (node.test && node.test.type === "BinaryExpression" && node.update) {
-                    for (const counterPosition of ["left", "right"]) {
-                        if (node.test[counterPosition].type !== "Identifier") {
-                            continue;
-                        }
-
-                        const counter = node.test[counterPosition].name;
-                        const operator = node.test.operator;
-                        const update = node.update;
-
-                        let wrongDirection;
-
-                        if (operator === "<" || operator === "<=") {
-                            wrongDirection = counterPosition === "left" ? -1 : 1;
-                        } else if (operator === ">" || operator === ">=") {
-                            wrongDirection = counterPosition === "left" ? 1 : -1;
-                        } else {
-                            return;
-                        }
-
-                        if (update.type === "UpdateExpression") {
-                            if (getUpdateDirection(update, counter) === wrongDirection) {
-                                report(node);
-                            }
-                        } else if (update.type === "AssignmentExpression" && getAssignmentDirection(update, counter) === wrongDirection) {
-                            report(node);
-                        }
-                    }
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/func-call-spacing.js

@@ -1,233 +0,0 @@
-/**
- * @fileoverview Rule to control spacing within function calls
- * @author Matt DuVall <http://www.mattduvall.com>
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Require or disallow spacing between function identifiers and their invocations",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/func-call-spacing"
-        },
-
-        fixable: "whitespace",
-
-        schema: {
-            anyOf: [
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["never"]
-                        }
-                    ],
-                    minItems: 0,
-                    maxItems: 1
-                },
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["always"]
-                        },
-                        {
-                            type: "object",
-                            properties: {
-                                allowNewlines: {
-                                    type: "boolean"
-                                }
-                            },
-                            additionalProperties: false
-                        }
-                    ],
-                    minItems: 0,
-                    maxItems: 2
-                }
-            ]
-        },
-
-        messages: {
-            unexpectedWhitespace: "Unexpected whitespace between function name and paren.",
-            unexpectedNewline: "Unexpected newline between function name and paren.",
-            missing: "Missing space between function name and paren."
-        }
-    },
-
-    create(context) {
-
-        const never = context.options[0] !== "always";
-        const allowNewlines = !never && context.options[1] && context.options[1].allowNewlines;
-        const sourceCode = context.sourceCode;
-        const text = sourceCode.getText();
-
-        /**
-         * Check if open space is present in a function name
-         * @param {ASTNode} node node to evaluate
-         * @param {Token} leftToken The last token of the callee. This may be the closing parenthesis that encloses the callee.
-         * @param {Token} rightToken Tha first token of the arguments. this is the opening parenthesis that encloses the arguments.
-         * @returns {void}
-         * @private
-         */
-        function checkSpacing(node, leftToken, rightToken) {
-            const textBetweenTokens = text.slice(leftToken.range[1], rightToken.range[0]).replace(/\/\*.*?\*\//gu, "");
-            const hasWhitespace = /\s/u.test(textBetweenTokens);
-            const hasNewline = hasWhitespace && astUtils.LINEBREAK_MATCHER.test(textBetweenTokens);
-
-            /*
-             * never allowNewlines hasWhitespace hasNewline message
-             * F     F             F             F          Missing space between function name and paren.
-             * F     F             F             T          (Invalid `!hasWhitespace && hasNewline`)
-             * F     F             T             T          Unexpected newline between function name and paren.
-             * F     F             T             F          (OK)
-             * F     T             T             F          (OK)
-             * F     T             T             T          (OK)
-             * F     T             F             T          (Invalid `!hasWhitespace && hasNewline`)
-             * F     T             F             F          Missing space between function name and paren.
-             * T     T             F             F          (Invalid `never && allowNewlines`)
-             * T     T             F             T          (Invalid `!hasWhitespace && hasNewline`)
-             * T     T             T             T          (Invalid `never && allowNewlines`)
-             * T     T             T             F          (Invalid `never && allowNewlines`)
-             * T     F             T             F          Unexpected space between function name and paren.
-             * T     F             T             T          Unexpected space between function name and paren.
-             * T     F             F             T          (Invalid `!hasWhitespace && hasNewline`)
-             * T     F             F             F          (OK)
-             *
-             * T                   T                        Unexpected space between function name and paren.
-             * F                   F                        Missing space between function name and paren.
-             * F     F                           T          Unexpected newline between function name and paren.
-             */
-
-            if (never && hasWhitespace) {
-                context.report({
-                    node,
-                    loc: {
-                        start: leftToken.loc.end,
-                        end: {
-                            line: rightToken.loc.start.line,
-                            column: rightToken.loc.start.column - 1
-                        }
-                    },
-                    messageId: "unexpectedWhitespace",
-                    fix(fixer) {
-
-                        // Don't remove comments.
-                        if (sourceCode.commentsExistBetween(leftToken, rightToken)) {
-                            return null;
-                        }
-
-                        // If `?.` exists, it doesn't hide no-unexpected-multiline errors
-                        if (node.optional) {
-                            return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], "?.");
-                        }
-
-                        /*
-                         * Only autofix if there is no newline
-                         * https://github.com/eslint/eslint/issues/7787
-                         */
-                        if (hasNewline) {
-                            return null;
-                        }
-                        return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
-                    }
-                });
-            } else if (!never && !hasWhitespace) {
-                context.report({
-                    node,
-                    loc: {
-                        start: {
-                            line: leftToken.loc.end.line,
-                            column: leftToken.loc.end.column - 1
-                        },
-                        end: rightToken.loc.start
-                    },
-                    messageId: "missing",
-                    fix(fixer) {
-                        if (node.optional) {
-                            return null; // Not sure if inserting a space to either before/after `?.` token.
-                        }
-                        return fixer.insertTextBefore(rightToken, " ");
-                    }
-                });
-            } else if (!never && !allowNewlines && hasNewline) {
-                context.report({
-                    node,
-                    loc: {
-                        start: leftToken.loc.end,
-                        end: rightToken.loc.start
-                    },
-                    messageId: "unexpectedNewline",
-                    fix(fixer) {
-
-                        /*
-                         * Only autofix if there is no newline
-                         * https://github.com/eslint/eslint/issues/7787
-                         * But if `?.` exists, it doesn't hide no-unexpected-multiline errors
-                         */
-                        if (!node.optional) {
-                            return null;
-                        }
-
-                        // Don't remove comments.
-                        if (sourceCode.commentsExistBetween(leftToken, rightToken)) {
-                            return null;
-                        }
-
-                        const range = [leftToken.range[1], rightToken.range[0]];
-                        const qdToken = sourceCode.getTokenAfter(leftToken);
-
-                        if (qdToken.range[0] === leftToken.range[1]) {
-                            return fixer.replaceTextRange(range, "?. ");
-                        }
-                        if (qdToken.range[1] === rightToken.range[0]) {
-                            return fixer.replaceTextRange(range, " ?.");
-                        }
-                        return fixer.replaceTextRange(range, " ?. ");
-                    }
-                });
-            }
-        }
-
-        return {
-            "CallExpression, NewExpression"(node) {
-                const lastToken = sourceCode.getLastToken(node);
-                const lastCalleeToken = sourceCode.getLastToken(node.callee);
-                const parenToken = sourceCode.getFirstTokenBetween(lastCalleeToken, lastToken, astUtils.isOpeningParenToken);
-                const prevToken = parenToken && sourceCode.getTokenBefore(parenToken, astUtils.isNotQuestionDotToken);
-
-                // Parens in NewExpression are optional
-                if (!(parenToken && parenToken.range[1] < node.range[1])) {
-                    return;
-                }
-
-                checkSpacing(node, prevToken, parenToken);
-            },
-
-            ImportExpression(node) {
-                const leftToken = sourceCode.getFirstToken(node);
-                const rightToken = sourceCode.getTokenAfter(leftToken);
-
-                checkSpacing(node, leftToken, rightToken);
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/func-name-matching.js

@@ -1,253 +0,0 @@
-/**
- * @fileoverview Rule to require function names to match the name of the variable or property to which they are assigned.
- * @author Annie Zhang, Pavel Strashkin
- */
-
-"use strict";
-
-//--------------------------------------------------------------------------
-// Requirements
-//--------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const esutils = require("esutils");
-
-//--------------------------------------------------------------------------
-// Helpers
-//--------------------------------------------------------------------------
-
-/**
- * Determines if a pattern is `module.exports` or `module["exports"]`
- * @param {ASTNode} pattern The left side of the AssignmentExpression
- * @returns {boolean} True if the pattern is `module.exports` or `module["exports"]`
- */
-function isModuleExports(pattern) {
-    if (pattern.type === "MemberExpression" && pattern.object.type === "Identifier" && pattern.object.name === "module") {
-
-        // module.exports
-        if (pattern.property.type === "Identifier" && pattern.property.name === "exports") {
-            return true;
-        }
-
-        // module["exports"]
-        if (pattern.property.type === "Literal" && pattern.property.value === "exports") {
-            return true;
-        }
-    }
-    return false;
-}
-
-/**
- * Determines if a string name is a valid identifier
- * @param {string} name The string to be checked
- * @param {int} ecmaVersion The ECMAScript version if specified in the parserOptions config
- * @returns {boolean} True if the string is a valid identifier
- */
-function isIdentifier(name, ecmaVersion) {
-    if (ecmaVersion >= 2015) {
-        return esutils.keyword.isIdentifierES6(name);
-    }
-    return esutils.keyword.isIdentifierES5(name);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const alwaysOrNever = { enum: ["always", "never"] };
-const optionsObject = {
-    type: "object",
-    properties: {
-        considerPropertyDescriptor: {
-            type: "boolean"
-        },
-        includeCommonJSModuleExports: {
-            type: "boolean"
-        }
-    },
-    additionalProperties: false
-};
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require function names to match the name of the variable or property to which they are assigned",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/func-name-matching"
-        },
-
-        schema: {
-            anyOf: [{
-                type: "array",
-                additionalItems: false,
-                items: [alwaysOrNever, optionsObject]
-            }, {
-                type: "array",
-                additionalItems: false,
-                items: [optionsObject]
-            }]
-        },
-
-        messages: {
-            matchProperty: "Function name `{{funcName}}` should match property name `{{name}}`.",
-            matchVariable: "Function name `{{funcName}}` should match variable name `{{name}}`.",
-            notMatchProperty: "Function name `{{funcName}}` should not match property name `{{name}}`.",
-            notMatchVariable: "Function name `{{funcName}}` should not match variable name `{{name}}`."
-        }
-    },
-
-    create(context) {
-        const options = (typeof context.options[0] === "object" ? context.options[0] : context.options[1]) || {};
-        const nameMatches = typeof context.options[0] === "string" ? context.options[0] : "always";
-        const considerPropertyDescriptor = options.considerPropertyDescriptor;
-        const includeModuleExports = options.includeCommonJSModuleExports;
-        const ecmaVersion = context.languageOptions.ecmaVersion;
-
-        /**
-         * Check whether node is a certain CallExpression.
-         * @param {string} objName object name
-         * @param {string} funcName function name
-         * @param {ASTNode} node The node to check
-         * @returns {boolean} `true` if node matches CallExpression
-         */
-        function isPropertyCall(objName, funcName, node) {
-            if (!node) {
-                return false;
-            }
-            return node.type === "CallExpression" && astUtils.isSpecificMemberAccess(node.callee, objName, funcName);
-        }
-
-        /**
-         * Compares identifiers based on the nameMatches option
-         * @param {string} x the first identifier
-         * @param {string} y the second identifier
-         * @returns {boolean} whether the two identifiers should warn.
-         */
-        function shouldWarn(x, y) {
-            return (nameMatches === "always" && x !== y) || (nameMatches === "never" && x === y);
-        }
-
-        /**
-         * Reports
-         * @param {ASTNode} node The node to report
-         * @param {string} name The variable or property name
-         * @param {string} funcName The function name
-         * @param {boolean} isProp True if the reported node is a property assignment
-         * @returns {void}
-         */
-        function report(node, name, funcName, isProp) {
-            let messageId;
-
-            if (nameMatches === "always" && isProp) {
-                messageId = "matchProperty";
-            } else if (nameMatches === "always") {
-                messageId = "matchVariable";
-            } else if (isProp) {
-                messageId = "notMatchProperty";
-            } else {
-                messageId = "notMatchVariable";
-            }
-            context.report({
-                node,
-                messageId,
-                data: {
-                    name,
-                    funcName
-                }
-            });
-        }
-
-        /**
-         * Determines whether a given node is a string literal
-         * @param {ASTNode} node The node to check
-         * @returns {boolean} `true` if the node is a string literal
-         */
-        function isStringLiteral(node) {
-            return node.type === "Literal" && typeof node.value === "string";
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            VariableDeclarator(node) {
-                if (!node.init || node.init.type !== "FunctionExpression" || node.id.type !== "Identifier") {
-                    return;
-                }
-                if (node.init.id && shouldWarn(node.id.name, node.init.id.name)) {
-                    report(node, node.id.name, node.init.id.name, false);
-                }
-            },
-
-            AssignmentExpression(node) {
-                if (
-                    node.right.type !== "FunctionExpression" ||
-                    (node.left.computed && node.left.property.type !== "Literal") ||
-                    (!includeModuleExports && isModuleExports(node.left)) ||
-                    (node.left.type !== "Identifier" && node.left.type !== "MemberExpression")
-                ) {
-                    return;
-                }
-
-                const isProp = node.left.type === "MemberExpression";
-                const name = isProp ? astUtils.getStaticPropertyName(node.left) : node.left.name;
-
-                if (node.right.id && name && isIdentifier(name) && shouldWarn(name, node.right.id.name)) {
-                    report(node, name, node.right.id.name, isProp);
-                }
-            },
-
-            "Property, PropertyDefinition[value]"(node) {
-                if (!(node.value.type === "FunctionExpression" && node.value.id)) {
-                    return;
-                }
-
-                if (node.key.type === "Identifier" && !node.computed) {
-                    const functionName = node.value.id.name;
-                    let propertyName = node.key.name;
-
-                    if (
-                        considerPropertyDescriptor &&
-                        propertyName === "value" &&
-                        node.parent.type === "ObjectExpression"
-                    ) {
-                        if (isPropertyCall("Object", "defineProperty", node.parent.parent) || isPropertyCall("Reflect", "defineProperty", node.parent.parent)) {
-                            const property = node.parent.parent.arguments[1];
-
-                            if (isStringLiteral(property) && shouldWarn(property.value, functionName)) {
-                                report(node, property.value, functionName, true);
-                            }
-                        } else if (isPropertyCall("Object", "defineProperties", node.parent.parent.parent.parent)) {
-                            propertyName = node.parent.parent.key.name;
-                            if (!node.parent.parent.computed && shouldWarn(propertyName, functionName)) {
-                                report(node, propertyName, functionName, true);
-                            }
-                        } else if (isPropertyCall("Object", "create", node.parent.parent.parent.parent)) {
-                            propertyName = node.parent.parent.key.name;
-                            if (!node.parent.parent.computed && shouldWarn(propertyName, functionName)) {
-                                report(node, propertyName, functionName, true);
-                            }
-                        } else if (shouldWarn(propertyName, functionName)) {
-                            report(node, propertyName, functionName, true);
-                        }
-                    } else if (shouldWarn(propertyName, functionName)) {
-                        report(node, propertyName, functionName, true);
-                    }
-                    return;
-                }
-
-                if (
-                    isStringLiteral(node.key) &&
-                    isIdentifier(node.key.value, ecmaVersion) &&
-                    shouldWarn(node.key.value, node.value.id.name)
-                ) {
-                    report(node, node.key.value, node.value.id.name, true);
-                }
-            }
-        };
-    }
-};