eslint-plugin-absolute 0.2.7 → 0.2.8

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

@@ -1,270 +0,0 @@
-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> = {
-	create(context) {
-		const handlerStack: HandlerState[] = [];
-
-		const getCurrentHandler = () => {
-			const state = handlerStack[handlerStack.length - 1];
-			if (!state) {
-				return null;
-			}
-			return state;
-		};
-
-		const isOnClickButtonHandler = (
-			node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression
-		) => {
-			const { parent } = node;
-			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 tagNameNode = openingElementCandidate.name;
-			if (
-				tagNameNode.type !== "JSXIdentifier" ||
-				tagNameNode.name !== "button"
-			) {
-				return null;
-			}
-			return attr;
-		};
-
-		const isWindowLocationMember = (member: TSESTree.MemberExpression) => {
-			const { object } = member;
-			if (object.type !== "MemberExpression") {
-				return false;
-			}
-			const outerObject = object.object;
-			const outerProperty = object.property;
-			return (
-				outerObject.type === "Identifier" &&
-				outerObject.name === "window" &&
-				outerProperty.type === "Identifier" &&
-				outerProperty.name === "location"
-			);
-		};
-
-		const isWindowHistoryMember = (member: TSESTree.MemberExpression) => {
-			const { object } = member;
-			if (object.type !== "MemberExpression") {
-				return false;
-			}
-			const outerObject = object.object;
-			const outerProperty = object.property;
-			return (
-				outerObject.type === "Identifier" &&
-				outerObject.name === "window" &&
-				outerProperty.type === "Identifier" &&
-				outerProperty.name === "history"
-			);
-		};
-
-		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 {
-			ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression) {
-				const attr = isOnClickButtonHandler(node);
-				if (!attr) {
-					return;
-				}
-				handlerStack.push({
-					attribute: attr,
-					reason: null,
-					sawAllowedLocationRead: false,
-					sawReplaceCall: false
-				});
-			},
-			"ArrowFunctionExpression:exit"(
-				node: TSESTree.ArrowFunctionExpression
-			) {
-				const attr = isOnClickButtonHandler(node);
-				if (!attr) {
-					return;
-				}
-				const state = handlerStack.pop();
-				if (!state) {
-					return;
-				}
-
-				reportHandlerExit(state);
-			},
-			AssignmentExpression(node: TSESTree.AssignmentExpression) {
-				const state = getCurrentHandler();
-				if (!state) {
-					return;
-				}
-				if (node.left.type !== "MemberExpression") {
-					return;
-				}
-				const { left } = node;
-
-				// 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;
-				}
-
-				// 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) {
-					return;
-				}
-				handlerStack.push({
-					attribute: attr,
-					reason: null,
-					sawAllowedLocationRead: false,
-					sawReplaceCall: false
-				});
-			},
-			"FunctionExpression:exit"(node: TSESTree.FunctionExpression) {
-				const attr = isOnClickButtonHandler(node);
-				if (!attr) {
-					return;
-				}
-				const state = handlerStack.pop();
-				if (!state) {
-					return;
-				}
-
-				reportHandlerExit(state);
-			},
-			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" &&
-					!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;
-				}
-			}
-		};
-	},
-	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

@@ -1,83 +0,0 @@
-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> = {
-	create(context) {
-		const hasSingleObjectReturn = (body: TSESTree.BlockStatement) => {
-			const returnStatements = body.body.filter(
-				(stmt) => stmt.type === "ReturnStatement"
-			);
-
-			if (returnStatements.length !== 1) {
-				return false;
-			}
-
-			const [returnStmt] = returnStatements;
-			return returnStmt?.argument?.type === "ObjectExpression";
-		};
-
-		return {
-			"FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(
-				node: AnyFunctionNode
-			) {
-				const { returnType } = node;
-				if (!returnType) {
-					return;
-				}
-
-				// Allow type predicate annotations for type guards.
-				const { typeAnnotation } = returnType;
-				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" &&
-					hasSingleObjectReturn(node.body)
-				) {
-					return;
-				}
-
-				// Otherwise, report an error.
-				context.report({
-					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

@@ -1,68 +0,0 @@
-import { TSESLint, TSESTree } from "@typescript-eslint/utils";
-
-type Options = [];
-type MessageIds = "noInlinePropTypes";
-
-export const noInlinePropTypes: TSESLint.RuleModule<MessageIds, Options> = {
-	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.
-		 */
-		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"
-			) {
-				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.
-			"FunctionDeclaration, ArrowFunctionExpression, FunctionExpression"(
-				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;
-				if (!firstParam) {
-					return;
-				}
-
-				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

@@ -1,80 +0,0 @@
-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";
-
-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").
-		 */
-		const checkObjectExpression = (node: TSESTree.ObjectExpression) => {
-			if (!node.properties.length) {
-				return;
-			}
-
-			const cssStyleProperties = node.properties.filter((prop) => {
-				if (prop.type !== "Property") {
-					return false;
-				}
-				const name = getPropertyName(prop);
-				return name !== null && name.endsWith("Style");
-			});
-
-			if (cssStyleProperties.length > 1) {
-				context.report({
-					messageId: "noMultiStyleObjects",
-					node
-				});
-			}
-		};
-
-		return {
-			// Check default exports that are object literals.
-			ExportDefaultDeclaration(node: TSESTree.ExportDefaultDeclaration) {
-				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;
-				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"
-	}
-};

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

@@ -1,205 +0,0 @@
-import { TSESLint, TSESTree, AST_NODE_TYPES } from "@typescript-eslint/utils";
-
-/**
- * @fileoverview Disallow nested functions that return non-component, non-singular JSX
- * to enforce one component per file.
- */
-
-type Options = [];
-type MessageIds =
-	| "nestedFunctionJSX"
-	| "nestedArrowJSX"
-	| "nestedArrowFragment";
-
-type AnyFunctionNode =
-	| TSESTree.FunctionDeclaration
-	| TSESTree.FunctionExpression
-	| TSESTree.ArrowFunctionExpression;
-
-export const noNestedJSXReturn: TSESLint.RuleModule<MessageIds, Options> = {
-	create(context) {
-		// Returns true if the node is a JSX element or fragment.
-		const isJSX = (
-			node: TSESTree.Node | null | undefined
-		): 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
-		) => {
-			let current: TSESTree.JSXTagNameExpression = name;
-			while (current.type === AST_NODE_TYPES.JSXMemberExpression) {
-				current = current.object;
-			}
-			if (current.type === AST_NODE_TYPES.JSXIdentifier) {
-				return current;
-			}
-			return null;
-		};
-
-		// Returns true if the JSX element is a component (its tag name starts with an uppercase letter).
-		const isJSXComponentElement = (
-			node: TSESTree.Node | null | undefined
-		) => {
-			if (!node || node.type !== AST_NODE_TYPES.JSXElement) {
-				return false;
-			}
-			const opening = node.openingElement;
-			const nameNode = opening.name;
-
-			if (nameNode.type === AST_NODE_TYPES.JSXIdentifier) {
-				return /^[A-Z]/.test(nameNode.name);
-			}
-
-			const leftmost = getLeftmostJSXIdentifier(nameNode);
-			if (!leftmost) {
-				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.
-		const isSingularJSXReturn = (
-			node: TSESTree.JSXElement | TSESTree.JSXFragment
-		) => {
-			if (!isJSX(node)) return false;
-
-			const children = node.children.filter((child) => {
-				if (child.type === AST_NODE_TYPES.JSXText) {
-					return child.value.trim() !== "";
-				}
-				return true;
-			});
-
-			// If there are no children, it's singular.
-			if (children.length === 0) {
-				return true;
-			}
-
-			// Check if the returned element has exactly one child.
-			if (children.length !== 1) {
-				return false;
-			}
-
-			const [child] = children;
-			if (!child) {
-				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[] = [];
-		const pushFunction = (node: AnyFunctionNode) => {
-			functionStack.push(node);
-		};
-		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"() {
-				popFunction();
-			},
-			"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;
-				if (!isJSX(argument)) {
-					return;
-				}
-				if (
-					!isJSXComponentElement(argument) &&
-					!isSingularJSXReturn(argument)
-				) {
-					context.report({
-						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"
-	}
-};