@alexlit/lint-kit 183.1.0 → 183.2.0

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

@@ -1,263 +0,0 @@
-/**
- * @fileoverview Rule to disallow useless backreferences in regular expressions
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const {
-	CALL,
-	CONSTRUCT,
-	ReferenceTracker,
-	getStringIfConstant,
-} = require("@eslint-community/eslint-utils");
-const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const parser = new RegExpParser();
-
-/**
- * Finds the path from the given `regexpp` AST node to the root node.
- * @param {regexpp.Node} node Node.
- * @returns {regexpp.Node[]} Array that starts with the given node and ends with the root node.
- */
-function getPathToRoot(node) {
-	const path = [];
-	let current = node;
-
-	do {
-		path.push(current);
-		current = current.parent;
-	} while (current);
-
-	return path;
-}
-
-/**
- * Determines whether the given `regexpp` AST node is a lookaround node.
- * @param {regexpp.Node} node Node.
- * @returns {boolean} `true` if it is a lookaround node.
- */
-function isLookaround(node) {
-	return (
-		node.type === "Assertion" &&
-		(node.kind === "lookahead" || node.kind === "lookbehind")
-	);
-}
-
-/**
- * Determines whether the given `regexpp` AST node is a negative lookaround node.
- * @param {regexpp.Node} node Node.
- * @returns {boolean} `true` if it is a negative lookaround node.
- */
-function isNegativeLookaround(node) {
-	return isLookaround(node) && node.negate;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description:
-				"Disallow useless backreferences in regular expressions",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-useless-backreference",
-		},
-
-		schema: [],
-
-		messages: {
-			nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} from within that group.",
-			forward:
-				"Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears later in the pattern.",
-			backward:
-				"Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears before in the same lookbehind.",
-			disjunctive:
-				"Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in another alternative.",
-			intoNegativeLookaround:
-				"Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in a negative lookaround.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Checks and reports useless backreferences in the given regular expression.
-		 * @param {ASTNode} node Node that represents regular expression. A regex literal or RegExp constructor call.
-		 * @param {string} pattern Regular expression pattern.
-		 * @param {string} flags Regular expression flags.
-		 * @returns {void}
-		 */
-		function checkRegex(node, pattern, flags) {
-			let regExpAST;
-
-			try {
-				regExpAST = parser.parsePattern(pattern, 0, pattern.length, {
-					unicode: flags.includes("u"),
-					unicodeSets: flags.includes("v"),
-				});
-			} catch {
-				// Ignore regular expressions with syntax errors
-				return;
-			}
-
-			visitRegExpAST(regExpAST, {
-				onBackreferenceEnter(bref) {
-					const groups = [bref.resolved].flat(),
-						brefPath = getPathToRoot(bref);
-
-					const problems = groups.map(group => {
-						const groupPath = getPathToRoot(group);
-
-						if (brefPath.includes(group)) {
-							// group is bref's ancestor => bref is nested ('nested reference') => group hasn't matched yet when bref starts to match.
-							return {
-								messageId: "nested",
-								group,
-							};
-						}
-
-						// Start from the root to find the lowest common ancestor.
-						let i = brefPath.length - 1,
-							j = groupPath.length - 1;
-
-						do {
-							i--;
-							j--;
-						} while (brefPath[i] === groupPath[j]);
-
-						const indexOfLowestCommonAncestor = j + 1,
-							groupCut = groupPath.slice(
-								0,
-								indexOfLowestCommonAncestor,
-							),
-							commonPath = groupPath.slice(
-								indexOfLowestCommonAncestor,
-							),
-							lowestCommonLookaround =
-								commonPath.find(isLookaround),
-							isMatchingBackward =
-								lowestCommonLookaround &&
-								lowestCommonLookaround.kind === "lookbehind";
-
-						if (groupCut.at(-1).type === "Alternative") {
-							// group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive.
-							return {
-								messageId: "disjunctive",
-								group,
-							};
-						}
-						if (!isMatchingBackward && bref.end <= group.start) {
-							// bref is left, group is right ('forward reference') => group hasn't matched yet when bref starts to match.
-							return {
-								messageId: "forward",
-								group,
-							};
-						}
-						if (isMatchingBackward && group.end <= bref.start) {
-							// the opposite of the previous when the regex is matching backward in a lookbehind context.
-							return {
-								messageId: "backward",
-								group,
-							};
-						}
-						if (groupCut.some(isNegativeLookaround)) {
-							// group is in a negative lookaround which isn't bref's ancestor => group has already failed when bref starts to match.
-							return {
-								messageId: "intoNegativeLookaround",
-								group,
-							};
-						}
-
-						return null;
-					});
-
-					if (
-						problems.length === 0 ||
-						problems.some(problem => !problem)
-					) {
-						// If there are no problems or no problems with any group then do not report it.
-						return;
-					}
-
-					let problemsToReport;
-
-					// Gets problems that appear in the same disjunction.
-					const problemsInSameDisjunction = problems.filter(
-						problem => problem.messageId !== "disjunctive",
-					);
-
-					if (problemsInSameDisjunction.length) {
-						// Only report problems that appear in the same disjunction.
-						problemsToReport = problemsInSameDisjunction;
-					} else {
-						// If all groups appear in different disjunctions, report it.
-						problemsToReport = problems;
-					}
-
-					const [{ messageId, group }, ...other] = problemsToReport;
-					let otherGroups = "";
-
-					if (other.length === 1) {
-						otherGroups = " and another group";
-					} else if (other.length > 1) {
-						otherGroups = ` and other ${other.length} groups`;
-					}
-					context.report({
-						node,
-						messageId,
-						data: {
-							bref: bref.raw,
-							group: group.raw,
-							otherGroups,
-						},
-					});
-				},
-			});
-		}
-
-		return {
-			"Literal[regex]"(node) {
-				const { pattern, flags } = node.regex;
-
-				checkRegex(node, pattern, flags);
-			},
-			Program(node) {
-				const scope = sourceCode.getScope(node),
-					tracker = new ReferenceTracker(scope),
-					traceMap = {
-						RegExp: {
-							[CALL]: true,
-							[CONSTRUCT]: true,
-						},
-					};
-
-				for (const { node: refNode } of tracker.iterateGlobalReferences(
-					traceMap,
-				)) {
-					const [patternNode, flagsNode] = refNode.arguments,
-						pattern = getStringIfConstant(patternNode, scope),
-						flags = getStringIfConstant(flagsNode, scope);
-
-					if (typeof pattern === "string") {
-						checkRegex(refNode, pattern, flags || "");
-					}
-				}
-			},
-		};
-	},
-};

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

@@ -1,95 +0,0 @@
-/**
- * @fileoverview A rule to disallow unnecessary `.call()` and `.apply()`.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether or not a node is a `.call()`/`.apply()`.
- * @param {ASTNode} node A CallExpression node to check.
- * @returns {boolean} Whether or not the node is a `.call()`/`.apply()`.
- */
-function isCallOrNonVariadicApply(node) {
-	const callee = astUtils.skipChainExpression(node.callee);
-
-	return (
-		callee.type === "MemberExpression" &&
-		callee.property.type === "Identifier" &&
-		callee.computed === false &&
-		((callee.property.name === "call" && node.arguments.length >= 1) ||
-			(callee.property.name === "apply" &&
-				node.arguments.length === 2 &&
-				node.arguments[1].type === "ArrayExpression"))
-	);
-}
-
-/**
- * Checks whether or not `thisArg` is not changed by `.call()`/`.apply()`.
- * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
- * @param {ASTNode} thisArg The node that is given to the first argument of the `.call()`/`.apply()`.
- * @param {SourceCode} sourceCode The ESLint source code object.
- * @returns {boolean} Whether or not `thisArg` is not changed by `.call()`/`.apply()`.
- */
-function isValidThisArg(expectedThis, thisArg, sourceCode) {
-	if (!expectedThis) {
-		return astUtils.isNullOrUndefined(thisArg);
-	}
-	return astUtils.equalTokens(expectedThis, thisArg, sourceCode);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow unnecessary calls to `.call()` and `.apply()`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-useless-call",
-		},
-
-		schema: [],
-
-		messages: {
-			unnecessaryCall: "Unnecessary '.{{name}}()'.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			CallExpression(node) {
-				if (!isCallOrNonVariadicApply(node)) {
-					return;
-				}
-
-				const callee = astUtils.skipChainExpression(node.callee);
-				const applied = astUtils.skipChainExpression(callee.object);
-				const expectedThis =
-					applied.type === "MemberExpression" ? applied.object : null;
-				const thisArg = node.arguments[0];
-
-				if (isValidThisArg(expectedThis, thisArg, sourceCode)) {
-					context.report({
-						node,
-						messageId: "unnecessaryCall",
-						data: { name: callee.property.name },
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,57 +0,0 @@
-/**
- * @fileoverview Reports useless `catch` clauses that just rethrow their error.
- * @author Teddy Katz
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow unnecessary `catch` clauses",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-useless-catch",
-		},
-
-		schema: [],
-
-		messages: {
-			unnecessaryCatchClause: "Unnecessary catch clause.",
-			unnecessaryCatch: "Unnecessary try/catch wrapper.",
-		},
-	},
-
-	create(context) {
-		return {
-			CatchClause(node) {
-				if (
-					node.param &&
-					node.param.type === "Identifier" &&
-					node.body.body.length &&
-					node.body.body[0].type === "ThrowStatement" &&
-					node.body.body[0].argument.type === "Identifier" &&
-					node.body.body[0].argument.name === node.param.name
-				) {
-					if (node.parent.finalizer) {
-						context.report({
-							node,
-							messageId: "unnecessaryCatchClause",
-						});
-					} else {
-						context.report({
-							node: node.parent,
-							messageId: "unnecessaryCatch",
-						});
-					}
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-useless-computed-key.js

@@ -1,204 +0,0 @@
-/**
- * @fileoverview Rule to disallow unnecessary computed property keys in object literals
- * @author Burak Yigit Kaya
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines whether the computed key syntax is unnecessarily used for the given node.
- * In particular, it determines whether removing the square brackets and using the content between them
- * directly as the key (e.g. ['foo'] -> 'foo') would produce valid syntax and preserve the same behavior.
- * Valid non-computed keys are only: identifiers, number literals and string literals.
- * Only literals can preserve the same behavior, with a few exceptions for specific node types:
- * Property
- *   - { ["__proto__"]: foo } defines a property named "__proto__"
- *     { "__proto__": foo } defines object's prototype
- * PropertyDefinition
- *   - class C { ["constructor"]; } defines an instance field named "constructor"
- *     class C { "constructor"; } produces a parsing error
- *   - class C { static ["constructor"]; } defines a static field named "constructor"
- *     class C { static "constructor"; } produces a parsing error
- *   - class C { static ["prototype"]; } produces a runtime error (doesn't break the whole script)
- *     class C { static "prototype"; } produces a parsing error (breaks the whole script)
- * MethodDefinition
- *   - class C { ["constructor"]() {} } defines a prototype method named "constructor"
- *     class C { "constructor"() {} } defines the constructor
- *   - class C { static ["prototype"]() {} } produces a runtime error (doesn't break the whole script)
- *     class C { static "prototype"() {} } produces a parsing error (breaks the whole script)
- * @param {ASTNode} node The node to check. It can be `Property`, `PropertyDefinition` or `MethodDefinition`.
- * @throws {Error} (Unreachable.)
- * @returns {void} `true` if the node has useless computed key.
- */
-function hasUselessComputedKey(node) {
-	if (!node.computed) {
-		return false;
-	}
-
-	const { key } = node;
-
-	if (key.type !== "Literal") {
-		return false;
-	}
-
-	const { value } = key;
-
-	if (typeof value !== "number" && typeof value !== "string") {
-		return false;
-	}
-
-	switch (node.type) {
-		case "Property":
-			if (node.parent.type === "ObjectExpression") {
-				return value !== "__proto__";
-			}
-			return true;
-
-		case "PropertyDefinition":
-			if (node.static) {
-				return value !== "constructor" && value !== "prototype";
-			}
-
-			return value !== "constructor";
-
-		case "MethodDefinition":
-			if (node.static) {
-				return value !== "prototype";
-			}
-
-			return value !== "constructor";
-
-		/* c8 ignore next */
-		default:
-			throw new Error(`Unexpected node type: ${node.type}`);
-	}
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				enforceForClassMembers: true,
-			},
-		],
-
-		docs: {
-			description:
-				"Disallow unnecessary computed property keys in objects and classes",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-useless-computed-key",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					enforceForClassMembers: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		fixable: "code",
-
-		messages: {
-			unnecessarilyComputedProperty:
-				"Unnecessarily computed property [{{property}}] found.",
-		},
-	},
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const [{ enforceForClassMembers }] = context.options;
-
-		/**
-		 * Reports a given node if it violated this rule.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {void}
-		 */
-		function check(node) {
-			if (hasUselessComputedKey(node)) {
-				const { key } = node;
-
-				context.report({
-					node,
-					messageId: "unnecessarilyComputedProperty",
-					data: { property: sourceCode.getText(key) },
-					fix(fixer) {
-						const leftSquareBracket = sourceCode.getTokenBefore(
-							key,
-							astUtils.isOpeningBracketToken,
-						);
-						const rightSquareBracket = sourceCode.getTokenAfter(
-							key,
-							astUtils.isClosingBracketToken,
-						);
-
-						// If there are comments between the brackets and the property name, don't do a fix.
-						if (
-							sourceCode.commentsExistBetween(
-								leftSquareBracket,
-								rightSquareBracket,
-							)
-						) {
-							return null;
-						}
-
-						const tokenBeforeLeftBracket =
-							sourceCode.getTokenBefore(leftSquareBracket);
-
-						// Insert a space before the key to avoid changing identifiers, e.g. ({ get[2]() {} }) to ({ get2() {} })
-						const needsSpaceBeforeKey =
-							tokenBeforeLeftBracket.range[1] ===
-								leftSquareBracket.range[0] &&
-							!astUtils.canTokensBeAdjacent(
-								tokenBeforeLeftBracket,
-								sourceCode.getFirstToken(key),
-							);
-
-						const replacementKey =
-							(needsSpaceBeforeKey ? " " : "") + key.raw;
-
-						return fixer.replaceTextRange(
-							[
-								leftSquareBracket.range[0],
-								rightSquareBracket.range[1],
-							],
-							replacementKey,
-						);
-					},
-				});
-			}
-		}
-
-		/**
-		 * A no-op function to act as placeholder for checking a node when the `enforceForClassMembers` option is `false`.
-		 * @returns {void}
-		 * @private
-		 */
-		function noop() {}
-
-		return {
-			Property: check,
-			MethodDefinition: enforceForClassMembers ? check : noop,
-			PropertyDefinition: enforceForClassMembers ? check : noop,
-		};
-	},
-};