@alexlit/lint-kit 127.0.0 → 127.2.0

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

@@ -1,141 +0,0 @@
-/**
- * @fileoverview Disallow use of multiple spaces.
- * @author Nicholas C. Zakas
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Disallow multiple spaces",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-multi-spaces"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    exceptions: {
-                        type: "object",
-                        patternProperties: {
-                            "^([A-Z][a-z]*)+$": {
-                                type: "boolean"
-                            }
-                        },
-                        additionalProperties: false
-                    },
-                    ignoreEOLComments: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            multipleSpaces: "Multiple spaces found before '{{displayValue}}'."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const options = context.options[0] || {};
-        const ignoreEOLComments = options.ignoreEOLComments;
-        const exceptions = Object.assign({ Property: true }, options.exceptions);
-        const hasExceptions = Object.keys(exceptions).some(key => exceptions[key]);
-
-        /**
-         * Formats value of given comment token for error message by truncating its length.
-         * @param {Token} token comment token
-         * @returns {string} formatted value
-         * @private
-         */
-        function formatReportedCommentValue(token) {
-            const valueLines = token.value.split("\n");
-            const value = valueLines[0];
-            const formattedValue = `${value.slice(0, 12)}...`;
-
-            return valueLines.length === 1 && value.length <= 12 ? value : formattedValue;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            Program() {
-                sourceCode.tokensAndComments.forEach((leftToken, leftIndex, tokensAndComments) => {
-                    if (leftIndex === tokensAndComments.length - 1) {
-                        return;
-                    }
-                    const rightToken = tokensAndComments[leftIndex + 1];
-
-                    // Ignore tokens that don't have 2 spaces between them or are on different lines
-                    if (
-                        !sourceCode.text.slice(leftToken.range[1], rightToken.range[0]).includes("  ") ||
-                        leftToken.loc.end.line < rightToken.loc.start.line
-                    ) {
-                        return;
-                    }
-
-                    // Ignore comments that are the last token on their line if `ignoreEOLComments` is active.
-                    if (
-                        ignoreEOLComments &&
-                        astUtils.isCommentToken(rightToken) &&
-                        (
-                            leftIndex === tokensAndComments.length - 2 ||
-                            rightToken.loc.end.line < tokensAndComments[leftIndex + 2].loc.start.line
-                        )
-                    ) {
-                        return;
-                    }
-
-                    // Ignore tokens that are in a node in the "exceptions" object
-                    if (hasExceptions) {
-                        const parentNode = sourceCode.getNodeByRangeIndex(rightToken.range[0] - 1);
-
-                        if (parentNode && exceptions[parentNode.type]) {
-                            return;
-                        }
-                    }
-
-                    let displayValue;
-
-                    if (rightToken.type === "Block") {
-                        displayValue = `/*${formatReportedCommentValue(rightToken)}*/`;
-                    } else if (rightToken.type === "Line") {
-                        displayValue = `//${formatReportedCommentValue(rightToken)}`;
-                    } else {
-                        displayValue = rightToken.value;
-                    }
-
-                    context.report({
-                        node: rightToken,
-                        loc: { start: leftToken.loc.end, end: rightToken.loc.start },
-                        messageId: "multipleSpaces",
-                        data: { displayValue },
-                        fix: fixer => fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ")
-                    });
-                });
-            }
-        };
-
-    }
-};

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

@@ -1,65 +0,0 @@
-/**
- * @fileoverview Rule to flag when using multiline strings
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow multiline strings",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-multi-str"
-        },
-
-        schema: [],
-
-        messages: {
-            multilineString: "Multiline support is limited to browsers supporting ES5 only."
-        }
-    },
-
-    create(context) {
-
-        /**
-         * Determines if a given node is part of JSX syntax.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} True if the node is a JSX node, false if not.
-         * @private
-         */
-        function isJSXElement(node) {
-            return node.type.indexOf("JSX") === 0;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-
-            Literal(node) {
-                if (astUtils.LINEBREAK_MATCHER.test(node.raw) && !isJSXElement(node.parent)) {
-                    context.report({
-                        node,
-                        messageId: "multilineString"
-                    });
-                }
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-multiple-empty-lines.js

@@ -1,154 +0,0 @@
-/**
- * @fileoverview Disallows multiple blank lines.
- * implementation adapted from the no-trailing-spaces rule.
- * @author Greg Cochard
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Disallow multiple empty lines",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-multiple-empty-lines"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    max: {
-                        type: "integer",
-                        minimum: 0
-                    },
-                    maxEOF: {
-                        type: "integer",
-                        minimum: 0
-                    },
-                    maxBOF: {
-                        type: "integer",
-                        minimum: 0
-                    }
-                },
-                required: ["max"],
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            blankBeginningOfFile: "Too many blank lines at the beginning of file. Max of {{max}} allowed.",
-            blankEndOfFile: "Too many blank lines at the end of file. Max of {{max}} allowed.",
-            consecutiveBlank: "More than {{max}} blank {{pluralizedLines}} not allowed."
-        }
-    },
-
-    create(context) {
-
-        // Use options.max or 2 as default
-        let max = 2,
-            maxEOF = max,
-            maxBOF = max;
-
-        if (context.options.length) {
-            max = context.options[0].max;
-            maxEOF = typeof context.options[0].maxEOF !== "undefined" ? context.options[0].maxEOF : max;
-            maxBOF = typeof context.options[0].maxBOF !== "undefined" ? context.options[0].maxBOF : max;
-        }
-
-        const sourceCode = context.sourceCode;
-
-        // Swallow the final newline, as some editors add it automatically and we don't want it to cause an issue
-        const allLines = sourceCode.lines.at(-1) === "" ? sourceCode.lines.slice(0, -1) : sourceCode.lines;
-        const templateLiteralLines = new Set();
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            TemplateLiteral(node) {
-                node.quasis.forEach(literalPart => {
-
-                    // Empty lines have a semantic meaning if they're inside template literals. Don't count these as empty lines.
-                    for (let ignoredLine = literalPart.loc.start.line; ignoredLine < literalPart.loc.end.line; ignoredLine++) {
-                        templateLiteralLines.add(ignoredLine);
-                    }
-                });
-            },
-            "Program:exit"(node) {
-                return allLines
-
-                    // Given a list of lines, first get a list of line numbers that are non-empty.
-                    .reduce((nonEmptyLineNumbers, line, index) => {
-                        if (line.trim() || templateLiteralLines.has(index + 1)) {
-                            nonEmptyLineNumbers.push(index + 1);
-                        }
-                        return nonEmptyLineNumbers;
-                    }, [])
-
-                    // Add a value at the end to allow trailing empty lines to be checked.
-                    .concat(allLines.length + 1)
-
-                    // Given two line numbers of non-empty lines, report the lines between if the difference is too large.
-                    .reduce((lastLineNumber, lineNumber) => {
-                        let messageId, maxAllowed;
-
-                        if (lastLineNumber === 0) {
-                            messageId = "blankBeginningOfFile";
-                            maxAllowed = maxBOF;
-                        } else if (lineNumber === allLines.length + 1) {
-                            messageId = "blankEndOfFile";
-                            maxAllowed = maxEOF;
-                        } else {
-                            messageId = "consecutiveBlank";
-                            maxAllowed = max;
-                        }
-
-                        if (lineNumber - lastLineNumber - 1 > maxAllowed) {
-                            context.report({
-                                node,
-                                loc: {
-                                    start: { line: lastLineNumber + maxAllowed + 1, column: 0 },
-                                    end: { line: lineNumber, column: 0 }
-                                },
-                                messageId,
-                                data: {
-                                    max: maxAllowed,
-                                    pluralizedLines: maxAllowed === 1 ? "line" : "lines"
-                                },
-                                fix(fixer) {
-                                    const rangeStart = sourceCode.getIndexFromLoc({ line: lastLineNumber + 1, column: 0 });
-
-                                    /*
-                                     * The end of the removal range is usually the start index of the next line.
-                                     * However, at the end of the file there is no next line, so the end of the
-                                     * range is just the length of the text.
-                                     */
-                                    const lineNumberAfterRemovedLines = lineNumber - maxAllowed;
-                                    const rangeEnd = lineNumberAfterRemovedLines <= allLines.length
-                                        ? sourceCode.getIndexFromLoc({ line: lineNumberAfterRemovedLines, column: 0 })
-                                        : sourceCode.text.length;
-
-                                    return fixer.removeRange([rangeStart, rangeEnd]);
-                                }
-                            });
-                        }
-
-                        return lineNumber;
-                    }, 0);
-            }
-        };
-    }
-};

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

@@ -1,98 +0,0 @@
-/**
- * @fileoverview Rule to disallow assignments to native objects or read-only global variables
- * @author Ilya Volodin
- * @deprecated in ESLint v3.3.0
- */
-
-"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: false,
-            url: "https://eslint.org/docs/latest/rules/no-native-reassign"
-        },
-
-        deprecated: true,
-
-        replacedBy: ["no-global-assign"],
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    exceptions: {
-                        type: "array",
-                        items: { type: "string" },
-                        uniqueItems: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            nativeReassign: "Read-only global '{{name}}' should not be modified."
-        }
-    },
-
-    create(context) {
-        const config = context.options[0];
-        const exceptions = (config && config.exceptions) || [];
-        const sourceCode = context.sourceCode;
-
-        /**
-         * 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: "nativeReassign",
-                    data: identifier
-                });
-            }
-        }
-
-        /**
-         * 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);
-            }
-        };
-    }
-};

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

@@ -1,95 +0,0 @@
-/**
- * @fileoverview Rule to disallow a negated condition
- * @author Alberto Rodríguez
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow negated conditions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-negated-condition"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpectedNegated: "Unexpected negated condition."
-        }
-    },
-
-    create(context) {
-
-        /**
-         * Determines if a given node is an if-else without a condition on the else
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} True if the node has an else without an if.
-         * @private
-         */
-        function hasElseWithoutCondition(node) {
-            return node.alternate && node.alternate.type !== "IfStatement";
-        }
-
-        /**
-         * Determines if a given node is a negated unary expression
-         * @param {Object} test The test object to check.
-         * @returns {boolean} True if the node is a negated unary expression.
-         * @private
-         */
-        function isNegatedUnaryExpression(test) {
-            return test.type === "UnaryExpression" && test.operator === "!";
-        }
-
-        /**
-         * Determines if a given node is a negated binary expression
-         * @param {Test} test The test to check.
-         * @returns {boolean} True if the node is a negated binary expression.
-         * @private
-         */
-        function isNegatedBinaryExpression(test) {
-            return test.type === "BinaryExpression" &&
-                (test.operator === "!=" || test.operator === "!==");
-        }
-
-        /**
-         * Determines if a given node has a negated if expression
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} True if the node has a negated if expression.
-         * @private
-         */
-        function isNegatedIf(node) {
-            return isNegatedUnaryExpression(node.test) || isNegatedBinaryExpression(node.test);
-        }
-
-        return {
-            IfStatement(node) {
-                if (!hasElseWithoutCondition(node)) {
-                    return;
-                }
-
-                if (isNegatedIf(node)) {
-                    context.report({
-                        node,
-                        messageId: "unexpectedNegated"
-                    });
-                }
-            },
-            ConditionalExpression(node) {
-                if (isNegatedIf(node)) {
-                    context.report({
-                        node,
-                        messageId: "unexpectedNegated"
-                    });
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-negated-in-lhs.js

@@ -1,46 +0,0 @@
-/**
- * @fileoverview A rule to disallow negated left operands of the `in` operator
- * @author Michael Ficarra
- * @deprecated in ESLint v3.3.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow negating the left operand in `in` expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-negated-in-lhs"
-        },
-
-        replacedBy: ["no-unsafe-negation"],
-
-        deprecated: true,
-        schema: [],
-
-        messages: {
-            negatedLHS: "The 'in' expression's left operand is negated."
-        }
-    },
-
-    create(context) {
-
-        return {
-
-            BinaryExpression(node) {
-                if (node.operator === "in" && node.left.type === "UnaryExpression" && node.left.operator === "!") {
-                    context.report({ node, messageId: "negatedLHS" });
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,44 +0,0 @@
-/**
- * @fileoverview Rule to flag nested ternary expressions
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow nested ternary expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-nested-ternary"
-        },
-
-        schema: [],
-
-        messages: {
-            noNestedTernary: "Do not nest ternary expressions."
-        }
-    },
-
-    create(context) {
-
-        return {
-            ConditionalExpression(node) {
-                if (node.alternate.type === "ConditionalExpression" ||
-                        node.consequent.type === "ConditionalExpression") {
-                    context.report({
-                        node,
-                        messageId: "noNestedTernary"
-                    });
-                }
-            }
-        };
-    }
-};