@alexlit/lint-kit 166.1.0 → 167.0.0

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

@@ -1,162 +0,0 @@
-/**
- * @fileoverview Disallows unnecessary `return await`
- * @author Jordan Harband
- * @deprecated in ESLint v8.46.0
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		hasSuggestions: true,
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow unnecessary `return await`",
-
-			recommended: false,
-
-			url: "https://eslint.org/docs/latest/rules/no-return-await",
-		},
-
-		fixable: null,
-
-		deprecated: {
-			message:
-				"The original assumption of the rule no longer holds true because of engine optimization.",
-			deprecatedSince: "8.46.0",
-			availableUntil: null,
-			replacedBy: [],
-		},
-
-		schema: [],
-
-		messages: {
-			removeAwait: "Remove redundant `await`.",
-			redundantUseOfAwait: "Redundant use of `await` on a return value.",
-		},
-	},
-
-	create(context) {
-		/**
-		 * Reports a found unnecessary `await` expression.
-		 * @param {ASTNode} node The node representing the `await` expression to report
-		 * @returns {void}
-		 */
-		function reportUnnecessaryAwait(node) {
-			context.report({
-				node: context.sourceCode.getFirstToken(node),
-				loc: node.loc,
-				messageId: "redundantUseOfAwait",
-				suggest: [
-					{
-						messageId: "removeAwait",
-						fix(fixer) {
-							const sourceCode = context.sourceCode;
-							const [awaitToken, tokenAfterAwait] =
-								sourceCode.getFirstTokens(node, 2);
-
-							const areAwaitAndAwaitedExpressionOnTheSameLine =
-								awaitToken.loc.start.line ===
-								tokenAfterAwait.loc.start.line;
-
-							if (!areAwaitAndAwaitedExpressionOnTheSameLine) {
-								return null;
-							}
-
-							const [startOfAwait, endOfAwait] = awaitToken.range;
-
-							const characterAfterAwait =
-								sourceCode.text[endOfAwait];
-							const trimLength =
-								characterAfterAwait === " " ? 1 : 0;
-
-							const range = [
-								startOfAwait,
-								endOfAwait + trimLength,
-							];
-
-							return fixer.removeRange(range);
-						},
-					},
-				],
-			});
-		}
-
-		/**
-		 * Determines whether a thrown error from this node will be caught/handled within this function rather than immediately halting
-		 * this function. For example, a statement in a `try` block will always have an error handler. A statement in
-		 * a `catch` block will only have an error handler if there is also a `finally` block.
-		 * @param {ASTNode} node A node representing a location where an could be thrown
-		 * @returns {boolean} `true` if a thrown error will be caught/handled in this function
-		 */
-		function hasErrorHandler(node) {
-			let ancestor = node;
-
-			while (
-				!astUtils.isFunction(ancestor) &&
-				ancestor.type !== "Program"
-			) {
-				if (
-					ancestor.parent.type === "TryStatement" &&
-					(ancestor === ancestor.parent.block ||
-						(ancestor === ancestor.parent.handler &&
-							ancestor.parent.finalizer))
-				) {
-					return true;
-				}
-				ancestor = ancestor.parent;
-			}
-			return false;
-		}
-
-		/**
-		 * Checks if a node is placed in tail call position. Once `return` arguments (or arrow function expressions) can be a complex expression,
-		 * an `await` expression could or could not be unnecessary by the definition of this rule. So we're looking for `await` expressions that are in tail position.
-		 * @param {ASTNode} node A node representing the `await` expression to check
-		 * @returns {boolean} The checking result
-		 */
-		function isInTailCallPosition(node) {
-			if (node.parent.type === "ArrowFunctionExpression") {
-				return true;
-			}
-			if (node.parent.type === "ReturnStatement") {
-				return !hasErrorHandler(node.parent);
-			}
-			if (
-				node.parent.type === "ConditionalExpression" &&
-				(node === node.parent.consequent ||
-					node === node.parent.alternate)
-			) {
-				return isInTailCallPosition(node.parent);
-			}
-			if (
-				node.parent.type === "LogicalExpression" &&
-				node === node.parent.right
-			) {
-				return isInTailCallPosition(node.parent);
-			}
-			if (
-				node.parent.type === "SequenceExpression" &&
-				node === node.parent.expressions.at(-1)
-			) {
-				return isInTailCallPosition(node.parent);
-			}
-			return false;
-		}
-
-		return {
-			AwaitExpression(node) {
-				if (isInTailCallPosition(node) && !hasErrorHandler(node)) {
-					reportUnnecessaryAwait(node);
-				}
-			},
-		};
-	},
-};

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

@@ -1,68 +0,0 @@
-/**
- * @fileoverview Rule to disallow `javascript:` URLs
- * @author Ilya Volodin
- */
-/* eslint no-script-url: 0 -- Code is checking to report such URLs */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow `javascript:` URLs",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-script-url",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpectedScriptURL: "Script URL is a form of eval.",
-		},
-	},
-
-	create(context) {
-		/**
-		 * Check whether a node's static value starts with `javascript:` or not.
-		 * And report an error for unexpected script URL.
-		 * @param {ASTNode} node node to check
-		 * @returns {void}
-		 */
-		function check(node) {
-			const value = astUtils.getStaticStringValue(node);
-
-			if (
-				typeof value === "string" &&
-				value.toLowerCase().indexOf("javascript:") === 0
-			) {
-				context.report({ node, messageId: "unexpectedScriptURL" });
-			}
-		}
-		return {
-			Literal(node) {
-				if (node.value && typeof node.value === "string") {
-					check(node);
-				}
-			},
-			TemplateLiteral(node) {
-				if (
-					!(
-						node.parent &&
-						node.parent.type === "TaggedTemplateExpression"
-					)
-				) {
-					check(node);
-				}
-			},
-		};
-	},
-};

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

@@ -1,186 +0,0 @@
-/**
- * @fileoverview Rule to disallow assignments where both sides are exactly the same
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const SPACES = /\s+/gu;
-
-/**
- * Traverses 2 Pattern nodes in parallel, then reports self-assignments.
- * @param {ASTNode|null} left A left node to traverse. This is a Pattern or
- *      a Property.
- * @param {ASTNode|null} right A right node to traverse. This is a Pattern or
- *      a Property.
- * @param {boolean} props The flag to check member expressions as well.
- * @param {Function} report A callback function to report.
- * @returns {void}
- */
-function eachSelfAssignment(left, right, props, report) {
-	if (!left || !right) {
-		// do nothing
-	} else if (
-		left.type === "Identifier" &&
-		right.type === "Identifier" &&
-		left.name === right.name
-	) {
-		report(right);
-	} else if (
-		left.type === "ArrayPattern" &&
-		right.type === "ArrayExpression"
-	) {
-		const end = Math.min(left.elements.length, right.elements.length);
-
-		for (let i = 0; i < end; ++i) {
-			const leftElement = left.elements[i];
-			const rightElement = right.elements[i];
-
-			// Avoid cases such as [...a] = [...a, 1]
-			if (
-				leftElement &&
-				leftElement.type === "RestElement" &&
-				i < right.elements.length - 1
-			) {
-				break;
-			}
-
-			eachSelfAssignment(leftElement, rightElement, props, report);
-
-			// After a spread element, those indices are unknown.
-			if (rightElement && rightElement.type === "SpreadElement") {
-				break;
-			}
-		}
-	} else if (left.type === "RestElement" && right.type === "SpreadElement") {
-		eachSelfAssignment(left.argument, right.argument, props, report);
-	} else if (
-		left.type === "ObjectPattern" &&
-		right.type === "ObjectExpression" &&
-		right.properties.length >= 1
-	) {
-		/*
-		 * Gets the index of the last spread property.
-		 * It's possible to overwrite properties followed by it.
-		 */
-		let startJ = 0;
-
-		for (let i = right.properties.length - 1; i >= 0; --i) {
-			const propType = right.properties[i].type;
-
-			if (
-				propType === "SpreadElement" ||
-				propType === "ExperimentalSpreadProperty"
-			) {
-				startJ = i + 1;
-				break;
-			}
-		}
-
-		for (let i = 0; i < left.properties.length; ++i) {
-			for (let j = startJ; j < right.properties.length; ++j) {
-				eachSelfAssignment(
-					left.properties[i],
-					right.properties[j],
-					props,
-					report,
-				);
-			}
-		}
-	} else if (
-		left.type === "Property" &&
-		right.type === "Property" &&
-		right.kind === "init" &&
-		!right.method
-	) {
-		const leftName = astUtils.getStaticPropertyName(left);
-
-		if (
-			leftName !== null &&
-			leftName === astUtils.getStaticPropertyName(right)
-		) {
-			eachSelfAssignment(left.value, right.value, props, report);
-		}
-	} else if (
-		props &&
-		astUtils.skipChainExpression(left).type === "MemberExpression" &&
-		astUtils.skipChainExpression(right).type === "MemberExpression" &&
-		astUtils.isSameReference(left, right)
-	) {
-		report(right);
-	}
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [{ props: true }],
-
-		docs: {
-			description:
-				"Disallow assignments where both sides are exactly the same",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-self-assign",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					props: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			selfAssignment: "'{{name}}' is assigned to itself.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const [{ props }] = context.options;
-
-		/**
-		 * Reports a given node as self assignments.
-		 * @param {ASTNode} node A node to report. This is an Identifier node.
-		 * @returns {void}
-		 */
-		function report(node) {
-			context.report({
-				node,
-				messageId: "selfAssignment",
-				data: {
-					name: sourceCode.getText(node).replace(SPACES, ""),
-				},
-			});
-		}
-
-		return {
-			AssignmentExpression(node) {
-				if (["=", "&&=", "||=", "??="].includes(node.operator)) {
-					eachSelfAssignment(node.left, node.right, props, report);
-				}
-			},
-		};
-	},
-};

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

@@ -1,77 +0,0 @@
-/**
- * @fileoverview Rule to flag comparison where left part is the same as the right
- * part.
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description:
-				"Disallow comparisons where both sides are exactly the same",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-self-compare",
-		},
-
-		schema: [],
-
-		messages: {
-			comparingToSelf: "Comparing to itself is potentially pointless.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Determines whether two nodes are composed of the same tokens.
-		 * @param {ASTNode} nodeA The first node
-		 * @param {ASTNode} nodeB The second node
-		 * @returns {boolean} true if the nodes have identical token representations
-		 */
-		function hasSameTokens(nodeA, nodeB) {
-			const tokensA = sourceCode.getTokens(nodeA);
-			const tokensB = sourceCode.getTokens(nodeB);
-
-			return (
-				tokensA.length === tokensB.length &&
-				tokensA.every(
-					(token, index) =>
-						token.type === tokensB[index].type &&
-						token.value === tokensB[index].value,
-				)
-			);
-		}
-
-		return {
-			BinaryExpression(node) {
-				const operators = new Set([
-					"===",
-					"==",
-					"!==",
-					"!=",
-					">",
-					"<",
-					">=",
-					"<=",
-				]);
-
-				if (
-					operators.has(node.operator) &&
-					hasSameTokens(node.left, node.right)
-				) {
-					context.report({ node, messageId: "comparingToSelf" });
-				}
-			},
-		};
-	},
-};

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

@@ -1,158 +0,0 @@
-/**
- * @fileoverview Rule to flag use of comma operator
- * @author Brandon Mills
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow comma operators",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-sequences",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowInParentheses: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		defaultOptions: [
-			{
-				allowInParentheses: true,
-			},
-		],
-
-		messages: {
-			unexpectedCommaExpression: "Unexpected use of comma operator.",
-		},
-	},
-
-	create(context) {
-		const [{ allowInParentheses }] = context.options;
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Parts of the grammar that are required to have parens.
-		 */
-		const parenthesized = {
-			DoWhileStatement: "test",
-			IfStatement: "test",
-			SwitchStatement: "discriminant",
-			WhileStatement: "test",
-			WithStatement: "object",
-			ArrowFunctionExpression: "body",
-
-			/*
-			 * Omitting CallExpression - commas are parsed as argument separators
-			 * Omitting NewExpression - commas are parsed as argument separators
-			 * Omitting ForInStatement - parts aren't individually parenthesised
-			 * Omitting ForStatement - parts aren't individually parenthesised
-			 */
-		};
-
-		/**
-		 * Determines whether a node is required by the grammar to be wrapped in
-		 * parens, e.g. the test of an if statement.
-		 * @param {ASTNode} node The AST node
-		 * @returns {boolean} True if parens around node belong to parent node.
-		 */
-		function requiresExtraParens(node) {
-			return (
-				node.parent &&
-				parenthesized[node.parent.type] &&
-				node === node.parent[parenthesized[node.parent.type]]
-			);
-		}
-
-		/**
-		 * Check if a node is wrapped in parens.
-		 * @param {ASTNode} node The AST node
-		 * @returns {boolean} True if the node has a paren on each side.
-		 */
-		function isParenthesised(node) {
-			return astUtils.isParenthesised(sourceCode, node);
-		}
-
-		/**
-		 * Check if a node is wrapped in two levels of parens.
-		 * @param {ASTNode} node The AST node
-		 * @returns {boolean} True if two parens surround the node on each side.
-		 */
-		function isParenthesisedTwice(node) {
-			const previousToken = sourceCode.getTokenBefore(node, 1),
-				nextToken = sourceCode.getTokenAfter(node, 1);
-
-			return (
-				isParenthesised(node) &&
-				previousToken &&
-				nextToken &&
-				astUtils.isOpeningParenToken(previousToken) &&
-				previousToken.range[1] <= node.range[0] &&
-				astUtils.isClosingParenToken(nextToken) &&
-				nextToken.range[0] >= node.range[1]
-			);
-		}
-
-		return {
-			SequenceExpression(node) {
-				// Always allow sequences in for statement update
-				if (
-					node.parent.type === "ForStatement" &&
-					(node === node.parent.init || node === node.parent.update)
-				) {
-					return;
-				}
-
-				// Wrapping a sequence in extra parens indicates intent
-				if (allowInParentheses) {
-					if (requiresExtraParens(node)) {
-						if (isParenthesisedTwice(node)) {
-							return;
-						}
-					} else {
-						if (isParenthesised(node)) {
-							return;
-						}
-					}
-				}
-
-				const firstCommaToken = sourceCode.getTokenAfter(
-					node.expressions[0],
-					astUtils.isCommaToken,
-				);
-
-				context.report({
-					node,
-					loc: firstCommaToken.loc,
-					messageId: "unexpectedCommaExpression",
-				});
-			},
-		};
-	},
-};