eslint-plugin-th-rules 1.15.4 → 1.15.6

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.15.6](https://github.com/tomerh2001/eslint-plugin-th-rules/compare/v1.15.5...v1.15.6) (2024-12-30)
+
+
+### Bug Fixes
+
+* enhance top-level functions rule to support async and export keywords ([cca9ceb](https://github.com/tomerh2001/eslint-plugin-th-rules/commit/cca9cebe77fa01820048a55c444e55bd297b883c))
+
+## [1.15.5](https://github.com/tomerh2001/eslint-plugin-th-rules/compare/v1.15.4...v1.15.5) (2024-12-30)
+
+
+### Bug Fixes
+
+* enforce naming conventions for top-level functions and improve error messages ([c50194d](https://github.com/tomerh2001/eslint-plugin-th-rules/commit/c50194d3ad4c2ef98387d3bbee8d06a30e2aa458))
+
 ## [1.15.4](https://github.com/tomerh2001/eslint-plugin-th-rules/compare/v1.15.3...v1.15.4) (2024-12-30)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-th-rules",
-  "version": "1.15.4",
+  "version": "1.15.6",
   "description": "A List of custom ESLint rules created by Tomer Horowitz",
   "keywords": [
     "eslint",

package/src/rules/top-level-functions.js

@@ -1,3 +1,5 @@
+/* eslint-disable unicorn/prefer-module */
+
 const meta = {
 	type: 'suggestion',
 	docs: {
@@ -10,45 +12,140 @@ const meta = {
 	schema: [],
 };
 
+/**
+ * Build a replacement code string for an arrow function:
+ *
+ * @param {string} funcName - The name of the new function.
+ * @param {ArrowFunctionExpression} arrowNode - The ArrowFunctionExpression node.
+ * @param {import('eslint').SourceCode} sourceCode - The ESLint SourceCode object.
+ * @param {boolean} isExport - Whether or not this function is exported (e.g., `export const foo = ...`).
+ * @returns {string} The replacement code.
+ */
+function buildArrowFunctionReplacement(functionName, arrowNode, sourceCode, isExport) {
+	const asyncKeyword = arrowNode.async ? 'async ' : '';
+	const exportKeyword = isExport ? 'export ' : '';
+
+	const parametersText = arrowNode.params.map(parameter => sourceCode.getText(parameter)).join(', ');
+
+	let bodyText;
+	if (arrowNode.body.type === 'BlockStatement') {
+		bodyText = sourceCode.getText(arrowNode.body);
+	} else {
+		const expressionText = sourceCode.getText(arrowNode.body);
+		bodyText = `{ return ${expressionText}; }`;
+	}
+
+	return `${exportKeyword}${asyncKeyword}function ${functionName}(${parametersText}) ${bodyText}`;
+}
+
+/**
+ * Build a replacement code string for a function expression:
+ *
+ * @param {string} funcName - The name of the new function.
+ * @param {FunctionExpression} funcExprNode - The FunctionExpression node.
+ * @param {import('eslint').SourceCode} sourceCode - The ESLint SourceCode object.
+ * @param {boolean} isExport - Whether or not this function is exported.
+ * @returns {string} The replacement code.
+ */
+function buildFunctionExpressionReplacement(functionName, functionExprNode, sourceCode, isExport) {
+	const asyncKeyword = functionExprNode.async ? 'async ' : '';
+	const exportKeyword = isExport ? 'export ' : '';
+
+	const parametersText = functionExprNode.params.map(parameter => sourceCode.getText(parameter)).join(', ');
+	const bodyText = sourceCode.getText(functionExprNode.body);
+
+	return `${exportKeyword}${asyncKeyword}function ${functionName}(${parametersText}) ${bodyText}`;
+}
+
+/**
+ * Build a replacement for an anonymous top-level FunctionDeclaration (including async).
+ *
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {import('estree').FunctionDeclaration} node
+ * @param {string} [funcName='defaultFunction']
+ * @param {boolean} [isExport=false]
+ */
+function buildAnonymousFunctionDeclarationReplacement(sourceCode, node, functionName = 'defaultFunction', isExport = false) {
+	const originalText = sourceCode.getText(node);
+	const asyncKeyword = node.async ? 'async ' : '';
+	const exportKeyword = isExport ? 'export ' : '';
+
+	let replaced = originalText;
+	const asyncFunctionRegex = /^\s*async\s+function\s*\(/;
+	const functionRegex = /^\s*function\s*\(/;
+
+	replaced = asyncFunctionRegex.test(replaced) ? replaced.replace(asyncFunctionRegex, `async function ${functionName}(`) : replaced.replace(functionRegex, `function ${functionName}(`);
+
+	if (isExport && !replaced.trimStart().startsWith('export')) {
+		replaced = `${exportKeyword}${replaced}`;
+	}
+
+	return replaced;
+}
+
 function create(context) {
+	const sourceCode = context.getSourceCode();
+
 	return {
 		VariableDeclarator(node) {
-			if (node.parent.parent.type !== 'Program') {
+			const declParent = node.parent;
+			const grandParent = declParent.parent;
+
+			const isTopLevel
+				= grandParent.type === 'Program'
+				|| grandParent.type === 'ExportNamedDeclaration'
+				|| grandParent.type === 'ExportDefaultDeclaration';
+
+			if (!isTopLevel) {
 				return;
 			}
 
-			const sourceCode = context.getSourceCode();
+			const isExport
+				= grandParent.type === 'ExportNamedDeclaration'
+				|| grandParent.type === 'ExportDefaultDeclaration';
 
-			if (node.init && node.init.type === 'ArrowFunctionExpression') {
-				const functionName = node.id.name;
-				const functionText = sourceCode.getText(node.init);
+			if (!node.init) {
+				return;
+			}
+
+			const functionName = node.id && node.id.name;
+			if (!functionName) {
+				return;
+			}
 
+			if (node.init.type === 'ArrowFunctionExpression') {
 				context.report({
 					node: node.init,
-					message: 'Top-level functions must be named/regular functions.',
+					message: 'Top-level arrow functions must be named/regular functions.',
 					fix(fixer) {
-						const isSingleExpression = node.init.body.type !== 'BlockStatement';
-						const functionBody = isSingleExpression
-							? `{ return ${functionText.slice(functionText.indexOf('=>') + 3)}; }`
-							: functionText.slice(functionText.indexOf('{'));
-						const functionParameters = functionText.slice(0, functionText.indexOf('=>')).trim();
-
-						const fixedCode = `function ${functionName}${functionParameters} ${functionBody}`;
-						return fixer.replaceText(node.parent, fixedCode);
+						const replacement = buildArrowFunctionReplacement(
+							functionName,
+							node.init,
+							sourceCode,
+							isExport,
+						);
+
+						return fixer.replaceText(
+							isExport ? grandParent : declParent,
+							replacement,
+						);
 					},
 				});
-			}
-
-			if (node.init && node.init.type === 'FunctionExpression') {
-				const functionName = node.id.name;
-				const functionText = sourceCode.getText(node.init);
-
+			} else if (node.init.type === 'FunctionExpression') {
 				context.report({
 					node: node.init,
-					message: 'Top-level functions must be named/regular functions.',
+					message: 'Top-level function expressions must be named/regular functions.',
 					fix(fixer) {
-						const fixedCode = `function ${functionName}${functionText.slice(functionText.indexOf('('))}`;
-						return fixer.replaceText(node.parent, fixedCode);
+						const replacement = buildFunctionExpressionReplacement(
+							functionName,
+							node.init,
+							sourceCode,
+							isExport,
+						);
+						return fixer.replaceText(
+							isExport ? grandParent : declParent,
+							replacement,
+						);
 					},
 				});
 			}
@@ -59,20 +156,39 @@ function create(context) {
 				return;
 			}
 
-			if (node.parent.type === 'Program') {
-				context.report({
-					node,
-					message: 'Top-level functions must be named.',
-					fix(fixer) {
-						const functionName = 'defaultFunction';
-						const sourceCode = context.getSourceCode();
-						const functionText = sourceCode.getText(node);
-						const fixedCode = functionText.replace('function (', `function ${functionName}(`);
+			const parent = node.parent;
 
-						return fixer.replaceText(node, fixedCode);
-					},
-				});
+			const isTopLevel
+				= parent.type === 'Program'
+				|| parent.type === 'ExportNamedDeclaration'
+				|| parent.type === 'ExportDefaultDeclaration';
+
+			if (!isTopLevel) {
+				return;
 			}
+
+			const isExport
+				= parent.type === 'ExportNamedDeclaration'
+				|| parent.type === 'ExportDefaultDeclaration';
+
+			context.report({
+				node,
+				message: 'Top-level anonymous function declarations must be named.',
+				fix(fixer) {
+					const newName = 'defaultFunction';
+					const replacement = buildAnonymousFunctionDeclarationReplacement(
+						sourceCode,
+						node,
+						newName,
+						isExport,
+					);
+
+					return fixer.replaceText(
+						isExport ? parent : node,
+						replacement,
+					);
+				},
+			});
 		},
 	};
 }