@alexlit/lint-kit 126.6.0 → 126.7.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-implicit-coercion.js

@@ -0,0 +1,422 @@
+/**
+ * @fileoverview A rule to disallow the type conversions with shorter notations.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const INDEX_OF_PATTERN = /^(?:i|lastI)ndexOf$/u;
+const ALLOWABLE_OPERATORS = ["~", "!!", "+", "- -", "-", "*"];
+
+/**
+ * Parses and normalizes an option object.
+ * @param {Object} options An option object to parse.
+ * @returns {Object} The parsed and normalized option object.
+ */
+function parseOptions(options) {
+    return {
+        boolean: "boolean" in options ? options.boolean : true,
+        number: "number" in options ? options.number : true,
+        string: "string" in options ? options.string : true,
+        disallowTemplateShorthand: "disallowTemplateShorthand" in options ? options.disallowTemplateShorthand : false,
+        allow: options.allow || []
+    };
+}
+
+/**
+ * Checks whether or not a node is a double logical negating.
+ * @param {ASTNode} node An UnaryExpression node to check.
+ * @returns {boolean} Whether or not the node is a double logical negating.
+ */
+function isDoubleLogicalNegating(node) {
+    return (
+        node.operator === "!" &&
+        node.argument.type === "UnaryExpression" &&
+        node.argument.operator === "!"
+    );
+}
+
+/**
+ * Checks whether or not a node is a binary negating of `.indexOf()` method calling.
+ * @param {ASTNode} node An UnaryExpression node to check.
+ * @returns {boolean} Whether or not the node is a binary negating of `.indexOf()` method calling.
+ */
+function isBinaryNegatingOfIndexOf(node) {
+    if (node.operator !== "~") {
+        return false;
+    }
+    const callNode = astUtils.skipChainExpression(node.argument);
+
+    return (
+        callNode.type === "CallExpression" &&
+        astUtils.isSpecificMemberAccess(callNode.callee, null, INDEX_OF_PATTERN)
+    );
+}
+
+/**
+ * Checks whether or not a node is a multiplying by one.
+ * @param {BinaryExpression} node A BinaryExpression node to check.
+ * @returns {boolean} Whether or not the node is a multiplying by one.
+ */
+function isMultiplyByOne(node) {
+    return node.operator === "*" && (
+        node.left.type === "Literal" && node.left.value === 1 ||
+        node.right.type === "Literal" && node.right.value === 1
+    );
+}
+
+/**
+ * Checks whether the given node logically represents multiplication by a fraction of `1`.
+ * For example, `a * 1` in `a * 1 / b` is technically multiplication by `1`, but the
+ * whole expression can be logically interpreted as `a * (1 / b)` rather than `(a * 1) / b`.
+ * @param {BinaryExpression} node A BinaryExpression node to check.
+ * @param {SourceCode} sourceCode The source code object.
+ * @returns {boolean} Whether or not the node is a multiplying by a fraction of `1`.
+ */
+function isMultiplyByFractionOfOne(node, sourceCode) {
+    return node.type === "BinaryExpression" &&
+        node.operator === "*" &&
+        (node.right.type === "Literal" && node.right.value === 1) &&
+        node.parent.type === "BinaryExpression" &&
+        node.parent.operator === "/" &&
+        node.parent.left === node &&
+        !astUtils.isParenthesised(sourceCode, node);
+}
+
+/**
+ * Checks whether the result of a node is numeric or not
+ * @param {ASTNode} node The node to test
+ * @returns {boolean} true if the node is a number literal or a `Number()`, `parseInt` or `parseFloat` call
+ */
+function isNumeric(node) {
+    return (
+        node.type === "Literal" && typeof node.value === "number" ||
+        node.type === "CallExpression" && (
+            node.callee.name === "Number" ||
+            node.callee.name === "parseInt" ||
+            node.callee.name === "parseFloat"
+        )
+    );
+}
+
+/**
+ * Returns the first non-numeric operand in a BinaryExpression. Designed to be
+ * used from bottom to up since it walks up the BinaryExpression trees using
+ * node.parent to find the result.
+ * @param {BinaryExpression} node The BinaryExpression node to be walked up on
+ * @returns {ASTNode|null} The first non-numeric item in the BinaryExpression tree or null
+ */
+function getNonNumericOperand(node) {
+    const left = node.left,
+        right = node.right;
+
+    if (right.type !== "BinaryExpression" && !isNumeric(right)) {
+        return right;
+    }
+
+    if (left.type !== "BinaryExpression" && !isNumeric(left)) {
+        return left;
+    }
+
+    return null;
+}
+
+/**
+ * Checks whether an expression evaluates to a string.
+ * @param {ASTNode} node node that represents the expression to check.
+ * @returns {boolean} Whether or not the expression evaluates to a string.
+ */
+function isStringType(node) {
+    return astUtils.isStringLiteral(node) ||
+        (
+            node.type === "CallExpression" &&
+            node.callee.type === "Identifier" &&
+            node.callee.name === "String"
+        );
+}
+
+/**
+ * Checks whether a node is an empty string literal or not.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} Whether or not the passed in node is an
+ * empty string literal or not.
+ */
+function isEmptyString(node) {
+    return astUtils.isStringLiteral(node) && (node.value === "" || (node.type === "TemplateLiteral" && node.quasis.length === 1 && node.quasis[0].value.cooked === ""));
+}
+
+/**
+ * Checks whether or not a node is a concatenating with an empty string.
+ * @param {ASTNode} node A BinaryExpression node to check.
+ * @returns {boolean} Whether or not the node is a concatenating with an empty string.
+ */
+function isConcatWithEmptyString(node) {
+    return node.operator === "+" && (
+        (isEmptyString(node.left) && !isStringType(node.right)) ||
+        (isEmptyString(node.right) && !isStringType(node.left))
+    );
+}
+
+/**
+ * Checks whether or not a node is appended with an empty string.
+ * @param {ASTNode} node An AssignmentExpression node to check.
+ * @returns {boolean} Whether or not the node is appended with an empty string.
+ */
+function isAppendEmptyString(node) {
+    return node.operator === "+=" && isEmptyString(node.right);
+}
+
+/**
+ * Returns the operand that is not an empty string from a flagged BinaryExpression.
+ * @param {ASTNode} node The flagged BinaryExpression node to check.
+ * @returns {ASTNode} The operand that is not an empty string from a flagged BinaryExpression.
+ */
+function getNonEmptyOperand(node) {
+    return isEmptyString(node.left) ? node.right : node.left;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        hasSuggestions: true,
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow shorthand type conversions",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-implicit-coercion"
+        },
+
+        fixable: "code",
+
+        schema: [{
+            type: "object",
+            properties: {
+                boolean: {
+                    type: "boolean",
+                    default: true
+                },
+                number: {
+                    type: "boolean",
+                    default: true
+                },
+                string: {
+                    type: "boolean",
+                    default: true
+                },
+                disallowTemplateShorthand: {
+                    type: "boolean",
+                    default: false
+                },
+                allow: {
+                    type: "array",
+                    items: {
+                        enum: ALLOWABLE_OPERATORS
+                    },
+                    uniqueItems: true
+                }
+            },
+            additionalProperties: false
+        }],
+
+        messages: {
+            implicitCoercion: "Unexpected implicit coercion encountered. Use `{{recommendation}}` instead.",
+            useRecommendation: "Use `{{recommendation}}` instead."
+        }
+    },
+
+    create(context) {
+        const options = parseOptions(context.options[0] || {});
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Reports an error and autofixes the node
+         * @param {ASTNode} node An ast node to report the error on.
+         * @param {string} recommendation The recommended code for the issue
+         * @param {bool} shouldSuggest Whether this report should offer a suggestion
+         * @param {bool} shouldFix Whether this report should fix the node
+         * @returns {void}
+         */
+        function report(node, recommendation, shouldSuggest, shouldFix) {
+
+            /**
+             * Fix function
+             * @param {RuleFixer} fixer The fixer to fix.
+             * @returns {Fix} The fix object.
+             */
+            function fix(fixer) {
+                const tokenBefore = sourceCode.getTokenBefore(node);
+
+                if (
+                    tokenBefore?.range[1] === node.range[0] &&
+                    !astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
+                ) {
+                    return fixer.replaceText(node, ` ${recommendation}`);
+                }
+
+                return fixer.replaceText(node, recommendation);
+            }
+
+            context.report({
+                node,
+                messageId: "implicitCoercion",
+                data: { recommendation },
+                fix(fixer) {
+                    if (!shouldFix) {
+                        return null;
+                    }
+
+                    return fix(fixer);
+                },
+                suggest: [
+                    {
+                        messageId: "useRecommendation",
+                        data: { recommendation },
+                        fix(fixer) {
+                            if (shouldFix || !shouldSuggest) {
+                                return null;
+                            }
+
+                            return fix(fixer);
+                        }
+                    }
+                ]
+            });
+        }
+
+        return {
+            UnaryExpression(node) {
+                let operatorAllowed;
+
+                // !!foo
+                operatorAllowed = options.allow.includes("!!");
+                if (!operatorAllowed && options.boolean && isDoubleLogicalNegating(node)) {
+                    const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
+                    const variable = astUtils.getVariableByName(sourceCode.getScope(node), "Boolean");
+                    const booleanExists = variable?.identifiers.length === 0;
+
+                    report(node, recommendation, true, booleanExists);
+                }
+
+                // ~foo.indexOf(bar)
+                operatorAllowed = options.allow.includes("~");
+                if (!operatorAllowed && options.boolean && isBinaryNegatingOfIndexOf(node)) {
+
+                    // `foo?.indexOf(bar) !== -1` will be true (== found) if the `foo` is nullish. So use `>= 0` in that case.
+                    const comparison = node.argument.type === "ChainExpression" ? ">= 0" : "!== -1";
+                    const recommendation = `${sourceCode.getText(node.argument)} ${comparison}`;
+
+                    report(node, recommendation, false, false);
+                }
+
+                // +foo
+                operatorAllowed = options.allow.includes("+");
+                if (!operatorAllowed && options.number && node.operator === "+" && !isNumeric(node.argument)) {
+                    const recommendation = `Number(${sourceCode.getText(node.argument)})`;
+
+                    report(node, recommendation, true, false);
+                }
+
+                // -(-foo)
+                operatorAllowed = options.allow.includes("- -");
+                if (!operatorAllowed && options.number && node.operator === "-" && node.argument.type === "UnaryExpression" && node.argument.operator === "-" && !isNumeric(node.argument.argument)) {
+                    const recommendation = `Number(${sourceCode.getText(node.argument.argument)})`;
+
+                    report(node, recommendation, true, false);
+                }
+            },
+
+            // Use `:exit` to prevent double reporting
+            "BinaryExpression:exit"(node) {
+                let operatorAllowed;
+
+                // 1 * foo
+                operatorAllowed = options.allow.includes("*");
+                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && !isMultiplyByFractionOfOne(node, sourceCode) &&
+                    getNonNumericOperand(node);
+
+                if (nonNumericOperand) {
+                    const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
+
+                    report(node, recommendation, true, false);
+                }
+
+                // foo - 0
+                operatorAllowed = options.allow.includes("-");
+                if (!operatorAllowed && options.number && node.operator === "-" && node.right.type === "Literal" && node.right.value === 0 && !isNumeric(node.left)) {
+                    const recommendation = `Number(${sourceCode.getText(node.left)})`;
+
+                    report(node, recommendation, true, false);
+                }
+
+                // "" + foo
+                operatorAllowed = options.allow.includes("+");
+                if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {
+                    const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
+
+                    report(node, recommendation, true, false);
+                }
+            },
+
+            AssignmentExpression(node) {
+
+                // foo += ""
+                const operatorAllowed = options.allow.includes("+");
+
+                if (!operatorAllowed && options.string && isAppendEmptyString(node)) {
+                    const code = sourceCode.getText(getNonEmptyOperand(node));
+                    const recommendation = `${code} = String(${code})`;
+
+                    report(node, recommendation, true, false);
+                }
+            },
+
+            TemplateLiteral(node) {
+                if (!options.disallowTemplateShorthand) {
+                    return;
+                }
+
+                // tag`${foo}`
+                if (node.parent.type === "TaggedTemplateExpression") {
+                    return;
+                }
+
+                // `` or `${foo}${bar}`
+                if (node.expressions.length !== 1) {
+                    return;
+                }
+
+
+                //  `prefix${foo}`
+                if (node.quasis[0].value.cooked !== "") {
+                    return;
+                }
+
+                //  `${foo}postfix`
+                if (node.quasis[1].value.cooked !== "") {
+                    return;
+                }
+
+                // if the expression is already a string, then this isn't a coercion
+                if (isStringType(node.expressions[0])) {
+                    return;
+                }
+
+                const code = sourceCode.getText(node.expressions[0]);
+                const recommendation = `String(${code})`;
+
+                report(node, recommendation, true, false);
+            }
+        };
+    }
+};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-implicit-globals.js

@@ -0,0 +1,146 @@
+/**
+ * @fileoverview Rule to check for implicit global variables, functions and classes.
+ * @author Joshua Peek
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow declarations in the global scope",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-implicit-globals"
+        },
+
+        schema: [{
+            type: "object",
+            properties: {
+                lexicalBindings: {
+                    type: "boolean",
+                    default: false
+                }
+            },
+            additionalProperties: false
+        }],
+
+        messages: {
+            globalNonLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.",
+            globalLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.",
+            globalVariableLeak: "Global variable leak, declare the variable if it is intended to be local.",
+            assignmentToReadonlyGlobal: "Unexpected assignment to read-only global variable.",
+            redeclarationOfReadonlyGlobal: "Unexpected redeclaration of read-only global variable."
+        }
+    },
+
+    create(context) {
+
+        const checkLexicalBindings = context.options[0] && context.options[0].lexicalBindings === true;
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Reports the node.
+         * @param {ASTNode} node Node to report.
+         * @param {string} messageId Id of the message to report.
+         * @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class.
+         * @returns {void}
+         */
+        function report(node, messageId, kind) {
+            context.report({
+                node,
+                messageId,
+                data: {
+                    kind
+                }
+            });
+        }
+
+        return {
+            Program(node) {
+                const scope = sourceCode.getScope(node);
+
+                scope.variables.forEach(variable => {
+
+                    // Only ESLint global variables have the `writable` key.
+                    const isReadonlyEslintGlobalVariable = variable.writeable === false;
+                    const isWritableEslintGlobalVariable = variable.writeable === true;
+
+                    if (isWritableEslintGlobalVariable) {
+
+                        // Everything is allowed with writable ESLint global variables.
+                        return;
+                    }
+
+                    // Variables exported by "exported" block comments
+                    if (variable.eslintExported) {
+                        return;
+                    }
+
+                    variable.defs.forEach(def => {
+                        const defNode = def.node;
+
+                        if (def.type === "FunctionName" || (def.type === "Variable" && def.parent.kind === "var")) {
+                            if (isReadonlyEslintGlobalVariable) {
+                                report(defNode, "redeclarationOfReadonlyGlobal");
+                            } else {
+                                report(
+                                    defNode,
+                                    "globalNonLexicalBinding",
+                                    def.type === "FunctionName" ? "function" : `'${def.parent.kind}'`
+                                );
+                            }
+                        }
+
+                        if (checkLexicalBindings) {
+                            if (def.type === "ClassName" ||
+                                    (def.type === "Variable" && (def.parent.kind === "let" || def.parent.kind === "const"))) {
+                                if (isReadonlyEslintGlobalVariable) {
+                                    report(defNode, "redeclarationOfReadonlyGlobal");
+                                } else {
+                                    report(
+                                        defNode,
+                                        "globalLexicalBinding",
+                                        def.type === "ClassName" ? "class" : `'${def.parent.kind}'`
+                                    );
+                                }
+                            }
+                        }
+                    });
+                });
+
+                // Undeclared assigned variables.
+                scope.implicit.variables.forEach(variable => {
+                    const scopeVariable = scope.set.get(variable.name);
+                    let messageId;
+
+                    if (scopeVariable) {
+
+                        // ESLint global variable
+                        if (scopeVariable.writeable) {
+                            return;
+                        }
+                        messageId = "assignmentToReadonlyGlobal";
+
+                    } else {
+
+                        // Reference to an unknown variable, possible global leak.
+                        messageId = "globalVariableLeak";
+                    }
+
+                    // def.node is an AssignmentExpression, ForInStatement or ForOfStatement.
+                    variable.defs.forEach(def => {
+                        report(def.node, messageId);
+                    });
+                });
+            }
+        };
+
+    }
+};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-implied-eval.js

@@ -0,0 +1,132 @@
+/**
+ * @fileoverview Rule to flag use of implied eval via setTimeout and setInterval
+ * @author James Allardice
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const { getStaticValue } = require("@eslint-community/eslint-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow the use of `eval()`-like methods",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-implied-eval"
+        },
+
+        schema: [],
+
+        messages: {
+            impliedEval: "Implied eval. Consider passing a function instead of a string."
+        }
+    },
+
+    create(context) {
+        const GLOBAL_CANDIDATES = Object.freeze(["global", "window", "globalThis"]);
+        const EVAL_LIKE_FUNC_PATTERN = /^(?:set(?:Interval|Timeout)|execScript)$/u;
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Checks whether a node is evaluated as a string or not.
+         * @param {ASTNode} node A node to check.
+         * @returns {boolean} True if the node is evaluated as a string.
+         */
+        function isEvaluatedString(node) {
+            if (
+                (node.type === "Literal" && typeof node.value === "string") ||
+                node.type === "TemplateLiteral"
+            ) {
+                return true;
+            }
+            if (node.type === "BinaryExpression" && node.operator === "+") {
+                return isEvaluatedString(node.left) || isEvaluatedString(node.right);
+            }
+            return false;
+        }
+
+        /**
+         * Reports if the `CallExpression` node has evaluated argument.
+         * @param {ASTNode} node A CallExpression to check.
+         * @returns {void}
+         */
+        function reportImpliedEvalCallExpression(node) {
+            const [firstArgument] = node.arguments;
+
+            if (firstArgument) {
+
+                const staticValue = getStaticValue(firstArgument, sourceCode.getScope(node));
+                const isStaticString = staticValue && typeof staticValue.value === "string";
+                const isString = isStaticString || isEvaluatedString(firstArgument);
+
+                if (isString) {
+                    context.report({
+                        node,
+                        messageId: "impliedEval"
+                    });
+                }
+            }
+
+        }
+
+        /**
+         * Reports calls of `implied eval` via the global references.
+         * @param {Variable} globalVar A global variable to check.
+         * @returns {void}
+         */
+        function reportImpliedEvalViaGlobal(globalVar) {
+            const { references, name } = globalVar;
+
+            references.forEach(ref => {
+                const identifier = ref.identifier;
+                let node = identifier.parent;
+
+                while (astUtils.isSpecificMemberAccess(node, null, name)) {
+                    node = node.parent;
+                }
+
+                if (astUtils.isSpecificMemberAccess(node, null, EVAL_LIKE_FUNC_PATTERN)) {
+                    const calleeNode = node.parent.type === "ChainExpression" ? node.parent : node;
+                    const parent = calleeNode.parent;
+
+                    if (parent.type === "CallExpression" && parent.callee === calleeNode) {
+                        reportImpliedEvalCallExpression(parent);
+                    }
+                }
+            });
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+            CallExpression(node) {
+                if (astUtils.isSpecificId(node.callee, EVAL_LIKE_FUNC_PATTERN)) {
+                    reportImpliedEvalCallExpression(node);
+                }
+            },
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
+
+                GLOBAL_CANDIDATES
+                    .map(candidate => astUtils.getVariableByName(globalScope, candidate))
+                    .filter(globalVar => !!globalVar && globalVar.defs.length === 0)
+                    .forEach(reportImpliedEvalViaGlobal);
+            }
+        };
+
+    }
+};