eslint-plugin-absolute 0.1.6 → 0.2.0

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

@@ -0,0 +1,164 @@
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+
+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 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 ancestors: TSESTree.Node[] = [];
+			let current: TSESTree.Node | null | undefined = node.parent;
+			while (current) {
+				ancestors.push(current);
+				current = current.parent;
+			}
+			return ancestors;
+		}
+
+		// Check if a block only contains a single early exit: return or throw.
+		function isEarlyExitBlock(node: TSESTree.BlockStatement) {
+			if (node.body.length !== 1) {
+				return false;
+			}
+			const first = node.body[0];
+			if (!first) {
+				return false;
+			}
+			return (
+				first.type === "ReturnStatement" ||
+				first.type === "ThrowStatement"
+			);
+		}
+
+		function incrementCurrentDepth(): number | null {
+			if (functionStack.length === 0) {
+				return null;
+			}
+			const index = functionStack.length - 1;
+			const currentDepth = functionStack[index];
+			if (typeof currentDepth !== "number") {
+				return null;
+			}
+			const nextDepth = currentDepth + 1;
+			functionStack[index] = nextDepth;
+			return nextDepth;
+		}
+
+		function decrementCurrentDepth(): void {
+			if (functionStack.length === 0) {
+				return;
+			}
+			const index = functionStack.length - 1;
+			const currentDepth = functionStack[index];
+			if (typeof currentDepth !== "number") {
+				return;
+			}
+			functionStack[index] = currentDepth - 1;
+		}
+
+		// Report if the current depth exceeds the allowed maximum.
+		function checkDepth(node: TSESTree.BlockStatement, depth: number) {
+			if (depth > maxDepth) {
+				context.report({
+					node,
+					messageId: "tooDeep",
+					data: { depth, maxDepth }
+				});
+			}
+		}
+
+		return {
+			FunctionDeclaration() {
+				functionStack.push(0);
+			},
+			FunctionExpression() {
+				functionStack.push(0);
+			},
+			ArrowFunctionExpression() {
+				functionStack.push(0);
+			},
+
+			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
+				) {
+					return;
+				}
+
+				// Skip blocks that only have an early exit.
+				if (isEarlyExitBlock(node)) {
+					return;
+				}
+
+				const depth = incrementCurrentDepth();
+				if (depth !== null) {
+					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
+				) {
+					return;
+				}
+
+				if (isEarlyExitBlock(node)) {
+					return;
+				}
+
+				decrementCurrentDepth();
+			},
+
+			"FunctionDeclaration:exit"() {
+				functionStack.pop();
+			},
+			"FunctionExpression:exit"() {
+				functionStack.pop();
+			},
+			"ArrowFunctionExpression:exit"() {
+				functionStack.pop();
+			}
+		};
+	}
+};

package/src/rules/{max-jsx-nesting.js → max-jsx-nesting.ts}

@@ -1,10 +1,14 @@
-export default {
+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.",
-			recommended: false
+				"Warn when JSX elements are nested too deeply, suggesting refactoring into a separate component."
 		},
 		// The rule accepts a single numeric option (minimum 1)
 		schema: [
@@ -18,9 +22,12 @@ export default {
 				"JSX element is nested too deeply ({{level}} levels, allowed is {{maxAllowed}} levels). Consider refactoring into a separate component."
 		}
 	},
+
+	defaultOptions: [1],
+
 	create(context) {
-		// At this point, the provided option is guaranteed to be a number >= 1.
-		const maxAllowed = context.options[0];
+		const option = context.options[0];
+		const maxAllowed = typeof option === "number" ? option : 1;
 
 		/**
 		 * Calculates the JSX nesting level for the given node by traversing the node.parent chain.
@@ -29,9 +36,9 @@ export default {
 		 * @param {ASTNode} node The JSX element node.
 		 * @returns {number} The nesting level.
 		 */
-		function getJSXNestingLevel(node) {
+		function getJSXNestingLevel(node: TSESTree.Node): number {
 			let level = 1; // count the current node as level 1
-			let current = node.parent;
+			let current: TSESTree.Node | null | undefined = node.parent;
 			while (current) {
 				if (
 					current.type === "JSXElement" ||
@@ -45,7 +52,7 @@ export default {
 		}
 
 		return {
-			JSXElement(node) {
+			JSXElement(node: TSESTree.JSXElement) {
 				const level = getJSXNestingLevel(node);
 				if (level > maxAllowed) {
 					context.report({

package/src/rules/{min-var-length.js → min-var-length.ts}

@@ -1,23 +1,19 @@
-/**
- * @fileoverview Disallow variable names shorter than a specified minimum length unless an outer variable
- * with a corresponding longer name exists, with an option to exempt specific variable names.
- *
- * Options:
- *  - minLength: a number specifying the minimum allowed length for variable names. Defaults to 1.
- *  - allowedVars: an array of variable names that are exempt from the minimum length rule.
- *    Each allowed variable name should have a length of at least 1 and at most minLength.
- *
- * This rule checks variable declarations, function parameters, catch clauses,
- * and destructuring patterns. It uses the ESLint v9 APIs (via the scopeManager on the
- * SourceCode object) and a custom helper to get ancestors.
- */
-export default {
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+
+type MinVarLengthOption = {
+	minLength?: number;
+	allowedVars?: string[];
+};
+
+type Options = [MinVarLengthOption?];
+type MessageIds = "variableNameTooShort";
+
+export const minVarLength: TSESLint.RuleModule<MessageIds, Options> = {
 	meta: {
 		type: "problem",
 		docs: {
 			description:
-				"Disallow variable names shorter than the configured minimum length unless an outer variable with a longer name starting with the same characters exists. You can exempt specific variable names using the allowedVars option.",
-			recommended: false
+				"Disallow variable names shorter than the configured minimum length unless an outer variable with a longer name starting with the same characters exists. You can exempt specific variable names using the allowedVars option."
 		},
 		schema: [
 			{
@@ -46,17 +42,27 @@ export default {
 		}
 	},
 
+	defaultOptions: [{}],
+
 	create(context) {
-		const sourceCode = context.getSourceCode();
-		const options = context.options[0] || {};
-		const minLength =
-			typeof options.minLength === "number" ? options.minLength : 1;
-		const allowedVars = options.allowedVars || [];
+		const sourceCode = context.sourceCode;
+		const options = context.options[0];
+		const configuredMinLength =
+			options && typeof options.minLength === "number"
+				? options.minLength
+				: 1;
+		const configuredAllowedVars =
+			options && Array.isArray(options.allowedVars)
+				? options.allowedVars
+				: [];
+
+		const minLength = configuredMinLength;
+		const allowedVars = configuredAllowedVars;
 
 		// Helper: walk up the node.parent chain to get ancestors.
-		function getAncestors(node) {
-			const ancestors = [];
-			let current = node.parent;
+		function getAncestors(node: TSESTree.Node) {
+			const ancestors: TSESTree.Node[] = [];
+			let current: TSESTree.Node | null | undefined = node.parent;
 			while (current) {
 				ancestors.push(current);
 				current = current.parent;
@@ -65,21 +71,30 @@ export default {
 		}
 
 		// Helper: retrieve the scope for a given node using the scopeManager.
-		function getScope(node) {
-			return (
-				sourceCode.scopeManager.acquire(node) ||
-				sourceCode.scopeManager.globalScope
-			);
+		function getScope(node: TSESTree.Node): TSESLint.Scope.Scope | null {
+			const scopeManager = sourceCode.scopeManager;
+			if (!scopeManager) {
+				return null;
+			}
+			const acquired = scopeManager.acquire(node);
+			if (acquired) {
+				return acquired;
+			}
+			return scopeManager.globalScope ?? null;
 		}
 
 		// Fallback: get declared variable names in the nearest BlockStatement.
-		function getVariablesInNearestBlock(node) {
-			let current = node.parent;
+		function getVariablesInNearestBlock(node: TSESTree.Node) {
+			let current: TSESTree.Node | null | undefined = node.parent;
 			while (current && current.type !== "BlockStatement") {
 				current = current.parent;
 			}
-			const names = [];
-			if (current && Array.isArray(current.body)) {
+			const names: string[] = [];
+			if (
+				current &&
+				current.type === "BlockStatement" &&
+				Array.isArray(current.body)
+			) {
 				for (const stmt of current.body) {
 					if (stmt.type === "VariableDeclaration") {
 						for (const decl of stmt.declarations) {
@@ -99,7 +114,10 @@ export default {
 		 * @param {string[]} identifiers Array to accumulate names.
 		 * @returns {string[]} Array of identifier names.
 		 */
-		function extractIdentifiersFromPattern(pattern, identifiers = []) {
+		function extractIdentifiersFromPattern(
+			pattern: TSESTree.Node | null,
+			identifiers: string[] = []
+		): string[] {
 			if (!pattern) return identifiers;
 			switch (pattern.type) {
 				case "Identifier":
@@ -122,8 +140,9 @@ export default {
 					break;
 				case "ArrayPattern":
 					for (const element of pattern.elements) {
-						if (element)
+						if (element) {
 							extractIdentifiersFromPattern(element, identifiers);
+						}
 					}
 					break;
 				case "AssignmentPattern":
@@ -144,10 +163,16 @@ export default {
 		 * @param {ASTNode} node The current identifier node.
 		 * @returns {boolean} True if an outer variable is found.
 		 */
-		function hasOuterCorrespondingIdentifier(shortName, node) {
+		function hasOuterCorrespondingIdentifier(
+			shortName: string,
+			node: TSESTree.Identifier
+		) {
 			// First, try using the scope manager.
-			let currentScope = getScope(node);
-			let outer = currentScope.upper;
+			const startingScope = getScope(node);
+			let outer =
+				startingScope && startingScope.upper
+					? startingScope.upper
+					: null;
 			while (outer) {
 				for (const variable of outer.variables) {
 					if (
@@ -228,9 +253,9 @@ export default {
 		 * and no outer variable with a longer name starting with the short name is found, it reports an error.
 		 * @param {ASTNode} node The Identifier node.
 		 */
-		function checkIdentifier(node) {
+		function checkIdentifier(node: TSESTree.Identifier) {
 			const name = node.name;
-			if (typeof name === "string" && name.length < minLength) {
+			if (name.length < minLength) {
 				// If the name is in the allowed list, skip.
 				if (allowedVars.includes(name)) {
 					return;
@@ -249,7 +274,7 @@ export default {
 		 * Recursively checks a pattern node for identifiers.
 		 * @param {ASTNode} pattern The pattern node.
 		 */
-		function checkPattern(pattern) {
+		function checkPattern(pattern: TSESTree.Node | null) {
 			if (!pattern) return;
 			switch (pattern.type) {
 				case "Identifier":
@@ -266,7 +291,9 @@ export default {
 					break;
 				case "ArrayPattern":
 					for (const element of pattern.elements) {
-						if (element) checkPattern(element);
+						if (element) {
+							checkPattern(element);
+						}
 					}
 					break;
 				case "AssignmentPattern":
@@ -278,19 +305,22 @@ export default {
 		}
 
 		return {
-			VariableDeclarator(node) {
+			VariableDeclarator(node: TSESTree.VariableDeclarator) {
 				if (node.id) {
 					checkPattern(node.id);
 				}
 			},
 			"FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(
-				node
+				node:
+					| TSESTree.FunctionDeclaration
+					| TSESTree.FunctionExpression
+					| TSESTree.ArrowFunctionExpression
 			) {
 				for (const param of node.params) {
 					checkPattern(param);
 				}
 			},
-			CatchClause(node) {
+			CatchClause(node: TSESTree.CatchClause) {
 				if (node.param) {
 					checkPattern(node.param);
 				}