@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/lines-around-directive.js

@@ -1,201 +0,0 @@
-/**
- * @fileoverview Require or disallow newlines around directives.
- * @author Kai Cataldo
- * @deprecated in ESLint v4.0.0
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "layout",
-
-        docs: {
-            description: "Require or disallow newlines around directives",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/lines-around-directive"
-        },
-
-        schema: [{
-            oneOf: [
-                {
-                    enum: ["always", "never"]
-                },
-                {
-                    type: "object",
-                    properties: {
-                        before: {
-                            enum: ["always", "never"]
-                        },
-                        after: {
-                            enum: ["always", "never"]
-                        }
-                    },
-                    additionalProperties: false,
-                    minProperties: 2
-                }
-            ]
-        }],
-
-        fixable: "whitespace",
-        messages: {
-            expected: "Expected newline {{location}} \"{{value}}\" directive.",
-            unexpected: "Unexpected newline {{location}} \"{{value}}\" directive."
-        },
-        deprecated: true,
-        replacedBy: ["padding-line-between-statements"]
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const config = context.options[0] || "always";
-        const expectLineBefore = typeof config === "string" ? config : config.before;
-        const expectLineAfter = typeof config === "string" ? config : config.after;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Check if node is preceded by a blank newline.
-         * @param {ASTNode} node Node to check.
-         * @returns {boolean} Whether or not the passed in node is preceded by a blank newline.
-         */
-        function hasNewlineBefore(node) {
-            const tokenBefore = sourceCode.getTokenBefore(node, { includeComments: true });
-            const tokenLineBefore = tokenBefore ? tokenBefore.loc.end.line : 0;
-
-            return node.loc.start.line - tokenLineBefore >= 2;
-        }
-
-        /**
-         * Gets the last token of a node that is on the same line as the rest of the node.
-         * This will usually be the last token of the node, but it will be the second-to-last token if the node has a trailing
-         * semicolon on a different line.
-         * @param {ASTNode} node A directive node
-         * @returns {Token} The last token of the node on the line
-         */
-        function getLastTokenOnLine(node) {
-            const lastToken = sourceCode.getLastToken(node);
-            const secondToLastToken = sourceCode.getTokenBefore(lastToken);
-
-            return astUtils.isSemicolonToken(lastToken) && lastToken.loc.start.line > secondToLastToken.loc.end.line
-                ? secondToLastToken
-                : lastToken;
-        }
-
-        /**
-         * Check if node is followed by a blank newline.
-         * @param {ASTNode} node Node to check.
-         * @returns {boolean} Whether or not the passed in node is followed by a blank newline.
-         */
-        function hasNewlineAfter(node) {
-            const lastToken = getLastTokenOnLine(node);
-            const tokenAfter = sourceCode.getTokenAfter(lastToken, { includeComments: true });
-
-            return tokenAfter.loc.start.line - lastToken.loc.end.line >= 2;
-        }
-
-        /**
-         * Report errors for newlines around directives.
-         * @param {ASTNode} node Node to check.
-         * @param {string} location Whether the error was found before or after the directive.
-         * @param {boolean} expected Whether or not a newline was expected or unexpected.
-         * @returns {void}
-         */
-        function reportError(node, location, expected) {
-            context.report({
-                node,
-                messageId: expected ? "expected" : "unexpected",
-                data: {
-                    value: node.expression.value,
-                    location
-                },
-                fix(fixer) {
-                    const lastToken = getLastTokenOnLine(node);
-
-                    if (expected) {
-                        return location === "before" ? fixer.insertTextBefore(node, "\n") : fixer.insertTextAfter(lastToken, "\n");
-                    }
-                    return fixer.removeRange(location === "before" ? [node.range[0] - 1, node.range[0]] : [lastToken.range[1], lastToken.range[1] + 1]);
-                }
-            });
-        }
-
-        /**
-         * Check lines around directives in node
-         * @param {ASTNode} node node to check
-         * @returns {void}
-         */
-        function checkDirectives(node) {
-            const directives = astUtils.getDirectivePrologue(node);
-
-            if (!directives.length) {
-                return;
-            }
-
-            const firstDirective = directives[0];
-            const leadingComments = sourceCode.getCommentsBefore(firstDirective);
-
-            /*
-             * Only check before the first directive if it is preceded by a comment or if it is at the top of
-             * the file and expectLineBefore is set to "never". This is to not force a newline at the top of
-             * the file if there are no comments as well as for compatibility with padded-blocks.
-             */
-            if (leadingComments.length) {
-                if (expectLineBefore === "always" && !hasNewlineBefore(firstDirective)) {
-                    reportError(firstDirective, "before", true);
-                }
-
-                if (expectLineBefore === "never" && hasNewlineBefore(firstDirective)) {
-                    reportError(firstDirective, "before", false);
-                }
-            } else if (
-                node.type === "Program" &&
-                expectLineBefore === "never" &&
-                !leadingComments.length &&
-                hasNewlineBefore(firstDirective)
-            ) {
-                reportError(firstDirective, "before", false);
-            }
-
-            const lastDirective = directives.at(-1);
-            const statements = node.type === "Program" ? node.body : node.body.body;
-
-            /*
-             * Do not check after the last directive if the body only
-             * contains a directive prologue and isn't followed by a comment to ensure
-             * this rule behaves well with padded-blocks.
-             */
-            if (lastDirective === statements.at(-1) && !lastDirective.trailingComments) {
-                return;
-            }
-
-            if (expectLineAfter === "always" && !hasNewlineAfter(lastDirective)) {
-                reportError(lastDirective, "after", true);
-            }
-
-            if (expectLineAfter === "never" && hasNewlineAfter(lastDirective)) {
-                reportError(lastDirective, "after", false);
-            }
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            Program: checkDirectives,
-            FunctionDeclaration: checkDirectives,
-            FunctionExpression: checkDirectives,
-            ArrowFunctionExpression: checkDirectives
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/lines-between-class-members.js

@@ -1,269 +0,0 @@
-/**
- * @fileoverview Rule to check empty newline between class members
- * @author 薛定谔的猫<hh_2013@foxmail.com>
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Types of class members.
- * Those have `test` method to check it matches to the given class member.
- * @private
- */
-const ClassMemberTypes = {
-    "*": { test: () => true },
-    field: { test: node => node.type === "PropertyDefinition" },
-    method: { test: node => node.type === "MethodDefinition" }
-};
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Require or disallow an empty line between class members",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/lines-between-class-members"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                anyOf: [
-                    {
-                        type: "object",
-                        properties: {
-                            enforce: {
-                                type: "array",
-                                items: {
-                                    type: "object",
-                                    properties: {
-                                        blankLine: { enum: ["always", "never"] },
-                                        prev: { enum: ["method", "field", "*"] },
-                                        next: { enum: ["method", "field", "*"] }
-                                    },
-                                    additionalProperties: false,
-                                    required: ["blankLine", "prev", "next"]
-                                },
-                                minItems: 1
-                            }
-                        },
-                        additionalProperties: false,
-                        required: ["enforce"]
-                    },
-                    {
-                        enum: ["always", "never"]
-                    }
-                ]
-            },
-            {
-                type: "object",
-                properties: {
-                    exceptAfterSingleLine: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-        messages: {
-            never: "Unexpected blank line between class members.",
-            always: "Expected blank line between class members."
-        }
-    },
-
-    create(context) {
-
-        const options = [];
-
-        options[0] = context.options[0] || "always";
-        options[1] = context.options[1] || { exceptAfterSingleLine: false };
-
-        const configureList = typeof options[0] === "object" ? options[0].enforce : [{ blankLine: options[0], prev: "*", next: "*" }];
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Gets a pair of tokens that should be used to check lines between two class member nodes.
-         *
-         * In most cases, this returns the very last token of the current node and
-         * the very first token of the next node.
-         * For example:
-         *
-         *     class C {
-         *         x = 1;   // curLast: `;` nextFirst: `in`
-         *         in = 2
-         *     }
-         *
-         * There is only one exception. If the given node ends with a semicolon, and it looks like
-         * a semicolon-less style's semicolon - one that is not on the same line as the preceding
-         * token, but is on the line where the next class member starts - this returns the preceding
-         * token and the semicolon as boundary tokens.
-         * For example:
-         *
-         *     class C {
-         *         x = 1    // curLast: `1` nextFirst: `;`
-         *         ;in = 2
-         *     }
-         * When determining the desired layout of the code, we should treat this semicolon as
-         * a part of the next class member node instead of the one it technically belongs to.
-         * @param {ASTNode} curNode Current class member node.
-         * @param {ASTNode} nextNode Next class member node.
-         * @returns {Token} The actual last token of `node`.
-         * @private
-         */
-        function getBoundaryTokens(curNode, nextNode) {
-            const lastToken = sourceCode.getLastToken(curNode);
-            const prevToken = sourceCode.getTokenBefore(lastToken);
-            const nextToken = sourceCode.getFirstToken(nextNode); // skip possible lone `;` between nodes
-
-            const isSemicolonLessStyle = (
-                astUtils.isSemicolonToken(lastToken) &&
-                !astUtils.isTokenOnSameLine(prevToken, lastToken) &&
-                astUtils.isTokenOnSameLine(lastToken, nextToken)
-            );
-
-            return isSemicolonLessStyle
-                ? { curLast: prevToken, nextFirst: lastToken }
-                : { curLast: lastToken, nextFirst: nextToken };
-        }
-
-        /**
-         * Return the last token among the consecutive tokens that have no exceed max line difference in between, before the first token in the next member.
-         * @param {Token} prevLastToken The last token in the previous member node.
-         * @param {Token} nextFirstToken The first token in the next member node.
-         * @param {number} maxLine The maximum number of allowed line difference between consecutive tokens.
-         * @returns {Token} The last token among the consecutive tokens.
-         */
-        function findLastConsecutiveTokenAfter(prevLastToken, nextFirstToken, maxLine) {
-            const after = sourceCode.getTokenAfter(prevLastToken, { includeComments: true });
-
-            if (after !== nextFirstToken && after.loc.start.line - prevLastToken.loc.end.line <= maxLine) {
-                return findLastConsecutiveTokenAfter(after, nextFirstToken, maxLine);
-            }
-            return prevLastToken;
-        }
-
-        /**
-         * Return the first token among the consecutive tokens that have no exceed max line difference in between, after the last token in the previous member.
-         * @param {Token} nextFirstToken The first token in the next member node.
-         * @param {Token} prevLastToken The last token in the previous member node.
-         * @param {number} maxLine The maximum number of allowed line difference between consecutive tokens.
-         * @returns {Token} The first token among the consecutive tokens.
-         */
-        function findFirstConsecutiveTokenBefore(nextFirstToken, prevLastToken, maxLine) {
-            const before = sourceCode.getTokenBefore(nextFirstToken, { includeComments: true });
-
-            if (before !== prevLastToken && nextFirstToken.loc.start.line - before.loc.end.line <= maxLine) {
-                return findFirstConsecutiveTokenBefore(before, prevLastToken, maxLine);
-            }
-            return nextFirstToken;
-        }
-
-        /**
-         * Checks if there is a token or comment between two tokens.
-         * @param {Token} before The token before.
-         * @param {Token} after The token after.
-         * @returns {boolean} True if there is a token or comment between two tokens.
-         */
-        function hasTokenOrCommentBetween(before, after) {
-            return sourceCode.getTokensBetween(before, after, { includeComments: true }).length !== 0;
-        }
-
-        /**
-         * Checks whether the given node matches the given type.
-         * @param {ASTNode} node The class member node to check.
-         * @param {string} type The class member type to check.
-         * @returns {boolean} `true` if the class member node matched the type.
-         * @private
-         */
-        function match(node, type) {
-            return ClassMemberTypes[type].test(node);
-        }
-
-        /**
-         * Finds the last matched configuration from the configureList.
-         * @param {ASTNode} prevNode The previous node to match.
-         * @param {ASTNode} nextNode The current node to match.
-         * @returns {string|null} Padding type or `null` if no matches were found.
-         * @private
-         */
-        function getPaddingType(prevNode, nextNode) {
-            for (let i = configureList.length - 1; i >= 0; --i) {
-                const configure = configureList[i];
-                const matched =
-                    match(prevNode, configure.prev) &&
-                    match(nextNode, configure.next);
-
-                if (matched) {
-                    return configure.blankLine;
-                }
-            }
-            return null;
-        }
-
-        return {
-            ClassBody(node) {
-                const body = node.body;
-
-                for (let i = 0; i < body.length - 1; i++) {
-                    const curFirst = sourceCode.getFirstToken(body[i]);
-                    const { curLast, nextFirst } = getBoundaryTokens(body[i], body[i + 1]);
-                    const isMulti = !astUtils.isTokenOnSameLine(curFirst, curLast);
-                    const skip = !isMulti && options[1].exceptAfterSingleLine;
-                    const beforePadding = findLastConsecutiveTokenAfter(curLast, nextFirst, 1);
-                    const afterPadding = findFirstConsecutiveTokenBefore(nextFirst, curLast, 1);
-                    const isPadded = afterPadding.loc.start.line - beforePadding.loc.end.line > 1;
-                    const hasTokenInPadding = hasTokenOrCommentBetween(beforePadding, afterPadding);
-                    const curLineLastToken = findLastConsecutiveTokenAfter(curLast, nextFirst, 0);
-                    const paddingType = getPaddingType(body[i], body[i + 1]);
-
-                    if (paddingType === "never" && isPadded) {
-                        context.report({
-                            node: body[i + 1],
-                            messageId: "never",
-
-                            fix(fixer) {
-                                if (hasTokenInPadding) {
-                                    return null;
-                                }
-                                return fixer.replaceTextRange([beforePadding.range[1], afterPadding.range[0]], "\n");
-                            }
-                        });
-                    } else if (paddingType === "always" && !skip && !isPadded) {
-                        context.report({
-                            node: body[i + 1],
-                            messageId: "always",
-
-                            fix(fixer) {
-                                if (hasTokenInPadding) {
-                                    return null;
-                                }
-                                return fixer.insertTextAfter(curLineLastToken, "\n");
-                            }
-                        });
-                    }
-
-                }
-            }
-        };
-    }
-};