eslint-plugin-absolute 0.2.0 → 0.2.2

package/src/rules/no-nested-jsx-return.ts

@@ -17,40 +17,19 @@ type AnyFunctionNode =
 	| TSESTree.ArrowFunctionExpression;
 
 export const noNestedJSXReturn: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Disallow nested functions that return non-component, non-singular JSX to enforce one component per file"
-		},
-		schema: [],
-		messages: {
-			nestedFunctionJSX:
-				"Nested function returning non-component, non-singular JSX detected. Extract it into its own component.",
-			nestedArrowJSX:
-				"Nested arrow function returning non-component, non-singular JSX detected. Extract it into its own component.",
-			nestedArrowFragment:
-				"Nested arrow function returning a non-singular JSX fragment detected. Extract it into its own component."
-		}
-	},
-
-	defaultOptions: [],
-
 	create(context) {
 		// Returns true if the node is a JSX element or fragment.
-		function isJSX(
+		const isJSX = (
 			node: TSESTree.Node | null | undefined
-		): node is TSESTree.JSXElement | TSESTree.JSXFragment {
-			return (
-				!!node &&
-				(node.type === AST_NODE_TYPES.JSXElement ||
-					node.type === AST_NODE_TYPES.JSXFragment)
-			);
-		}
-
-		function getLeftmostJSXIdentifier(
+		): node is TSESTree.JSXElement | TSESTree.JSXFragment =>
+			node !== null &&
+			node !== undefined &&
+			(node.type === AST_NODE_TYPES.JSXElement ||
+				node.type === AST_NODE_TYPES.JSXFragment);
+
+		const getLeftmostJSXIdentifier = (
 			name: TSESTree.JSXTagNameExpression
-		): TSESTree.JSXIdentifier | null {
+		) => {
 			let current: TSESTree.JSXTagNameExpression = name;
 			while (current.type === AST_NODE_TYPES.JSXMemberExpression) {
 				current = current.object;
@@ -59,10 +38,12 @@ export const noNestedJSXReturn: TSESLint.RuleModule<MessageIds, Options> = {
 				return current;
 			}
 			return null;
-		}
+		};
 
 		// Returns true if the JSX element is a component (its tag name starts with an uppercase letter).
-		function isJSXComponentElement(node: TSESTree.Node | null | undefined) {
+		const isJSXComponentElement = (
+			node: TSESTree.Node | null | undefined
+		) => {
 			if (!node || node.type !== AST_NODE_TYPES.JSXElement) {
 				return false;
 			}
@@ -78,13 +59,23 @@ export const noNestedJSXReturn: TSESLint.RuleModule<MessageIds, Options> = {
 				return false;
 			}
 			return /^[A-Z]/.test(leftmost.name);
-		}
+		};
+
+		const hasNoMeaningfulChildren = (children: TSESTree.JSXChild[]) => {
+			const filtered = children.filter((child) => {
+				if (child.type === AST_NODE_TYPES.JSXText) {
+					return child.value.trim() !== "";
+				}
+				return true;
+			});
+			return filtered.length === 0;
+		};
 
 		// Returns true if the returned JSX is singular.
 		// For both JSXElement and JSXFragment, singular means 0 or 1 non-whitespace child.
-		function isSingularJSXReturn(
+		const isSingularJSXReturn = (
 			node: TSESTree.JSXElement | TSESTree.JSXFragment
-		) {
+		) => {
 			if (!isJSX(node)) return false;
 
 			const children = node.children.filter((child) => {
@@ -100,69 +91,85 @@ export const noNestedJSXReturn: TSESLint.RuleModule<MessageIds, Options> = {
 			}
 
 			// Check if the returned element has exactly one child.
-			if (children.length === 1) {
-				const child = children[0];
-				if (!child) {
-					return false;
-				}
+			if (children.length !== 1) {
+				return false;
+			}
 
-				// If the singular child is also a JSX element or fragment,
-				// ensure that it doesn't have any meaningful children.
-				if (
-					child.type === AST_NODE_TYPES.JSXElement ||
-					child.type === AST_NODE_TYPES.JSXFragment
-				) {
-					const innerChildren = child.children.filter(
-						(innerChild) => {
-							if (innerChild.type === AST_NODE_TYPES.JSXText) {
-								return innerChild.value.trim() !== "";
-							}
-							return true;
-						}
-					);
-					return innerChildren.length === 0;
-				}
-				// If it’s not a JSX element (maybe a simple expression), it's acceptable.
-				return true;
+			const [child] = children;
+			if (!child) {
+				return false;
 			}
 
-			// If there is more than one meaningful child, it's not singular.
-			return false;
-		}
+			// If the singular child is also a JSX element or fragment,
+			// ensure that it doesn't have any meaningful children.
+			if (
+				child.type === AST_NODE_TYPES.JSXElement ||
+				child.type === AST_NODE_TYPES.JSXFragment
+			) {
+				return hasNoMeaningfulChildren(child.children);
+			}
+			// If it's not a JSX element (maybe a simple expression), it's acceptable.
+			return true;
+		};
 
 		// Stack to track nested function nodes.
 		const functionStack: AnyFunctionNode[] = [];
-		function pushFunction(node: AnyFunctionNode) {
+		const pushFunction = (node: AnyFunctionNode) => {
 			functionStack.push(node);
-		}
-		function popFunction() {
+		};
+		const popFunction = () => {
 			functionStack.pop();
-		}
+		};
 
 		return {
+			// For implicit returns in arrow functions, use the same checks.
+			"ArrowFunctionExpression > JSXElement"(node: TSESTree.JSXElement) {
+				if (functionStack.length <= 1) {
+					return;
+				}
+				if (
+					!isJSXComponentElement(node) &&
+					!isSingularJSXReturn(node)
+				) {
+					context.report({
+						messageId: "nestedArrowJSX",
+						node
+					});
+				}
+			},
+			"ArrowFunctionExpression > JSXFragment"(
+				node: TSESTree.JSXFragment
+			) {
+				if (functionStack.length <= 1) {
+					return;
+				}
+				if (!isSingularJSXReturn(node)) {
+					context.report({
+						messageId: "nestedArrowFragment",
+						node
+					});
+				}
+			},
+			"ArrowFunctionExpression:exit"() {
+				popFunction();
+			},
 			"FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(
 				node: AnyFunctionNode
 			) {
 				pushFunction(node);
 			},
-			"FunctionDeclaration:exit"(_node: TSESTree.FunctionDeclaration) {
+			"FunctionDeclaration:exit"() {
 				popFunction();
 			},
-			"FunctionExpression:exit"(_node: TSESTree.FunctionExpression) {
-				popFunction();
-			},
-			"ArrowFunctionExpression:exit"(
-				_node: TSESTree.ArrowFunctionExpression
-			) {
+			"FunctionExpression:exit"() {
 				popFunction();
 			},
-
 			// For explicit return statements, report if the returned JSX is not a component and not singular.
 			ReturnStatement(node: TSESTree.ReturnStatement) {
 				if (functionStack.length <= 1) {
 					return;
 				}
-				const argument = node.argument;
+				const { argument } = node;
 				if (!isJSX(argument)) {
 					return;
 				}
@@ -171,40 +178,28 @@ export const noNestedJSXReturn: TSESLint.RuleModule<MessageIds, Options> = {
 					!isSingularJSXReturn(argument)
 				) {
 					context.report({
-						node,
-						messageId: "nestedFunctionJSX"
-					});
-				}
-			},
-
-			// For implicit returns in arrow functions, use the same checks.
-			"ArrowFunctionExpression > JSXElement"(node: TSESTree.JSXElement) {
-				if (functionStack.length <= 1) {
-					return;
-				}
-				if (
-					!isJSXComponentElement(node) &&
-					!isSingularJSXReturn(node)
-				) {
-					context.report({
-						node,
-						messageId: "nestedArrowJSX"
-					});
-				}
-			},
-			"ArrowFunctionExpression > JSXFragment"(
-				node: TSESTree.JSXFragment
-			) {
-				if (functionStack.length <= 1) {
-					return;
-				}
-				if (!isSingularJSXReturn(node)) {
-					context.report({
-						node,
-						messageId: "nestedArrowFragment"
+						messageId: "nestedFunctionJSX",
+						node
 					});
 				}
 			}
 		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description:
+				"Disallow nested functions that return non-component, non-singular JSX to enforce one component per file"
+		},
+		messages: {
+			nestedArrowFragment:
+				"Nested arrow function returning a non-singular JSX fragment detected. Extract it into its own component.",
+			nestedArrowJSX:
+				"Nested arrow function returning non-component, non-singular JSX detected. Extract it into its own component.",
+			nestedFunctionJSX:
+				"Nested function returning non-component, non-singular JSX detected. Extract it into its own component."
+		},
+		schema: [],
+		type: "problem"
 	}
 };

package/src/rules/no-or-none-component.ts

@@ -4,25 +4,10 @@ type Options = [];
 type MessageIds = "useLogicalAnd";
 
 export const noOrNoneComponent: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Prefer using logical && operator over ternary with null/undefined for conditional JSX rendering."
-		},
-		schema: [],
-		messages: {
-			useLogicalAnd:
-				"Prefer using the logical '&&' operator instead of a ternary with null/undefined for conditional rendering."
-		}
-	},
-
-	defaultOptions: [],
-
 	create(context) {
 		return {
 			ConditionalExpression(node: TSESTree.ConditionalExpression) {
-				const alternate = node.alternate;
+				const { alternate } = node;
 
 				// Check if alternate is explicitly null or undefined
 				const isNullAlternate =
@@ -40,7 +25,7 @@ export const noOrNoneComponent: TSESLint.RuleModule<MessageIds, Options> = {
 				}
 
 				// Check if the node is within a JSX expression container.
-				const parent = node.parent;
+				const { parent } = node;
 				if (!parent || parent.type !== "JSXExpressionContainer") {
 					return;
 				}
@@ -53,12 +38,25 @@ export const noOrNoneComponent: TSESLint.RuleModule<MessageIds, Options> = {
 					containerParent.type !== "JSXAttribute"
 				) {
 					context.report({
-						node,
-						messageId: "useLogicalAnd"
+						messageId: "useLogicalAnd",
+						node
 					});
 				}
 			}
 		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description:
+				"Prefer using logical && operator over ternary with null/undefined for conditional JSX rendering."
+		},
+		messages: {
+			useLogicalAnd:
+				"Prefer using the logical '&&' operator instead of a ternary with null/undefined for conditional rendering."
+		},
+		schema: [],
+		type: "suggestion"
 	}
 };
 

package/src/rules/no-transition-cssproperties.ts

@@ -13,27 +13,62 @@ import { TSESLint, TSESTree } from "@typescript-eslint/utils";
 type Options = [];
 type MessageIds = "forbiddenTransition";
 
+const getKeyName = (prop: TSESTree.Property) => {
+	if (prop.key.type === "Identifier") {
+		return prop.key.name;
+	}
+	if (prop.key.type !== "Literal") {
+		return null;
+	}
+	return typeof prop.key.value === "string"
+		? prop.key.value
+		: String(prop.key.value);
+};
+
+const checkPropForTransition = (
+	context: TSESLint.RuleContext<MessageIds, Options>,
+	prop: TSESTree.Property
+) => {
+	if (prop.computed) {
+		return;
+	}
+	const keyName = getKeyName(prop);
+	if (keyName === "transition") {
+		context.report({
+			messageId: "forbiddenTransition",
+			node: prop
+		});
+	}
+};
+
 export const noTransitionCSSProperties: TSESLint.RuleModule<
 	MessageIds,
 	Options
 > = {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring."
-		},
-		schema: [], // no options
-		messages: {
-			forbiddenTransition:
-				"Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring."
-		}
-	},
+	create(context) {
+		const { sourceCode } = context;
 
-	defaultOptions: [],
+		const isCSSPropertiesType = (typeAnnotation: TSESTree.TypeNode) => {
+			if (typeAnnotation.type !== "TSTypeReference") {
+				return false;
+			}
 
-	create(context) {
-		const sourceCode = context.sourceCode;
+			const { typeName } = typeAnnotation;
+
+			if (
+				typeName.type === "Identifier" &&
+				typeName.name === "CSSProperties"
+			) {
+				return true;
+			}
+
+			return (
+				typeName.type === "TSQualifiedName" &&
+				typeName.right &&
+				typeName.right.type === "Identifier" &&
+				typeName.right.name === "CSSProperties"
+			);
+		};
 
 		return {
 			VariableDeclarator(node: TSESTree.VariableDeclarator) {
@@ -46,39 +81,17 @@ export const noTransitionCSSProperties: TSESLint.RuleModule<
 					return;
 				}
 
-				let isStyleType = false;
-				const typeAnnotation = node.id.typeAnnotation.typeAnnotation;
+				const { typeAnnotation } = node.id.typeAnnotation;
 
-				// First try: check if it's a TSTypeReference with typeName "CSSProperties"
-				if (
-					typeAnnotation &&
-					typeAnnotation.type === "TSTypeReference"
-				) {
-					const typeName = typeAnnotation.typeName;
-
-					if (
-						typeName.type === "Identifier" &&
-						typeName.name === "CSSProperties"
-					) {
-						isStyleType = true;
-					} else if (
-						typeName.type === "TSQualifiedName" &&
-						typeName.right &&
-						typeName.right.type === "Identifier" &&
-						typeName.right.name === "CSSProperties"
-					) {
-						isStyleType = true;
-					}
-				}
+				// Check if the type annotation is CSSProperties
+				let isStyleType = isCSSPropertiesType(typeAnnotation);
 
 				// Fallback: if the AST shape doesn't match, check the raw text of the annotation.
 				if (!isStyleType) {
 					const annotationText = sourceCode.getText(
 						node.id.typeAnnotation
 					);
-					if (annotationText.includes("CSSProperties")) {
-						isStyleType = true;
-					}
+					isStyleType = annotationText.includes("CSSProperties");
 				}
 
 				if (!isStyleType) {
@@ -86,40 +99,33 @@ export const noTransitionCSSProperties: TSESLint.RuleModule<
 				}
 
 				// Check that the initializer is an object literal.
-				const init = node.init;
+				const { init } = node;
 				if (!init || init.type !== "ObjectExpression") {
 					return;
 				}
 
-				for (const prop of init.properties) {
-					// Only consider regular properties.
-					if (prop.type !== "Property") {
-						continue;
-					}
-					if (prop.computed) {
-						continue;
-					}
-
-					let keyName: string | null = null;
-
-					if (prop.key.type === "Identifier") {
-						keyName = prop.key.name;
-					} else if (prop.key.type === "Literal") {
-						if (typeof prop.key.value === "string") {
-							keyName = prop.key.value;
-						} else {
-							keyName = String(prop.key.value);
-						}
-					}
-
-					if (keyName === "transition") {
-						context.report({
-							node: prop,
-							messageId: "forbiddenTransition"
-						});
-					}
-				}
+				const properties = init.properties.filter(
+					(prop): prop is TSESTree.Property =>
+						prop.type === "Property"
+				);
+
+				properties.forEach((prop) => {
+					checkPropForTransition(context, prop);
+				});
 			}
 		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description:
+				"Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring."
+		},
+		messages: {
+			forbiddenTransition:
+				"Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring."
+		},
+		schema: [], // no options,
+		type: "problem"
 	}
 };

package/src/rules/no-unnecessary-div.ts

@@ -4,45 +4,24 @@ type Options = [];
 type MessageIds = "unnecessaryDivWrapper";
 
 export const noUnnecessaryDiv: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Flag unnecessary <div> wrappers that enclose a single JSX element. Remove the wrapper if it doesn't add semantic or functional value, or replace it with a semantic element if wrapping is needed."
-		},
-		schema: [],
-		messages: {
-			unnecessaryDivWrapper:
-				"Unnecessary <div> wrapper detected. Remove it if not needed, or replace with a semantic element that reflects its purpose."
-		}
-	},
-
-	defaultOptions: [],
-
 	create(context) {
-		function isDivElement(node: TSESTree.JSXElement) {
+		const isDivElement = (node: TSESTree.JSXElement) => {
 			const nameNode = node.openingElement.name;
 			return (
 				nameNode.type === AST_NODE_TYPES.JSXIdentifier &&
 				nameNode.name === "div"
 			);
-		}
+		};
 
-		function getMeaningfulChildren(
-			node: TSESTree.JSXElement
-		): TSESTree.JSXChild[] {
-			const result: TSESTree.JSXChild[] = [];
-			for (const child of node.children) {
-				if (child.type === AST_NODE_TYPES.JSXText) {
-					if (child.value.trim() !== "") {
-						result.push(child);
-					}
-				} else {
-					result.push(child);
-				}
+		const isMeaningfulChild = (child: TSESTree.JSXChild) => {
+			if (child.type === AST_NODE_TYPES.JSXText) {
+				return child.value.trim() !== "";
 			}
-			return result;
-		}
+			return true;
+		};
+
+		const getMeaningfulChildren = (node: TSESTree.JSXElement) =>
+			node.children.filter(isMeaningfulChild);
 
 		return {
 			JSXElement(node: TSESTree.JSXElement) {
@@ -56,18 +35,31 @@ export const noUnnecessaryDiv: TSESLint.RuleModule<MessageIds, Options> = {
 					return;
 				}
 
-				const onlyChild = meaningfulChildren[0];
+				const [onlyChild] = meaningfulChildren;
 				if (!onlyChild) {
 					return;
 				}
 
 				if (onlyChild.type === AST_NODE_TYPES.JSXElement) {
 					context.report({
-						node,
-						messageId: "unnecessaryDivWrapper"
+						messageId: "unnecessaryDivWrapper",
+						node
 					});
 				}
 			}
 		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description:
+				"Flag unnecessary <div> wrappers that enclose a single JSX element. Remove the wrapper if it doesn't add semantic or functional value, or replace it with a semantic element if wrapping is needed."
+		},
+		messages: {
+			unnecessaryDivWrapper:
+				"Unnecessary <div> wrapper detected. Remove it if not needed, or replace with a semantic element that reflects its purpose."
+		},
+		schema: [],
+		type: "suggestion"
 	}
 };