eslint-plugin-absolute 0.2.6 → 0.2.8

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

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

@@ -1,111 +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.
- *
- * Note: This rule does not auto-fix.
- */
-
-import { TSESLint, TSESTree } from "@typescript-eslint/utils";
-
-type Options = [];
-type MessageIds = "unnecessaryKey";
-
-const isMapCallExpression = (node: TSESTree.Node) => {
-	if (
-		node.type !== "CallExpression" ||
-		node.callee.type !== "MemberExpression"
-	) {
-		return false;
-	}
-
-	const { property } = node.callee;
-	return (
-		(property.type === "Identifier" && property.name === "map") ||
-		(property.type === "Literal" && property.value === "map")
-	);
-};
-
-export const noUnnecessaryKey: TSESLint.RuleModule<MessageIds, Options> = {
-	create(context) {
-		// Polyfill for context.getAncestors if it's not available.
-		const getAncestors = (node: TSESTree.Node) => {
-			const ancestors: TSESTree.Node[] = [];
-			let current: TSESTree.Node | null | undefined = 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.
-		 */
-		const isInsideMapCall = (ancestors: TSESTree.Node[]) =>
-			ancestors.some(isMapCallExpression);
-
-		/**
-		 * Checks whether the JSX element is being returned from a helper render
-		 * function.
-		 */
-		const isReturnedFromFunction = (ancestors: TSESTree.Node[]) =>
-			ancestors.some((ancestor) => ancestor.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).
-		 */
-		const checkJSXOpeningElement = (node: TSESTree.JSXOpeningElement) => {
-			// Find a key attribute.
-			const keyAttribute = node.attributes.find(
-				(attr) =>
-					attr.type === "JSXAttribute" &&
-					attr.name.type === "JSXIdentifier" &&
-					attr.name.name === "key"
-			);
-
-			if (!keyAttribute) {
-				return;
-			}
-
-			// Retrieve ancestors.
-			const ancestors = 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({
-				messageId: "unnecessaryKey",
-				node: keyAttribute
-			});
-		};
-
-		return {
-			JSXOpeningElement: checkJSXOpeningElement
-		};
-	},
-	defaultOptions: [],
-	meta: {
-		docs: {
-			description:
-				"enforce that the key prop is only used on components rendered as part of a mapping"
-		},
-		messages: {
-			unnecessaryKey:
-				"The key prop should only be used on elements that are directly rendered as part of an array mapping."
-		},
-		schema: [],
-		type: "problem"
-	}
-};

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

@@ -1,56 +0,0 @@
-import { TSESLint, TSESTree } from "@typescript-eslint/utils";
-
-type Options = [];
-type MessageIds = "uselessFunction";
-
-export const noUselessFunction: TSESLint.RuleModule<MessageIds, Options> = {
-	create(context) {
-		const isCallbackFunction = (node: TSESTree.ArrowFunctionExpression) => {
-			const { parent } = node;
-			if (!parent || parent.type !== "CallExpression") {
-				return false;
-			}
-
-			for (const arg of parent.arguments) {
-				if (arg === node) {
-					return true;
-				}
-			}
-
-			return false;
-		};
-
-		return {
-			ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression) {
-				// 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({
-						messageId: "uselessFunction",
-						node
-					});
-				}
-			}
-		};
-	},
-	defaultOptions: [],
-	meta: {
-		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)."
-		},
-		messages: {
-			uselessFunction:
-				"This function has no parameters and simply returns an object. Consider exporting the object directly instead of wrapping it in a function."
-		},
-		schema: [],
-		type: "suggestion"
-	}
-};

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

@@ -1,79 +0,0 @@
-import { TSESLint, TSESTree } from "@typescript-eslint/utils";
-
-type Options = [];
-type MessageIds = "moveToFile";
-
-export const seperateStyleFiles: TSESLint.RuleModule<MessageIds, Options> = {
-	create(context) {
-		// Only run this rule on .tsx or .jsx files.
-		const { filename } = context;
-		if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) {
-			return {};
-		}
-
-		return {
-			VariableDeclarator(node: TSESTree.VariableDeclarator) {
-				// 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.
-				const idTypeAnnotation = identifier.typeAnnotation;
-				if (
-					!idTypeAnnotation ||
-					idTypeAnnotation.type !== "TSTypeAnnotation"
-				) {
-					return;
-				}
-
-				const typeNode = idTypeAnnotation.typeAnnotation;
-				if (!typeNode || typeNode.type !== "TSTypeReference") {
-					return;
-				}
-
-				// Handle both Identifier and TSQualifiedName cases.
-				const typeNameNode = typeNode.typeName;
-				let typeName: string | null = null;
-
-				// When typeName is a simple Identifier.
-				if (typeNameNode.type === "Identifier") {
-					typeName = typeNameNode.name;
-				}
-				// When typeName is a TSQualifiedName, e.g., React.CSSProperties.
-				else if (typeNameNode.type === "TSQualifiedName") {
-					const { right } = typeNameNode;
-					typeName = right.name;
-				}
-
-				// Report if the type name is CSSProperties.
-				if (typeName === "CSSProperties") {
-					context.report({
-						data: {
-							name: identifier.name,
-							typeName
-						},
-						messageId: "moveToFile",
-						node
-					});
-				}
-			}
-		};
-	},
-	defaultOptions: [],
-	meta: {
-		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."
-		},
-		messages: {
-			moveToFile:
-				'Style object "{{name}}" is typed as {{typeName}}. Move it to its own file under the style folder.'
-		},
-		schema: [],
-		type: "suggestion"
-	}
-};