@alexlit/lint-kit 126.6.0 → 126.7.0

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

@@ -0,0 +1,147 @@
+/**
+ * @fileoverview Rule to flag use of unnecessary semicolons
+ * @author Nicholas C. Zakas
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const FixTracker = require("./utils/fix-tracker");
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        deprecated: true,
+        replacedBy: [],
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow unnecessary semicolons",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-extra-semi"
+        },
+
+        fixable: "code",
+        schema: [],
+
+        messages: {
+            unexpected: "Unnecessary semicolon."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Checks if a node or token is fixable.
+         * A node is fixable if it can be removed without turning a subsequent statement into a directive after fixing other nodes.
+         * @param {Token} nodeOrToken The node or token to check.
+         * @returns {boolean} Whether or not the node is fixable.
+         */
+        function isFixable(nodeOrToken) {
+            const nextToken = sourceCode.getTokenAfter(nodeOrToken);
+
+            if (!nextToken || nextToken.type !== "String") {
+                return true;
+            }
+            const stringNode = sourceCode.getNodeByRangeIndex(nextToken.range[0]);
+
+            return !astUtils.isTopLevelExpressionStatement(stringNode.parent);
+        }
+
+        /**
+         * Reports an unnecessary semicolon error.
+         * @param {Node|Token} nodeOrToken A node or a token to be reported.
+         * @returns {void}
+         */
+        function report(nodeOrToken) {
+            context.report({
+                node: nodeOrToken,
+                messageId: "unexpected",
+                fix: isFixable(nodeOrToken)
+                    ? fixer =>
+
+                        /*
+                         * Expand the replacement range to include the surrounding
+                         * tokens to avoid conflicting with semi.
+                         * https://github.com/eslint/eslint/issues/7928
+                         */
+                        new FixTracker(fixer, context.sourceCode)
+                            .retainSurroundingTokens(nodeOrToken)
+                            .remove(nodeOrToken)
+                    : null
+            });
+        }
+
+        /**
+         * Checks for a part of a class body.
+         * This checks tokens from a specified token to a next MethodDefinition or the end of class body.
+         * @param {Token} firstToken The first token to check.
+         * @returns {void}
+         */
+        function checkForPartOfClassBody(firstToken) {
+            for (let token = firstToken;
+                token.type === "Punctuator" && !astUtils.isClosingBraceToken(token);
+                token = sourceCode.getTokenAfter(token)
+            ) {
+                if (astUtils.isSemicolonToken(token)) {
+                    report(token);
+                }
+            }
+        }
+
+        return {
+
+            /**
+             * Reports this empty statement, except if the parent node is a loop.
+             * @param {Node} node A EmptyStatement node to be reported.
+             * @returns {void}
+             */
+            EmptyStatement(node) {
+                const parent = node.parent,
+                    allowedParentTypes = [
+                        "ForStatement",
+                        "ForInStatement",
+                        "ForOfStatement",
+                        "WhileStatement",
+                        "DoWhileStatement",
+                        "IfStatement",
+                        "LabeledStatement",
+                        "WithStatement"
+                    ];
+
+                if (!allowedParentTypes.includes(parent.type)) {
+                    report(node);
+                }
+            },
+
+            /**
+             * Checks tokens from the head of this class body to the first MethodDefinition or the end of this class body.
+             * @param {Node} node A ClassBody node to check.
+             * @returns {void}
+             */
+            ClassBody(node) {
+                checkForPartOfClassBody(sourceCode.getFirstToken(node, 1)); // 0 is `{`.
+            },
+
+            /**
+             * Checks tokens from this MethodDefinition to the next MethodDefinition or the end of this class body.
+             * @param {Node} node A MethodDefinition node of the start point.
+             * @returns {void}
+             */
+            "MethodDefinition, PropertyDefinition, StaticBlock"(node) {
+                checkForPartOfClassBody(sourceCode.getTokenAfter(node));
+            }
+        };
+
+    }
+};

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

@@ -0,0 +1,221 @@
+/**
+ * @fileoverview Rule to flag fall-through cases in switch statements.
+ * @author Matt DuVall <http://mattduvall.com/>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { directivesPattern } = require("../shared/directives");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu;
+
+/**
+ * Checks all segments in a set and returns true if any are reachable.
+ * @param {Set<CodePathSegment>} segments The segments to check.
+ * @returns {boolean} True if any segment is reachable; false otherwise.
+ */
+function isAnySegmentReachable(segments) {
+
+    for (const segment of segments) {
+        if (segment.reachable) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Checks whether or not a given comment string is really a fallthrough comment and not an ESLint directive.
+ * @param {string} comment The comment string to check.
+ * @param {RegExp} fallthroughCommentPattern The regular expression used for checking for fallthrough comments.
+ * @returns {boolean} `true` if the comment string is truly a fallthrough comment.
+ */
+function isFallThroughComment(comment, fallthroughCommentPattern) {
+    return fallthroughCommentPattern.test(comment) && !directivesPattern.test(comment.trim());
+}
+
+/**
+ * Checks whether or not a given case has a fallthrough comment.
+ * @param {ASTNode} caseWhichFallsThrough SwitchCase node which falls through.
+ * @param {ASTNode} subsequentCase The case after caseWhichFallsThrough.
+ * @param {RuleContext} context A rule context which stores comments.
+ * @param {RegExp} fallthroughCommentPattern A pattern to match comment to.
+ * @returns {null | object} the comment if the case has a valid fallthrough comment, otherwise null
+ */
+function getFallthroughComment(caseWhichFallsThrough, subsequentCase, context, fallthroughCommentPattern) {
+    const sourceCode = context.sourceCode;
+
+    if (caseWhichFallsThrough.consequent.length === 1 && caseWhichFallsThrough.consequent[0].type === "BlockStatement") {
+        const trailingCloseBrace = sourceCode.getLastToken(caseWhichFallsThrough.consequent[0]);
+        const commentInBlock = sourceCode.getCommentsBefore(trailingCloseBrace).pop();
+
+        if (commentInBlock && isFallThroughComment(commentInBlock.value, fallthroughCommentPattern)) {
+            return commentInBlock;
+        }
+    }
+
+    const comment = sourceCode.getCommentsBefore(subsequentCase).pop();
+
+    if (comment && isFallThroughComment(comment.value, fallthroughCommentPattern)) {
+        return comment;
+    }
+
+    return null;
+}
+
+/**
+ * Checks whether a node and a token are separated by blank lines
+ * @param {ASTNode} node The node to check
+ * @param {Token} token The token to compare against
+ * @returns {boolean} `true` if there are blank lines between node and token
+ */
+function hasBlankLinesBetween(node, token) {
+    return token.loc.start.line > node.loc.end.line + 1;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "Disallow fallthrough of `case` statements",
+            recommended: true,
+            url: "https://eslint.org/docs/latest/rules/no-fallthrough"
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    commentPattern: {
+                        type: "string",
+                        default: ""
+                    },
+                    allowEmptyCase: {
+                        type: "boolean",
+                        default: false
+                    },
+                    reportUnusedFallthroughComment: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+        messages: {
+            unusedFallthroughComment: "Found a comment that would permit fallthrough, but case cannot fall through.",
+            case: "Expected a 'break' statement before 'case'.",
+            default: "Expected a 'break' statement before 'default'."
+        }
+    },
+
+    create(context) {
+        const options = context.options[0] || {};
+        const codePathSegments = [];
+        let currentCodePathSegments = new Set();
+        const sourceCode = context.sourceCode;
+        const allowEmptyCase = options.allowEmptyCase || false;
+        const reportUnusedFallthroughComment = options.reportUnusedFallthroughComment || false;
+
+        /*
+         * We need to use leading comments of the next SwitchCase node because
+         * trailing comments is wrong if semicolons are omitted.
+         */
+        let previousCase = null;
+        let fallthroughCommentPattern = null;
+
+        if (options.commentPattern) {
+            fallthroughCommentPattern = new RegExp(options.commentPattern, "u");
+        } else {
+            fallthroughCommentPattern = DEFAULT_FALLTHROUGH_COMMENT;
+        }
+        return {
+
+            onCodePathStart() {
+                codePathSegments.push(currentCodePathSegments);
+                currentCodePathSegments = new Set();
+            },
+
+            onCodePathEnd() {
+                currentCodePathSegments = codePathSegments.pop();
+            },
+
+            onUnreachableCodePathSegmentStart(segment) {
+                currentCodePathSegments.add(segment);
+            },
+
+            onUnreachableCodePathSegmentEnd(segment) {
+                currentCodePathSegments.delete(segment);
+            },
+
+            onCodePathSegmentStart(segment) {
+                currentCodePathSegments.add(segment);
+            },
+
+            onCodePathSegmentEnd(segment) {
+                currentCodePathSegments.delete(segment);
+            },
+
+
+            SwitchCase(node) {
+
+                /*
+                 * Checks whether or not there is a fallthrough comment.
+                 * And reports the previous fallthrough node if that does not exist.
+                 */
+
+                if (previousCase && previousCase.node.parent === node.parent) {
+                    const previousCaseFallthroughComment = getFallthroughComment(previousCase.node, node, context, fallthroughCommentPattern);
+
+                    if (previousCase.isFallthrough && !(previousCaseFallthroughComment)) {
+                        context.report({
+                            messageId: node.test ? "case" : "default",
+                            node
+                        });
+                    } else if (reportUnusedFallthroughComment && !previousCase.isSwitchExitReachable && previousCaseFallthroughComment) {
+                        context.report({
+                            messageId: "unusedFallthroughComment",
+                            node: previousCaseFallthroughComment
+                        });
+                    }
+
+                }
+                previousCase = null;
+            },
+
+            "SwitchCase:exit"(node) {
+                const nextToken = sourceCode.getTokenAfter(node);
+
+                /*
+                 * `reachable` meant fall through because statements preceded by
+                 * `break`, `return`, or `throw` are unreachable.
+                 * And allows empty cases and the last case.
+                 */
+                const isSwitchExitReachable = isAnySegmentReachable(currentCodePathSegments);
+                const isFallthrough = isSwitchExitReachable && (node.consequent.length > 0 || (!allowEmptyCase && hasBlankLinesBetween(node, nextToken))) &&
+                    node.parent.cases.at(-1) !== node;
+
+                previousCase = {
+                    node,
+                    isSwitchExitReachable,
+                    isFallthrough
+                };
+
+            }
+        };
+    }
+};

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

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Rule to flag use of a leading/trailing decimal point in a numeric literal
+ * @author James Allardice
+ * @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: "suggestion",
+
+        docs: {
+            description: "Disallow leading or trailing decimal points in numeric literals",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-floating-decimal"
+        },
+
+        schema: [],
+        fixable: "code",
+        messages: {
+            leading: "A leading decimal point can be confused with a dot.",
+            trailing: "A trailing decimal point can be confused with a dot."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode;
+
+        return {
+            Literal(node) {
+
+                if (typeof node.value === "number") {
+                    if (node.raw.startsWith(".")) {
+                        context.report({
+                            node,
+                            messageId: "leading",
+                            fix(fixer) {
+                                const tokenBefore = sourceCode.getTokenBefore(node);
+                                const needsSpaceBefore = tokenBefore &&
+                                    tokenBefore.range[1] === node.range[0] &&
+                                    !astUtils.canTokensBeAdjacent(tokenBefore, `0${node.raw}`);
+
+                                return fixer.insertTextBefore(node, needsSpaceBefore ? " 0" : "0");
+                            }
+                        });
+                    }
+                    if (node.raw.indexOf(".") === node.raw.length - 1) {
+                        context.report({
+                            node,
+                            messageId: "trailing",
+                            fix: fixer => fixer.insertTextAfter(node, "0")
+                        });
+                    }
+                }
+            }
+        };
+
+    }
+};

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

@@ -0,0 +1,78 @@
+/**
+ * @fileoverview Rule to flag use of function declaration identifiers as variables.
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "Disallow reassigning `function` declarations",
+            recommended: true,
+            url: "https://eslint.org/docs/latest/rules/no-func-assign"
+        },
+
+        schema: [],
+
+        messages: {
+            isAFunction: "'{{name}}' is a function."
+        }
+    },
+
+    create(context) {
+
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Reports a reference if is non initializer and writable.
+         * @param {References} references Collection of reference to check.
+         * @returns {void}
+         */
+        function checkReference(references) {
+            astUtils.getModifyingReferences(references).forEach(reference => {
+                context.report({
+                    node: reference.identifier,
+                    messageId: "isAFunction",
+                    data: {
+                        name: reference.identifier.name
+                    }
+                });
+            });
+        }
+
+        /**
+         * Finds and reports references that are non initializer and writable.
+         * @param {Variable} variable A variable to check.
+         * @returns {void}
+         */
+        function checkVariable(variable) {
+            if (variable.defs[0].type === "FunctionName") {
+                checkReference(variable.references);
+            }
+        }
+
+        /**
+         * Checks parameters of a given function node.
+         * @param {ASTNode} node A function node to check.
+         * @returns {void}
+         */
+        function checkForFunction(node) {
+            sourceCode.getDeclaredVariables(node).forEach(checkVariable);
+        }
+
+        return {
+            FunctionDeclaration: checkForFunction,
+            FunctionExpression: checkForFunction
+        };
+    }
+};

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

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Rule to disallow assignments to native objects or read-only global variables
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow assignments to native objects or read-only global variables",
+            recommended: true,
+            url: "https://eslint.org/docs/latest/rules/no-global-assign"
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    exceptions: {
+                        type: "array",
+                        items: { type: "string" },
+                        uniqueItems: true
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            globalShouldNotBeModified: "Read-only global '{{name}}' should not be modified."
+        }
+    },
+
+    create(context) {
+        const config = context.options[0];
+        const sourceCode = context.sourceCode;
+        const exceptions = (config && config.exceptions) || [];
+
+        /**
+         * Reports write references.
+         * @param {Reference} reference A reference to check.
+         * @param {int} index The index of the reference in the references.
+         * @param {Reference[]} references The array that the reference belongs to.
+         * @returns {void}
+         */
+        function checkReference(reference, index, references) {
+            const identifier = reference.identifier;
+
+            if (reference.init === false &&
+                reference.isWrite() &&
+
+                /*
+                 * Destructuring assignments can have multiple default value,
+                 * so possibly there are multiple writeable references for the same identifier.
+                 */
+                (index === 0 || references[index - 1].identifier !== identifier)
+            ) {
+                context.report({
+                    node: identifier,
+                    messageId: "globalShouldNotBeModified",
+                    data: {
+                        name: identifier.name
+                    }
+                });
+            }
+        }
+
+        /**
+         * Reports write references if a given variable is read-only builtin.
+         * @param {Variable} variable A variable to check.
+         * @returns {void}
+         */
+        function checkVariable(variable) {
+            if (variable.writeable === false && !exceptions.includes(variable.name)) {
+                variable.references.forEach(checkReference);
+            }
+        }
+
+        return {
+            Program(node) {
+                const globalScope = sourceCode.getScope(node);
+
+                globalScope.variables.forEach(checkVariable);
+            }
+        };
+    }
+};