@alexlit/lint-kit 127.0.0 → 127.2.0

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

@@ -1,47 +0,0 @@
-/**
- * @fileoverview Disallow the use of process.exit()
- * @author Nicholas C. Zakas
- * @deprecated in ESLint v7.0.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-
-        replacedBy: [],
-
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow the use of `process.exit()`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-process-exit"
-        },
-
-        schema: [],
-
-        messages: {
-            noProcessExit: "Don't use process.exit(); throw an error instead."
-        }
-    },
-
-    create(context) {
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            "CallExpression > MemberExpression.callee[object.name = 'process'][property.name = 'exit']"(node) {
-                context.report({ node: node.parent, messageId: "noProcessExit" });
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-promise-executor-return.js

@@ -1,263 +0,0 @@
-/**
- * @fileoverview Rule to disallow returning values from Promise executor functions
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { findVariable } = require("@eslint-community/eslint-utils");
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const functionTypesToCheck = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
-
-/**
- * Determines whether the given identifier node is a reference to a global variable.
- * @param {ASTNode} node `Identifier` node to check.
- * @param {Scope} scope Scope to which the node belongs.
- * @returns {boolean} True if the identifier is a reference to a global variable.
- */
-function isGlobalReference(node, scope) {
-    const variable = findVariable(scope, node);
-
-    return variable !== null && variable.scope.type === "global" && variable.defs.length === 0;
-}
-
-/**
- * Finds function's outer scope.
- * @param {Scope} scope Function's own scope.
- * @returns {Scope} Function's outer scope.
- */
-function getOuterScope(scope) {
-    const upper = scope.upper;
-
-    if (upper.type === "function-expression-name") {
-        return upper.upper;
-    }
-    return upper;
-}
-
-/**
- * Determines whether the given function node is used as a Promise executor.
- * @param {ASTNode} node The node to check.
- * @param {Scope} scope Function's own scope.
- * @returns {boolean} `true` if the node is a Promise executor.
- */
-function isPromiseExecutor(node, scope) {
-    const parent = node.parent;
-
-    return parent.type === "NewExpression" &&
-        parent.arguments[0] === node &&
-        parent.callee.type === "Identifier" &&
-        parent.callee.name === "Promise" &&
-        isGlobalReference(parent.callee, getOuterScope(scope));
-}
-
-/**
- * Checks if the given node is a void expression.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} - `true` if the node is a void expression
- */
-function expressionIsVoid(node) {
-    return node.type === "UnaryExpression" && node.operator === "void";
-}
-
-/**
- * Fixes the linting error by prepending "void " to the given node
- * @param {Object} sourceCode context given by context.sourceCode
- * @param {ASTNode} node The node to fix.
- * @param {Object} fixer The fixer object provided by ESLint.
- * @returns {Array<Object>} - An array of fix objects to apply to the node.
- */
-function voidPrependFixer(sourceCode, node, fixer) {
-
-    const requiresParens =
-
-        // prepending `void ` will fail if the node has a lower precedence than void
-        astUtils.getPrecedence(node) < astUtils.getPrecedence({ type: "UnaryExpression", operator: "void" }) &&
-
-        // check if there are parentheses around the node to avoid redundant parentheses
-        !astUtils.isParenthesised(sourceCode, node);
-
-    // avoid parentheses issues
-    const returnOrArrowToken = sourceCode.getTokenBefore(
-        node,
-        node.parent.type === "ArrowFunctionExpression"
-            ? astUtils.isArrowToken
-
-            // isReturnToken
-            : token => token.type === "Keyword" && token.value === "return"
-    );
-
-    const firstToken = sourceCode.getTokenAfter(returnOrArrowToken);
-
-    const prependSpace =
-
-        // is return token, as => allows void to be adjacent
-        returnOrArrowToken.value === "return" &&
-
-        // If two tokens (return and "(") are adjacent
-        returnOrArrowToken.range[1] === firstToken.range[0];
-
-    return [
-        fixer.insertTextBefore(firstToken, `${prependSpace ? " " : ""}void ${requiresParens ? "(" : ""}`),
-        fixer.insertTextAfter(node, requiresParens ? ")" : "")
-    ];
-}
-
-/**
- * Fixes the linting error by `wrapping {}` around the given node's body.
- * @param {Object} sourceCode context given by context.sourceCode
- * @param {ASTNode} node The node to fix.
- * @param {Object} fixer The fixer object provided by ESLint.
- * @returns {Array<Object>} - An array of fix objects to apply to the node.
- */
-function curlyWrapFixer(sourceCode, node, fixer) {
-
-    // https://github.com/eslint/eslint/pull/17282#issuecomment-1592795923
-    const arrowToken = sourceCode.getTokenBefore(node.body, astUtils.isArrowToken);
-    const firstToken = sourceCode.getTokenAfter(arrowToken);
-    const lastToken = sourceCode.getLastToken(node);
-
-    return [
-        fixer.insertTextBefore(firstToken, "{"),
-        fixer.insertTextAfter(lastToken, "}")
-    ];
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow returning values from Promise executor functions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-promise-executor-return"
-        },
-
-        hasSuggestions: true,
-
-        schema: [{
-            type: "object",
-            properties: {
-                allowVoid: {
-                    type: "boolean",
-                    default: false
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            returnsValue: "Return values from promise executor functions cannot be read.",
-
-            // arrow and function suggestions
-            prependVoid: "Prepend `void` to the expression.",
-
-            // only arrow suggestions
-            wrapBraces: "Wrap the expression in `{}`."
-        }
-    },
-
-    create(context) {
-
-        let funcInfo = null;
-        const sourceCode = context.sourceCode;
-        const {
-            allowVoid = false
-        } = context.options[0] || {};
-
-        return {
-
-            onCodePathStart(_, node) {
-                funcInfo = {
-                    upper: funcInfo,
-                    shouldCheck:
-                        functionTypesToCheck.has(node.type) &&
-                        isPromiseExecutor(node, sourceCode.getScope(node))
-                };
-
-                if (// Is a Promise executor
-                    funcInfo.shouldCheck &&
-                    node.type === "ArrowFunctionExpression" &&
-                    node.expression &&
-
-                    // Except void
-                    !(allowVoid && expressionIsVoid(node.body))
-                ) {
-                    const suggest = [];
-
-                    // prevent useless refactors
-                    if (allowVoid) {
-                        suggest.push({
-                            messageId: "prependVoid",
-                            fix(fixer) {
-                                return voidPrependFixer(sourceCode, node.body, fixer);
-                            }
-                        });
-                    }
-
-                    // Do not suggest wrapping an unnamed FunctionExpression in braces as that would be invalid syntax.
-                    if (!(node.body.type === "FunctionExpression" && !node.body.id)) {
-                        suggest.push({
-                            messageId: "wrapBraces",
-                            fix(fixer) {
-                                return curlyWrapFixer(sourceCode, node, fixer);
-                            }
-                        });
-                    }
-
-                    context.report({
-                        node: node.body,
-                        messageId: "returnsValue",
-                        suggest
-                    });
-                }
-            },
-
-            onCodePathEnd() {
-                funcInfo = funcInfo.upper;
-            },
-
-            ReturnStatement(node) {
-                if (!(funcInfo.shouldCheck && node.argument)) {
-                    return;
-                }
-
-                // node is `return <expression>`
-                if (!allowVoid) {
-                    context.report({ node, messageId: "returnsValue" });
-                    return;
-                }
-
-                if (expressionIsVoid(node.argument)) {
-                    return;
-                }
-
-                // allowVoid && !expressionIsVoid
-                context.report({
-                    node,
-                    messageId: "returnsValue",
-                    suggest: [{
-                        messageId: "prependVoid",
-                        fix(fixer) {
-                            return voidPrependFixer(sourceCode, node.argument, fixer);
-                        }
-                    }]
-                });
-            }
-        };
-    }
-};

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

@@ -1,48 +0,0 @@
-/**
- * @fileoverview Rule to flag usage of __proto__ property
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { getStaticPropertyName } = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow the use of the `__proto__` property",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-proto"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpectedProto: "The '__proto__' property is deprecated."
-        }
-    },
-
-    create(context) {
-
-        return {
-
-            MemberExpression(node) {
-                if (getStaticPropertyName(node) === "__proto__") {
-                    context.report({ node, messageId: "unexpectedProto" });
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,159 +0,0 @@
-/**
- * @fileoverview Rule to disallow use of Object.prototype builtins on objects
- * @author Andrew Levine
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Returns true if the node or any of the objects
- * to the left of it in the member/call chain is optional.
- *
- * e.g. `a?.b`, `a?.b.c`, `a?.()`, `a()?.()`
- * @param {ASTNode} node The expression to check
- * @returns {boolean} `true` if there is a short-circuiting optional `?.`
- * in the same option chain to the left of this call or member expression,
- * or the node itself is an optional call or member `?.`.
- */
-function isAfterOptional(node) {
-    let leftNode;
-
-    if (node.type === "MemberExpression") {
-        leftNode = node.object;
-    } else if (node.type === "CallExpression") {
-        leftNode = node.callee;
-    } else {
-        return false;
-    }
-    if (node.optional) {
-        return true;
-    }
-    return isAfterOptional(leftNode);
-}
-
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow calling some `Object.prototype` methods directly on objects",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-prototype-builtins"
-        },
-
-        hasSuggestions: true,
-
-        schema: [],
-
-        messages: {
-            prototypeBuildIn: "Do not access Object.prototype method '{{prop}}' from target object.",
-            callObjectPrototype: "Call Object.prototype.{{prop}} explicitly."
-        }
-    },
-
-    create(context) {
-        const DISALLOWED_PROPS = new Set([
-            "hasOwnProperty",
-            "isPrototypeOf",
-            "propertyIsEnumerable"
-        ]);
-
-        /**
-         * Reports if a disallowed property is used in a CallExpression
-         * @param {ASTNode} node The CallExpression node.
-         * @returns {void}
-         */
-        function disallowBuiltIns(node) {
-
-            const callee = astUtils.skipChainExpression(node.callee);
-
-            if (callee.type !== "MemberExpression") {
-                return;
-            }
-
-            const propName = astUtils.getStaticPropertyName(callee);
-
-            if (propName !== null && DISALLOWED_PROPS.has(propName)) {
-                context.report({
-                    messageId: "prototypeBuildIn",
-                    loc: callee.property.loc,
-                    data: { prop: propName },
-                    node,
-                    suggest: [
-                        {
-                            messageId: "callObjectPrototype",
-                            data: { prop: propName },
-                            fix(fixer) {
-                                const sourceCode = context.sourceCode;
-
-                                /*
-                                 * A call after an optional chain (e.g. a?.b.hasOwnProperty(c))
-                                 * must be fixed manually because the call can be short-circuited
-                                 */
-                                if (isAfterOptional(node)) {
-                                    return null;
-                                }
-
-                                /*
-                                 * A call on a ChainExpression (e.g. (a?.hasOwnProperty)(c)) will trigger
-                                 * no-unsafe-optional-chaining which should be fixed before this suggestion
-                                 */
-                                if (node.callee.type === "ChainExpression") {
-                                    return null;
-                                }
-
-                                const objectVariable = astUtils.getVariableByName(sourceCode.getScope(node), "Object");
-
-                                /*
-                                 * We can't use Object if the global Object was shadowed,
-                                 * or Object does not exist in the global scope for some reason
-                                 */
-                                if (!objectVariable || objectVariable.scope.type !== "global" || objectVariable.defs.length > 0) {
-                                    return null;
-                                }
-
-                                let objectText = sourceCode.getText(callee.object);
-
-                                if (astUtils.getPrecedence(callee.object) <= astUtils.getPrecedence({ type: "SequenceExpression" })) {
-                                    objectText = `(${objectText})`;
-                                }
-
-                                const openParenToken = sourceCode.getTokenAfter(
-                                    node.callee,
-                                    astUtils.isOpeningParenToken
-                                );
-                                const isEmptyParameters = node.arguments.length === 0;
-                                const delim = isEmptyParameters ? "" : ", ";
-                                const fixes = [
-                                    fixer.replaceText(callee, `Object.prototype.${propName}.call`),
-                                    fixer.insertTextAfter(openParenToken, objectText + delim)
-                                ];
-
-                                return fixes;
-                            }
-                        }
-                    ]
-                });
-            }
-        }
-
-        return {
-            CallExpression: disallowBuiltIns
-        };
-    }
-};

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

@@ -1,174 +0,0 @@
-/**
- * @fileoverview Rule to flag when the same variable is declared more then once.
- * @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 variable redeclaration",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-redeclare"
-        },
-
-        messages: {
-            redeclared: "'{{id}}' is already defined.",
-            redeclaredAsBuiltin: "'{{id}}' is already defined as a built-in global variable.",
-            redeclaredBySyntax: "'{{id}}' is already defined by a variable declaration."
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    builtinGlobals: { type: "boolean", default: true }
-                },
-                additionalProperties: false
-            }
-        ]
-    },
-
-    create(context) {
-        const options = {
-            builtinGlobals: Boolean(
-                context.options.length === 0 ||
-                context.options[0].builtinGlobals
-            )
-        };
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Iterate declarations of a given variable.
-         * @param {escope.variable} variable The variable object to iterate declarations.
-         * @returns {IterableIterator<{type:string,node:ASTNode,loc:SourceLocation}>} The declarations.
-         */
-        function *iterateDeclarations(variable) {
-            if (options.builtinGlobals && (
-                variable.eslintImplicitGlobalSetting === "readonly" ||
-                variable.eslintImplicitGlobalSetting === "writable"
-            )) {
-                yield { type: "builtin" };
-            }
-
-            for (const id of variable.identifiers) {
-                yield { type: "syntax", node: id, loc: id.loc };
-            }
-
-            if (variable.eslintExplicitGlobalComments) {
-                for (const comment of variable.eslintExplicitGlobalComments) {
-                    yield {
-                        type: "comment",
-                        node: comment,
-                        loc: astUtils.getNameLocationInGlobalDirectiveComment(
-                            sourceCode,
-                            comment,
-                            variable.name
-                        )
-                    };
-                }
-            }
-        }
-
-        /**
-         * Find variables in a given scope and flag redeclared ones.
-         * @param {Scope} scope An eslint-scope scope object.
-         * @returns {void}
-         * @private
-         */
-        function findVariablesInScope(scope) {
-            for (const variable of scope.variables) {
-                const [
-                    declaration,
-                    ...extraDeclarations
-                ] = iterateDeclarations(variable);
-
-                if (extraDeclarations.length === 0) {
-                    continue;
-                }
-
-                /*
-                 * If the type of a declaration is different from the type of
-                 * the first declaration, it shows the location of the first
-                 * declaration.
-                 */
-                const detailMessageId = declaration.type === "builtin"
-                    ? "redeclaredAsBuiltin"
-                    : "redeclaredBySyntax";
-                const data = { id: variable.name };
-
-                // Report extra declarations.
-                for (const { type, node, loc } of extraDeclarations) {
-                    const messageId = type === declaration.type
-                        ? "redeclared"
-                        : detailMessageId;
-
-                    context.report({ node, loc, messageId, data });
-                }
-            }
-        }
-
-        /**
-         * Find variables in the current scope.
-         * @param {ASTNode} node The node of the current scope.
-         * @returns {void}
-         * @private
-         */
-        function checkForBlock(node) {
-            const scope = sourceCode.getScope(node);
-
-            /*
-             * In ES5, some node type such as `BlockStatement` doesn't have that scope.
-             * `scope.block` is a different node in such a case.
-             */
-            if (scope.block === node) {
-                findVariablesInScope(scope);
-            }
-        }
-
-        return {
-            Program(node) {
-                const scope = sourceCode.getScope(node);
-
-                findVariablesInScope(scope);
-
-                // Node.js or ES modules has a special scope.
-                if (
-                    scope.type === "global" &&
-                    scope.childScopes[0] &&
-
-                    // The special scope's block is the Program node.
-                    scope.block === scope.childScopes[0].block
-                ) {
-                    findVariablesInScope(scope.childScopes[0]);
-                }
-            },
-
-            FunctionDeclaration: checkForBlock,
-            FunctionExpression: checkForBlock,
-            ArrowFunctionExpression: checkForBlock,
-
-            StaticBlock: checkForBlock,
-
-            BlockStatement: checkForBlock,
-            ForStatement: checkForBlock,
-            ForInStatement: checkForBlock,
-            ForOfStatement: checkForBlock,
-            SwitchStatement: checkForBlock
-        };
-    }
-};