eslint-plugin-absolute 0.2.0 → 0.2.1

package/src/rules/no-button-navigation.ts

@@ -11,36 +11,21 @@ type HandlerState = {
 };
 
 export const noButtonNavigation: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Enforce using anchor tags for navigation instead of buttons whose onClick handlers change the path. Allow only query/hash updates via window.location.search or history.replaceState(window.location.pathname + …)."
-		},
-		schema: [],
-		messages: {
-			noButtonNavigation:
-				"Use an anchor tag for navigation instead of a button whose onClick handler changes the path. Detected: {{reason}}. Only query/hash updates (reading window.location.search, .pathname, or .hash) are allowed."
-		}
-	},
-
-	defaultOptions: [],
-
 	create(context) {
 		const handlerStack: HandlerState[] = [];
 
-		function getCurrentHandler(): HandlerState | null {
+		const getCurrentHandler = () => {
 			const state = handlerStack[handlerStack.length - 1];
 			if (!state) {
 				return null;
 			}
 			return state;
-		}
+		};
 
-		function isOnClickButtonHandler(
+		const isOnClickButtonHandler = (
 			node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression
-		): TSESTree.JSXAttribute | null {
-			const parent = node.parent;
+		) => {
+			const { parent } = node;
 			if (!parent || parent.type !== "JSXExpressionContainer") {
 				return null;
 			}
@@ -66,8 +51,7 @@ export const noButtonNavigation: TSESLint.RuleModule<MessageIds, Options> = {
 			) {
 				return null;
 			}
-			const openingElement = openingElementCandidate;
-			const tagNameNode = openingElement.name;
+			const tagNameNode = openingElementCandidate.name;
 			if (
 				tagNameNode.type !== "JSXIdentifier" ||
 				tagNameNode.name !== "button"
@@ -75,47 +59,60 @@ export const noButtonNavigation: TSESLint.RuleModule<MessageIds, Options> = {
 				return null;
 			}
 			return attr;
-		}
+		};
 
-		function isWindowLocationMember(
-			member: TSESTree.MemberExpression
-		): boolean {
-			const object = member.object;
+		const isWindowLocationMember = (member: TSESTree.MemberExpression) => {
+			const { object } = member;
 			if (object.type !== "MemberExpression") {
 				return false;
 			}
 			const outerObject = object.object;
 			const outerProperty = object.property;
-			if (
+			return (
 				outerObject.type === "Identifier" &&
 				outerObject.name === "window" &&
 				outerProperty.type === "Identifier" &&
 				outerProperty.name === "location"
-			) {
-				return true;
-			}
-			return false;
-		}
+			);
+		};
 
-		function isWindowHistoryMember(
-			member: TSESTree.MemberExpression
-		): boolean {
-			const object = member.object;
+		const isWindowHistoryMember = (member: TSESTree.MemberExpression) => {
+			const { object } = member;
 			if (object.type !== "MemberExpression") {
 				return false;
 			}
 			const outerObject = object.object;
 			const outerProperty = object.property;
-			if (
+			return (
 				outerObject.type === "Identifier" &&
 				outerObject.name === "window" &&
 				outerProperty.type === "Identifier" &&
 				outerProperty.name === "history"
-			) {
-				return true;
+			);
+		};
+
+		const reportHandlerExit = (state: HandlerState) => {
+			const { reason, sawReplaceCall, sawAllowedLocationRead } = state;
+
+			if (reason) {
+				context.report({
+					data: { reason },
+					messageId: "noButtonNavigation",
+					node: state.attribute
+				});
+				return;
+			}
+
+			if (sawReplaceCall && !sawAllowedLocationRead) {
+				context.report({
+					data: {
+						reason: "history.replaceState/pushState without reading window.location"
+					},
+					messageId: "noButtonNavigation",
+					node: state.attribute
+				});
 			}
-			return false;
-		}
+		};
 
 		return {
 			ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression) {
@@ -126,8 +123,8 @@ export const noButtonNavigation: TSESLint.RuleModule<MessageIds, Options> = {
 				handlerStack.push({
 					attribute: attr,
 					reason: null,
-					sawReplaceCall: false,
-					sawAllowedLocationRead: false
+					sawAllowedLocationRead: false,
+					sawReplaceCall: false
 				});
 			},
 			"ArrowFunctionExpression:exit"(
@@ -142,30 +139,67 @@ export const noButtonNavigation: TSESLint.RuleModule<MessageIds, Options> = {
 					return;
 				}
 
-				const reason = state.reason;
-				const sawReplaceCall = state.sawReplaceCall;
-				const sawAllowedLocationRead = state.sawAllowedLocationRead;
+				reportHandlerExit(state);
+			},
+			AssignmentExpression(node: TSESTree.AssignmentExpression) {
+				const state = getCurrentHandler();
+				if (!state) {
+					return;
+				}
+				if (node.left.type !== "MemberExpression") {
+					return;
+				}
+				const { left } = node;
 
-				if (reason) {
-					context.report({
-						node: state.attribute,
-						messageId: "noButtonNavigation",
-						data: { reason }
-					});
+				// window.location = ...
+				if (
+					left.object.type === "Identifier" &&
+					left.object.name === "window" &&
+					left.property.type === "Identifier" &&
+					left.property.name === "location" &&
+					!state.reason
+				) {
+					state.reason = "assignment to window.location";
 					return;
 				}
 
-				if (sawReplaceCall && !sawAllowedLocationRead) {
-					context.report({
-						node: state.attribute,
-						messageId: "noButtonNavigation",
-						data: {
-							reason: "history.replaceState/pushState without reading window.location"
-						}
-					});
+				// window.location.href = ... OR window.location.pathname = ...
+				if (isWindowLocationMember(left) && !state.reason) {
+					state.reason = "assignment to window.location sub-property";
 				}
 			},
+			CallExpression(node: TSESTree.CallExpression) {
+				const state = getCurrentHandler();
+				if (!state) {
+					return;
+				}
+				const { callee } = node;
+
+				if (callee.type !== "MemberExpression") {
+					return;
+				}
 
+				// 3) window.location.replace(...)
+				if (
+					isWindowLocationMember(callee) &&
+					callee.property.type === "Identifier" &&
+					callee.property.name === "replace" &&
+					!state.reason
+				) {
+					state.reason = "window.location.replace";
+					return;
+				}
+
+				// 4) window.history.pushState(...) or replaceState(...)
+				if (
+					isWindowHistoryMember(callee) &&
+					callee.property.type === "Identifier" &&
+					(callee.property.name === "pushState" ||
+						callee.property.name === "replaceState")
+				) {
+					state.sawReplaceCall = true;
+				}
+			},
 			FunctionExpression(node: TSESTree.FunctionExpression) {
 				const attr = isOnClickButtonHandler(node);
 				if (!attr) {
@@ -174,8 +208,8 @@ export const noButtonNavigation: TSESLint.RuleModule<MessageIds, Options> = {
 				handlerStack.push({
 					attribute: attr,
 					reason: null,
-					sawReplaceCall: false,
-					sawAllowedLocationRead: false
+					sawAllowedLocationRead: false,
+					sawReplaceCall: false
 				});
 			},
 			"FunctionExpression:exit"(node: TSESTree.FunctionExpression) {
@@ -188,30 +222,8 @@ export const noButtonNavigation: TSESLint.RuleModule<MessageIds, Options> = {
 					return;
 				}
 
-				const reason = state.reason;
-				const sawReplaceCall = state.sawReplaceCall;
-				const sawAllowedLocationRead = state.sawAllowedLocationRead;
-
-				if (reason) {
-					context.report({
-						node: state.attribute,
-						messageId: "noButtonNavigation",
-						data: { reason }
-					});
-					return;
-				}
-
-				if (sawReplaceCall && !sawAllowedLocationRead) {
-					context.report({
-						node: state.attribute,
-						messageId: "noButtonNavigation",
-						data: {
-							reason: "history.replaceState/pushState without reading window.location"
-						}
-					});
-				}
+				reportHandlerExit(state);
 			},
-
 			MemberExpression(node: TSESTree.MemberExpression) {
 				const state = getCurrentHandler();
 				if (!state) {
@@ -223,11 +235,10 @@ export const noButtonNavigation: TSESLint.RuleModule<MessageIds, Options> = {
 					node.object.type === "Identifier" &&
 					node.object.name === "window" &&
 					node.property.type === "Identifier" &&
-					node.property.name === "open"
+					node.property.name === "open" &&
+					!state.reason
 				) {
-					if (!state.reason) {
-						state.reason = "window.open";
-					}
+					state.reason = "window.open";
 				}
 
 				// 5) Reading window.location.search, .pathname, or .hash
@@ -240,73 +251,20 @@ export const noButtonNavigation: TSESLint.RuleModule<MessageIds, Options> = {
 				) {
 					state.sawAllowedLocationRead = true;
 				}
-			},
-
-			AssignmentExpression(node: TSESTree.AssignmentExpression) {
-				const state = getCurrentHandler();
-				if (!state) {
-					return;
-				}
-				if (node.left.type !== "MemberExpression") {
-					return;
-				}
-				const left = node.left;
-
-				// window.location = ...
-				if (
-					left.object.type === "Identifier" &&
-					left.object.name === "window" &&
-					left.property.type === "Identifier" &&
-					left.property.name === "location"
-				) {
-					if (!state.reason) {
-						state.reason = "assignment to window.location";
-					}
-					return;
-				}
-
-				// window.location.href = ... OR window.location.pathname = ...
-				if (isWindowLocationMember(left)) {
-					if (!state.reason) {
-						state.reason =
-							"assignment to window.location sub-property";
-					}
-				}
-			},
-
-			CallExpression(node: TSESTree.CallExpression) {
-				const state = getCurrentHandler();
-				if (!state) {
-					return;
-				}
-				const callee = node.callee;
-
-				if (callee.type !== "MemberExpression") {
-					return;
-				}
-
-				// 3) window.location.replace(...)
-				if (
-					isWindowLocationMember(callee) &&
-					callee.property.type === "Identifier" &&
-					callee.property.name === "replace"
-				) {
-					if (!state.reason) {
-						state.reason = "window.location.replace";
-					}
-					return;
-				}
-
-				// 4) window.history.pushState(...) or replaceState(...)
-				if (
-					isWindowHistoryMember(callee) &&
-					callee.property.type === "Identifier" &&
-					(callee.property.name === "pushState" ||
-						callee.property.name === "replaceState")
-				) {
-					state.sawReplaceCall = true;
-				}
 			}
 		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description:
+				"Enforce using anchor tags for navigation instead of buttons whose onClick handlers change the path. Allow only query/hash updates via window.location.search or history.replaceState(window.location.pathname + …)."
+		},
+		messages: {
+			noButtonNavigation:
+				"Use an anchor tag for navigation instead of a button whose onClick handler changes the path. Detected: {{reason}}. Only query/hash updates (reading window.location.search, .pathname, or .hash) are allowed."
+		},
+		schema: [],
+		type: "suggestion"
 	}
 };

package/src/rules/no-explicit-return-types.ts

@@ -9,50 +9,31 @@ type AnyFunctionNode =
 	| TSESTree.ArrowFunctionExpression;
 
 export const noExplicitReturnTypes: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Disallow explicit return type annotations on functions, except when using type predicates for type guards or inline object literal returns (e.g., style objects)."
-		},
-		schema: [],
-		messages: {
-			noExplicitReturnType:
-				"Explicit return types are disallowed; rely on TypeScript's inference instead."
-		}
-	},
-
-	defaultOptions: [],
-
 	create(context) {
-		function hasSingleObjectReturn(body: TSESTree.BlockStatement) {
-			let returnCount = 0;
-			let returnedObject: TSESTree.ObjectExpression | null = null;
+		const hasSingleObjectReturn = (body: TSESTree.BlockStatement) => {
+			const returnStatements = body.body.filter(
+				(stmt) => stmt.type === "ReturnStatement"
+			);
 
-			for (const stmt of body.body) {
-				if (stmt.type === "ReturnStatement") {
-					returnCount++;
-					const arg = stmt.argument;
-					if (arg && arg.type === "ObjectExpression") {
-						returnedObject = arg;
-					}
-				}
+			if (returnStatements.length !== 1) {
+				return false;
 			}
 
-			return returnCount === 1 && returnedObject !== null;
-		}
+			const [returnStmt] = returnStatements;
+			return returnStmt?.argument?.type === "ObjectExpression";
+		};
 
 		return {
 			"FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(
 				node: AnyFunctionNode
 			) {
-				const returnType = node.returnType;
+				const { returnType } = node;
 				if (!returnType) {
 					return;
 				}
 
 				// Allow type predicate annotations for type guards.
-				const typeAnnotation = returnType.typeAnnotation;
+				const { typeAnnotation } = returnType;
 				if (
 					typeAnnotation &&
 					typeAnnotation.type === "TSTypePredicate"
@@ -70,18 +51,33 @@ export const noExplicitReturnTypes: TSESLint.RuleModule<MessageIds, Options> = {
 				}
 
 				// Allow if the function has a block body with a single return statement that returns an object literal.
-				if (node.body && node.body.type === "BlockStatement") {
-					if (hasSingleObjectReturn(node.body)) {
-						return;
-					}
+				if (
+					node.body &&
+					node.body.type === "BlockStatement" &&
+					hasSingleObjectReturn(node.body)
+				) {
+					return;
 				}
 
 				// Otherwise, report an error.
 				context.report({
-					node: returnType,
-					messageId: "noExplicitReturnType"
+					messageId: "noExplicitReturnType",
+					node: returnType
 				});
 			}
 		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description:
+				"Disallow explicit return type annotations on functions, except when using type predicates for type guards or inline object literal returns (e.g., style objects)."
+		},
+		messages: {
+			noExplicitReturnType:
+				"Explicit return types are disallowed; rely on TypeScript's inference instead."
+		},
+		schema: [],
+		type: "suggestion"
 	}
 };

package/src/rules/no-inline-prop-types.ts

@@ -4,44 +4,31 @@ type Options = [];
 type MessageIds = "noInlinePropTypes";
 
 export const noInlinePropTypes: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Enforce that component prop types are not defined inline (using an object literal) but rather use a named type or interface."
-		},
-		schema: [],
-		messages: {
-			noInlinePropTypes:
-				"Inline prop type definitions are not allowed. Use a named type alias or interface instead of an inline object type."
-		}
-	},
-
-	defaultOptions: [],
-
 	create(context) {
 		/**
 		 * Checks the node representing a parameter to determine if it is an ObjectPattern with an inline type literal.
 		 * @param {ASTNode} param The parameter node from the function declaration/expression.
 		 */
-		function checkParameter(param: TSESTree.Parameter) {
+		const checkParameter = (param: TSESTree.Parameter) => {
 			// Ensure we are dealing with a destructured object pattern with a type annotation.
 			if (
-				param.type === "ObjectPattern" &&
-				param.typeAnnotation &&
-				param.typeAnnotation.type === "TSTypeAnnotation"
+				param.type !== "ObjectPattern" ||
+				!param.typeAnnotation ||
+				param.typeAnnotation.type !== "TSTypeAnnotation"
 			) {
-				// The actual type annotation node (for example, { mode: string } yields a TSTypeLiteral).
-				const annotation = param.typeAnnotation.typeAnnotation;
-				// If the type is an inline object (TSTypeLiteral), we want to report it.
-				if (annotation.type === "TSTypeLiteral") {
-					context.report({
-						node: param,
-						messageId: "noInlinePropTypes"
-					});
-				}
+				return;
 			}
-		}
+
+			// The actual type annotation node (for example, { mode: string } yields a TSTypeLiteral).
+			const annotation = param.typeAnnotation.typeAnnotation;
+			// If the type is an inline object (TSTypeLiteral), we want to report it.
+			if (annotation.type === "TSTypeLiteral") {
+				context.report({
+					messageId: "noInlinePropTypes",
+					node: param
+				});
+			}
+		};
 
 		return {
 			// Applies to FunctionDeclaration, ArrowFunctionExpression, and FunctionExpression nodes.
@@ -56,7 +43,7 @@ export const noInlinePropTypes: TSESLint.RuleModule<MessageIds, Options> = {
 					return;
 				}
 
-				const firstParam = node.params[0];
+				const [firstParam] = node.params;
 				if (!firstParam) {
 					return;
 				}
@@ -64,5 +51,18 @@ export const noInlinePropTypes: TSESLint.RuleModule<MessageIds, Options> = {
 				checkParameter(firstParam);
 			}
 		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description:
+				"Enforce that component prop types are not defined inline (using an object literal) but rather use a named type or interface."
+		},
+		messages: {
+			noInlinePropTypes:
+				"Inline prop type definitions are not allowed. Use a named type alias or interface instead of an inline object type."
+		},
+		schema: [],
+		type: "suggestion"
 	}
 };

package/src/rules/no-multi-style-objects.ts

@@ -9,79 +9,72 @@ import { TSESLint, TSESTree } from "@typescript-eslint/utils";
 type Options = [];
 type MessageIds = "noMultiStyleObjects";
 
-export const noMultiStyleObjects: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Disallow grouping CSS style objects in a single export; export each style separately."
-		},
-		schema: [], // no options
-		messages: {
-			noMultiStyleObjects:
-				"Do not group CSS style objects in a single export; export each style separately."
-		}
-	},
-
-	defaultOptions: [],
+const getPropertyName = (prop: TSESTree.Property) => {
+	const { key } = prop;
+	if (key.type === "Identifier") {
+		return key.name;
+	}
+	if (key.type === "Literal" && typeof key.value === "string") {
+		return key.value;
+	}
+	return null;
+};
 
+export const noMultiStyleObjects: TSESLint.RuleModule<MessageIds, Options> = {
 	create(context) {
 		/**
 		 * Checks if the given ObjectExpression node contains multiple properties
 		 * that look like CSS style objects (i.e. property keys ending with "Style").
 		 */
-		function checkObjectExpression(node: TSESTree.ObjectExpression) {
+		const checkObjectExpression = (node: TSESTree.ObjectExpression) => {
 			if (!node.properties.length) {
 				return;
 			}
 
-			const cssStyleProperties: TSESTree.Property[] = [];
-
-			for (const prop of node.properties) {
+			const cssStyleProperties = node.properties.filter((prop) => {
 				if (prop.type !== "Property") {
-					continue;
+					return false;
 				}
-
-				const key = prop.key;
-				let name: string | null = null;
-
-				if (key.type === "Identifier") {
-					name = key.name;
-				} else if (
-					key.type === "Literal" &&
-					typeof key.value === "string"
-				) {
-					name = key.value;
-				}
-
-				if (name && name.endsWith("Style")) {
-					cssStyleProperties.push(prop);
-				}
-			}
+				const name = getPropertyName(prop);
+				return name !== null && name.endsWith("Style");
+			});
 
 			if (cssStyleProperties.length > 1) {
 				context.report({
-					node,
-					messageId: "noMultiStyleObjects"
+					messageId: "noMultiStyleObjects",
+					node
 				});
 			}
-		}
+		};
 
 		return {
 			// Check default exports that are object literals.
 			ExportDefaultDeclaration(node: TSESTree.ExportDefaultDeclaration) {
-				const declaration = node.declaration;
+				const { declaration } = node;
 				if (declaration && declaration.type === "ObjectExpression") {
 					checkObjectExpression(declaration);
 				}
 			},
 			// Optionally, also check for object literals returned from exported functions.
 			ReturnStatement(node: TSESTree.ReturnStatement) {
-				const argument = node.argument;
+				const { argument } = node;
 				if (argument && argument.type === "ObjectExpression") {
 					checkObjectExpression(argument);
 				}
 			}
 		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description:
+				"Disallow grouping CSS style objects in a single export; export each style separately."
+		},
+		messages: {
+			noMultiStyleObjects:
+				"Do not group CSS style objects in a single export; export each style separately."
+		},
+		schema: [], // no options,
+		type: "problem"
 	}
 };