@alexlit/lint-kit 127.0.0 → 127.2.0

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

@@ -1,147 +0,0 @@
-/**
- * @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

@@ -1,221 +0,0 @@
-/**
- * @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

@@ -1,73 +0,0 @@
-/**
- * @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

@@ -1,78 +0,0 @@
-/**
- * @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

@@ -1,95 +0,0 @@
-/**
- * @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);
-            }
-        };
-    }
-};