@alexlit/lint-kit 127.0.0 → 127.2.0

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

@@ -1,64 +0,0 @@
-/**
- * @fileoverview Rule to disallow use of void operator.
- * @author Mike Sidorov
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `void` operators",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-void"
-        },
-
-        messages: {
-            noVoid: "Expected 'undefined' and instead saw 'void'."
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowAsStatement: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ]
-    },
-
-    create(context) {
-        const allowAsStatement =
-            context.options[0] && context.options[0].allowAsStatement;
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            'UnaryExpression[operator="void"]'(node) {
-                if (
-                    allowAsStatement &&
-                    node.parent &&
-                    node.parent.type === "ExpressionStatement"
-                ) {
-                    return;
-                }
-                context.report({
-                    node,
-                    messageId: "noVoid"
-                });
-            }
-        };
-    }
-};

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

@@ -1,201 +0,0 @@
-/**
- * @fileoverview Rule that warns about used warning comments
- * @author Alexander Schmidt <https://github.com/lxanders>
- */
-
-"use strict";
-
-const escapeRegExp = require("escape-string-regexp");
-const astUtils = require("./utils/ast-utils");
-
-const CHAR_LIMIT = 40;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow specified warning terms in comments",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-warning-comments"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    terms: {
-                        type: "array",
-                        items: {
-                            type: "string"
-                        }
-                    },
-                    location: {
-                        enum: ["start", "anywhere"]
-                    },
-                    decoration: {
-                        type: "array",
-                        items: {
-                            type: "string",
-                            pattern: "^\\S$"
-                        },
-                        minItems: 1,
-                        uniqueItems: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpectedComment: "Unexpected '{{matchedTerm}}' comment: '{{comment}}'."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode,
-            configuration = context.options[0] || {},
-            warningTerms = configuration.terms || ["todo", "fixme", "xxx"],
-            location = configuration.location || "start",
-            decoration = [...configuration.decoration || []].join(""),
-            selfConfigRegEx = /\bno-warning-comments\b/u;
-
-        /**
-         * Convert a warning term into a RegExp which will match a comment containing that whole word in the specified
-         * location ("start" or "anywhere"). If the term starts or ends with non word characters, then the match will not
-         * require word boundaries on that side.
-         * @param {string} term A term to convert to a RegExp
-         * @returns {RegExp} The term converted to a RegExp
-         */
-        function convertToRegExp(term) {
-            const escaped = escapeRegExp(term);
-            const escapedDecoration = escapeRegExp(decoration);
-
-            /*
-             * When matching at the start, ignore leading whitespace, and
-             * there's no need to worry about word boundaries.
-             *
-             * These expressions for the prefix and suffix are designed as follows:
-             * ^   handles any terms at the beginning of a comment.
-             *     e.g. terms ["TODO"] matches `//TODO something`
-             * $   handles any terms at the end of a comment
-             *     e.g. terms ["TODO"] matches `// something TODO`
-             * \b  handles terms preceded/followed by word boundary
-             *     e.g. terms: ["!FIX", "FIX!"] matches `// FIX!something` or `// something!FIX`
-             *          terms: ["FIX"] matches `// FIX!` or `// !FIX`, but not `// fixed or affix`
-             *
-             * For location start:
-             * [\s]* handles optional leading spaces
-             *     e.g. terms ["TODO"] matches `//    TODO something`
-             * [\s\*]* (where "\*" is the escaped string of decoration)
-             *     handles optional leading spaces or decoration characters (for "start" location only)
-             *     e.g. terms ["TODO"] matches `/**** TODO something ... `
-             */
-            const wordBoundary = "\\b";
-
-            let prefix = "";
-
-            if (location === "start") {
-                prefix = `^[\\s${escapedDecoration}]*`;
-            } else if (/^\w/u.test(term)) {
-                prefix = wordBoundary;
-            }
-
-            const suffix = /\w$/u.test(term) ? wordBoundary : "";
-            const flags = "iu"; // Case-insensitive with Unicode case folding.
-
-            /*
-             * For location "start", the typical regex is:
-             *   /^[\s]*ESCAPED_TERM\b/iu.
-             * Or if decoration characters are specified (e.g. "*"), then any of
-             * those characters may appear in any order at the start:
-             *   /^[\s\*]*ESCAPED_TERM\b/iu.
-             *
-             * For location "anywhere" the typical regex is
-             *   /\bESCAPED_TERM\b/iu
-             *
-             * If it starts or ends with non-word character, the prefix and suffix are empty, respectively.
-             */
-            return new RegExp(`${prefix}${escaped}${suffix}`, flags);
-        }
-
-        const warningRegExps = warningTerms.map(convertToRegExp);
-
-        /**
-         * Checks the specified comment for matches of the configured warning terms and returns the matches.
-         * @param {string} comment The comment which is checked.
-         * @returns {Array} All matched warning terms for this comment.
-         */
-        function commentContainsWarningTerm(comment) {
-            const matches = [];
-
-            warningRegExps.forEach((regex, index) => {
-                if (regex.test(comment)) {
-                    matches.push(warningTerms[index]);
-                }
-            });
-
-            return matches;
-        }
-
-        /**
-         * Checks the specified node for matching warning comments and reports them.
-         * @param {ASTNode} node The AST node being checked.
-         * @returns {void} undefined.
-         */
-        function checkComment(node) {
-            const comment = node.value;
-
-            if (
-                astUtils.isDirectiveComment(node) &&
-                selfConfigRegEx.test(comment)
-            ) {
-                return;
-            }
-
-            const matches = commentContainsWarningTerm(comment);
-
-            matches.forEach(matchedTerm => {
-                let commentToDisplay = "";
-                let truncated = false;
-
-                for (const c of comment.trim().split(/\s+/u)) {
-                    const tmp = commentToDisplay ? `${commentToDisplay} ${c}` : c;
-
-                    if (tmp.length <= CHAR_LIMIT) {
-                        commentToDisplay = tmp;
-                    } else {
-                        truncated = true;
-                        break;
-                    }
-                }
-
-                context.report({
-                    node,
-                    messageId: "unexpectedComment",
-                    data: {
-                        matchedTerm,
-                        comment: `${commentToDisplay}${
-                            truncated ? "..." : ""
-                        }`
-                    }
-                });
-            });
-        }
-
-        return {
-            Program() {
-                const comments = sourceCode.getAllComments();
-
-                comments
-                    .filter(token => token.type !== "Shebang")
-                    .forEach(checkComment);
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-whitespace-before-property.js

@@ -1,116 +0,0 @@
-/**
- * @fileoverview Rule to disallow whitespace before properties
- * @author Kai Cataldo
- * @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: "layout",
-
-        docs: {
-            description: "Disallow whitespace before properties",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-whitespace-before-property"
-        },
-
-        fixable: "whitespace",
-        schema: [],
-
-        messages: {
-            unexpectedWhitespace: "Unexpected whitespace before property {{propName}}."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Reports whitespace before property token
-         * @param {ASTNode} node the node to report in the event of an error
-         * @param {Token} leftToken the left token
-         * @param {Token} rightToken the right token
-         * @returns {void}
-         * @private
-         */
-        function reportError(node, leftToken, rightToken) {
-            context.report({
-                node,
-                messageId: "unexpectedWhitespace",
-                data: {
-                    propName: sourceCode.getText(node.property)
-                },
-                fix(fixer) {
-                    let replacementText = "";
-
-                    if (!node.computed && !node.optional && astUtils.isDecimalInteger(node.object)) {
-
-                        /*
-                         * If the object is a number literal, fixing it to something like 5.toString() would cause a SyntaxError.
-                         * Don't fix this case.
-                         */
-                        return null;
-                    }
-
-                    // Don't fix if comments exist.
-                    if (sourceCode.commentsExistBetween(leftToken, rightToken)) {
-                        return null;
-                    }
-
-                    if (node.optional) {
-                        replacementText = "?.";
-                    } else if (!node.computed) {
-                        replacementText = ".";
-                    }
-
-                    return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], replacementText);
-                }
-            });
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            MemberExpression(node) {
-                let rightToken;
-                let leftToken;
-
-                if (!astUtils.isTokenOnSameLine(node.object, node.property)) {
-                    return;
-                }
-
-                if (node.computed) {
-                    rightToken = sourceCode.getTokenBefore(node.property, astUtils.isOpeningBracketToken);
-                    leftToken = sourceCode.getTokenBefore(rightToken, node.optional ? 1 : 0);
-                } else {
-                    rightToken = sourceCode.getFirstToken(node.property);
-                    leftToken = sourceCode.getTokenBefore(rightToken, 1);
-                }
-
-                if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken)) {
-                    reportError(node, leftToken, rightToken);
-                }
-            }
-        };
-    }
-};

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

@@ -1,39 +0,0 @@
-/**
- * @fileoverview Rule to flag use of with statement
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `with` statements",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-with"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpectedWith: "Unexpected use of 'with' statement."
-        }
-    },
-
-    create(context) {
-
-        return {
-            WithStatement(node) {
-                context.report({ node, messageId: "unexpectedWith" });
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/nonblock-statement-body-position.js

@@ -1,127 +0,0 @@
-/**
- * @fileoverview enforce the location of single-line statements
- * @author Teddy Katz
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const POSITION_SCHEMA = { enum: ["beside", "below", "any"] };
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Enforce the location of single-line statements",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/nonblock-statement-body-position"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            POSITION_SCHEMA,
-            {
-                properties: {
-                    overrides: {
-                        properties: {
-                            if: POSITION_SCHEMA,
-                            else: POSITION_SCHEMA,
-                            while: POSITION_SCHEMA,
-                            do: POSITION_SCHEMA,
-                            for: POSITION_SCHEMA
-                        },
-                        additionalProperties: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            expectNoLinebreak: "Expected no linebreak before this statement.",
-            expectLinebreak: "Expected a linebreak before this statement."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        //----------------------------------------------------------------------
-        // Helpers
-        //----------------------------------------------------------------------
-
-        /**
-         * Gets the applicable preference for a particular keyword
-         * @param {string} keywordName The name of a keyword, e.g. 'if'
-         * @returns {string} The applicable option for the keyword, e.g. 'beside'
-         */
-        function getOption(keywordName) {
-            return context.options[1] && context.options[1].overrides && context.options[1].overrides[keywordName] ||
-                context.options[0] ||
-                "beside";
-        }
-
-        /**
-         * Validates the location of a single-line statement
-         * @param {ASTNode} node The single-line statement
-         * @param {string} keywordName The applicable keyword name for the single-line statement
-         * @returns {void}
-         */
-        function validateStatement(node, keywordName) {
-            const option = getOption(keywordName);
-
-            if (node.type === "BlockStatement" || option === "any") {
-                return;
-            }
-
-            const tokenBefore = sourceCode.getTokenBefore(node);
-
-            if (tokenBefore.loc.end.line === node.loc.start.line && option === "below") {
-                context.report({
-                    node,
-                    messageId: "expectLinebreak",
-                    fix: fixer => fixer.insertTextBefore(node, "\n")
-                });
-            } else if (tokenBefore.loc.end.line !== node.loc.start.line && option === "beside") {
-                context.report({
-                    node,
-                    messageId: "expectNoLinebreak",
-                    fix(fixer) {
-                        if (sourceCode.getText().slice(tokenBefore.range[1], node.range[0]).trim()) {
-                            return null;
-                        }
-                        return fixer.replaceTextRange([tokenBefore.range[1], node.range[0]], " ");
-                    }
-                });
-            }
-        }
-
-        //----------------------------------------------------------------------
-        // Public
-        //----------------------------------------------------------------------
-
-        return {
-            IfStatement(node) {
-                validateStatement(node.consequent, "if");
-
-                // Check the `else` node, but don't check 'else if' statements.
-                if (node.alternate && node.alternate.type !== "IfStatement") {
-                    validateStatement(node.alternate, "else");
-                }
-            },
-            WhileStatement: node => validateStatement(node.body, "while"),
-            DoWhileStatement: node => validateStatement(node.body, "do"),
-            ForStatement: node => validateStatement(node.body, "for"),
-            ForInStatement: node => validateStatement(node.body, "for"),
-            ForOfStatement: node => validateStatement(node.body, "for")
-        };
-    }
-};