eslint-plugin-absolute 0.2.0 → 0.2.1

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

@@ -4,11 +4,6 @@
  * 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.
  */
 
@@ -17,25 +12,25 @@ import { TSESLint, TSESTree } from "@typescript-eslint/utils";
 type Options = [];
 type MessageIds = "unnecessaryKey";
 
-export const noUnnecessaryKey: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"enforce that the key prop is only used on components rendered as part of a mapping"
-		},
-		schema: [],
-		messages: {
-			unnecessaryKey:
-				"The key prop should only be used on elements that are directly rendered as part of an array mapping."
-		}
-	},
+const isMapCallExpression = (node: TSESTree.Node) => {
+	if (
+		node.type !== "CallExpression" ||
+		node.callee.type !== "MemberExpression"
+	) {
+		return false;
+	}
 
-	defaultOptions: [],
+	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.
-		function getAncestors(node: TSESTree.Node) {
+		const getAncestors = (node: TSESTree.Node) => {
 			const ancestors: TSESTree.Node[] = [];
 			let current: TSESTree.Node | null | undefined = node.parent;
 			while (current) {
@@ -43,64 +38,27 @@ export const noUnnecessaryKey: TSESLint.RuleModule<MessageIds, Options> = {
 				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.
+		 * representing an array mapping.
 		 */
-		function isInsideMapCall(ancestors: TSESTree.Node[]) {
-			for (const node of ancestors) {
-				if (
-					node.type === "CallExpression" &&
-					node.callee.type === "MemberExpression"
-				) {
-					const property = node.callee.property;
-					if (
-						property.type === "Identifier" &&
-						property.name === "map"
-					) {
-						return true;
-					}
-					if (
-						property.type === "Literal" &&
-						property.value === "map"
-					) {
-						return true;
-					}
-				}
-			}
-			return false;
-		}
+		const isInsideMapCall = (ancestors: TSESTree.Node[]) =>
+			ancestors.some(isMapCallExpression);
 
 		/**
 		 * 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.
 		 */
-		function isReturnedFromFunction(ancestors: TSESTree.Node[]) {
-			for (const node of ancestors) {
-				if (node.type === "ReturnStatement") {
-					return true;
-				}
-			}
-			return false;
-		}
+		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).
-		 *
-		 * @param {ASTNode} node - The JSXOpeningElement node.
 		 */
-		function checkJSXOpeningElement(node: TSESTree.JSXOpeningElement) {
+		const checkJSXOpeningElement = (node: TSESTree.JSXOpeningElement) => {
 			// Find a key attribute.
 			const keyAttribute = node.attributes.find(
 				(attr) =>
@@ -113,13 +71,8 @@ export const noUnnecessaryKey: TSESLint.RuleModule<MessageIds, Options> = {
 				return;
 			}
 
-			// Retrieve ancestors (using context.getAncestors if available).
-			let ancestors: TSESTree.Node[];
-			if (typeof context.getAncestors === "function") {
-				ancestors = context.getAncestors();
-			} else {
-				ancestors = getAncestors(node);
-			}
+			// Retrieve ancestors.
+			const ancestors = getAncestors(node);
 
 			// If the element is (directly or indirectly) part of a map call, allow it.
 			if (isInsideMapCall(ancestors)) {
@@ -133,13 +86,26 @@ export const noUnnecessaryKey: TSESLint.RuleModule<MessageIds, Options> = {
 
 			// Otherwise, report the key prop as unnecessary.
 			context.report({
-				node: keyAttribute,
-				messageId: "unnecessaryKey"
+				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

@@ -4,24 +4,9 @@ type Options = [];
 type MessageIds = "uselessFunction";
 
 export const noUselessFunction: TSESLint.RuleModule<MessageIds, Options> = {
-	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)."
-		},
-		schema: [],
-		messages: {
-			uselessFunction:
-				"This function has no parameters and simply returns an object. Consider exporting the object directly instead of wrapping it in a function."
-		}
-	},
-
-	defaultOptions: [],
-
 	create(context) {
-		function isCallbackFunction(node: TSESTree.ArrowFunctionExpression) {
-			const parent = node.parent;
+		const isCallbackFunction = (node: TSESTree.ArrowFunctionExpression) => {
+			const { parent } = node;
 			if (!parent || parent.type !== "CallExpression") {
 				return false;
 			}
@@ -33,7 +18,7 @@ export const noUselessFunction: TSESLint.RuleModule<MessageIds, Options> = {
 			}
 
 			return false;
-		}
+		};
 
 		return {
 			ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression) {
@@ -48,11 +33,24 @@ export const noUselessFunction: TSESLint.RuleModule<MessageIds, Options> = {
 						return;
 					}
 					context.report({
-						node,
-						messageId: "uselessFunction"
+						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

@@ -4,25 +4,9 @@ type Options = [];
 type MessageIds = "moveToFile";
 
 export const seperateStyleFiles: TSESLint.RuleModule<MessageIds, Options> = {
-	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."
-		},
-		schema: [],
-		messages: {
-			moveToFile:
-				'Style object "{{name}}" is typed as {{typeName}}. Move it to its own file under the style folder.'
-		}
-	},
-
-	defaultOptions: [],
-
 	create(context) {
 		// Only run this rule on .tsx or .jsx files.
-		const filename = context.filename;
+		const { filename } = context;
 		if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) {
 			return {};
 		}
@@ -60,22 +44,36 @@ export const seperateStyleFiles: TSESLint.RuleModule<MessageIds, Options> = {
 				}
 				// When typeName is a TSQualifiedName, e.g., React.CSSProperties.
 				else if (typeNameNode.type === "TSQualifiedName") {
-					const right = typeNameNode.right;
+					const { right } = typeNameNode;
 					typeName = right.name;
 				}
 
 				// Report if the type name is CSSProperties.
 				if (typeName === "CSSProperties") {
 					context.report({
-						node,
-						messageId: "moveToFile",
 						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"
 	}
 };