@alexlit/lint-kit 127.0.0 → 127.2.0

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

@@ -1,87 +0,0 @@
-/**
- * @fileoverview Rule to flag when using new Function
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const callMethods = new Set(["apply", "bind", "call"]);
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `new` operators with the `Function` object",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-new-func"
-        },
-
-        schema: [],
-
-        messages: {
-            noFunctionConstructor: "The Function constructor is eval."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            "Program:exit"(node) {
-                const globalScope = sourceCode.getScope(node);
-                const variable = globalScope.set.get("Function");
-
-                if (variable && variable.defs.length === 0) {
-                    variable.references.forEach(ref => {
-                        const idNode = ref.identifier;
-                        const { parent } = idNode;
-                        let evalNode;
-
-                        if (parent) {
-                            if (idNode === parent.callee && (
-                                parent.type === "NewExpression" ||
-                                parent.type === "CallExpression"
-                            )) {
-                                evalNode = parent;
-                            } else if (
-                                parent.type === "MemberExpression" &&
-                                idNode === parent.object &&
-                                callMethods.has(astUtils.getStaticPropertyName(parent))
-                            ) {
-                                const maybeCallee = parent.parent.type === "ChainExpression" ? parent.parent : parent;
-
-                                if (maybeCallee.parent.type === "CallExpression" && maybeCallee.parent.callee === maybeCallee) {
-                                    evalNode = maybeCallee.parent;
-                                }
-                            }
-                        }
-
-                        if (evalNode) {
-                            context.report({
-                                node: evalNode,
-                                messageId: "noFunctionConstructor"
-                            });
-                        }
-                    });
-                }
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-new-native-nonconstructor.js

@@ -1,66 +0,0 @@
-/**
- * @fileoverview Rule to disallow use of the new operator with global non-constructor functions
- * @author Sosuke Suzuki
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const nonConstructorGlobalFunctionNames = ["Symbol", "BigInt"];
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow `new` operators with global non-constructor functions",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-new-native-nonconstructor"
-        },
-
-        schema: [],
-
-        messages: {
-            noNewNonconstructor: "`{{name}}` cannot be called as a constructor."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        return {
-            "Program:exit"(node) {
-                const globalScope = sourceCode.getScope(node);
-
-                for (const nonConstructorName of nonConstructorGlobalFunctionNames) {
-                    const variable = globalScope.set.get(nonConstructorName);
-
-                    if (variable && variable.defs.length === 0) {
-                        variable.references.forEach(ref => {
-                            const idNode = ref.identifier;
-                            const parent = idNode.parent;
-
-                            if (parent && parent.type === "NewExpression" && parent.callee === idNode) {
-                                context.report({
-                                    node: idNode,
-                                    messageId: "noNewNonconstructor",
-                                    data: { name: nonConstructorName }
-                                });
-                            }
-                        });
-                    }
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,67 +0,0 @@
-/**
- * @fileoverview A rule to disallow calls to the Object constructor
- * @author Matt DuVall <http://www.mattduvall.com/>
- * @deprecated in ESLint v8.50.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `Object` constructors",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-new-object"
-        },
-
-        deprecated: true,
-
-        replacedBy: [
-            "no-object-constructor"
-        ],
-
-        schema: [],
-
-        messages: {
-            preferLiteral: "The object literal notation {} is preferable."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        return {
-            NewExpression(node) {
-                const variable = astUtils.getVariableByName(
-                    sourceCode.getScope(node),
-                    node.callee.name
-                );
-
-                if (variable && variable.identifiers.length > 0) {
-                    return;
-                }
-
-                if (node.callee.name === "Object") {
-                    context.report({
-                        node,
-                        messageId: "preferLiteral"
-                    });
-                }
-            }
-        };
-    }
-};

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

@@ -1,50 +0,0 @@
-/**
- * @fileoverview Rule to disallow use of new operator with the `require` function
- * @author Wil Moore III
- * @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 `new` operators with calls to `require`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-new-require"
-        },
-
-        schema: [],
-
-        messages: {
-            noNewRequire: "Unexpected use of new with require."
-        }
-    },
-
-    create(context) {
-
-        return {
-
-            NewExpression(node) {
-                if (node.callee.type === "Identifier" && node.callee.name === "require") {
-                    context.report({
-                        node,
-                        messageId: "noNewRequire"
-                    });
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,63 +0,0 @@
-/**
- * @fileoverview Rule to disallow use of the new operator with the `Symbol` object
- * @author Alberto Rodríguez
- * @deprecated in ESLint v9.0.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow `new` operators with the `Symbol` object",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-new-symbol"
-        },
-
-        deprecated: true,
-
-        replacedBy: [
-            "no-new-native-nonconstructor"
-        ],
-
-        schema: [],
-
-        messages: {
-            noNewSymbol: "`Symbol` cannot be called as a constructor."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        return {
-            "Program:exit"(node) {
-                const globalScope = sourceCode.getScope(node);
-                const variable = globalScope.set.get("Symbol");
-
-                if (variable && variable.defs.length === 0) {
-                    variable.references.forEach(ref => {
-                        const idNode = ref.identifier;
-                        const parent = idNode.parent;
-
-                        if (parent && parent.type === "NewExpression" && parent.callee === idNode) {
-                            context.report({
-                                node: idNode,
-                                messageId: "noNewSymbol"
-                            });
-                        }
-                    });
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,60 +0,0 @@
-/**
- * @fileoverview Rule to flag when using constructor for wrapper objects
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { getVariableByName } = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `new` operators with the `String`, `Number`, and `Boolean` objects",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-new-wrappers"
-        },
-
-        schema: [],
-
-        messages: {
-            noConstructor: "Do not use {{fn}} as a constructor."
-        }
-    },
-
-    create(context) {
-        const { sourceCode } = context;
-
-        return {
-
-            NewExpression(node) {
-                const wrapperObjects = ["String", "Number", "Boolean"];
-                const { name } = node.callee;
-
-                if (wrapperObjects.includes(name)) {
-                    const variable = getVariableByName(sourceCode.getScope(node), name);
-
-                    if (variable && variable.identifiers.length === 0) {
-                        context.report({
-                            node,
-                            messageId: "noConstructor",
-                            data: { fn: name }
-                        });
-                    }
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,43 +0,0 @@
-/**
- * @fileoverview Rule to flag statements with function invocation preceded by
- * "new" and not part of assignment
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `new` operators outside of assignments or comparisons",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-new"
-        },
-
-        schema: [],
-
-        messages: {
-            noNewStatement: "Do not use 'new' for side effects."
-        }
-    },
-
-    create(context) {
-
-        return {
-            "ExpressionStatement > NewExpression"(node) {
-                context.report({
-                    node: node.parent,
-                    messageId: "noNewStatement"
-                });
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-nonoctal-decimal-escape.js

@@ -1,148 +0,0 @@
-/**
- * @fileoverview Rule to disallow `\8` and `\9` escape sequences in string literals.
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const QUICK_TEST_REGEX = /\\[89]/u;
-
-/**
- * Returns unicode escape sequence that represents the given character.
- * @param {string} character A single code unit.
- * @returns {string} "\uXXXX" sequence.
- */
-function getUnicodeEscape(character) {
-    return `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `\\8` and `\\9` escape sequences in string literals",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape"
-        },
-
-        hasSuggestions: true,
-
-        schema: [],
-
-        messages: {
-            decimalEscape: "Don't use '{{decimalEscape}}' escape sequence.",
-
-            // suggestions
-            refactor: "Replace '{{original}}' with '{{replacement}}'. This maintains the current functionality.",
-            escapeBackslash: "Replace '{{original}}' with '{{replacement}}' to include the actual backslash character."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Creates a new Suggestion object.
-         * @param {string} messageId "refactor" or "escapeBackslash".
-         * @param {int[]} range The range to replace.
-         * @param {string} replacement New text for the range.
-         * @returns {Object} Suggestion
-         */
-        function createSuggestion(messageId, range, replacement) {
-            return {
-                messageId,
-                data: {
-                    original: sourceCode.getText().slice(...range),
-                    replacement
-                },
-                fix(fixer) {
-                    return fixer.replaceTextRange(range, replacement);
-                }
-            };
-        }
-
-        return {
-            Literal(node) {
-                if (typeof node.value !== "string") {
-                    return;
-                }
-
-                if (!QUICK_TEST_REGEX.test(node.raw)) {
-                    return;
-                }
-
-                const regex = /(?:[^\\]|(?<previousEscape>\\.))*?(?<decimalEscape>\\[89])/suy;
-                let match;
-
-                while ((match = regex.exec(node.raw))) {
-                    const { previousEscape, decimalEscape } = match.groups;
-                    const decimalEscapeRangeEnd = node.range[0] + match.index + match[0].length;
-                    const decimalEscapeRangeStart = decimalEscapeRangeEnd - decimalEscape.length;
-                    const decimalEscapeRange = [decimalEscapeRangeStart, decimalEscapeRangeEnd];
-                    const suggest = [];
-
-                    // When `regex` is matched, `previousEscape` can only capture characters adjacent to `decimalEscape`
-                    if (previousEscape === "\\0") {
-
-                        /*
-                         * Now we have a NULL escape "\0" immediately followed by a decimal escape, e.g.: "\0\8".
-                         * Fixing this to "\08" would turn "\0" into a legacy octal escape. To avoid producing
-                         * an octal escape while fixing a decimal escape, we provide different suggestions.
-                         */
-                        suggest.push(
-                            createSuggestion( // "\0\8" -> "\u00008"
-                                "refactor",
-                                [decimalEscapeRangeStart - previousEscape.length, decimalEscapeRangeEnd],
-                                `${getUnicodeEscape("\0")}${decimalEscape[1]}`
-                            ),
-                            createSuggestion( // "\8" -> "\u0038"
-                                "refactor",
-                                decimalEscapeRange,
-                                getUnicodeEscape(decimalEscape[1])
-                            )
-                        );
-                    } else {
-                        suggest.push(
-                            createSuggestion( // "\8" -> "8"
-                                "refactor",
-                                decimalEscapeRange,
-                                decimalEscape[1]
-                            )
-                        );
-                    }
-
-                    suggest.push(
-                        createSuggestion( // "\8" -> "\\8"
-                            "escapeBackslash",
-                            decimalEscapeRange,
-                            `\\${decimalEscape}`
-                        )
-                    );
-
-                    context.report({
-                        node,
-                        loc: {
-                            start: sourceCode.getLocFromIndex(decimalEscapeRangeStart),
-                            end: sourceCode.getLocFromIndex(decimalEscapeRangeEnd)
-                        },
-                        messageId: "decimalEscape",
-                        data: {
-                            decimalEscape
-                        },
-                        suggest
-                    });
-                }
-            }
-        };
-    }
-};

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

@@ -1,86 +0,0 @@
-/**
- * @fileoverview Rule to flag use of an object property of the global object (Math and JSON) as a function
- * @author James Allardice
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { CALL, CONSTRUCT, ReferenceTracker } = require("@eslint-community/eslint-utils");
-const getPropertyName = require("./utils/ast-utils").getStaticPropertyName;
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect", "Intl"];
-
-/**
- * Returns the name of the node to report
- * @param {ASTNode} node A node to report
- * @returns {string} name to report
- */
-function getReportNodeName(node) {
-    if (node.type === "ChainExpression") {
-        return getReportNodeName(node.expression);
-    }
-    if (node.type === "MemberExpression") {
-        return getPropertyName(node);
-    }
-    return node.name;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow calling global object properties as functions",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-obj-calls"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpectedCall: "'{{name}}' is not a function.",
-            unexpectedRefCall: "'{{name}}' is reference to '{{ref}}', which is not a function."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        return {
-            Program(node) {
-                const scope = sourceCode.getScope(node);
-                const tracker = new ReferenceTracker(scope);
-                const traceMap = {};
-
-                for (const g of nonCallableGlobals) {
-                    traceMap[g] = {
-                        [CALL]: true,
-                        [CONSTRUCT]: true
-                    };
-                }
-
-                for (const { node: refNode, path } of tracker.iterateGlobalReferences(traceMap)) {
-                    const name = getReportNodeName(refNode.callee);
-                    const ref = path[0];
-                    const messageId = name === ref ? "unexpectedCall" : "unexpectedRefCall";
-
-                    context.report({ node: refNode, messageId, data: { name, ref } });
-                }
-            }
-        };
-    }
-};