eslint-plugin-absolute 0.2.7 → 0.3.0

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