@alexlit/lint-kit 127.0.0 → 127.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-mixed-operators.js

@@ -1,229 +0,0 @@
-/**
- * @fileoverview Rule to disallow mixed binary operators.
- * @author Toru Nagashima
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils.js");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const ARITHMETIC_OPERATORS = ["+", "-", "*", "/", "%", "**"];
-const BITWISE_OPERATORS = ["&", "|", "^", "~", "<<", ">>", ">>>"];
-const COMPARISON_OPERATORS = ["==", "!=", "===", "!==", ">", ">=", "<", "<="];
-const LOGICAL_OPERATORS = ["&&", "||"];
-const RELATIONAL_OPERATORS = ["in", "instanceof"];
-const TERNARY_OPERATOR = ["?:"];
-const COALESCE_OPERATOR = ["??"];
-const ALL_OPERATORS = [].concat(
-    ARITHMETIC_OPERATORS,
-    BITWISE_OPERATORS,
-    COMPARISON_OPERATORS,
-    LOGICAL_OPERATORS,
-    RELATIONAL_OPERATORS,
-    TERNARY_OPERATOR,
-    COALESCE_OPERATOR
-);
-const DEFAULT_GROUPS = [
-    ARITHMETIC_OPERATORS,
-    BITWISE_OPERATORS,
-    COMPARISON_OPERATORS,
-    LOGICAL_OPERATORS,
-    RELATIONAL_OPERATORS
-];
-const TARGET_NODE_TYPE = /^(?:Binary|Logical|Conditional)Expression$/u;
-
-/**
- * Normalizes options.
- * @param {Object|undefined} options A options object to normalize.
- * @returns {Object} Normalized option object.
- */
-function normalizeOptions(options = {}) {
-    const hasGroups = options.groups && options.groups.length > 0;
-    const groups = hasGroups ? options.groups : DEFAULT_GROUPS;
-    const allowSamePrecedence = options.allowSamePrecedence !== false;
-
-    return {
-        groups,
-        allowSamePrecedence
-    };
-}
-
-/**
- * Checks whether any group which includes both given operator exists or not.
- * @param {Array<string[]>} groups A list of groups to check.
- * @param {string} left An operator.
- * @param {string} right Another operator.
- * @returns {boolean} `true` if such group existed.
- */
-function includesBothInAGroup(groups, left, right) {
-    return groups.some(group => group.includes(left) && group.includes(right));
-}
-
-/**
- * Checks whether the given node is a conditional expression and returns the test node else the left node.
- * @param {ASTNode} node A node which can be a BinaryExpression or a LogicalExpression node.
- * This parent node can be BinaryExpression, LogicalExpression
- *      , or a ConditionalExpression node
- * @returns {ASTNode} node the appropriate node(left or test).
- */
-function getChildNode(node) {
-    return node.type === "ConditionalExpression" ? node.test : node.left;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow mixed binary operators",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-mixed-operators"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    groups: {
-                        type: "array",
-                        items: {
-                            type: "array",
-                            items: { enum: ALL_OPERATORS },
-                            minItems: 2,
-                            uniqueItems: true
-                        },
-                        uniqueItems: true
-                    },
-                    allowSamePrecedence: {
-                        type: "boolean",
-                        default: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpectedMixedOperator: "Unexpected mix of '{{leftOperator}}' and '{{rightOperator}}'. Use parentheses to clarify the intended order of operations."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const options = normalizeOptions(context.options[0]);
-
-        /**
-         * Checks whether a given node should be ignored by options or not.
-         * @param {ASTNode} node A node to check. This is a BinaryExpression
-         *      node or a LogicalExpression node. This parent node is one of
-         *      them, too.
-         * @returns {boolean} `true` if the node should be ignored.
-         */
-        function shouldIgnore(node) {
-            const a = node;
-            const b = node.parent;
-
-            return (
-                !includesBothInAGroup(options.groups, a.operator, b.type === "ConditionalExpression" ? "?:" : b.operator) ||
-                (
-                    options.allowSamePrecedence &&
-                    astUtils.getPrecedence(a) === astUtils.getPrecedence(b)
-                )
-            );
-        }
-
-        /**
-         * Checks whether the operator of a given node is mixed with parent
-         * node's operator or not.
-         * @param {ASTNode} node A node to check. This is a BinaryExpression
-         *      node or a LogicalExpression node. This parent node is one of
-         *      them, too.
-         * @returns {boolean} `true` if the node was mixed.
-         */
-        function isMixedWithParent(node) {
-
-            return (
-                node.operator !== node.parent.operator &&
-                !astUtils.isParenthesised(sourceCode, node)
-            );
-        }
-
-        /**
-         * Gets the operator token of a given node.
-         * @param {ASTNode} node A node to check. This is a BinaryExpression
-         *      node or a LogicalExpression node.
-         * @returns {Token} The operator token of the node.
-         */
-        function getOperatorToken(node) {
-            return sourceCode.getTokenAfter(getChildNode(node), astUtils.isNotClosingParenToken);
-        }
-
-        /**
-         * Reports both the operator of a given node and the operator of the
-         * parent node.
-         * @param {ASTNode} node A node to check. This is a BinaryExpression
-         *      node or a LogicalExpression node. This parent node is one of
-         *      them, too.
-         * @returns {void}
-         */
-        function reportBothOperators(node) {
-            const parent = node.parent;
-            const left = (getChildNode(parent) === node) ? node : parent;
-            const right = (getChildNode(parent) !== node) ? node : parent;
-            const data = {
-                leftOperator: left.operator || "?:",
-                rightOperator: right.operator || "?:"
-            };
-
-            context.report({
-                node: left,
-                loc: getOperatorToken(left).loc,
-                messageId: "unexpectedMixedOperator",
-                data
-            });
-            context.report({
-                node: right,
-                loc: getOperatorToken(right).loc,
-                messageId: "unexpectedMixedOperator",
-                data
-            });
-        }
-
-        /**
-         * Checks between the operator of this node and the operator of the
-         * parent node.
-         * @param {ASTNode} node A node to check.
-         * @returns {void}
-         */
-        function check(node) {
-            if (
-                TARGET_NODE_TYPE.test(node.parent.type) &&
-                isMixedWithParent(node) &&
-                !shouldIgnore(node)
-            ) {
-                reportBothOperators(node);
-            }
-        }
-
-        return {
-            BinaryExpression: check,
-            LogicalExpression: check
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-mixed-requires.js

@@ -1,238 +0,0 @@
-/**
- * @fileoverview Rule to enforce grouped require statements for Node.JS
- * @author Raphael Pigulla
- * @deprecated in ESLint v7.0.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-
-        replacedBy: [],
-
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `require` calls to be mixed with regular variable declarations",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-mixed-requires"
-        },
-
-        schema: [
-            {
-                oneOf: [
-                    {
-                        type: "boolean"
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            grouping: {
-                                type: "boolean"
-                            },
-                            allowCall: {
-                                type: "boolean"
-                            }
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
-
-        messages: {
-            noMixRequire: "Do not mix 'require' and other declarations.",
-            noMixCoreModuleFileComputed: "Do not mix core, module, file and computed requires."
-        }
-    },
-
-    create(context) {
-
-        const options = context.options[0];
-        let grouping = false,
-            allowCall = false;
-
-        if (typeof options === "object") {
-            grouping = options.grouping;
-            allowCall = options.allowCall;
-        } else {
-            grouping = !!options;
-        }
-
-        /**
-         * Returns the list of built-in modules.
-         * @returns {string[]} An array of built-in Node.js modules.
-         */
-        function getBuiltinModules() {
-
-            /*
-             * This list is generated using:
-             * `require("repl")._builtinLibs.concat('repl').sort()`
-             * This particular list is as per nodejs v0.12.2 and iojs v0.7.1
-             */
-            return [
-                "assert", "buffer", "child_process", "cluster", "crypto",
-                "dgram", "dns", "domain", "events", "fs", "http", "https",
-                "net", "os", "path", "punycode", "querystring", "readline",
-                "repl", "smalloc", "stream", "string_decoder", "tls", "tty",
-                "url", "util", "v8", "vm", "zlib"
-            ];
-        }
-
-        const BUILTIN_MODULES = getBuiltinModules();
-
-        const DECL_REQUIRE = "require",
-            DECL_UNINITIALIZED = "uninitialized",
-            DECL_OTHER = "other";
-
-        const REQ_CORE = "core",
-            REQ_FILE = "file",
-            REQ_MODULE = "module",
-            REQ_COMPUTED = "computed";
-
-        /**
-         * Determines the type of a declaration statement.
-         * @param {ASTNode} initExpression The init node of the VariableDeclarator.
-         * @returns {string} The type of declaration represented by the expression.
-         */
-        function getDeclarationType(initExpression) {
-            if (!initExpression) {
-
-                // "var x;"
-                return DECL_UNINITIALIZED;
-            }
-
-            if (initExpression.type === "CallExpression" &&
-                initExpression.callee.type === "Identifier" &&
-                initExpression.callee.name === "require"
-            ) {
-
-                // "var x = require('util');"
-                return DECL_REQUIRE;
-            }
-            if (allowCall &&
-                initExpression.type === "CallExpression" &&
-                initExpression.callee.type === "CallExpression"
-            ) {
-
-                // "var x = require('diagnose')('sub-module');"
-                return getDeclarationType(initExpression.callee);
-            }
-            if (initExpression.type === "MemberExpression") {
-
-                // "var x = require('glob').Glob;"
-                return getDeclarationType(initExpression.object);
-            }
-
-            // "var x = 42;"
-            return DECL_OTHER;
-        }
-
-        /**
-         * Determines the type of module that is loaded via require.
-         * @param {ASTNode} initExpression The init node of the VariableDeclarator.
-         * @returns {string} The module type.
-         */
-        function inferModuleType(initExpression) {
-            if (initExpression.type === "MemberExpression") {
-
-                // "var x = require('glob').Glob;"
-                return inferModuleType(initExpression.object);
-            }
-            if (initExpression.arguments.length === 0) {
-
-                // "var x = require();"
-                return REQ_COMPUTED;
-            }
-
-            const arg = initExpression.arguments[0];
-
-            if (arg.type !== "Literal" || typeof arg.value !== "string") {
-
-                // "var x = require(42);"
-                return REQ_COMPUTED;
-            }
-
-            if (BUILTIN_MODULES.includes(arg.value)) {
-
-                // "var fs = require('fs');"
-                return REQ_CORE;
-            }
-            if (/^\.{0,2}\//u.test(arg.value)) {
-
-                // "var utils = require('./utils');"
-                return REQ_FILE;
-            }
-
-            // "var async = require('async');"
-            return REQ_MODULE;
-
-        }
-
-        /**
-         * Check if the list of variable declarations is mixed, i.e. whether it
-         * contains both require and other declarations.
-         * @param {ASTNode} declarations The list of VariableDeclarators.
-         * @returns {boolean} True if the declarations are mixed, false if not.
-         */
-        function isMixed(declarations) {
-            const contains = {};
-
-            declarations.forEach(declaration => {
-                const type = getDeclarationType(declaration.init);
-
-                contains[type] = true;
-            });
-
-            return !!(
-                contains[DECL_REQUIRE] &&
-                (contains[DECL_UNINITIALIZED] || contains[DECL_OTHER])
-            );
-        }
-
-        /**
-         * Check if all require declarations in the given list are of the same
-         * type.
-         * @param {ASTNode} declarations The list of VariableDeclarators.
-         * @returns {boolean} True if the declarations are grouped, false if not.
-         */
-        function isGrouped(declarations) {
-            const found = {};
-
-            declarations.forEach(declaration => {
-                if (getDeclarationType(declaration.init) === DECL_REQUIRE) {
-                    found[inferModuleType(declaration.init)] = true;
-                }
-            });
-
-            return Object.keys(found).length <= 1;
-        }
-
-
-        return {
-
-            VariableDeclaration(node) {
-
-                if (isMixed(node.declarations)) {
-                    context.report({
-                        node,
-                        messageId: "noMixRequire"
-                    });
-                } else if (grouping && !isGrouped(node.declarations)) {
-                    context.report({
-                        node,
-                        messageId: "noMixCoreModuleFileComputed"
-                    });
-                }
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-mixed-spaces-and-tabs.js

@@ -1,116 +0,0 @@
-/**
- * @fileoverview Disallow mixed spaces and tabs for indentation
- * @author Jary Niebur
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Disallow mixed spaces and tabs for indentation",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs"
-        },
-
-        schema: [
-            {
-                enum: ["smart-tabs", true, false]
-            }
-        ],
-
-        messages: {
-            mixedSpacesAndTabs: "Mixed spaces and tabs."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        let smartTabs;
-
-        switch (context.options[0]) {
-            case true: // Support old syntax, maybe add deprecation warning here
-            case "smart-tabs":
-                smartTabs = true;
-                break;
-            default:
-                smartTabs = false;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-
-            "Program:exit"(node) {
-                const lines = sourceCode.lines,
-                    comments = sourceCode.getAllComments(),
-                    ignoredCommentLines = new Set();
-
-                // Add all lines except the first ones.
-                comments.forEach(comment => {
-                    for (let i = comment.loc.start.line + 1; i <= comment.loc.end.line; i++) {
-                        ignoredCommentLines.add(i);
-                    }
-                });
-
-                /*
-                 * At least one space followed by a tab
-                 * or the reverse before non-tab/-space
-                 * characters begin.
-                 */
-                let regex = /^(?=( +|\t+))\1(?:\t| )/u;
-
-                if (smartTabs) {
-
-                    /*
-                     * At least one space followed by a tab
-                     * before non-tab/-space characters begin.
-                     */
-                    regex = /^(?=(\t*))\1(?=( +))\2\t/u;
-                }
-
-                lines.forEach((line, i) => {
-                    const match = regex.exec(line);
-
-                    if (match) {
-                        const lineNumber = i + 1;
-                        const loc = {
-                            start: {
-                                line: lineNumber,
-                                column: match[0].length - 2
-                            },
-                            end: {
-                                line: lineNumber,
-                                column: match[0].length
-                            }
-                        };
-
-                        if (!ignoredCommentLines.has(lineNumber)) {
-                            const containingNode = sourceCode.getNodeByRangeIndex(sourceCode.getIndexFromLoc(loc.start));
-
-                            if (!(containingNode && ["Literal", "TemplateElement"].includes(containingNode.type))) {
-                                context.report({
-                                    node,
-                                    loc,
-                                    messageId: "mixedSpacesAndTabs"
-                                });
-                            }
-                        }
-                    }
-                });
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-multi-assign.js

@@ -1,67 +0,0 @@
-/**
- * @fileoverview Rule to check use of chained assignment expressions
- * @author Stewart Rand
- */
-
-"use strict";
-
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow use of chained assignment expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-multi-assign"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                ignoreNonDeclaration: {
-                    type: "boolean",
-                    default: false
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            unexpectedChain: "Unexpected chained assignment."
-        }
-    },
-
-    create(context) {
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-        const options = context.options[0] || {
-            ignoreNonDeclaration: false
-        };
-        const selectors = [
-            "VariableDeclarator > AssignmentExpression.init",
-            "PropertyDefinition > AssignmentExpression.value"
-        ];
-
-        if (!options.ignoreNonDeclaration) {
-            selectors.push("AssignmentExpression > AssignmentExpression.right");
-        }
-
-        return {
-            [selectors](node) {
-                context.report({
-                    node,
-                    messageId: "unexpectedChain"
-                });
-            }
-        };
-
-    }
-};