@alexlit/lint-kit 164.15.0 → 165.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/arrow-body-style.js

@@ -0,0 +1,418 @@
+/**
+ * @fileoverview Rule to require braces in arrow function body.
+ * @author Alberto Rodríguez
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: ["as-needed"],
+
+		docs: {
+			description: "Require braces around arrow function bodies",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/arrow-body-style",
+		},
+
+		schema: {
+			anyOf: [
+				{
+					type: "array",
+					items: [
+						{
+							enum: ["always", "never"],
+						},
+					],
+					minItems: 0,
+					maxItems: 1,
+				},
+				{
+					type: "array",
+					items: [
+						{
+							enum: ["as-needed"],
+						},
+						{
+							type: "object",
+							properties: {
+								requireReturnForObjectLiteral: {
+									type: "boolean",
+								},
+							},
+							additionalProperties: false,
+						},
+					],
+					minItems: 0,
+					maxItems: 2,
+				},
+			],
+		},
+
+		fixable: "code",
+
+		messages: {
+			unexpectedOtherBlock:
+				"Unexpected block statement surrounding arrow body.",
+			unexpectedEmptyBlock:
+				"Unexpected block statement surrounding arrow body; put a value of `undefined` immediately after the `=>`.",
+			unexpectedObjectBlock:
+				"Unexpected block statement surrounding arrow body; parenthesize the returned value and move it immediately after the `=>`.",
+			unexpectedSingleBlock:
+				"Unexpected block statement surrounding arrow body; move the returned value immediately after the `=>`.",
+			expectedBlock: "Expected block statement surrounding arrow body.",
+		},
+	},
+
+	create(context) {
+		const options = context.options;
+		const always = options[0] === "always";
+		const asNeeded = options[0] === "as-needed";
+		const never = options[0] === "never";
+		const requireReturnForObjectLiteral =
+			options[1] && options[1].requireReturnForObjectLiteral;
+		const sourceCode = context.sourceCode;
+		let funcInfo = null;
+
+		/**
+		 * Checks whether the given node has ASI problem or not.
+		 * @param {Token} token The token to check.
+		 * @returns {boolean} `true` if it changes semantics if `;` or `}` followed by the token are removed.
+		 */
+		function hasASIProblem(token) {
+			return (
+				token &&
+				token.type === "Punctuator" &&
+				/^[([/`+-]/u.test(token.value)
+			);
+		}
+
+		/**
+		 * Gets the closing parenthesis by the given node.
+		 * @param {ASTNode} node first node after an opening parenthesis.
+		 * @returns {Token} The found closing parenthesis token.
+		 */
+		function findClosingParen(node) {
+			let nodeToCheck = node;
+
+			while (!astUtils.isParenthesised(sourceCode, nodeToCheck)) {
+				nodeToCheck = nodeToCheck.parent;
+			}
+			return sourceCode.getTokenAfter(nodeToCheck);
+		}
+
+		/**
+		 * Check whether the node is inside of a for loop's init
+		 * @param {ASTNode} node node is inside for loop
+		 * @returns {boolean} `true` if the node is inside of a for loop, else `false`
+		 */
+		function isInsideForLoopInitializer(node) {
+			if (node && node.parent) {
+				if (
+					node.parent.type === "ForStatement" &&
+					node.parent.init === node
+				) {
+					return true;
+				}
+				return isInsideForLoopInitializer(node.parent);
+			}
+			return false;
+		}
+
+		/**
+		 * Determines whether a arrow function body needs braces
+		 * @param {ASTNode} node The arrow function node.
+		 * @returns {void}
+		 */
+		function validate(node) {
+			const arrowBody = node.body;
+
+			if (arrowBody.type === "BlockStatement") {
+				const blockBody = arrowBody.body;
+
+				if (blockBody.length !== 1 && !never) {
+					return;
+				}
+
+				if (
+					asNeeded &&
+					requireReturnForObjectLiteral &&
+					blockBody[0].type === "ReturnStatement" &&
+					blockBody[0].argument &&
+					blockBody[0].argument.type === "ObjectExpression"
+				) {
+					return;
+				}
+
+				if (
+					never ||
+					(asNeeded && blockBody[0].type === "ReturnStatement")
+				) {
+					let messageId;
+
+					if (blockBody.length === 0) {
+						messageId = "unexpectedEmptyBlock";
+					} else if (
+						blockBody.length > 1 ||
+						blockBody[0].type !== "ReturnStatement"
+					) {
+						messageId = "unexpectedOtherBlock";
+					} else if (blockBody[0].argument === null) {
+						messageId = "unexpectedSingleBlock";
+					} else if (
+						astUtils.isOpeningBraceToken(
+							sourceCode.getFirstToken(blockBody[0], { skip: 1 }),
+						)
+					) {
+						messageId = "unexpectedObjectBlock";
+					} else {
+						messageId = "unexpectedSingleBlock";
+					}
+
+					context.report({
+						node,
+						loc: arrowBody.loc,
+						messageId,
+						fix(fixer) {
+							const fixes = [];
+
+							if (
+								blockBody.length !== 1 ||
+								blockBody[0].type !== "ReturnStatement" ||
+								!blockBody[0].argument ||
+								hasASIProblem(
+									sourceCode.getTokenAfter(arrowBody),
+								)
+							) {
+								return fixes;
+							}
+
+							const openingBrace =
+								sourceCode.getFirstToken(arrowBody);
+							const closingBrace =
+								sourceCode.getLastToken(arrowBody);
+							const firstValueToken = sourceCode.getFirstToken(
+								blockBody[0],
+								1,
+							);
+							const lastValueToken = sourceCode.getLastToken(
+								blockBody[0],
+							);
+							const commentsExist =
+								sourceCode.commentsExistBetween(
+									openingBrace,
+									firstValueToken,
+								) ||
+								sourceCode.commentsExistBetween(
+									lastValueToken,
+									closingBrace,
+								);
+
+							/*
+							 * Remove tokens around the return value.
+							 * If comments don't exist, remove extra spaces as well.
+							 */
+							if (commentsExist) {
+								fixes.push(
+									fixer.remove(openingBrace),
+									fixer.remove(closingBrace),
+									fixer.remove(
+										sourceCode.getTokenAfter(openingBrace),
+									), // return keyword
+								);
+							} else {
+								fixes.push(
+									fixer.removeRange([
+										openingBrace.range[0],
+										firstValueToken.range[0],
+									]),
+									fixer.removeRange([
+										lastValueToken.range[1],
+										closingBrace.range[1],
+									]),
+								);
+							}
+
+							/*
+							 * If the first token of the return value is `{` or the return value is a sequence expression,
+							 * enclose the return value by parentheses to avoid syntax error.
+							 */
+							if (
+								astUtils.isOpeningBraceToken(firstValueToken) ||
+								blockBody[0].argument.type ===
+									"SequenceExpression" ||
+								(funcInfo.hasInOperator &&
+									isInsideForLoopInitializer(node))
+							) {
+								if (
+									!astUtils.isParenthesised(
+										sourceCode,
+										blockBody[0].argument,
+									)
+								) {
+									fixes.push(
+										fixer.insertTextBefore(
+											firstValueToken,
+											"(",
+										),
+										fixer.insertTextAfter(
+											lastValueToken,
+											")",
+										),
+									);
+								}
+							}
+
+							/*
+							 * If the last token of the return statement is semicolon, remove it.
+							 * Non-block arrow body is an expression, not a statement.
+							 */
+							if (astUtils.isSemicolonToken(lastValueToken)) {
+								fixes.push(fixer.remove(lastValueToken));
+							}
+
+							return fixes;
+						},
+					});
+				}
+			} else {
+				if (
+					always ||
+					(asNeeded &&
+						requireReturnForObjectLiteral &&
+						arrowBody.type === "ObjectExpression")
+				) {
+					context.report({
+						node,
+						loc: arrowBody.loc,
+						messageId: "expectedBlock",
+						fix(fixer) {
+							const fixes = [];
+							const arrowToken = sourceCode.getTokenBefore(
+								arrowBody,
+								astUtils.isArrowToken,
+							);
+							const [
+								firstTokenAfterArrow,
+								secondTokenAfterArrow,
+							] = sourceCode.getTokensAfter(arrowToken, {
+								count: 2,
+							});
+							const lastToken = sourceCode.getLastToken(node);
+
+							let parenthesisedObjectLiteral = null;
+
+							if (
+								astUtils.isOpeningParenToken(
+									firstTokenAfterArrow,
+								) &&
+								astUtils.isOpeningBraceToken(
+									secondTokenAfterArrow,
+								)
+							) {
+								const braceNode =
+									sourceCode.getNodeByRangeIndex(
+										secondTokenAfterArrow.range[0],
+									);
+
+								if (braceNode.type === "ObjectExpression") {
+									parenthesisedObjectLiteral = braceNode;
+								}
+							}
+
+							// If the value is object literal, remove parentheses which were forced by syntax.
+							if (parenthesisedObjectLiteral) {
+								const openingParenToken = firstTokenAfterArrow;
+								const openingBraceToken = secondTokenAfterArrow;
+
+								if (
+									astUtils.isTokenOnSameLine(
+										openingParenToken,
+										openingBraceToken,
+									)
+								) {
+									fixes.push(
+										fixer.replaceText(
+											openingParenToken,
+											"{return ",
+										),
+									);
+								} else {
+									// Avoid ASI
+									fixes.push(
+										fixer.replaceText(
+											openingParenToken,
+											"{",
+										),
+										fixer.insertTextBefore(
+											openingBraceToken,
+											"return ",
+										),
+									);
+								}
+
+								// Closing paren for the object doesn't have to be lastToken, e.g.: () => ({}).foo()
+								fixes.push(
+									fixer.remove(
+										findClosingParen(
+											parenthesisedObjectLiteral,
+										),
+									),
+								);
+								fixes.push(
+									fixer.insertTextAfter(lastToken, "}"),
+								);
+							} else {
+								fixes.push(
+									fixer.insertTextBefore(
+										firstTokenAfterArrow,
+										"{return ",
+									),
+								);
+								fixes.push(
+									fixer.insertTextAfter(lastToken, "}"),
+								);
+							}
+
+							return fixes;
+						},
+					});
+				}
+			}
+		}
+
+		return {
+			"BinaryExpression[operator='in']"() {
+				let info = funcInfo;
+
+				while (info) {
+					info.hasInOperator = true;
+					info = info.upper;
+				}
+			},
+			ArrowFunctionExpression() {
+				funcInfo = {
+					upper: funcInfo,
+					hasInOperator: false,
+				};
+			},
+			"ArrowFunctionExpression:exit"(node) {
+				validate(node);
+				funcInfo = funcInfo.upper;
+			},
+		};
+	},
+};

package/packages/config-eslint/node_modules/eslint/lib/rules/arrow-parens.js

@@ -0,0 +1,237 @@
+/**
+ * @fileoverview Rule to require parens in arrow function arguments.
+ * @author Jxck
+ * @deprecated in ESLint v8.53.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines if the given arrow function has block body.
+ * @param {ASTNode} node `ArrowFunctionExpression` node.
+ * @returns {boolean} `true` if the function has block body.
+ */
+function hasBlockBody(node) {
+	return node.body.type === "BlockStatement";
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		deprecated: {
+			message: "Formatting rules are being moved out of ESLint core.",
+			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+			deprecatedSince: "8.53.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					message:
+						"ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style",
+					},
+					rule: {
+						name: "arrow-parens",
+						url: "https://eslint.style/rules/arrow-parens",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Require parentheses around arrow function arguments",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/arrow-parens",
+		},
+
+		fixable: "code",
+
+		schema: [
+			{
+				enum: ["always", "as-needed"],
+			},
+			{
+				type: "object",
+				properties: {
+					requireForBlockBody: {
+						type: "boolean",
+						default: false,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			unexpectedParens:
+				"Unexpected parentheses around single function argument.",
+			expectedParens:
+				"Expected parentheses around arrow function argument.",
+
+			unexpectedParensInline:
+				"Unexpected parentheses around single function argument having a body with no curly braces.",
+			expectedParensBlock:
+				"Expected parentheses around arrow function argument having a body with curly braces.",
+		},
+	},
+
+	create(context) {
+		const asNeeded = context.options[0] === "as-needed";
+		const requireForBlockBody =
+			asNeeded &&
+			context.options[1] &&
+			context.options[1].requireForBlockBody === true;
+
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Finds opening paren of parameters for the given arrow function, if it exists.
+		 * It is assumed that the given arrow function has exactly one parameter.
+		 * @param {ASTNode} node `ArrowFunctionExpression` node.
+		 * @returns {Token|null} the opening paren, or `null` if the given arrow function doesn't have parens of parameters.
+		 */
+		function findOpeningParenOfParams(node) {
+			const tokenBeforeParams = sourceCode.getTokenBefore(node.params[0]);
+
+			if (
+				tokenBeforeParams &&
+				astUtils.isOpeningParenToken(tokenBeforeParams) &&
+				node.range[0] <= tokenBeforeParams.range[0]
+			) {
+				return tokenBeforeParams;
+			}
+
+			return null;
+		}
+
+		/**
+		 * Finds closing paren of parameters for the given arrow function.
+		 * It is assumed that the given arrow function has parens of parameters and that it has exactly one parameter.
+		 * @param {ASTNode} node `ArrowFunctionExpression` node.
+		 * @returns {Token} the closing paren of parameters.
+		 */
+		function getClosingParenOfParams(node) {
+			return sourceCode.getTokenAfter(
+				node.params[0],
+				astUtils.isClosingParenToken,
+			);
+		}
+
+		/**
+		 * Determines whether the given arrow function has comments inside parens of parameters.
+		 * It is assumed that the given arrow function has parens of parameters.
+		 * @param {ASTNode} node `ArrowFunctionExpression` node.
+		 * @param {Token} openingParen Opening paren of parameters.
+		 * @returns {boolean} `true` if the function has at least one comment inside of parens of parameters.
+		 */
+		function hasCommentsInParensOfParams(node, openingParen) {
+			return sourceCode.commentsExistBetween(
+				openingParen,
+				getClosingParenOfParams(node),
+			);
+		}
+
+		/**
+		 * Determines whether the given arrow function has unexpected tokens before opening paren of parameters,
+		 * in which case it will be assumed that the existing parens of parameters are necessary.
+		 * Only tokens within the range of the arrow function (tokens that are part of the arrow function) are taken into account.
+		 * Example: <T>(a) => b
+		 * @param {ASTNode} node `ArrowFunctionExpression` node.
+		 * @param {Token} openingParen Opening paren of parameters.
+		 * @returns {boolean} `true` if the function has at least one unexpected token.
+		 */
+		function hasUnexpectedTokensBeforeOpeningParen(node, openingParen) {
+			const expectedCount = node.async ? 1 : 0;
+
+			return (
+				sourceCode.getFirstToken(node, { skip: expectedCount }) !==
+				openingParen
+			);
+		}
+
+		return {
+			"ArrowFunctionExpression[params.length=1]"(node) {
+				const shouldHaveParens =
+					!asNeeded || (requireForBlockBody && hasBlockBody(node));
+				const openingParen = findOpeningParenOfParams(node);
+				const hasParens = openingParen !== null;
+				const [param] = node.params;
+
+				if (shouldHaveParens && !hasParens) {
+					context.report({
+						node,
+						messageId: requireForBlockBody
+							? "expectedParensBlock"
+							: "expectedParens",
+						loc: param.loc,
+						*fix(fixer) {
+							yield fixer.insertTextBefore(param, "(");
+							yield fixer.insertTextAfter(param, ")");
+						},
+					});
+				}
+
+				if (
+					!shouldHaveParens &&
+					hasParens &&
+					param.type === "Identifier" &&
+					!param.typeAnnotation &&
+					!node.returnType &&
+					!hasCommentsInParensOfParams(node, openingParen) &&
+					!hasUnexpectedTokensBeforeOpeningParen(node, openingParen)
+				) {
+					context.report({
+						node,
+						messageId: requireForBlockBody
+							? "unexpectedParensInline"
+							: "unexpectedParens",
+						loc: param.loc,
+						*fix(fixer) {
+							const tokenBeforeOpeningParen =
+								sourceCode.getTokenBefore(openingParen);
+							const closingParen = getClosingParenOfParams(node);
+
+							if (
+								tokenBeforeOpeningParen &&
+								tokenBeforeOpeningParen.range[1] ===
+									openingParen.range[0] &&
+								!astUtils.canTokensBeAdjacent(
+									tokenBeforeOpeningParen,
+									sourceCode.getFirstToken(param),
+								)
+							) {
+								yield fixer.insertTextBefore(openingParen, " ");
+							}
+
+							// remove parens, whitespace inside parens, and possible trailing comma
+							yield fixer.removeRange([
+								openingParen.range[0],
+								param.range[0],
+							]);
+							yield fixer.removeRange([
+								param.range[1],
+								closingParen.range[1],
+							]);
+						},
+					});
+				}
+			},
+		};
+	},
+};