eslint-plugin-absolute 0.1.6 → 0.2.0

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

@@ -0,0 +1,312 @@
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+
+type Options = [];
+type MessageIds = "noButtonNavigation";
+
+type HandlerState = {
+	attribute: TSESTree.JSXAttribute;
+	reason: string | null;
+	sawReplaceCall: boolean;
+	sawAllowedLocationRead: boolean;
+};
+
+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 state = handlerStack[handlerStack.length - 1];
+			if (!state) {
+				return null;
+			}
+			return state;
+		}
+
+		function isOnClickButtonHandler(
+			node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression
+		): TSESTree.JSXAttribute | null {
+			const parent = node.parent;
+			if (!parent || parent.type !== "JSXExpressionContainer") {
+				return null;
+			}
+			const attributeCandidate = parent.parent;
+			if (
+				!attributeCandidate ||
+				attributeCandidate.type !== "JSXAttribute"
+			) {
+				return null;
+			}
+			const attr = attributeCandidate;
+			if (
+				!attr.name ||
+				attr.name.type !== "JSXIdentifier" ||
+				attr.name.name !== "onClick"
+			) {
+				return null;
+			}
+			const openingElementCandidate = attr.parent;
+			if (
+				!openingElementCandidate ||
+				openingElementCandidate.type !== "JSXOpeningElement"
+			) {
+				return null;
+			}
+			const openingElement = openingElementCandidate;
+			const tagNameNode = openingElement.name;
+			if (
+				tagNameNode.type !== "JSXIdentifier" ||
+				tagNameNode.name !== "button"
+			) {
+				return null;
+			}
+			return attr;
+		}
+
+		function isWindowLocationMember(
+			member: TSESTree.MemberExpression
+		): boolean {
+			const object = member.object;
+			if (object.type !== "MemberExpression") {
+				return false;
+			}
+			const outerObject = object.object;
+			const outerProperty = object.property;
+			if (
+				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;
+			if (object.type !== "MemberExpression") {
+				return false;
+			}
+			const outerObject = object.object;
+			const outerProperty = object.property;
+			if (
+				outerObject.type === "Identifier" &&
+				outerObject.name === "window" &&
+				outerProperty.type === "Identifier" &&
+				outerProperty.name === "history"
+			) {
+				return true;
+			}
+			return false;
+		}
+
+		return {
+			ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression) {
+				const attr = isOnClickButtonHandler(node);
+				if (!attr) {
+					return;
+				}
+				handlerStack.push({
+					attribute: attr,
+					reason: null,
+					sawReplaceCall: false,
+					sawAllowedLocationRead: false
+				});
+			},
+			"ArrowFunctionExpression:exit"(
+				node: TSESTree.ArrowFunctionExpression
+			) {
+				const attr = isOnClickButtonHandler(node);
+				if (!attr) {
+					return;
+				}
+				const state = handlerStack.pop();
+				if (!state) {
+					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"
+						}
+					});
+				}
+			},
+
+			FunctionExpression(node: TSESTree.FunctionExpression) {
+				const attr = isOnClickButtonHandler(node);
+				if (!attr) {
+					return;
+				}
+				handlerStack.push({
+					attribute: attr,
+					reason: null,
+					sawReplaceCall: false,
+					sawAllowedLocationRead: false
+				});
+			},
+			"FunctionExpression:exit"(node: TSESTree.FunctionExpression) {
+				const attr = isOnClickButtonHandler(node);
+				if (!attr) {
+					return;
+				}
+				const state = handlerStack.pop();
+				if (!state) {
+					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"
+						}
+					});
+				}
+			},
+
+			MemberExpression(node: TSESTree.MemberExpression) {
+				const state = getCurrentHandler();
+				if (!state) {
+					return;
+				}
+
+				// 1) window.open(...)
+				if (
+					node.object.type === "Identifier" &&
+					node.object.name === "window" &&
+					node.property.type === "Identifier" &&
+					node.property.name === "open"
+				) {
+					if (!state.reason) {
+						state.reason = "window.open";
+					}
+				}
+
+				// 5) Reading window.location.search, .pathname, or .hash
+				if (
+					isWindowLocationMember(node) &&
+					node.property.type === "Identifier" &&
+					(node.property.name === "search" ||
+						node.property.name === "pathname" ||
+						node.property.name === "hash")
+				) {
+					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;
+				}
+			}
+		};
+	}
+};

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

@@ -0,0 +1,87 @@
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+
+type Options = [];
+type MessageIds = "noExplicitReturnType";
+
+type AnyFunctionNode =
+	| TSESTree.FunctionDeclaration
+	| TSESTree.FunctionExpression
+	| 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;
+
+			for (const stmt of body.body) {
+				if (stmt.type === "ReturnStatement") {
+					returnCount++;
+					const arg = stmt.argument;
+					if (arg && arg.type === "ObjectExpression") {
+						returnedObject = arg;
+					}
+				}
+			}
+
+			return returnCount === 1 && returnedObject !== null;
+		}
+
+		return {
+			"FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(
+				node: AnyFunctionNode
+			) {
+				const returnType = node.returnType;
+				if (!returnType) {
+					return;
+				}
+
+				// Allow type predicate annotations for type guards.
+				const typeAnnotation = returnType.typeAnnotation;
+				if (
+					typeAnnotation &&
+					typeAnnotation.type === "TSTypePredicate"
+				) {
+					return;
+				}
+
+				// Allow if it's an arrow function that directly returns an object literal.
+				if (
+					node.type === "ArrowFunctionExpression" &&
+					node.expression === true &&
+					node.body.type === "ObjectExpression"
+				) {
+					return;
+				}
+
+				// 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;
+					}
+				}
+
+				// Otherwise, report an error.
+				context.report({
+					node: returnType,
+					messageId: "noExplicitReturnType"
+				});
+			}
+		};
+	}
+};

package/src/rules/{no-inline-prop-types.js → no-inline-prop-types.ts}

@@ -1,11 +1,14 @@
-export default {
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+
+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.",
-			category: "Best Practices",
-			recommended: false
+				"Enforce that component prop types are not defined inline (using an object literal) but rather use a named type or interface."
 		},
 		schema: [],
 		messages: {
@@ -14,15 +17,16 @@ export default {
 		}
 	},
 
+	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) {
+		function checkParameter(param: TSESTree.Parameter) {
 			// Ensure we are dealing with a destructured object pattern with a type annotation.
 			if (
-				param &&
 				param.type === "ObjectPattern" &&
 				param.typeAnnotation &&
 				param.typeAnnotation.type === "TSTypeAnnotation"
@@ -42,13 +46,22 @@ export default {
 		return {
 			// Applies to FunctionDeclaration, ArrowFunctionExpression, and FunctionExpression nodes.
 			"FunctionDeclaration, ArrowFunctionExpression, FunctionExpression"(
-				node
+				node:
+					| TSESTree.FunctionDeclaration
+					| TSESTree.ArrowFunctionExpression
+					| TSESTree.FunctionExpression
 			) {
 				// It is common to define props as the first parameter.
+				if (node.params.length === 0) {
+					return;
+				}
+
 				const firstParam = node.params[0];
-				if (firstParam) {
-					checkParameter(firstParam);
+				if (!firstParam) {
+					return;
 				}
+
+				checkParameter(firstParam);
 			}
 		};
 	}

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

@@ -0,0 +1,87 @@
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+
+/**
+ * @fileoverview Disallow grouping CSS style objects in a single export.
+ * Instead of exporting an object that contains multiple CSS style objects,
+ * export each style separately.
+ */
+
+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: [],
+
+	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) {
+			if (!node.properties.length) {
+				return;
+			}
+
+			const cssStyleProperties: TSESTree.Property[] = [];
+
+			for (const prop of node.properties) {
+				if (prop.type !== "Property") {
+					continue;
+				}
+
+				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);
+				}
+			}
+
+			if (cssStyleProperties.length > 1) {
+				context.report({
+					node,
+					messageId: "noMultiStyleObjects"
+				});
+			}
+		}
+
+		return {
+			// Check default exports that are object literals.
+			ExportDefaultDeclaration(node: TSESTree.ExportDefaultDeclaration) {
+				const declaration = node.declaration;
+				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;
+				if (argument && argument.type === "ObjectExpression") {
+					checkObjectExpression(argument);
+				}
+			}
+		};
+	}
+};