eslint-plugin-absolute 0.1.6 → 0.2.1

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

@@ -0,0 +1,111 @@
+/**
+ * @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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,79 @@
+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"
+	}
+};

package/src/rules/sort-exports.ts

@@ -0,0 +1,424 @@
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+
+/**
+ * @fileoverview Enforce that top-level export declarations are sorted.
+ *
+ * This rule supports the following options:
+ *  - order: "asc" or "desc" (default: "asc")
+ *  - caseSensitive: boolean (default: false)
+ *  - natural: boolean (default: false)
+ *  - minKeys: integer, minimum number of exports in a contiguous block to check (default: 2)
+ *  - variablesBeforeFunctions: boolean (default: false)
+ */
+
+type SortExportsOptions = {
+	order?: "asc" | "desc";
+	caseSensitive?: boolean;
+	natural?: boolean;
+	minKeys?: number;
+	variablesBeforeFunctions?: boolean;
+};
+
+type Options = [SortExportsOptions?];
+
+type MessageIds = "alphabetical" | "variablesBeforeFunctions";
+
+type ExportItem = {
+	name: string;
+	node: TSESTree.ExportNamedDeclaration;
+	isFunction: boolean;
+	text: string;
+};
+
+const SORT_BEFORE: -1 = -1;
+
+const getVariableDeclaratorName = (
+	declaration: TSESTree.VariableDeclaration
+) => {
+	if (declaration.declarations.length !== 1) {
+		return null;
+	}
+	const [firstDeclarator] = declaration.declarations;
+	if (firstDeclarator && firstDeclarator.id.type === "Identifier") {
+		return firstDeclarator.id.name;
+	}
+	return null;
+};
+
+const getDeclarationName = (
+	declaration: TSESTree.ExportNamedDeclaration["declaration"]
+) => {
+	if (!declaration) {
+		return null;
+	}
+
+	if (declaration.type === "VariableDeclaration") {
+		return getVariableDeclaratorName(declaration);
+	}
+
+	if (
+		(declaration.type === "FunctionDeclaration" ||
+			declaration.type === "ClassDeclaration") &&
+		declaration.id &&
+		declaration.id.type === "Identifier"
+	) {
+		return declaration.id.name;
+	}
+
+	return null;
+};
+
+const getSpecifierName = (node: TSESTree.ExportNamedDeclaration) => {
+	if (node.specifiers.length !== 1) {
+		return null;
+	}
+	const [spec] = node.specifiers;
+	if (!spec) {
+		return null;
+	}
+	if (spec.exported.type === "Identifier") {
+		return spec.exported.name;
+	}
+	if (
+		spec.exported.type === "Literal" &&
+		typeof spec.exported.value === "string"
+	) {
+		return spec.exported.value;
+	}
+	return null;
+};
+
+const getExportName = (node: TSESTree.ExportNamedDeclaration) =>
+	getDeclarationName(node.declaration) ?? getSpecifierName(node);
+
+const isFixableExport = (exportNode: TSESTree.ExportNamedDeclaration) => {
+	const { declaration } = exportNode;
+
+	if (!declaration) {
+		return exportNode.specifiers.length === 1;
+	}
+
+	if (
+		declaration.type === "VariableDeclaration" &&
+		declaration.declarations.length === 1
+	) {
+		const [firstDecl] = declaration.declarations;
+		return firstDecl !== undefined && firstDecl.id.type === "Identifier";
+	}
+
+	return (
+		(declaration.type === "FunctionDeclaration" ||
+			declaration.type === "ClassDeclaration") &&
+		declaration.id !== null &&
+		declaration.id.type === "Identifier"
+	);
+};
+
+export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
+	create(context) {
+		const { sourceCode } = context;
+		const [option] = context.options;
+
+		const order: "asc" | "desc" =
+			option && option.order ? option.order : "asc";
+
+		const caseSensitive =
+			option && typeof option.caseSensitive === "boolean"
+				? option.caseSensitive
+				: false;
+
+		const natural =
+			option && typeof option.natural === "boolean"
+				? option.natural
+				: false;
+
+		const minKeys =
+			option && typeof option.minKeys === "number" ? option.minKeys : 2;
+
+		const variablesBeforeFunctions =
+			option && typeof option.variablesBeforeFunctions === "boolean"
+				? option.variablesBeforeFunctions
+				: false;
+
+		const generateExportText = (node: TSESTree.ExportNamedDeclaration) =>
+			sourceCode
+				.getText(node)
+				.trim()
+				.replace(/\s*;?\s*$/, ";");
+
+		const compareStrings = (strLeft: string, strRight: string) => {
+			let left = strLeft;
+			let right = strRight;
+
+			if (!caseSensitive) {
+				left = left.toLowerCase();
+				right = right.toLowerCase();
+			}
+
+			const cmp = natural
+				? left.localeCompare(right, undefined, { numeric: true })
+				: left.localeCompare(right);
+
+			return order === "asc" ? cmp : -cmp;
+		};
+
+		const isFunctionExport = (node: TSESTree.ExportNamedDeclaration) => {
+			const { declaration } = node;
+
+			if (!declaration) {
+				return false;
+			}
+
+			if (declaration.type === "FunctionDeclaration") {
+				return true;
+			}
+
+			if (declaration.type !== "VariableDeclaration") {
+				return false;
+			}
+
+			if (declaration.declarations.length !== 1) {
+				return false;
+			}
+
+			const [firstDeclarator] = declaration.declarations;
+			if (!firstDeclarator) {
+				return false;
+			}
+			const { init } = firstDeclarator;
+			if (!init) {
+				return false;
+			}
+			return (
+				init.type === "FunctionExpression" ||
+				init.type === "ArrowFunctionExpression"
+			);
+		};
+
+		const sortComparator = (left: ExportItem, right: ExportItem) => {
+			const kindA = left.node.exportKind ?? "value";
+			const kindB = right.node.exportKind ?? "value";
+
+			if (kindA !== kindB) {
+				return kindA === "type" ? SORT_BEFORE : 1;
+			}
+
+			if (
+				variablesBeforeFunctions &&
+				left.isFunction !== right.isFunction
+			) {
+				return left.isFunction ? 1 : SORT_BEFORE;
+			}
+
+			return compareStrings(left.name, right.name);
+		};
+
+		/**
+		 * Very lightweight dependency check: look at the text of the node and see
+		 * if it references any of the later export names.
+		 */
+		const hasForwardDependency = (
+			node: TSESTree.Node,
+			laterNames: Set<string>
+		) => {
+			const text = sourceCode.getText(node);
+			for (const name of laterNames) {
+				if (text.includes(name)) {
+					return true;
+				}
+			}
+			return false;
+		};
+
+		const buildItems = (block: TSESTree.ExportNamedDeclaration[]) =>
+			block
+				.map((node) => {
+					const name = getExportName(node);
+					if (!name) {
+						return null;
+					}
+					const item: ExportItem = {
+						isFunction: isFunctionExport(node),
+						name,
+						node,
+						text: sourceCode.getText(node)
+					};
+					return item;
+				})
+				.filter((item): item is ExportItem => item !== null);
+
+		const findFirstUnsorted = (items: ExportItem[]) => {
+			let messageId: MessageIds = "alphabetical";
+
+			const unsorted = items.some((current, idx) => {
+				if (idx === 0) {
+					return false;
+				}
+				const prev = items[idx - 1];
+				if (!prev) {
+					return false;
+				}
+				if (sortComparator(prev, current) <= 0) {
+					return false;
+				}
+				if (
+					variablesBeforeFunctions &&
+					prev.isFunction &&
+					!current.isFunction
+				) {
+					messageId = "variablesBeforeFunctions";
+				}
+				return true;
+			});
+
+			return unsorted ? messageId : null;
+		};
+
+		const checkForwardDependencies = (items: ExportItem[]) => {
+			const exportNames = items.map((item) => item.name);
+			return items.some((item, idx) => {
+				const laterNames = new Set(exportNames.slice(idx + 1));
+				const nodeToCheck: TSESTree.Node =
+					item.node.declaration ?? item.node;
+				return hasForwardDependency(nodeToCheck, laterNames);
+			});
+		};
+
+		const processExportBlock = (
+			block: TSESTree.ExportNamedDeclaration[]
+		) => {
+			if (block.length < minKeys) {
+				return;
+			}
+
+			const items = buildItems(block);
+
+			if (items.length < minKeys) {
+				return;
+			}
+
+			const messageId = findFirstUnsorted(items);
+			if (!messageId) {
+				return;
+			}
+
+			if (checkForwardDependencies(items)) {
+				return;
+			}
+
+			const sortedItems = items.slice().sort(sortComparator);
+
+			const expectedOrder = sortedItems
+				.map((item) => item.name)
+				.join(", ");
+
+			const [firstNode] = block;
+			const lastNode = block[block.length - 1];
+
+			if (!firstNode || !lastNode) {
+				return;
+			}
+
+			context.report({
+				data: {
+					expectedOrder
+				},
+				fix(fixer) {
+					const fixableNodes = block.filter(isFixableExport);
+
+					if (fixableNodes.length < minKeys) {
+						return null;
+					}
+
+					const sortedText = sortedItems
+						.map((item) => generateExportText(item.node))
+						.join("\n");
+
+					const [rangeStart] = firstNode.range;
+					const [, rangeEnd] = lastNode.range;
+
+					const fullText = sourceCode.getText();
+					const originalText = fullText.slice(rangeStart, rangeEnd);
+
+					if (originalText === sortedText) {
+						return null;
+					}
+
+					return fixer.replaceTextRange(
+						[rangeStart, rangeEnd],
+						sortedText
+					);
+				},
+				messageId,
+				node: firstNode
+			});
+		};
+
+		return {
+			"Program:exit"(node: TSESTree.Program) {
+				const { body } = node;
+				const block: TSESTree.ExportNamedDeclaration[] = [];
+
+				body.forEach((stmt) => {
+					if (
+						stmt.type === "ExportNamedDeclaration" &&
+						!stmt.source &&
+						getExportName(stmt) !== null
+					) {
+						block.push(stmt);
+						return;
+					}
+
+					if (block.length > 0) {
+						processExportBlock(block);
+						block.length = 0;
+					}
+				});
+
+				if (block.length > 0) {
+					processExportBlock(block);
+				}
+			}
+		};
+	},
+	defaultOptions: [{}],
+	meta: {
+		docs: {
+			description:
+				"Enforce that top-level export declarations are sorted by exported name and, optionally, that variable exports come before function exports"
+		},
+		fixable: "code",
+		messages: {
+			alphabetical:
+				"Export declarations are not sorted alphabetically. Expected order: {{expectedOrder}}.",
+			variablesBeforeFunctions:
+				"Non-function exports should come before function exports."
+		},
+		schema: [
+			{
+				additionalProperties: false,
+				properties: {
+					caseSensitive: {
+						type: "boolean"
+					},
+					minKeys: {
+						minimum: 2,
+						type: "integer"
+					},
+					natural: {
+						type: "boolean"
+					},
+					order: {
+						enum: ["asc", "desc"],
+						type: "string"
+					},
+					variablesBeforeFunctions: {
+						type: "boolean"
+					}
+				},
+				type: "object"
+			}
+		],
+		type: "suggestion"
+	}
+};