eslint-plugin-absolute 0.2.0 → 0.2.1

package/src/rules/max-depth-extended.ts

@@ -4,33 +4,13 @@ type Options = [number?];
 type MessageIds = "tooDeep";
 
 export const maxDepthExtended: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"disallow too many nested blocks except when the block only contains an early exit (return or throw)"
-		},
-		schema: [
-			{
-				// Accepts a single number as the maximum allowed depth.
-				type: "number"
-			}
-		],
-		messages: {
-			tooDeep:
-				"Blocks are nested too deeply ({{depth}}). Maximum allowed is {{maxDepth}} or an early exit."
-		}
-	},
-
-	defaultOptions: [1],
-
 	create(context) {
-		const option = context.options[0];
+		const [option] = context.options;
 		const maxDepth = typeof option === "number" ? option : 1;
 		const functionStack: number[] = [];
 
 		// Helper to get ancestors of a node by walking its parent chain.
-		function getAncestors(node: TSESTree.Node) {
+		const getAncestors = (node: TSESTree.Node) => {
 			const ancestors: TSESTree.Node[] = [];
 			let current: TSESTree.Node | null | undefined = node.parent;
 			while (current) {
@@ -38,14 +18,14 @@ export const maxDepthExtended: TSESLint.RuleModule<MessageIds, Options> = {
 				current = current.parent;
 			}
 			return ancestors;
-		}
+		};
 
 		// Check if a block only contains a single early exit: return or throw.
-		function isEarlyExitBlock(node: TSESTree.BlockStatement) {
+		const isEarlyExitBlock = (node: TSESTree.BlockStatement) => {
 			if (node.body.length !== 1) {
 				return false;
 			}
-			const first = node.body[0];
+			const [first] = node.body;
 			if (!first) {
 				return false;
 			}
@@ -53,9 +33,21 @@ export const maxDepthExtended: TSESLint.RuleModule<MessageIds, Options> = {
 				first.type === "ReturnStatement" ||
 				first.type === "ThrowStatement"
 			);
-		}
+		};
 
-		function incrementCurrentDepth(): number | null {
+		const isFunctionBody = (node: TSESTree.BlockStatement) => {
+			const ancestors = getAncestors(node);
+			const [parent] = ancestors;
+			return (
+				parent &&
+				(parent.type === "FunctionDeclaration" ||
+					parent.type === "FunctionExpression" ||
+					parent.type === "ArrowFunctionExpression") &&
+				node === parent.body
+			);
+		};
+
+		const incrementCurrentDepth = () => {
 			if (functionStack.length === 0) {
 				return null;
 			}
@@ -67,9 +59,9 @@ export const maxDepthExtended: TSESLint.RuleModule<MessageIds, Options> = {
 			const nextDepth = currentDepth + 1;
 			functionStack[index] = nextDepth;
 			return nextDepth;
-		}
+		};
 
-		function decrementCurrentDepth(): void {
+		const decrementCurrentDepth = () => {
 			if (functionStack.length === 0) {
 				return;
 			}
@@ -79,42 +71,29 @@ export const maxDepthExtended: TSESLint.RuleModule<MessageIds, Options> = {
 				return;
 			}
 			functionStack[index] = currentDepth - 1;
-		}
+		};
 
 		// Report if the current depth exceeds the allowed maximum.
-		function checkDepth(node: TSESTree.BlockStatement, depth: number) {
+		const checkDepth = (node: TSESTree.BlockStatement, depth: number) => {
 			if (depth > maxDepth) {
 				context.report({
-					node,
+					data: { depth, maxDepth },
 					messageId: "tooDeep",
-					data: { depth, maxDepth }
+					node
 				});
 			}
-		}
+		};
 
 		return {
-			FunctionDeclaration() {
-				functionStack.push(0);
-			},
-			FunctionExpression() {
-				functionStack.push(0);
-			},
 			ArrowFunctionExpression() {
 				functionStack.push(0);
 			},
-
+			"ArrowFunctionExpression:exit"() {
+				functionStack.pop();
+			},
 			BlockStatement(node: TSESTree.BlockStatement) {
-				const ancestors = getAncestors(node);
-				const parent = ancestors.length > 0 ? ancestors[0] : undefined;
-
 				// Do not count if this block is the body of a function.
-				if (
-					parent &&
-					(parent.type === "FunctionDeclaration" ||
-						parent.type === "FunctionExpression" ||
-						parent.type === "ArrowFunctionExpression") &&
-					node === parent.body
-				) {
+				if (isFunctionBody(node)) {
 					return;
 				}
 
@@ -128,18 +107,8 @@ export const maxDepthExtended: TSESLint.RuleModule<MessageIds, Options> = {
 					checkDepth(node, depth);
 				}
 			},
-
 			"BlockStatement:exit"(node: TSESTree.BlockStatement) {
-				const ancestors = getAncestors(node);
-				const parent = ancestors.length > 0 ? ancestors[0] : undefined;
-
-				if (
-					parent &&
-					(parent.type === "FunctionDeclaration" ||
-						parent.type === "FunctionExpression" ||
-						parent.type === "ArrowFunctionExpression") &&
-					node === parent.body
-				) {
+				if (isFunctionBody(node)) {
 					return;
 				}
 
@@ -149,16 +118,36 @@ export const maxDepthExtended: TSESLint.RuleModule<MessageIds, Options> = {
 
 				decrementCurrentDepth();
 			},
-
+			FunctionDeclaration() {
+				functionStack.push(0);
+			},
 			"FunctionDeclaration:exit"() {
 				functionStack.pop();
 			},
-			"FunctionExpression:exit"() {
-				functionStack.pop();
+			FunctionExpression() {
+				functionStack.push(0);
 			},
-			"ArrowFunctionExpression:exit"() {
+			"FunctionExpression:exit"() {
 				functionStack.pop();
 			}
 		};
+	},
+	defaultOptions: [1],
+	meta: {
+		docs: {
+			description:
+				"disallow too many nested blocks except when the block only contains an early exit (return or throw)"
+		},
+		messages: {
+			tooDeep:
+				"Blocks are nested too deeply ({{depth}}). Maximum allowed is {{maxDepth}} or an early exit."
+		},
+		schema: [
+			{
+				// Accepts a single number as the maximum allowed depth.
+				type: "number"
+			}
+		],
+		type: "suggestion"
 	}
 };

package/src/rules/max-jsx-nesting.ts

@@ -3,65 +3,57 @@ import { TSESLint, TSESTree } from "@typescript-eslint/utils";
 type Options = [number];
 type MessageIds = "tooDeeplyNested";
 
-export const maxJSXNesting: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Warn when JSX elements are nested too deeply, suggesting refactoring into a separate component."
-		},
-		// The rule accepts a single numeric option (minimum 1)
-		schema: [
-			{
-				type: "number",
-				minimum: 1
-			}
-		],
-		messages: {
-			tooDeeplyNested:
-				"JSX element is nested too deeply ({{level}} levels, allowed is {{maxAllowed}} levels). Consider refactoring into a separate component."
-		}
-	},
-
-	defaultOptions: [1],
+const isJSXAncestor = (node: TSESTree.Node) =>
+	node.type === "JSXElement" || node.type === "JSXFragment";
 
+export const maxJSXNesting: TSESLint.RuleModule<MessageIds, Options> = {
 	create(context) {
-		const option = context.options[0];
+		const [option] = context.options;
 		const maxAllowed = typeof option === "number" ? option : 1;
 
 		/**
 		 * Calculates the JSX nesting level for the given node by traversing the node.parent chain.
-		 * The level is computed by counting the current node (level 1) plus each ancestor
-		 * that is a JSXElement or JSXFragment.
-		 * @param {ASTNode} node The JSX element node.
-		 * @returns {number} The nesting level.
 		 */
-		function getJSXNestingLevel(node: TSESTree.Node): number {
+		const getJSXNestingLevel = (node: TSESTree.Node) => {
 			let level = 1; // count the current node as level 1
 			let current: TSESTree.Node | null | undefined = node.parent;
 			while (current) {
-				if (
-					current.type === "JSXElement" ||
-					current.type === "JSXFragment"
-				) {
-					level++;
-				}
+				level += isJSXAncestor(current) ? 1 : 0;
 				current = current.parent;
 			}
 			return level;
-		}
+		};
 
 		return {
 			JSXElement(node: TSESTree.JSXElement) {
 				const level = getJSXNestingLevel(node);
 				if (level > maxAllowed) {
 					context.report({
-						node,
+						data: { level, maxAllowed },
 						messageId: "tooDeeplyNested",
-						data: { level, maxAllowed }
+						node
 					});
 				}
 			}
 		};
+	},
+	defaultOptions: [1],
+	meta: {
+		docs: {
+			description:
+				"Warn when JSX elements are nested too deeply, suggesting refactoring into a separate component."
+		},
+		messages: {
+			tooDeeplyNested:
+				"JSX element is nested too deeply ({{level}} levels, allowed is {{maxAllowed}} levels). Consider refactoring into a separate component."
+		},
+		// The rule accepts a single numeric option (minimum 1)
+		schema: [
+			{
+				minimum: 1,
+				type: "number"
+			}
+		],
+		type: "suggestion"
 	}
 };