@alexlit/lint-kit 127.0.0 → 127.2.0

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

@@ -1,191 +0,0 @@
-/**
- * @fileoverview Rule to warn when a function expression does not have a name.
- * @author Kyle T. Nunery
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-/**
- * Checks whether or not a given variable is a function name.
- * @param {eslint-scope.Variable} variable A variable to check.
- * @returns {boolean} `true` if the variable is a function name.
- */
-function isFunctionName(variable) {
-    return variable && variable.defs[0].type === "FunctionName";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require or disallow named `function` expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/func-names"
-        },
-
-        schema: {
-            definitions: {
-                value: {
-                    enum: [
-                        "always",
-                        "as-needed",
-                        "never"
-                    ]
-                }
-            },
-            items: [
-                {
-                    $ref: "#/definitions/value"
-                },
-                {
-                    type: "object",
-                    properties: {
-                        generators: {
-                            $ref: "#/definitions/value"
-                        }
-                    },
-                    additionalProperties: false
-                }
-            ]
-        },
-
-        messages: {
-            unnamed: "Unexpected unnamed {{name}}.",
-            named: "Unexpected named {{name}}."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Returns the config option for the given node.
-         * @param {ASTNode} node A node to get the config for.
-         * @returns {string} The config option.
-         */
-        function getConfigForNode(node) {
-            if (
-                node.generator &&
-                context.options.length > 1 &&
-                context.options[1].generators
-            ) {
-                return context.options[1].generators;
-            }
-
-            return context.options[0] || "always";
-        }
-
-        /**
-         * Determines whether the current FunctionExpression node is a get, set, or
-         * shorthand method in an object literal or a class.
-         * @param {ASTNode} node A node to check.
-         * @returns {boolean} True if the node is a get, set, or shorthand method.
-         */
-        function isObjectOrClassMethod(node) {
-            const parent = node.parent;
-
-            return (parent.type === "MethodDefinition" || (
-                parent.type === "Property" && (
-                    parent.method ||
-                    parent.kind === "get" ||
-                    parent.kind === "set"
-                )
-            ));
-        }
-
-        /**
-         * Determines whether the current FunctionExpression node has a name that would be
-         * inferred from context in a conforming ES6 environment.
-         * @param {ASTNode} node A node to check.
-         * @returns {boolean} True if the node would have a name assigned automatically.
-         */
-        function hasInferredName(node) {
-            const parent = node.parent;
-
-            return isObjectOrClassMethod(node) ||
-                (parent.type === "VariableDeclarator" && parent.id.type === "Identifier" && parent.init === node) ||
-                (parent.type === "Property" && parent.value === node) ||
-                (parent.type === "PropertyDefinition" && parent.value === node) ||
-                (parent.type === "AssignmentExpression" && parent.left.type === "Identifier" && parent.right === node) ||
-                (parent.type === "AssignmentPattern" && parent.left.type === "Identifier" && parent.right === node);
-        }
-
-        /**
-         * Reports that an unnamed function should be named
-         * @param {ASTNode} node The node to report in the event of an error.
-         * @returns {void}
-         */
-        function reportUnexpectedUnnamedFunction(node) {
-            context.report({
-                node,
-                messageId: "unnamed",
-                loc: astUtils.getFunctionHeadLoc(node, sourceCode),
-                data: { name: astUtils.getFunctionNameWithKind(node) }
-            });
-        }
-
-        /**
-         * Reports that a named function should be unnamed
-         * @param {ASTNode} node The node to report in the event of an error.
-         * @returns {void}
-         */
-        function reportUnexpectedNamedFunction(node) {
-            context.report({
-                node,
-                messageId: "named",
-                loc: astUtils.getFunctionHeadLoc(node, sourceCode),
-                data: { name: astUtils.getFunctionNameWithKind(node) }
-            });
-        }
-
-        /**
-         * The listener for function nodes.
-         * @param {ASTNode} node function node
-         * @returns {void}
-         */
-        function handleFunction(node) {
-
-            // Skip recursive functions.
-            const nameVar = sourceCode.getDeclaredVariables(node)[0];
-
-            if (isFunctionName(nameVar) && nameVar.references.length > 0) {
-                return;
-            }
-
-            const hasName = Boolean(node.id && node.id.name);
-            const config = getConfigForNode(node);
-
-            if (config === "never") {
-                if (hasName && node.type !== "FunctionDeclaration") {
-                    reportUnexpectedNamedFunction(node);
-                }
-            } else if (config === "as-needed") {
-                if (!hasName && !hasInferredName(node)) {
-                    reportUnexpectedUnnamedFunction(node);
-                }
-            } else {
-                if (!hasName && !isObjectOrClassMethod(node)) {
-                    reportUnexpectedUnnamedFunction(node);
-                }
-            }
-        }
-
-        return {
-            "FunctionExpression:exit": handleFunction,
-            "ExportDefaultDeclaration > FunctionDeclaration": handleFunction
-        };
-    }
-};

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

@@ -1,136 +0,0 @@
-/**
- * @fileoverview Rule to enforce a particular function style
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce the consistent use of either `function` declarations or expressions assigned to variables",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/func-style"
-        },
-
-        schema: [
-            {
-                enum: ["declaration", "expression"]
-            },
-            {
-                type: "object",
-                properties: {
-                    allowArrowFunctions: {
-                        type: "boolean",
-                        default: false
-                    },
-                    overrides: {
-                        type: "object",
-                        properties: {
-                            namedExports: {
-                                enum: ["declaration", "expression", "ignore"]
-                            }
-                        },
-                        additionalProperties: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            expression: "Expected a function expression.",
-            declaration: "Expected a function declaration."
-        }
-    },
-
-    create(context) {
-
-        const style = context.options[0],
-            allowArrowFunctions = context.options[1] && context.options[1].allowArrowFunctions,
-            enforceDeclarations = (style === "declaration"),
-            exportFunctionStyle = context.options[1] && context.options[1].overrides && context.options[1].overrides.namedExports,
-            stack = [];
-
-        const nodesToCheck = {
-            FunctionDeclaration(node) {
-                stack.push(false);
-
-                if (
-                    !enforceDeclarations &&
-                    node.parent.type !== "ExportDefaultDeclaration" &&
-                    (typeof exportFunctionStyle === "undefined" || node.parent.type !== "ExportNamedDeclaration")
-                ) {
-                    context.report({ node, messageId: "expression" });
-                }
-
-                if (node.parent.type === "ExportNamedDeclaration" && exportFunctionStyle === "expression") {
-                    context.report({ node, messageId: "expression" });
-                }
-            },
-            "FunctionDeclaration:exit"() {
-                stack.pop();
-            },
-
-            FunctionExpression(node) {
-                stack.push(false);
-
-                if (
-                    enforceDeclarations &&
-                    node.parent.type === "VariableDeclarator" &&
-                    (typeof exportFunctionStyle === "undefined" || node.parent.parent.parent.type !== "ExportNamedDeclaration")
-                ) {
-                    context.report({ node: node.parent, messageId: "declaration" });
-                }
-
-                if (
-                    node.parent.type === "VariableDeclarator" && node.parent.parent.parent.type === "ExportNamedDeclaration" &&
-                    exportFunctionStyle === "declaration"
-                ) {
-                    context.report({ node: node.parent, messageId: "declaration" });
-                }
-            },
-            "FunctionExpression:exit"() {
-                stack.pop();
-            },
-
-            "ThisExpression, Super"() {
-                if (stack.length > 0) {
-                    stack[stack.length - 1] = true;
-                }
-            }
-        };
-
-        if (!allowArrowFunctions) {
-            nodesToCheck.ArrowFunctionExpression = function() {
-                stack.push(false);
-            };
-
-            nodesToCheck["ArrowFunctionExpression:exit"] = function(node) {
-                const hasThisOrSuperExpr = stack.pop();
-
-                if (!hasThisOrSuperExpr && node.parent.type === "VariableDeclarator") {
-                    if (
-                        enforceDeclarations &&
-                        (typeof exportFunctionStyle === "undefined" || node.parent.parent.parent.type !== "ExportNamedDeclaration")
-                    ) {
-                        context.report({ node: node.parent, messageId: "declaration" });
-                    }
-
-                    if (node.parent.parent.parent.type === "ExportNamedDeclaration" && exportFunctionStyle === "declaration") {
-                        context.report({ node: node.parent, messageId: "declaration" });
-                    }
-                }
-            };
-        }
-
-        return nodesToCheck;
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/function-call-argument-newline.js

@@ -1,125 +0,0 @@
-/**
- * @fileoverview Rule to enforce line breaks between arguments of a function call
- * @author Alexey Gonchar <https://github.com/finico>
- * @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: "Enforce line breaks between arguments of a function call",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/function-call-argument-newline"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                enum: ["always", "never", "consistent"]
-            }
-        ],
-
-        messages: {
-            unexpectedLineBreak: "There should be no line break here.",
-            missingLineBreak: "There should be a line break after this argument."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        const checkers = {
-            unexpected: {
-                messageId: "unexpectedLineBreak",
-                check: (prevToken, currentToken) => prevToken.loc.end.line !== currentToken.loc.start.line,
-                createFix: (token, tokenBefore) => fixer =>
-                    fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], " ")
-            },
-            missing: {
-                messageId: "missingLineBreak",
-                check: (prevToken, currentToken) => prevToken.loc.end.line === currentToken.loc.start.line,
-                createFix: (token, tokenBefore) => fixer =>
-                    fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], "\n")
-            }
-        };
-
-        /**
-         * Check all arguments for line breaks in the CallExpression
-         * @param {CallExpression} node node to evaluate
-         * @param {{ messageId: string, check: Function }} checker selected checker
-         * @returns {void}
-         * @private
-         */
-        function checkArguments(node, checker) {
-            for (let i = 1; i < node.arguments.length; i++) {
-                const prevArgToken = sourceCode.getLastToken(node.arguments[i - 1]);
-                const currentArgToken = sourceCode.getFirstToken(node.arguments[i]);
-
-                if (checker.check(prevArgToken, currentArgToken)) {
-                    const tokenBefore = sourceCode.getTokenBefore(
-                        currentArgToken,
-                        { includeComments: true }
-                    );
-
-                    const hasLineCommentBefore = tokenBefore.type === "Line";
-
-                    context.report({
-                        node,
-                        loc: {
-                            start: tokenBefore.loc.end,
-                            end: currentArgToken.loc.start
-                        },
-                        messageId: checker.messageId,
-                        fix: hasLineCommentBefore ? null : checker.createFix(currentArgToken, tokenBefore)
-                    });
-                }
-            }
-        }
-
-        /**
-         * Check if open space is present in a function name
-         * @param {CallExpression} node node to evaluate
-         * @returns {void}
-         * @private
-         */
-        function check(node) {
-            if (node.arguments.length < 2) {
-                return;
-            }
-
-            const option = context.options[0] || "always";
-
-            if (option === "never") {
-                checkArguments(node, checkers.unexpected);
-            } else if (option === "always") {
-                checkArguments(node, checkers.missing);
-            } else if (option === "consistent") {
-                const firstArgToken = sourceCode.getLastToken(node.arguments[0]);
-                const secondArgToken = sourceCode.getFirstToken(node.arguments[1]);
-
-                if (firstArgToken.loc.end.line === secondArgToken.loc.start.line) {
-                    checkArguments(node, checkers.unexpected);
-                } else {
-                    checkArguments(node, checkers.missing);
-                }
-            }
-        }
-
-        return {
-            CallExpression: check,
-            NewExpression: check
-        };
-    }
-};