@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-script-url.js

@@ -1,61 +0,0 @@
-/**
- * @fileoverview Rule to flag when using javascript: urls
- * @author Ilya Volodin
- */
-/* eslint no-script-url: 0 -- Code is checking to report such URLs */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `javascript:` urls",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-script-url"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpectedScriptURL: "Script URL is a form of eval."
-        }
-    },
-
-    create(context) {
-
-        /**
-         * Check whether a node's static value starts with "javascript:" or not.
-         * And report an error for unexpected script URL.
-         * @param {ASTNode} node node to check
-         * @returns {void}
-         */
-        function check(node) {
-            const value = astUtils.getStaticStringValue(node);
-
-            if (typeof value === "string" && value.toLowerCase().indexOf("javascript:") === 0) {
-                context.report({ node, messageId: "unexpectedScriptURL" });
-            }
-        }
-        return {
-            Literal(node) {
-                if (node.value && typeof node.value === "string") {
-                    check(node);
-                }
-            },
-            TemplateLiteral(node) {
-                if (!(node.parent && node.parent.type === "TaggedTemplateExpression")) {
-                    check(node);
-                }
-            }
-        };
-    }
-};

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

@@ -1,183 +0,0 @@
-/**
- * @fileoverview Rule to disallow assignments where both sides are exactly the same
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const SPACES = /\s+/gu;
-
-/**
- * Traverses 2 Pattern nodes in parallel, then reports self-assignments.
- * @param {ASTNode|null} left A left node to traverse. This is a Pattern or
- *      a Property.
- * @param {ASTNode|null} right A right node to traverse. This is a Pattern or
- *      a Property.
- * @param {boolean} props The flag to check member expressions as well.
- * @param {Function} report A callback function to report.
- * @returns {void}
- */
-function eachSelfAssignment(left, right, props, report) {
-    if (!left || !right) {
-
-        // do nothing
-    } else if (
-        left.type === "Identifier" &&
-        right.type === "Identifier" &&
-        left.name === right.name
-    ) {
-        report(right);
-    } else if (
-        left.type === "ArrayPattern" &&
-        right.type === "ArrayExpression"
-    ) {
-        const end = Math.min(left.elements.length, right.elements.length);
-
-        for (let i = 0; i < end; ++i) {
-            const leftElement = left.elements[i];
-            const rightElement = right.elements[i];
-
-            // Avoid cases such as [...a] = [...a, 1]
-            if (
-                leftElement &&
-                leftElement.type === "RestElement" &&
-                i < right.elements.length - 1
-            ) {
-                break;
-            }
-
-            eachSelfAssignment(leftElement, rightElement, props, report);
-
-            // After a spread element, those indices are unknown.
-            if (rightElement && rightElement.type === "SpreadElement") {
-                break;
-            }
-        }
-    } else if (
-        left.type === "RestElement" &&
-        right.type === "SpreadElement"
-    ) {
-        eachSelfAssignment(left.argument, right.argument, props, report);
-    } else if (
-        left.type === "ObjectPattern" &&
-        right.type === "ObjectExpression" &&
-        right.properties.length >= 1
-    ) {
-
-        /*
-         * Gets the index of the last spread property.
-         * It's possible to overwrite properties followed by it.
-         */
-        let startJ = 0;
-
-        for (let i = right.properties.length - 1; i >= 0; --i) {
-            const propType = right.properties[i].type;
-
-            if (propType === "SpreadElement" || propType === "ExperimentalSpreadProperty") {
-                startJ = i + 1;
-                break;
-            }
-        }
-
-        for (let i = 0; i < left.properties.length; ++i) {
-            for (let j = startJ; j < right.properties.length; ++j) {
-                eachSelfAssignment(
-                    left.properties[i],
-                    right.properties[j],
-                    props,
-                    report
-                );
-            }
-        }
-    } else if (
-        left.type === "Property" &&
-        right.type === "Property" &&
-        right.kind === "init" &&
-        !right.method
-    ) {
-        const leftName = astUtils.getStaticPropertyName(left);
-
-        if (leftName !== null && leftName === astUtils.getStaticPropertyName(right)) {
-            eachSelfAssignment(left.value, right.value, props, report);
-        }
-    } else if (
-        props &&
-        astUtils.skipChainExpression(left).type === "MemberExpression" &&
-        astUtils.skipChainExpression(right).type === "MemberExpression" &&
-        astUtils.isSameReference(left, right)
-    ) {
-        report(right);
-    }
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow assignments where both sides are exactly the same",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-self-assign"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    props: {
-                        type: "boolean",
-                        default: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            selfAssignment: "'{{name}}' is assigned to itself."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const [{ props = true } = {}] = context.options;
-
-        /**
-         * Reports a given node as self assignments.
-         * @param {ASTNode} node A node to report. This is an Identifier node.
-         * @returns {void}
-         */
-        function report(node) {
-            context.report({
-                node,
-                messageId: "selfAssignment",
-                data: {
-                    name: sourceCode.getText(node).replace(SPACES, "")
-                }
-            });
-        }
-
-        return {
-            AssignmentExpression(node) {
-                if (["=", "&&=", "||=", "??="].includes(node.operator)) {
-                    eachSelfAssignment(node.left, node.right, props, report);
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-self-compare.js

@@ -1,60 +0,0 @@
-/**
- * @fileoverview Rule to flag comparison where left part is the same as the right
- * part.
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow comparisons where both sides are exactly the same",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-self-compare"
-        },
-
-        schema: [],
-
-        messages: {
-            comparingToSelf: "Comparing to itself is potentially pointless."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Determines whether two nodes are composed of the same tokens.
-         * @param {ASTNode} nodeA The first node
-         * @param {ASTNode} nodeB The second node
-         * @returns {boolean} true if the nodes have identical token representations
-         */
-        function hasSameTokens(nodeA, nodeB) {
-            const tokensA = sourceCode.getTokens(nodeA);
-            const tokensB = sourceCode.getTokens(nodeB);
-
-            return tokensA.length === tokensB.length &&
-                tokensA.every((token, index) => token.type === tokensB[index].type && token.value === tokensB[index].value);
-        }
-
-        return {
-
-            BinaryExpression(node) {
-                const operators = new Set(["===", "==", "!==", "!=", ">", "<", ">=", "<="]);
-
-                if (operators.has(node.operator) && hasSameTokens(node.left, node.right)) {
-                    context.report({ node, messageId: "comparingToSelf" });
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,139 +0,0 @@
-/**
- * @fileoverview Rule to flag use of comma operator
- * @author Brandon Mills
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const DEFAULT_OPTIONS = {
-    allowInParentheses: true
-};
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow comma operators",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-sequences"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                allowInParentheses: {
-                    type: "boolean",
-                    default: true
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            unexpectedCommaExpression: "Unexpected use of comma operator."
-        }
-    },
-
-    create(context) {
-        const options = Object.assign({}, DEFAULT_OPTIONS, context.options[0]);
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Parts of the grammar that are required to have parens.
-         */
-        const parenthesized = {
-            DoWhileStatement: "test",
-            IfStatement: "test",
-            SwitchStatement: "discriminant",
-            WhileStatement: "test",
-            WithStatement: "object",
-            ArrowFunctionExpression: "body"
-
-            /*
-             * Omitting CallExpression - commas are parsed as argument separators
-             * Omitting NewExpression - commas are parsed as argument separators
-             * Omitting ForInStatement - parts aren't individually parenthesised
-             * Omitting ForStatement - parts aren't individually parenthesised
-             */
-        };
-
-        /**
-         * Determines whether a node is required by the grammar to be wrapped in
-         * parens, e.g. the test of an if statement.
-         * @param {ASTNode} node The AST node
-         * @returns {boolean} True if parens around node belong to parent node.
-         */
-        function requiresExtraParens(node) {
-            return node.parent && parenthesized[node.parent.type] &&
-                    node === node.parent[parenthesized[node.parent.type]];
-        }
-
-        /**
-         * Check if a node is wrapped in parens.
-         * @param {ASTNode} node The AST node
-         * @returns {boolean} True if the node has a paren on each side.
-         */
-        function isParenthesised(node) {
-            return astUtils.isParenthesised(sourceCode, node);
-        }
-
-        /**
-         * Check if a node is wrapped in two levels of parens.
-         * @param {ASTNode} node The AST node
-         * @returns {boolean} True if two parens surround the node on each side.
-         */
-        function isParenthesisedTwice(node) {
-            const previousToken = sourceCode.getTokenBefore(node, 1),
-                nextToken = sourceCode.getTokenAfter(node, 1);
-
-            return isParenthesised(node) && previousToken && nextToken &&
-                astUtils.isOpeningParenToken(previousToken) && previousToken.range[1] <= node.range[0] &&
-                astUtils.isClosingParenToken(nextToken) && nextToken.range[0] >= node.range[1];
-        }
-
-        return {
-            SequenceExpression(node) {
-
-                // Always allow sequences in for statement update
-                if (node.parent.type === "ForStatement" &&
-                        (node === node.parent.init || node === node.parent.update)) {
-                    return;
-                }
-
-                // Wrapping a sequence in extra parens indicates intent
-                if (options.allowInParentheses) {
-                    if (requiresExtraParens(node)) {
-                        if (isParenthesisedTwice(node)) {
-                            return;
-                        }
-                    } else {
-                        if (isParenthesised(node)) {
-                            return;
-                        }
-                    }
-                }
-
-                const firstCommaToken = sourceCode.getTokenAfter(node.expressions[0], astUtils.isCommaToken);
-
-                context.report({ node, loc: firstCommaToken.loc, messageId: "unexpectedCommaExpression" });
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-setter-return.js

@@ -1,226 +0,0 @@
-/**
- * @fileoverview Rule to disallow returning values from setters
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const { findVariable } = require("@eslint-community/eslint-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines whether the given identifier node is a reference to a global variable.
- * @param {ASTNode} node `Identifier` node to check.
- * @param {Scope} scope Scope to which the node belongs.
- * @returns {boolean} True if the identifier is a reference to a global variable.
- */
-function isGlobalReference(node, scope) {
-    const variable = findVariable(scope, node);
-
-    return variable !== null && variable.scope.type === "global" && variable.defs.length === 0;
-}
-
-/**
- * Determines whether the given node is an argument of the specified global method call, at the given `index` position.
- * E.g., for given `index === 1`, this function checks for `objectName.methodName(foo, node)`, where objectName is a global variable.
- * @param {ASTNode} node The node to check.
- * @param {Scope} scope Scope to which the node belongs.
- * @param {string} objectName Name of the global object.
- * @param {string} methodName Name of the method.
- * @param {number} index The given position.
- * @returns {boolean} `true` if the node is argument at the given position.
- */
-function isArgumentOfGlobalMethodCall(node, scope, objectName, methodName, index) {
-    const callNode = node.parent;
-
-    return callNode.type === "CallExpression" &&
-        callNode.arguments[index] === node &&
-        astUtils.isSpecificMemberAccess(callNode.callee, objectName, methodName) &&
-        isGlobalReference(astUtils.skipChainExpression(callNode.callee).object, scope);
-}
-
-/**
- * Determines whether the given node is used as a property descriptor.
- * @param {ASTNode} node The node to check.
- * @param {Scope} scope Scope to which the node belongs.
- * @returns {boolean} `true` if the node is a property descriptor.
- */
-function isPropertyDescriptor(node, scope) {
-    if (
-        isArgumentOfGlobalMethodCall(node, scope, "Object", "defineProperty", 2) ||
-        isArgumentOfGlobalMethodCall(node, scope, "Reflect", "defineProperty", 2)
-    ) {
-        return true;
-    }
-
-    const parent = node.parent;
-
-    if (
-        parent.type === "Property" &&
-        parent.value === node
-    ) {
-        const grandparent = parent.parent;
-
-        if (
-            grandparent.type === "ObjectExpression" &&
-            (
-                isArgumentOfGlobalMethodCall(grandparent, scope, "Object", "create", 1) ||
-                isArgumentOfGlobalMethodCall(grandparent, scope, "Object", "defineProperties", 1)
-            )
-        ) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/**
- * Determines whether the given function node is used as a setter function.
- * @param {ASTNode} node The node to check.
- * @param {Scope} scope Scope to which the node belongs.
- * @returns {boolean} `true` if the node is a setter.
- */
-function isSetter(node, scope) {
-    const parent = node.parent;
-
-    if (
-        (parent.type === "Property" || parent.type === "MethodDefinition") &&
-        parent.kind === "set" &&
-        parent.value === node
-    ) {
-
-        // Setter in an object literal or in a class
-        return true;
-    }
-
-    if (
-        parent.type === "Property" &&
-        parent.value === node &&
-        astUtils.getStaticPropertyName(parent) === "set" &&
-        parent.parent.type === "ObjectExpression" &&
-        isPropertyDescriptor(parent.parent, scope)
-    ) {
-
-        // Setter in a property descriptor
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * Finds function's outer scope.
- * @param {Scope} scope Function's own scope.
- * @returns {Scope} Function's outer scope.
- */
-function getOuterScope(scope) {
-    const upper = scope.upper;
-
-    if (upper.type === "function-expression-name") {
-        return upper.upper;
-    }
-
-    return upper;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow returning values from setters",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-setter-return"
-        },
-
-        schema: [],
-
-        messages: {
-            returnsValue: "Setter cannot return a value."
-        }
-    },
-
-    create(context) {
-        let funcInfo = null;
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Creates and pushes to the stack a function info object for the given function node.
-         * @param {ASTNode} node The function node.
-         * @returns {void}
-         */
-        function enterFunction(node) {
-            const outerScope = getOuterScope(sourceCode.getScope(node));
-
-            funcInfo = {
-                upper: funcInfo,
-                isSetter: isSetter(node, outerScope)
-            };
-        }
-
-        /**
-         * Pops the current function info object from the stack.
-         * @returns {void}
-         */
-        function exitFunction() {
-            funcInfo = funcInfo.upper;
-        }
-
-        /**
-         * Reports the given node.
-         * @param {ASTNode} node Node to report.
-         * @returns {void}
-         */
-        function report(node) {
-            context.report({ node, messageId: "returnsValue" });
-        }
-
-        return {
-
-            /*
-             * Function declarations cannot be setters, but we still have to track them in the `funcInfo` stack to avoid
-             * false positives, because a ReturnStatement node can belong to a function declaration inside a setter.
-             *
-             * Note: A previously declared function can be referenced and actually used as a setter in a property descriptor,
-             * but that's out of scope for this rule.
-             */
-            FunctionDeclaration: enterFunction,
-            FunctionExpression: enterFunction,
-            ArrowFunctionExpression(node) {
-                enterFunction(node);
-
-                if (funcInfo.isSetter && node.expression) {
-
-                    // { set: foo => bar } property descriptor. Report implicit return 'bar' as the equivalent for a return statement.
-                    report(node.body);
-                }
-            },
-
-            "FunctionDeclaration:exit": exitFunction,
-            "FunctionExpression:exit": exitFunction,
-            "ArrowFunctionExpression:exit": exitFunction,
-
-            ReturnStatement(node) {
-
-                // Global returns (e.g., at the top level of a Node module) don't have `funcInfo`.
-                if (funcInfo && funcInfo.isSetter && node.argument) {
-                    report(node);
-                }
-            }
-        };
-    }
-};