@alexlit/lint-kit 127.0.0 → 127.2.0

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

@@ -1,241 +0,0 @@
-/**
- * @fileoverview Rule to flag updates of imported bindings.
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const { findVariable } = require("@eslint-community/eslint-utils");
-const astUtils = require("./utils/ast-utils");
-
-const WellKnownMutationFunctions = {
-    Object: /^(?:assign|definePropert(?:y|ies)|freeze|setPrototypeOf)$/u,
-    Reflect: /^(?:(?:define|delete)Property|set(?:PrototypeOf)?)$/u
-};
-
-/**
- * Check if a given node is LHS of an assignment node.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is LHS.
- */
-function isAssignmentLeft(node) {
-    const { parent } = node;
-
-    return (
-        (
-            parent.type === "AssignmentExpression" &&
-            parent.left === node
-        ) ||
-
-        // Destructuring assignments
-        parent.type === "ArrayPattern" ||
-        (
-            parent.type === "Property" &&
-            parent.value === node &&
-            parent.parent.type === "ObjectPattern"
-        ) ||
-        parent.type === "RestElement" ||
-        (
-            parent.type === "AssignmentPattern" &&
-            parent.left === node
-        )
-    );
-}
-
-/**
- * Check if a given node is the operand of mutation unary operator.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is the operand of mutation unary operator.
- */
-function isOperandOfMutationUnaryOperator(node) {
-    const argumentNode = node.parent.type === "ChainExpression"
-        ? node.parent
-        : node;
-    const { parent } = argumentNode;
-
-    return (
-        (
-            parent.type === "UpdateExpression" &&
-            parent.argument === argumentNode
-        ) ||
-        (
-            parent.type === "UnaryExpression" &&
-            parent.operator === "delete" &&
-            parent.argument === argumentNode
-        )
-    );
-}
-
-/**
- * Check if a given node is the iteration variable of `for-in`/`for-of` syntax.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is the iteration variable.
- */
-function isIterationVariable(node) {
-    const { parent } = node;
-
-    return (
-        (
-            parent.type === "ForInStatement" &&
-            parent.left === node
-        ) ||
-        (
-            parent.type === "ForOfStatement" &&
-            parent.left === node
-        )
-    );
-}
-
-/**
- * Check if a given node is at the first argument of a well-known mutation function.
- * - `Object.assign`
- * - `Object.defineProperty`
- * - `Object.defineProperties`
- * - `Object.freeze`
- * - `Object.setPrototypeOf`
- * - `Reflect.defineProperty`
- * - `Reflect.deleteProperty`
- * - `Reflect.set`
- * - `Reflect.setPrototypeOf`
- * @param {ASTNode} node The node to check.
- * @param {Scope} scope A `escope.Scope` object to find variable (whichever).
- * @returns {boolean} `true` if the node is at the first argument of a well-known mutation function.
- */
-function isArgumentOfWellKnownMutationFunction(node, scope) {
-    const { parent } = node;
-
-    if (parent.type !== "CallExpression" || parent.arguments[0] !== node) {
-        return false;
-    }
-    const callee = astUtils.skipChainExpression(parent.callee);
-
-    if (
-        !astUtils.isSpecificMemberAccess(callee, "Object", WellKnownMutationFunctions.Object) &&
-        !astUtils.isSpecificMemberAccess(callee, "Reflect", WellKnownMutationFunctions.Reflect)
-    ) {
-        return false;
-    }
-    const variable = findVariable(scope, callee.object);
-
-    return variable !== null && variable.scope.type === "global";
-}
-
-/**
- * Check if the identifier node is placed at to update members.
- * @param {ASTNode} id The Identifier node to check.
- * @param {Scope} scope A `escope.Scope` object to find variable (whichever).
- * @returns {boolean} `true` if the member of `id` was updated.
- */
-function isMemberWrite(id, scope) {
-    const { parent } = id;
-
-    return (
-        (
-            parent.type === "MemberExpression" &&
-            parent.object === id &&
-            (
-                isAssignmentLeft(parent) ||
-                isOperandOfMutationUnaryOperator(parent) ||
-                isIterationVariable(parent)
-            )
-        ) ||
-        isArgumentOfWellKnownMutationFunction(id, scope)
-    );
-}
-
-/**
- * Get the mutation node.
- * @param {ASTNode} id The Identifier node to get.
- * @returns {ASTNode} The mutation node.
- */
-function getWriteNode(id) {
-    let node = id.parent;
-
-    while (
-        node &&
-        node.type !== "AssignmentExpression" &&
-        node.type !== "UpdateExpression" &&
-        node.type !== "UnaryExpression" &&
-        node.type !== "CallExpression" &&
-        node.type !== "ForInStatement" &&
-        node.type !== "ForOfStatement"
-    ) {
-        node = node.parent;
-    }
-
-    return node || id;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow assigning to imported bindings",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-import-assign"
-        },
-
-        schema: [],
-
-        messages: {
-            readonly: "'{{name}}' is read-only.",
-            readonlyMember: "The members of '{{name}}' are read-only."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            ImportDeclaration(node) {
-                const scope = sourceCode.getScope(node);
-
-                for (const variable of sourceCode.getDeclaredVariables(node)) {
-                    const shouldCheckMembers = variable.defs.some(
-                        d => d.node.type === "ImportNamespaceSpecifier"
-                    );
-                    let prevIdNode = null;
-
-                    for (const reference of variable.references) {
-                        const idNode = reference.identifier;
-
-                        /*
-                         * AssignmentPattern (e.g. `[a = 0] = b`) makes two write
-                         * references for the same identifier. This should skip
-                         * the one of the two in order to prevent redundant reports.
-                         */
-                        if (idNode === prevIdNode) {
-                            continue;
-                        }
-                        prevIdNode = idNode;
-
-                        if (reference.isWrite()) {
-                            context.report({
-                                node: getWriteNode(idNode),
-                                messageId: "readonly",
-                                data: { name: idNode.name }
-                            });
-                        } else if (shouldCheckMembers && isMemberWrite(idNode, scope)) {
-                            context.report({
-                                node: getWriteNode(idNode),
-                                messageId: "readonlyMember",
-                                data: { name: idNode.name }
-                            });
-                        }
-                    }
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,110 +0,0 @@
-/**
- * @fileoverview Enforces or disallows inline comments.
- * @author Greg Cochard
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow inline comments after code",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-inline-comments"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    ignorePattern: {
-                        type: "string"
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpectedInlineComment: "Unexpected comment inline with code."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const options = context.options[0];
-        let customIgnoreRegExp;
-
-        if (options && options.ignorePattern) {
-            customIgnoreRegExp = new RegExp(options.ignorePattern, "u");
-        }
-
-        /**
-         * Will check that comments are not on lines starting with or ending with code
-         * @param {ASTNode} node The comment node to check
-         * @private
-         * @returns {void}
-         */
-        function testCodeAroundComment(node) {
-
-            const startLine = String(sourceCode.lines[node.loc.start.line - 1]),
-                endLine = String(sourceCode.lines[node.loc.end.line - 1]),
-                preamble = startLine.slice(0, node.loc.start.column).trim(),
-                postamble = endLine.slice(node.loc.end.column).trim(),
-                isPreambleEmpty = !preamble,
-                isPostambleEmpty = !postamble;
-
-            // Nothing on both sides
-            if (isPreambleEmpty && isPostambleEmpty) {
-                return;
-            }
-
-            // Matches the ignore pattern
-            if (customIgnoreRegExp && customIgnoreRegExp.test(node.value)) {
-                return;
-            }
-
-            // JSX Exception
-            if (
-                (isPreambleEmpty || preamble === "{") &&
-                (isPostambleEmpty || postamble === "}")
-            ) {
-                const enclosingNode = sourceCode.getNodeByRangeIndex(node.range[0]);
-
-                if (enclosingNode && enclosingNode.type === "JSXEmptyExpression") {
-                    return;
-                }
-            }
-
-            // Don't report ESLint directive comments
-            if (astUtils.isDirectiveComment(node)) {
-                return;
-            }
-
-            context.report({
-                node,
-                messageId: "unexpectedInlineComment"
-            });
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            Program() {
-                sourceCode.getAllComments()
-                    .filter(token => token.type !== "Shebang")
-                    .forEach(testCodeAroundComment);
-            }
-        };
-    }
-};

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

@@ -1,131 +0,0 @@
-/**
- * @fileoverview Rule to enforce declarations in program or function body root.
- * @author Brandon Mills
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const validParent = new Set(["Program", "StaticBlock", "ExportNamedDeclaration", "ExportDefaultDeclaration"]);
-const validBlockStatementParent = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
-
-/**
- * Finds the nearest enclosing context where this rule allows declarations and returns its description.
- * @param {ASTNode} node Node to search from.
- * @returns {string} Description. One of "program", "function body", "class static block body".
- */
-function getAllowedBodyDescription(node) {
-    let { parent } = node;
-
-    while (parent) {
-
-        if (parent.type === "StaticBlock") {
-            return "class static block body";
-        }
-
-        if (astUtils.isFunction(parent)) {
-            return "function body";
-        }
-
-        ({ parent } = parent);
-    }
-
-    return "program";
-}
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow variable or `function` declarations in nested blocks",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-inner-declarations"
-        },
-
-        schema: [
-            {
-                enum: ["functions", "both"]
-            },
-            {
-                type: "object",
-                properties: {
-                    blockScopedFunctions: {
-                        enum: ["allow", "disallow"]
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            moveDeclToRoot: "Move {{type}} declaration to {{body}} root."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-        const ecmaVersion = context.languageOptions.ecmaVersion;
-        const blockScopedFunctions = context.options[1]?.blockScopedFunctions ?? "allow";
-
-        /**
-         * Ensure that a given node is at a program or function body's root.
-         * @param {ASTNode} node Declaration node to check.
-         * @returns {void}
-         */
-        function check(node) {
-            const parent = node.parent;
-
-            if (
-                parent.type === "BlockStatement" && validBlockStatementParent.has(parent.parent.type)
-            ) {
-                return;
-            }
-
-            if (validParent.has(parent.type)) {
-                return;
-            }
-
-            context.report({
-                node,
-                messageId: "moveDeclToRoot",
-                data: {
-                    type: (node.type === "FunctionDeclaration" ? "function" : "variable"),
-                    body: getAllowedBodyDescription(node)
-                }
-            });
-        }
-
-
-        return {
-
-            FunctionDeclaration(node) {
-                const isInStrictCode = sourceCode.getScope(node).upper.isStrict;
-
-                if (blockScopedFunctions === "allow" && ecmaVersion >= 2015 && isInStrictCode) {
-                    return;
-                }
-
-                check(node);
-            },
-            VariableDeclaration(node) {
-                if (context.options[0] === "both" && node.kind === "var") {
-                    check(node);
-                }
-            }
-
-        };
-
-    }
-};

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

@@ -1,194 +0,0 @@
-/**
- * @fileoverview Validate strings passed to the RegExp constructor
- * @author Michael Ficarra
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
-const validator = new RegExpValidator();
-const validFlags = /[dgimsuvy]/gu;
-const undefined1 = void 0;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow invalid regular expression strings in `RegExp` constructors",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-invalid-regexp"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                allowConstructorFlags: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            regexMessage: "{{message}}."
-        }
-    },
-
-    create(context) {
-
-        const options = context.options[0];
-        let allowedFlags = null;
-
-        if (options && options.allowConstructorFlags) {
-            const temp = options.allowConstructorFlags.join("").replace(validFlags, "");
-
-            if (temp) {
-                allowedFlags = new RegExp(`[${temp}]`, "gu");
-            }
-        }
-
-        /**
-         * Reports error with the provided message.
-         * @param {ASTNode} node The node holding the invalid RegExp
-         * @param {string} message The message to report.
-         * @returns {void}
-         */
-        function report(node, message) {
-            context.report({
-                node,
-                messageId: "regexMessage",
-                data: { message }
-            });
-        }
-
-        /**
-         * Check if node is a string
-         * @param {ASTNode} node node to evaluate
-         * @returns {boolean} True if its a string
-         * @private
-         */
-        function isString(node) {
-            return node && node.type === "Literal" && typeof node.value === "string";
-        }
-
-        /**
-         * Gets flags of a regular expression created by the given `RegExp()` or `new RegExp()` call
-         * Examples:
-         *     new RegExp(".")         // => ""
-         *     new RegExp(".", "gu")   // => "gu"
-         *     new RegExp(".", flags)  // => null
-         * @param {ASTNode} node `CallExpression` or `NewExpression` node
-         * @returns {string|null} flags if they can be determined, `null` otherwise
-         * @private
-         */
-        function getFlags(node) {
-            if (node.arguments.length < 2) {
-                return "";
-            }
-
-            if (isString(node.arguments[1])) {
-                return node.arguments[1].value;
-            }
-
-            return null;
-        }
-
-        /**
-         * Check syntax error in a given pattern.
-         * @param {string} pattern The RegExp pattern to validate.
-         * @param {Object} flags The RegExp flags to validate.
-         * @param {boolean} [flags.unicode] The Unicode flag.
-         * @param {boolean} [flags.unicodeSets] The UnicodeSets flag.
-         * @returns {string|null} The syntax error.
-         */
-        function validateRegExpPattern(pattern, flags) {
-            try {
-                validator.validatePattern(pattern, undefined1, undefined1, flags);
-                return null;
-            } catch (err) {
-                return err.message;
-            }
-        }
-
-        /**
-         * Check syntax error in a given flags.
-         * @param {string|null} flags The RegExp flags to validate.
-         * @returns {string|null} The syntax error.
-         */
-        function validateRegExpFlags(flags) {
-            if (!flags) {
-                return null;
-            }
-            try {
-                validator.validateFlags(flags);
-            } catch {
-                return `Invalid flags supplied to RegExp constructor '${flags}'`;
-            }
-
-            /*
-             * `regexpp` checks the combination of `u` and `v` flags when parsing `Pattern` according to `ecma262`,
-             * but this rule may check only the flag when the pattern is unidentifiable, so check it here.
-             * https://tc39.es/ecma262/multipage/text-processing.html#sec-parsepattern
-             */
-            if (flags.includes("u") && flags.includes("v")) {
-                return "Regex 'u' and 'v' flags cannot be used together";
-            }
-            return null;
-        }
-
-        return {
-            "CallExpression, NewExpression"(node) {
-                if (node.callee.type !== "Identifier" || node.callee.name !== "RegExp") {
-                    return;
-                }
-
-                let flags = getFlags(node);
-
-                if (flags && allowedFlags) {
-                    flags = flags.replace(allowedFlags, "");
-                }
-
-                let message = validateRegExpFlags(flags);
-
-                if (message) {
-                    report(node, message);
-                    return;
-                }
-
-                if (!isString(node.arguments[0])) {
-                    return;
-                }
-
-                const pattern = node.arguments[0].value;
-
-                message = (
-
-                    // If flags are unknown, report the regex only if its pattern is invalid both with and without the "u" flag
-                    flags === null
-                        ? (
-                            validateRegExpPattern(pattern, { unicode: true, unicodeSets: false }) &&
-                            validateRegExpPattern(pattern, { unicode: false, unicodeSets: true }) &&
-                            validateRegExpPattern(pattern, { unicode: false, unicodeSets: false })
-                        )
-                        : validateRegExpPattern(pattern, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") })
-                );
-
-                if (message) {
-                    report(node, message);
-                }
-            }
-        };
-    }
-};