@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/class-methods-use-this.js

@@ -1,187 +0,0 @@
-/**
- * @fileoverview Rule to enforce that all class methods use 'this'.
- * @author Patrick Williams
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce that class methods utilize `this`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/class-methods-use-this"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                exceptMethods: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                enforceForClassFields: {
-                    type: "boolean",
-                    default: true
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            missingThis: "Expected 'this' to be used by class {{name}}."
-        }
-    },
-    create(context) {
-        const config = Object.assign({}, context.options[0]);
-        const enforceForClassFields = config.enforceForClassFields !== false;
-        const exceptMethods = new Set(config.exceptMethods || []);
-
-        const stack = [];
-
-        /**
-         * Push `this` used flag initialized with `false` onto the stack.
-         * @returns {void}
-         */
-        function pushContext() {
-            stack.push(false);
-        }
-
-        /**
-         * Pop `this` used flag from the stack.
-         * @returns {boolean | undefined} `this` used flag
-         */
-        function popContext() {
-            return stack.pop();
-        }
-
-        /**
-         * Initializes the current context to false and pushes it onto the stack.
-         * These booleans represent whether 'this' has been used in the context.
-         * @returns {void}
-         * @private
-         */
-        function enterFunction() {
-            pushContext();
-        }
-
-        /**
-         * Check if the node is an instance method
-         * @param {ASTNode} node node to check
-         * @returns {boolean} True if its an instance method
-         * @private
-         */
-        function isInstanceMethod(node) {
-            switch (node.type) {
-                case "MethodDefinition":
-                    return !node.static && node.kind !== "constructor";
-                case "PropertyDefinition":
-                    return !node.static && enforceForClassFields;
-                default:
-                    return false;
-            }
-        }
-
-        /**
-         * Check if the node is an instance method not excluded by config
-         * @param {ASTNode} node node to check
-         * @returns {boolean} True if it is an instance method, and not excluded by config
-         * @private
-         */
-        function isIncludedInstanceMethod(node) {
-            if (isInstanceMethod(node)) {
-                if (node.computed) {
-                    return true;
-                }
-
-                const hashIfNeeded = node.key.type === "PrivateIdentifier" ? "#" : "";
-                const name = node.key.type === "Literal"
-                    ? astUtils.getStaticStringValue(node.key)
-                    : (node.key.name || "");
-
-                return !exceptMethods.has(hashIfNeeded + name);
-            }
-            return false;
-        }
-
-        /**
-         * Checks if we are leaving a function that is a method, and reports if 'this' has not been used.
-         * Static methods and the constructor are exempt.
-         * Then pops the context off the stack.
-         * @param {ASTNode} node A function node that was entered.
-         * @returns {void}
-         * @private
-         */
-        function exitFunction(node) {
-            const methodUsesThis = popContext();
-
-            if (isIncludedInstanceMethod(node.parent) && !methodUsesThis) {
-                context.report({
-                    node,
-                    loc: astUtils.getFunctionHeadLoc(node, context.sourceCode),
-                    messageId: "missingThis",
-                    data: {
-                        name: astUtils.getFunctionNameWithKind(node)
-                    }
-                });
-            }
-        }
-
-        /**
-         * Mark the current context as having used 'this'.
-         * @returns {void}
-         * @private
-         */
-        function markThisUsed() {
-            if (stack.length) {
-                stack[stack.length - 1] = true;
-            }
-        }
-
-        return {
-            FunctionDeclaration: enterFunction,
-            "FunctionDeclaration:exit": exitFunction,
-            FunctionExpression: enterFunction,
-            "FunctionExpression:exit": exitFunction,
-
-            /*
-             * Class field value are implicit functions.
-             */
-            "PropertyDefinition > *.key:exit": pushContext,
-            "PropertyDefinition:exit": popContext,
-
-            /*
-             * Class static blocks are implicit functions. They aren't required to use `this`,
-             * but we have to push context so that it captures any use of `this` in the static block
-             * separately from enclosing contexts, because static blocks have their own `this` and it
-             * shouldn't count as used `this` in enclosing contexts.
-             */
-            StaticBlock: pushContext,
-            "StaticBlock:exit": popContext,
-
-            ThisExpression: markThisUsed,
-            Super: markThisUsed,
-            ...(
-                enforceForClassFields && {
-                    "PropertyDefinition > ArrowFunctionExpression.value": enterFunction,
-                    "PropertyDefinition > ArrowFunctionExpression.value:exit": exitFunction
-                }
-            )
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/comma-dangle.js

@@ -1,373 +0,0 @@
-/**
- * @fileoverview Rule to forbid or enforce dangling commas.
- * @author Ian Christian Myers
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const DEFAULT_OPTIONS = Object.freeze({
-    arrays: "never",
-    objects: "never",
-    imports: "never",
-    exports: "never",
-    functions: "never"
-});
-
-/**
- * Checks whether or not a trailing comma is allowed in a given node.
- * If the `lastItem` is `RestElement` or `RestProperty`, it disallows trailing commas.
- * @param {ASTNode} lastItem The node of the last element in the given node.
- * @returns {boolean} `true` if a trailing comma is allowed.
- */
-function isTrailingCommaAllowed(lastItem) {
-    return !(
-        lastItem.type === "RestElement" ||
-        lastItem.type === "RestProperty" ||
-        lastItem.type === "ExperimentalRestProperty"
-    );
-}
-
-/**
- * Normalize option value.
- * @param {string|Object|undefined} optionValue The 1st option value to normalize.
- * @param {number} ecmaVersion The normalized ECMAScript version.
- * @returns {Object} The normalized option value.
- */
-function normalizeOptions(optionValue, ecmaVersion) {
-    if (typeof optionValue === "string") {
-        return {
-            arrays: optionValue,
-            objects: optionValue,
-            imports: optionValue,
-            exports: optionValue,
-            functions: ecmaVersion < 2017 ? "ignore" : optionValue
-        };
-    }
-    if (typeof optionValue === "object" && optionValue !== null) {
-        return {
-            arrays: optionValue.arrays || DEFAULT_OPTIONS.arrays,
-            objects: optionValue.objects || DEFAULT_OPTIONS.objects,
-            imports: optionValue.imports || DEFAULT_OPTIONS.imports,
-            exports: optionValue.exports || DEFAULT_OPTIONS.exports,
-            functions: optionValue.functions || DEFAULT_OPTIONS.functions
-        };
-    }
-
-    return DEFAULT_OPTIONS;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Require or disallow trailing commas",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/comma-dangle"
-        },
-
-        fixable: "code",
-
-        schema: {
-            definitions: {
-                value: {
-                    enum: [
-                        "always-multiline",
-                        "always",
-                        "never",
-                        "only-multiline"
-                    ]
-                },
-                valueWithIgnore: {
-                    enum: [
-                        "always-multiline",
-                        "always",
-                        "ignore",
-                        "never",
-                        "only-multiline"
-                    ]
-                }
-            },
-            type: "array",
-            items: [
-                {
-                    oneOf: [
-                        {
-                            $ref: "#/definitions/value"
-                        },
-                        {
-                            type: "object",
-                            properties: {
-                                arrays: { $ref: "#/definitions/valueWithIgnore" },
-                                objects: { $ref: "#/definitions/valueWithIgnore" },
-                                imports: { $ref: "#/definitions/valueWithIgnore" },
-                                exports: { $ref: "#/definitions/valueWithIgnore" },
-                                functions: { $ref: "#/definitions/valueWithIgnore" }
-                            },
-                            additionalProperties: false
-                        }
-                    ]
-                }
-            ],
-            additionalItems: false
-        },
-
-        messages: {
-            unexpected: "Unexpected trailing comma.",
-            missing: "Missing trailing comma."
-        }
-    },
-
-    create(context) {
-        const options = normalizeOptions(context.options[0], context.languageOptions.ecmaVersion);
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Gets the last item of the given node.
-         * @param {ASTNode} node The node to get.
-         * @returns {ASTNode|null} The last node or null.
-         */
-        function getLastItem(node) {
-
-            /**
-             * Returns the last element of an array
-             * @param {any[]} array The input array
-             * @returns {any} The last element
-             */
-            function last(array) {
-                return array.at(-1);
-            }
-
-            switch (node.type) {
-                case "ObjectExpression":
-                case "ObjectPattern":
-                    return last(node.properties);
-                case "ArrayExpression":
-                case "ArrayPattern":
-                    return last(node.elements);
-                case "ImportDeclaration":
-                case "ExportNamedDeclaration":
-                    return last(node.specifiers);
-                case "FunctionDeclaration":
-                case "FunctionExpression":
-                case "ArrowFunctionExpression":
-                    return last(node.params);
-                case "CallExpression":
-                case "NewExpression":
-                    return last(node.arguments);
-                default:
-                    return null;
-            }
-        }
-
-        /**
-         * Gets the trailing comma token of the given node.
-         * If the trailing comma does not exist, this returns the token which is
-         * the insertion point of the trailing comma token.
-         * @param {ASTNode} node The node to get.
-         * @param {ASTNode} lastItem The last item of the node.
-         * @returns {Token} The trailing comma token or the insertion point.
-         */
-        function getTrailingToken(node, lastItem) {
-            switch (node.type) {
-                case "ObjectExpression":
-                case "ArrayExpression":
-                case "CallExpression":
-                case "NewExpression":
-                    return sourceCode.getLastToken(node, 1);
-                default: {
-                    const nextToken = sourceCode.getTokenAfter(lastItem);
-
-                    if (astUtils.isCommaToken(nextToken)) {
-                        return nextToken;
-                    }
-                    return sourceCode.getLastToken(lastItem);
-                }
-            }
-        }
-
-        /**
-         * Checks whether or not a given node is multiline.
-         * This rule handles a given node as multiline when the closing parenthesis
-         * and the last element are not on the same line.
-         * @param {ASTNode} node A node to check.
-         * @returns {boolean} `true` if the node is multiline.
-         */
-        function isMultiline(node) {
-            const lastItem = getLastItem(node);
-
-            if (!lastItem) {
-                return false;
-            }
-
-            const penultimateToken = getTrailingToken(node, lastItem);
-            const lastToken = sourceCode.getTokenAfter(penultimateToken);
-
-            return lastToken.loc.end.line !== penultimateToken.loc.end.line;
-        }
-
-        /**
-         * Reports a trailing comma if it exists.
-         * @param {ASTNode} node A node to check. Its type is one of
-         *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
-         *   ImportDeclaration, and ExportNamedDeclaration.
-         * @returns {void}
-         */
-        function forbidTrailingComma(node) {
-            const lastItem = getLastItem(node);
-
-            if (!lastItem || (node.type === "ImportDeclaration" && lastItem.type !== "ImportSpecifier")) {
-                return;
-            }
-
-            const trailingToken = getTrailingToken(node, lastItem);
-
-            if (astUtils.isCommaToken(trailingToken)) {
-                context.report({
-                    node: lastItem,
-                    loc: trailingToken.loc,
-                    messageId: "unexpected",
-                    *fix(fixer) {
-                        yield fixer.remove(trailingToken);
-
-                        /*
-                         * Extend the range of the fix to include surrounding tokens to ensure
-                         * that the element after which the comma is removed stays _last_.
-                         * This intentionally makes conflicts in fix ranges with rules that may be
-                         * adding or removing elements in the same autofix pass.
-                         * https://github.com/eslint/eslint/issues/15660
-                         */
-                        yield fixer.insertTextBefore(sourceCode.getTokenBefore(trailingToken), "");
-                        yield fixer.insertTextAfter(sourceCode.getTokenAfter(trailingToken), "");
-                    }
-                });
-            }
-        }
-
-        /**
-         * Reports the last element of a given node if it does not have a trailing
-         * comma.
-         *
-         * If a given node is `ArrayPattern` which has `RestElement`, the trailing
-         * comma is disallowed, so report if it exists.
-         * @param {ASTNode} node A node to check. Its type is one of
-         *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
-         *   ImportDeclaration, and ExportNamedDeclaration.
-         * @returns {void}
-         */
-        function forceTrailingComma(node) {
-            const lastItem = getLastItem(node);
-
-            if (!lastItem || (node.type === "ImportDeclaration" && lastItem.type !== "ImportSpecifier")) {
-                return;
-            }
-            if (!isTrailingCommaAllowed(lastItem)) {
-                forbidTrailingComma(node);
-                return;
-            }
-
-            const trailingToken = getTrailingToken(node, lastItem);
-
-            if (trailingToken.value !== ",") {
-                context.report({
-                    node: lastItem,
-                    loc: {
-                        start: trailingToken.loc.end,
-                        end: astUtils.getNextLocation(sourceCode, trailingToken.loc.end)
-                    },
-                    messageId: "missing",
-                    *fix(fixer) {
-                        yield fixer.insertTextAfter(trailingToken, ",");
-
-                        /*
-                         * Extend the range of the fix to include surrounding tokens to ensure
-                         * that the element after which the comma is inserted stays _last_.
-                         * This intentionally makes conflicts in fix ranges with rules that may be
-                         * adding or removing elements in the same autofix pass.
-                         * https://github.com/eslint/eslint/issues/15660
-                         */
-                        yield fixer.insertTextBefore(trailingToken, "");
-                        yield fixer.insertTextAfter(sourceCode.getTokenAfter(trailingToken), "");
-                    }
-                });
-            }
-        }
-
-        /**
-         * If a given node is multiline, reports the last element of a given node
-         * when it does not have a trailing comma.
-         * Otherwise, reports a trailing comma if it exists.
-         * @param {ASTNode} node A node to check. Its type is one of
-         *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
-         *   ImportDeclaration, and ExportNamedDeclaration.
-         * @returns {void}
-         */
-        function forceTrailingCommaIfMultiline(node) {
-            if (isMultiline(node)) {
-                forceTrailingComma(node);
-            } else {
-                forbidTrailingComma(node);
-            }
-        }
-
-        /**
-         * Only if a given node is not multiline, reports the last element of a given node
-         * when it does not have a trailing comma.
-         * Otherwise, reports a trailing comma if it exists.
-         * @param {ASTNode} node A node to check. Its type is one of
-         *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
-         *   ImportDeclaration, and ExportNamedDeclaration.
-         * @returns {void}
-         */
-        function allowTrailingCommaIfMultiline(node) {
-            if (!isMultiline(node)) {
-                forbidTrailingComma(node);
-            }
-        }
-
-        const predicate = {
-            always: forceTrailingComma,
-            "always-multiline": forceTrailingCommaIfMultiline,
-            "only-multiline": allowTrailingCommaIfMultiline,
-            never: forbidTrailingComma,
-            ignore() {}
-        };
-
-        return {
-            ObjectExpression: predicate[options.objects],
-            ObjectPattern: predicate[options.objects],
-
-            ArrayExpression: predicate[options.arrays],
-            ArrayPattern: predicate[options.arrays],
-
-            ImportDeclaration: predicate[options.imports],
-
-            ExportNamedDeclaration: predicate[options.exports],
-
-            FunctionDeclaration: predicate[options.functions],
-            FunctionExpression: predicate[options.functions],
-            ArrowFunctionExpression: predicate[options.functions],
-            CallExpression: predicate[options.functions],
-            NewExpression: predicate[options.functions]
-        };
-    }
-};