eslint-plugin-absolute 0.2.7 → 0.3.0

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"
-	}
-};

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

@@ -1,63 +0,0 @@
-import { TSESLint, TSESTree } from "@typescript-eslint/utils";
-
-type Options = [];
-type MessageIds = "useLogicalAnd";
-
-export const noOrNoneComponent: TSESLint.RuleModule<MessageIds, Options> = {
-	create(context) {
-		return {
-			ConditionalExpression(node: TSESTree.ConditionalExpression) {
-				const { alternate } = node;
-
-				// Check if alternate is explicitly null or undefined
-				const isNullAlternate =
-					alternate &&
-					alternate.type === "Literal" &&
-					alternate.value === null;
-
-				const isUndefinedAlternate =
-					alternate &&
-					alternate.type === "Identifier" &&
-					alternate.name === "undefined";
-
-				if (!isNullAlternate && !isUndefinedAlternate) {
-					return;
-				}
-
-				// Check if the node is within a JSX expression container.
-				const { parent } = node;
-				if (!parent || parent.type !== "JSXExpressionContainer") {
-					return;
-				}
-
-				const containerParent = parent.parent;
-				// Only flag if the JSXExpressionContainer is used as a child,
-				// not as a prop (i.e. not within a JSXAttribute)
-				if (
-					containerParent &&
-					containerParent.type !== "JSXAttribute"
-				) {
-					context.report({
-						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"
-	}
-};
-
-// TODO : Add a fix function to this rule, it needs a deep unconflicting fix becasue of react/jsx-no-leaked-render, it needs to explicitly be === something like that

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

@@ -1,131 +0,0 @@
-/**
- * @fileoverview Disallow the "transition" property in objects typed as CSSProperties.
- *
- * This rule inspects VariableDeclarators where the identifier has a type annotation that
- * includes "CSSProperties" (either as a TSTypeReference or by a text check fallback).
- * It then checks if the initializer is an object literal containing a property named "transition".
- *
- * This is intended to help avoid conflicts with react-spring.
- */
-
-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
-> = {
-	create(context) {
-		const { sourceCode } = context;
-
-		const isCSSPropertiesType = (typeAnnotation: TSESTree.TypeNode) => {
-			if (typeAnnotation.type !== "TSTypeReference") {
-				return false;
-			}
-
-			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) {
-				// Ensure the variable identifier exists, is an Identifier, and has a type annotation.
-				if (
-					!node.id ||
-					node.id.type !== "Identifier" ||
-					!node.id.typeAnnotation
-				) {
-					return;
-				}
-
-				const { typeAnnotation } = node.id.typeAnnotation;
-
-				// 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
-					);
-					isStyleType = annotationText.includes("CSSProperties");
-				}
-
-				if (!isStyleType) {
-					return;
-				}
-
-				// Check that the initializer is an object literal.
-				const { init } = node;
-				if (!init || init.type !== "ObjectExpression") {
-					return;
-				}
-
-				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

@@ -1,65 +0,0 @@
-import { TSESLint, TSESTree, AST_NODE_TYPES } from "@typescript-eslint/utils";
-
-type Options = [];
-type MessageIds = "unnecessaryDivWrapper";
-
-export const noUnnecessaryDiv: TSESLint.RuleModule<MessageIds, Options> = {
-	create(context) {
-		const isDivElement = (node: TSESTree.JSXElement) => {
-			const nameNode = node.openingElement.name;
-			return (
-				nameNode.type === AST_NODE_TYPES.JSXIdentifier &&
-				nameNode.name === "div"
-			);
-		};
-
-		const isMeaningfulChild = (child: TSESTree.JSXChild) => {
-			if (child.type === AST_NODE_TYPES.JSXText) {
-				return child.value.trim() !== "";
-			}
-			return true;
-		};
-
-		const getMeaningfulChildren = (node: TSESTree.JSXElement) =>
-			node.children.filter(isMeaningfulChild);
-
-		return {
-			JSXElement(node: TSESTree.JSXElement) {
-				if (!isDivElement(node)) {
-					return;
-				}
-
-				const meaningfulChildren = getMeaningfulChildren(node);
-
-				if (meaningfulChildren.length !== 1) {
-					return;
-				}
-
-				const [onlyChild] = meaningfulChildren;
-				if (!onlyChild) {
-					return;
-				}
-
-				if (onlyChild.type === AST_NODE_TYPES.JSXElement) {
-					context.report({
-						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"
-	}
-};