@alexlit/lint-kit 127.0.0 → 127.1.0

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

@@ -1,78 +0,0 @@
-/**
- * @fileoverview Rule to disallow an empty pattern
- * @author Alberto Rodríguez
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow empty destructuring patterns",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-empty-pattern"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowObjectPatternsAsParameters: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpected: "Unexpected empty {{type}} pattern."
-        }
-    },
-
-    create(context) {
-        const options = context.options[0] || {},
-            allowObjectPatternsAsParameters = options.allowObjectPatternsAsParameters || false;
-
-        return {
-            ObjectPattern(node) {
-
-                if (node.properties.length > 0) {
-                    return;
-                }
-
-                // Allow {} and {} = {} empty object patterns as parameters when allowObjectPatternsAsParameters is true
-                if (
-                    allowObjectPatternsAsParameters &&
-                    (
-                        astUtils.isFunction(node.parent) ||
-                        (
-                            node.parent.type === "AssignmentPattern" &&
-                            astUtils.isFunction(node.parent.parent) &&
-                            node.parent.right.type === "ObjectExpression" &&
-                            node.parent.right.properties.length === 0
-                        )
-                    )
-                ) {
-                    return;
-                }
-
-                context.report({ node, messageId: "unexpected", data: { type: "object" } });
-            },
-            ArrayPattern(node) {
-                if (node.elements.length === 0) {
-                    context.report({ node, messageId: "unexpected", data: { type: "array" } });
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-empty-static-block.js

@@ -1,47 +0,0 @@
-/**
- * @fileoverview Rule to disallow empty static blocks.
- * @author Sosuke Suzuki
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow empty static blocks",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-empty-static-block"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpected: "Unexpected empty static block."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            StaticBlock(node) {
-                if (node.body.length === 0) {
-                    const closingBrace = sourceCode.getLastToken(node);
-
-                    if (sourceCode.getCommentsBefore(closingBrace).length === 0) {
-                        context.report({
-                            node,
-                            messageId: "unexpected"
-                        });
-                    }
-                }
-            }
-        };
-    }
-};

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

@@ -1,103 +0,0 @@
-/**
- * @fileoverview Rule to flag use of an empty block statement
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        hasSuggestions: true,
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow empty block statements",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-empty"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowEmptyCatch: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpected: "Empty {{type}} statement.",
-            suggestComment: "Add comment inside empty {{type}} statement."
-        }
-    },
-
-    create(context) {
-        const options = context.options[0] || {},
-            allowEmptyCatch = options.allowEmptyCatch || false;
-
-        const sourceCode = context.sourceCode;
-
-        return {
-            BlockStatement(node) {
-
-                // if the body is not empty, we can just return immediately
-                if (node.body.length !== 0) {
-                    return;
-                }
-
-                // a function is generally allowed to be empty
-                if (astUtils.isFunction(node.parent)) {
-                    return;
-                }
-
-                if (allowEmptyCatch && node.parent.type === "CatchClause") {
-                    return;
-                }
-
-                // any other block is only allowed to be empty, if it contains a comment
-                if (sourceCode.getCommentsInside(node).length > 0) {
-                    return;
-                }
-
-                context.report({
-                    node,
-                    messageId: "unexpected",
-                    data: { type: "block" },
-                    suggest: [
-                        {
-                            messageId: "suggestComment",
-                            data: { type: "block" },
-                            fix(fixer) {
-                                const range = [node.range[0] + 1, node.range[1] - 1];
-
-                                return fixer.replaceTextRange(range, " /* empty */ ");
-                            }
-                        }
-                    ]
-                });
-            },
-
-            SwitchStatement(node) {
-
-                if (typeof node.cases === "undefined" || node.cases.length === 0) {
-                    context.report({ node, messageId: "unexpected", data: { type: "switch" } });
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,46 +0,0 @@
-/**
- * @fileoverview Rule to flag comparisons to null without a type-checking
- * operator.
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `null` comparisons without type-checking operators",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-eq-null"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpected: "Use '===' to compare with null."
-        }
-    },
-
-    create(context) {
-
-        return {
-
-            BinaryExpression(node) {
-                const badOperator = node.operator === "==" || node.operator === "!=";
-
-                if (node.right.type === "Literal" && node.right.raw === "null" && badOperator ||
-                        node.left.type === "Literal" && node.left.raw === "null" && badOperator) {
-                    context.report({ node, messageId: "unexpected" });
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,286 +0,0 @@
-/**
- * @fileoverview Rule to flag use of eval() statement
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const candidatesOfGlobalObject = Object.freeze([
-    "global",
-    "window",
-    "globalThis"
-]);
-
-/**
- * Checks a given node is a MemberExpression node which has the specified name's
- * property.
- * @param {ASTNode} node A node to check.
- * @param {string} name A name to check.
- * @returns {boolean} `true` if the node is a MemberExpression node which has
- *      the specified name's property
- */
-function isMember(node, name) {
-    return astUtils.isSpecificMemberAccess(node, null, name);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow the use of `eval()`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-eval"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowIndirect: { type: "boolean", default: false }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpected: "eval can be harmful."
-        }
-    },
-
-    create(context) {
-        const allowIndirect = Boolean(
-            context.options[0] &&
-            context.options[0].allowIndirect
-        );
-        const sourceCode = context.sourceCode;
-        let funcInfo = null;
-
-        /**
-         * Pushes a `this` scope (non-arrow function, class static block, or class field initializer) information to the stack.
-         * Top-level scopes are handled separately.
-         *
-         * This is used in order to check whether or not `this` binding is a
-         * reference to the global object.
-         * @param {ASTNode} node A node of the scope.
-         *      For functions, this is one of FunctionDeclaration, FunctionExpression.
-         *      For class static blocks, this is StaticBlock.
-         *      For class field initializers, this can be any node that is PropertyDefinition#value.
-         * @returns {void}
-         */
-        function enterThisScope(node) {
-            const strict = sourceCode.getScope(node).isStrict;
-
-            funcInfo = {
-                upper: funcInfo,
-                node,
-                strict,
-                isTopLevelOfScript: false,
-                defaultThis: false,
-                initialized: strict
-            };
-        }
-
-        /**
-         * Pops a variable scope from the stack.
-         * @returns {void}
-         */
-        function exitThisScope() {
-            funcInfo = funcInfo.upper;
-        }
-
-        /**
-         * Reports a given node.
-         *
-         * `node` is `Identifier` or `MemberExpression`.
-         * The parent of `node` might be `CallExpression`.
-         *
-         * The location of the report is always `eval` `Identifier` (or possibly
-         * `Literal`). The type of the report is `CallExpression` if the parent is
-         * `CallExpression`. Otherwise, it's the given node type.
-         * @param {ASTNode} node A node to report.
-         * @returns {void}
-         */
-        function report(node) {
-            const parent = node.parent;
-            const locationNode = node.type === "MemberExpression"
-                ? node.property
-                : node;
-
-            const reportNode = parent.type === "CallExpression" && parent.callee === node
-                ? parent
-                : node;
-
-            context.report({
-                node: reportNode,
-                loc: locationNode.loc,
-                messageId: "unexpected"
-            });
-        }
-
-        /**
-         * Reports accesses of `eval` via the global object.
-         * @param {eslint-scope.Scope} globalScope The global scope.
-         * @returns {void}
-         */
-        function reportAccessingEvalViaGlobalObject(globalScope) {
-            for (let i = 0; i < candidatesOfGlobalObject.length; ++i) {
-                const name = candidatesOfGlobalObject[i];
-                const variable = astUtils.getVariableByName(globalScope, name);
-
-                if (!variable) {
-                    continue;
-                }
-
-                const references = variable.references;
-
-                for (let j = 0; j < references.length; ++j) {
-                    const identifier = references[j].identifier;
-                    let node = identifier.parent;
-
-                    // To detect code like `window.window.eval`.
-                    while (isMember(node, name)) {
-                        node = node.parent;
-                    }
-
-                    // Reports.
-                    if (isMember(node, "eval")) {
-                        report(node);
-                    }
-                }
-            }
-        }
-
-        /**
-         * Reports all accesses of `eval` (excludes direct calls to eval).
-         * @param {eslint-scope.Scope} globalScope The global scope.
-         * @returns {void}
-         */
-        function reportAccessingEval(globalScope) {
-            const variable = astUtils.getVariableByName(globalScope, "eval");
-
-            if (!variable) {
-                return;
-            }
-
-            const references = variable.references;
-
-            for (let i = 0; i < references.length; ++i) {
-                const reference = references[i];
-                const id = reference.identifier;
-
-                if (id.name === "eval" && !astUtils.isCallee(id)) {
-
-                    // Is accessing to eval (excludes direct calls to eval)
-                    report(id);
-                }
-            }
-        }
-
-        if (allowIndirect) {
-
-            // Checks only direct calls to eval. It's simple!
-            return {
-                "CallExpression:exit"(node) {
-                    const callee = node.callee;
-
-                    /*
-                     * Optional call (`eval?.("code")`) is not direct eval.
-                     * The direct eval is only step 6.a.vi of https://tc39.es/ecma262/#sec-function-calls-runtime-semantics-evaluation
-                     * But the optional call is https://tc39.es/ecma262/#sec-optional-chaining-chain-evaluation
-                     */
-                    if (!node.optional && astUtils.isSpecificId(callee, "eval")) {
-                        report(callee);
-                    }
-                }
-            };
-        }
-
-        return {
-            "CallExpression:exit"(node) {
-                const callee = node.callee;
-
-                if (astUtils.isSpecificId(callee, "eval")) {
-                    report(callee);
-                }
-            },
-
-            Program(node) {
-                const scope = sourceCode.getScope(node),
-                    features = context.parserOptions.ecmaFeatures || {},
-                    strict =
-                        scope.isStrict ||
-                        node.sourceType === "module" ||
-                        (features.globalReturn && scope.childScopes[0].isStrict),
-                    isTopLevelOfScript = node.sourceType !== "module" && !features.globalReturn;
-
-                funcInfo = {
-                    upper: null,
-                    node,
-                    strict,
-                    isTopLevelOfScript,
-                    defaultThis: true,
-                    initialized: true
-                };
-            },
-
-            "Program:exit"(node) {
-                const globalScope = sourceCode.getScope(node);
-
-                exitThisScope();
-                reportAccessingEval(globalScope);
-                reportAccessingEvalViaGlobalObject(globalScope);
-            },
-
-            FunctionDeclaration: enterThisScope,
-            "FunctionDeclaration:exit": exitThisScope,
-            FunctionExpression: enterThisScope,
-            "FunctionExpression:exit": exitThisScope,
-            "PropertyDefinition > *.value": enterThisScope,
-            "PropertyDefinition > *.value:exit": exitThisScope,
-            StaticBlock: enterThisScope,
-            "StaticBlock:exit": exitThisScope,
-
-            ThisExpression(node) {
-                if (!isMember(node.parent, "eval")) {
-                    return;
-                }
-
-                /*
-                 * `this.eval` is found.
-                 * Checks whether or not the value of `this` is the global object.
-                 */
-                if (!funcInfo.initialized) {
-                    funcInfo.initialized = true;
-                    funcInfo.defaultThis = astUtils.isDefaultThisBinding(
-                        funcInfo.node,
-                        sourceCode
-                    );
-                }
-
-                // `this` at the top level of scripts always refers to the global object
-                if (funcInfo.isTopLevelOfScript || (!funcInfo.strict && funcInfo.defaultThis)) {
-
-                    // `this.eval` is possible built-in `eval`.
-                    report(node.parent);
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,54 +0,0 @@
-/**
- * @fileoverview Rule to flag assignment of the exception parameter
- * @author Stephen Murray <spmurrayzzz>
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow reassigning exceptions in `catch` clauses",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-ex-assign"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpected: "Do not assign to the exception parameter."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Finds and reports references that are non initializer and writable.
-         * @param {Variable} variable A variable to check.
-         * @returns {void}
-         */
-        function checkVariable(variable) {
-            astUtils.getModifyingReferences(variable.references).forEach(reference => {
-                context.report({ node: reference.identifier, messageId: "unexpected" });
-            });
-        }
-
-        return {
-            CatchClause(node) {
-                sourceCode.getDeclaredVariables(node).forEach(checkVariable);
-            }
-        };
-
-    }
-};