eslint-plugin-absolute 0.1.6 → 0.2.1

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

@@ -1,70 +0,0 @@
-/**
- * @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.
- */
-
-export default {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Disallow grouping CSS style objects in a single export; export each style separately.",
-			category: "Best Practices",
-			recommended: false
-		},
-		schema: [] // no 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) {
-			if (node.properties && node.properties.length > 0) {
-				const cssStyleProperties = node.properties.filter((prop) => {
-					if (prop.key) {
-						if (prop.key.type === "Identifier") {
-							return prop.key.name.endsWith("Style");
-						}
-						if (
-							prop.key.type === "Literal" &&
-							typeof prop.key.value === "string"
-						) {
-							return prop.key.value.endsWith("Style");
-						}
-					}
-					return false;
-				});
-				if (cssStyleProperties.length > 1) {
-					context.report({
-						node,
-						message:
-							"Do not group CSS style objects in a single export; export each style separately."
-					});
-				}
-			}
-		}
-
-		return {
-			// Check default exports that are object literals.
-			ExportDefaultDeclaration(node) {
-				if (
-					node.declaration &&
-					node.declaration.type === "ObjectExpression"
-				) {
-					checkObjectExpression(node.declaration);
-				}
-			},
-			// Optionally, also check for object literals returned from exported functions.
-			ReturnStatement(node) {
-				if (
-					node.argument &&
-					node.argument.type === "ObjectExpression"
-				) {
-					checkObjectExpression(node.argument);
-				}
-			}
-		};
-	}
-};

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

@@ -1,154 +0,0 @@
-export default {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Disallow nested functions that return non-component, non-singular JSX to enforce one component per file",
-			recommended: false
-		},
-		schema: []
-	},
-	create(context) {
-		// Returns true if the node is a JSX element or fragment.
-		function isJSX(node) {
-			return (
-				node &&
-				(node.type === "JSXElement" || node.type === "JSXFragment")
-			);
-		}
-
-		// Returns true if the JSX element is a component (its tag name starts with an uppercase letter).
-		function isJSXComponentElement(node) {
-			if (node && node.type === "JSXElement") {
-				const opening = node.openingElement;
-				if (opening && opening.name) {
-					if (opening.name.type === "JSXIdentifier") {
-						return /^[A-Z]/.test(opening.name.name);
-					}
-					if (opening.name.type === "JSXMemberExpression") {
-						let current = opening.name;
-						while (
-							current &&
-							current.type === "JSXMemberExpression"
-						) {
-							current = current.object;
-						}
-						return (
-							current &&
-							current.type === "JSXIdentifier" &&
-							/^[A-Z]/.test(current.name)
-						);
-					}
-				}
-				return false;
-			}
-			return false;
-		}
-
-		// Returns true if the returned JSX is singular.
-		// For both JSXElement and JSXFragment, singular means 0 or 1 non-whitespace child.
-		function isSingularJSXReturn(node) {
-			if (!isJSX(node)) return false;
-			let children = [];
-			if (node.type === "JSXElement" || node.type === "JSXFragment") {
-				children = node.children.filter((child) => {
-					if (child.type === "JSXText") {
-						return child.value.trim() !== "";
-					}
-					return true;
-				});
-				// Check if the returned element has exactly one child.
-				if (children.length === 1) {
-					const child = children[0];
-					// If the singular child is also a JSX element or fragment,
-					// ensure that it doesn't have any meaningful children.
-					if (
-						child.type === "JSXElement" ||
-						child.type === "JSXFragment"
-					) {
-						const innerChildren = child.children.filter(
-							(innerChild) => {
-								if (innerChild.type === "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;
-				}
-				// If there are no children or more than one child, it's not singular.
-				return children.length === 0;
-			}
-			return false;
-		}
-
-		// Stack to track nested function nodes.
-		const functionStack = [];
-		function pushFunction(node) {
-			functionStack.push(node);
-		}
-		function popFunction() {
-			functionStack.pop();
-		}
-
-		return {
-			"FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(
-				node
-			) {
-				pushFunction(node);
-			},
-			"FunctionDeclaration:exit"(node) {
-				popFunction();
-			},
-			"FunctionExpression:exit"(node) {
-				popFunction();
-			},
-			"ArrowFunctionExpression:exit"(node) {
-				popFunction();
-			},
-
-			// For explicit return statements, report if the returned JSX is not a component and not singular.
-			ReturnStatement(node) {
-				if (
-					functionStack.length > 1 &&
-					isJSX(node.argument) &&
-					!isJSXComponentElement(node.argument) &&
-					!isSingularJSXReturn(node.argument)
-				) {
-					context.report({
-						node,
-						message:
-							"Nested function returning non-component, non-singular JSX detected. Extract it into its own component."
-					});
-				}
-			},
-
-			// For implicit returns in arrow functions, use the same checks.
-			"ArrowFunctionExpression > JSXElement"(node) {
-				if (
-					functionStack.length > 1 &&
-					!isJSXComponentElement(node) &&
-					!isSingularJSXReturn(node)
-				) {
-					context.report({
-						node,
-						message:
-							"Nested arrow function returning non-component, non-singular JSX detected. Extract it into its own component."
-					});
-				}
-			},
-			"ArrowFunctionExpression > JSXFragment"(node) {
-				if (functionStack.length > 1 && !isSingularJSXReturn(node)) {
-					context.report({
-						node,
-						message:
-							"Nested arrow function returning a non-singular JSX fragment detected. Extract it into its own component."
-					});
-				}
-			}
-		};
-	}
-};

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

@@ -1,50 +0,0 @@
-export default {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Prefer using logical && operator over ternary with null/undefined for conditional JSX rendering.",
-			recommended: false
-		},
-		messages: {
-			useLogicalAnd:
-				"Prefer using the logical '&&' operator instead of a ternary with null/undefined for conditional rendering."
-		}
-	},
-	create(context) {
-		return {
-			ConditionalExpression(node) {
-				const alternate = node.alternate;
-				// Check if alternate is explicitly null or undefined
-				if (
-					alternate &&
-					((alternate.type === "Literal" &&
-						alternate.value === null) ||
-						(alternate.type === "Identifier" &&
-							alternate.name === "undefined"))
-				) {
-					// Check if the node is within a JSX expression container.
-					if (
-						node.parent &&
-						node.parent.type === "JSXExpressionContainer"
-					) {
-						const containerParent = node.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({
-								node,
-								messageId: "useLogicalAnd"
-							});
-						}
-					}
-				}
-			}
-		};
-	}
-};
-
-// 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.js

@@ -1,102 +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.
- */
-
-export default {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring.",
-			recommended: false
-		},
-		schema: [],
-		messages: {
-			forbiddenTransition:
-				"Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring."
-		}
-	},
-
-	create(context) {
-		const sourceCode = context.getSourceCode();
-		return {
-			VariableDeclarator(node) {
-				// Ensure the variable identifier exists, is an Identifier, and has a type annotation.
-				if (
-					!node.id ||
-					node.id.type !== "Identifier" ||
-					!node.id.typeAnnotation
-				) {
-					return;
-				}
-				let isStyleType = false;
-				const typeAnnotation = node.id.typeAnnotation.typeAnnotation;
-
-				// First try: check if it's a TSTypeReference with typeName "CSSProperties"
-				if (
-					typeAnnotation &&
-					typeAnnotation.type === "TSTypeReference"
-				) {
-					const { typeName } = typeAnnotation;
-					if (
-						typeName.type === "Identifier" &&
-						typeName.name === "CSSProperties"
-					) {
-						isStyleType = true;
-					} else if (
-						typeName.type === "TSQualifiedName" &&
-						typeName.right &&
-						typeName.right.name === "CSSProperties"
-					) {
-						isStyleType = true;
-					}
-				}
-
-				// 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;
-					}
-				}
-
-				if (!isStyleType) {
-					return;
-				}
-
-				// Check that the initializer is an object literal.
-				if (node.init && node.init.type === "ObjectExpression") {
-					node.init.properties.forEach((prop) => {
-						// Only consider regular properties.
-						if (prop.type !== "Property") {
-							return;
-						}
-						if (prop.computed) {
-							return;
-						}
-						let keyName = null;
-						if (prop.key.type === "Identifier") {
-							keyName = prop.key.name;
-						} else if (prop.key.type === "Literal") {
-							keyName = String(prop.key.value);
-						}
-						if (keyName === "transition") {
-							context.report({
-								node: prop,
-								messageId: "forbiddenTransition"
-							});
-						}
-					});
-				}
-			}
-		};
-	}
-};

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

@@ -1,40 +0,0 @@
-export default {
-	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.",
-			category: "Best Practices",
-			recommended: false
-		}
-	},
-
-	create(context) {
-		return {
-			JSXElement(node) {
-				if (
-					node.openingElement.name &&
-					node.openingElement.name.name === "div"
-				) {
-					const meaningfulChildren = node.children.filter((child) => {
-						if (child.type === "JSXText") {
-							return child.value.trim() !== "";
-						}
-						return true;
-					});
-
-					if (
-						meaningfulChildren.length === 1 &&
-						meaningfulChildren[0].type === "JSXElement"
-					) {
-						context.report({
-							node,
-							message:
-								"Unnecessary <div> wrapper detected. Remove it if not needed, or replace with a semantic element that reflects its purpose."
-						});
-					}
-				}
-			}
-		};
-	}
-};

package/src/rules/no-unnecessary-key.js

@@ -1,128 +0,0 @@
-/**
- * @fileoverview Enforce that the key prop is only used on components
- * rendered as part of an array mapping. This rule disallows having a key prop
- * on a JSX element when it is not part of a mapping, except when the element is
- * returned from a helper render function.
- *
- * The rule walks up the ancestors of the JSX element to check if one of them
- * is a CallExpression where the callee is a MemberExpression with the property "map".
- * If not—and if the JSX element is not directly returned from a helper function—
- * then a key prop is considered unnecessary and an error is reported.
- *
- * Note: This rule does not auto-fix.
- */
-
-export default {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"enforce that the key prop is only used on components rendered as part of a mapping",
-			recommended: false
-		},
-		schema: [],
-		messages: {
-			unnecessaryKey:
-				"The key prop should only be used on elements that are directly rendered as part of an array mapping."
-		}
-	},
-
-	create(context) {
-		// Polyfill for context.getAncestors if it's not available.
-		function getAncestors(node) {
-			const ancestors = [];
-			let current = node.parent;
-			while (current) {
-				ancestors.push(current);
-				current = current.parent;
-			}
-			return ancestors;
-		}
-
-		/**
-		 * Checks if any of the ancestors is a CallExpression
-		 * representing an array mapping (i.e. its callee is a MemberExpression
-		 * whose property is an identifier or literal named "map").
-		 *
-		 * @param {ASTNode[]} ancestors - The array of ancestor nodes.
-		 * @returns {boolean} True if a mapping is detected; otherwise, false.
-		 */
-		function isInsideMapCall(ancestors) {
-			return ancestors.some((node) => {
-				if (
-					node.type === "CallExpression" &&
-					node.callee &&
-					node.callee.type === "MemberExpression"
-				) {
-					const property = node.callee.property;
-					return (
-						(property.type === "Identifier" &&
-							property.name === "map") ||
-						(property.type === "Literal" &&
-							property.value === "map")
-					);
-				}
-				return false;
-			});
-		}
-
-		/**
-		 * Checks whether the JSX element is being returned from a helper render
-		 * function. If so, we assume the key prop might be needed when the function
-		 * is eventually invoked from a mapping.
-		 *
-		 * @param {ASTNode[]} ancestors - The array of ancestor nodes.
-		 * @returns {boolean} True if the element is inside a helper render function.
-		 */
-		function isReturnedFromFunction(ancestors) {
-			// Look for a ReturnStatement in the ancestry.
-			return ancestors.some((node) => node.type === "ReturnStatement");
-		}
-
-		/**
-		 * Reports a JSX element if it has a key prop and is not rendered as part
-		 * of an inline mapping (and not simply returned from a render helper function).
-		 *
-		 * @param {ASTNode} node - The JSXOpeningElement node.
-		 */
-		function checkJSXOpeningElement(node) {
-			// Find a key attribute.
-			const keyAttribute = node.attributes.find(
-				(attr) =>
-					attr.type === "JSXAttribute" &&
-					attr.name &&
-					attr.name.name === "key"
-			);
-
-			if (!keyAttribute) {
-				return;
-			}
-
-			// Retrieve ancestors (using context.getAncestors if available).
-			const ancestors =
-				typeof context.getAncestors === "function"
-					? context.getAncestors()
-					: getAncestors(node);
-
-			// If the element is (directly or indirectly) part of a map call, allow it.
-			if (isInsideMapCall(ancestors)) {
-				return;
-			}
-
-			// If the element is simply returned from a helper function, allow it.
-			if (isReturnedFromFunction(ancestors)) {
-				return;
-			}
-
-			// Otherwise, report the key prop as unnecessary.
-			context.report({
-				node: keyAttribute,
-				messageId: "unnecessaryKey"
-			});
-		}
-
-		return {
-			JSXOpeningElement: checkJSXOpeningElement
-		};
-	}
-};

package/src/rules/no-useless-function.js

@@ -1,43 +0,0 @@
-export default {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Disallow functions that have no parameters and just return an object literal; consider exporting the object directly, unless the function is used as a callback (e.g., in react-spring).",
-			category: "Best Practices",
-			recommended: false
-		},
-		fixable: null
-	},
-	create(context) {
-		function isCallbackFunction(node) {
-			// Check if the node is an argument of a CallExpression
-			return (
-				node.parent &&
-				node.parent.type === "CallExpression" &&
-				node.parent.arguments.includes(node)
-			);
-		}
-
-		return {
-			ArrowFunctionExpression(node) {
-				// Check for functions with no parameters and a body that's an ObjectExpression
-				if (
-					node.params.length === 0 &&
-					node.body &&
-					node.body.type === "ObjectExpression"
-				) {
-					// If the function is used as a callback (like in react-spring), skip reporting.
-					if (isCallbackFunction(node)) {
-						return;
-					}
-					context.report({
-						node,
-						message:
-							"This function has no parameters and simply returns an object. Consider exporting the object directly instead of wrapping it in a function."
-					});
-				}
-			}
-		};
-	}
-};

package/src/rules/seperate-style-files.js

@@ -1,62 +0,0 @@
-export default {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Warn when a component file (.jsx or .tsx) contains a style object typed as CSSProperties. " +
-				"Style objects should be moved to their own file under the style folder.",
-			recommended: false
-		},
-		schema: [],
-		messages: {
-			moveToFile:
-				'Style object "{{name}}" is typed as {{typeName}}. Move it to its own file under the style folder.'
-		}
-	},
-
-	create(context) {
-		// Only run this rule on .tsx or .jsx files.
-		const filename = context.getFilename();
-		if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) {
-			return {};
-		}
-
-		return {
-			VariableDeclarator(node) {
-				// Ensure this is a variable declaration with an Identifier.
-				if (!node.id || node.id.type !== "Identifier") return;
-
-				const identifier = node.id;
-				// Check if there's a type annotation on the variable.
-				if (!identifier.typeAnnotation) return;
-
-				const typeNode = identifier.typeAnnotation.typeAnnotation;
-				// Handle both Identifier and TSQualifiedName cases.
-				if (typeNode.type === "TSTypeReference" && typeNode.typeName) {
-					let typeName = null;
-
-					// When typeName is a simple Identifier.
-					if (typeNode.typeName.type === "Identifier") {
-						typeName = typeNode.typeName.name;
-					}
-					// When typeName is a TSQualifiedName, e.g., React.CSSProperties.
-					else if (typeNode.typeName.type === "TSQualifiedName") {
-						typeName = typeNode.typeName.right.name;
-					}
-
-					// Report if the type name is CSSProperties.
-					if (typeName === "CSSProperties") {
-						context.report({
-							node,
-							messageId: "moveToFile",
-							data: {
-								name: identifier.name,
-								typeName: typeName
-							}
-						});
-					}
-				}
-			}
-		};
-	}
-};