eslint-plugin-th-rules 2.7.1 → 2.8.0

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

@@ -1,200 +0,0 @@
-/* eslint-disable unicorn/prefer-module */
-
-const meta = {
-	type: 'suggestion',
-	docs: {
-		description: 'Require all top-level functions to be named/regular functions.',
-		category: 'Stylistic Issues',
-		recommended: false,
-		url: 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/top-level-functions.md',
-	},
-	fixable: 'code',
-	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 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) {
-			const declParent = node.parent;
-			const grandParent = declParent.parent;
-
-			const isTopLevel
-				= grandParent.type === 'Program'
-				|| grandParent.type === 'ExportNamedDeclaration'
-				|| grandParent.type === 'ExportDefaultDeclaration';
-
-			if (!isTopLevel) {
-				return;
-			}
-
-			const isExport
-				= grandParent.type === 'ExportNamedDeclaration'
-				|| grandParent.type === 'ExportDefaultDeclaration';
-
-			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 arrow functions must be named/regular functions.',
-					fix(fixer) {
-						const replacement = buildArrowFunctionReplacement(
-							functionName,
-							node.init,
-							sourceCode,
-							isExport,
-						);
-
-						return fixer.replaceText(
-							isExport ? grandParent : declParent,
-							replacement,
-						);
-					},
-				});
-			} else if (node.init.type === 'FunctionExpression') {
-				context.report({
-					node: node.init,
-					message: 'Top-level function expressions must be named/regular functions.',
-					fix(fixer) {
-						const replacement = buildFunctionExpressionReplacement(
-							functionName,
-							node.init,
-							sourceCode,
-							isExport,
-						);
-						return fixer.replaceText(
-							isExport ? grandParent : declParent,
-							replacement,
-						);
-					},
-				});
-			}
-		},
-
-		FunctionDeclaration(node) {
-			if (node.id) {
-				return;
-			}
-
-			const parent = node.parent;
-
-			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,
-					);
-				},
-			});
-		},
-	};
-}
-
-const rule = {
-	meta,
-	create,
-};
-
-module.exports = rule;

package/src/rules/types-in-dts.js

@@ -1,94 +0,0 @@
-/**
- * @fileoverview Enforce that TypeScript type declarations exist only in .d.ts files.
- */
-
-const meta = {
-	type: 'problem',
-	docs: {
-		description: 'Require TypeScript type declarations (type/interface/enum) to be placed in .d.ts files',
-		category: 'Best Practices',
-		recommended: true,
-		url: 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/types-in-dts.md',
-	},
-	schema: [
-		{
-			type: 'object',
-			properties: {
-				allowEnums: {type: 'boolean'},
-				allowDeclare: {type: 'boolean'},
-			},
-			additionalProperties: false,
-		},
-	],
-	messages: {
-		moveToDts:
-			'Type declarations must be defined in a a .d.ts file.',
-	},
-};
-
-/**
- * @param {import('eslint').Rule.RuleContext} context
- */
-function create(context) {
-	const options = context.options?.[0] ?? {};
-	const allowEnums = Boolean(options.allowEnums);
-	const allowDeclare = Boolean(options.allowDeclare);
-
-	function isDtsFile(filename) {
-		if (!filename || filename === '<input>') {
-			return false;
-		}
-
-		return filename.endsWith('.d.ts');
-	}
-
-	function hasDeclareModifier(node) {
-		if (node && node.declare === true) {
-			return true;
-		}
-
-		const mods = node && Array.isArray(node.modifiers) ? node.modifiers : [];
-		return mods.some(m => m && m.type === 'TSDeclareKeyword');
-	}
-
-	function reportIfNotDts(node) {
-		const filename = context.getFilename();
-		if (isDtsFile(filename)) {
-			return;
-		}
-
-		if (allowDeclare && hasDeclareModifier(node)) {
-			return;
-		}
-
-		context.report({
-			node,
-			messageId: 'moveToDts',
-			data: {filename},
-		});
-	}
-
-	return {
-		TSTypeAliasDeclaration(node) {
-			reportIfNotDts(node);
-		},
-
-		TSInterfaceDeclaration(node) {
-			reportIfNotDts(node);
-		},
-
-		TSEnumDeclaration(node) {
-			if (allowEnums) {
-				return;
-			}
-
-			reportIfNotDts(node);
-		},
-
-	};
-}
-
-module.exports = {
-	meta,
-	create,
-};

package/tests/no-boolean-coercion.test.ts

@@ -1,83 +0,0 @@
-const {RuleTester} = require('@typescript-eslint/rule-tester');
-const rule = require('../src/rules/no-boolean-coercion');
-
-const ruleTester = new RuleTester({
-	languageOptions: {
-		ecmaVersion: 2020,
-		sourceType: 'module',
-	},
-});
-
-ruleTester.run('no-boolean-coercion', rule, {
-	valid: [
-		'_.isNil(value);',
-		'_.isEmpty(list);',
-		'if (value != null) {}',
-		'if (list.length > 0) {}',
-		'Boolean;',
-		'const BooleanValue = true;',
-		'const fn = Boolean;',
-	],
-
-	invalid: [
-		{
-			code: 'Boolean(foo);',
-			errors: [
-				{
-					messageId: 'useIsNil',
-					suggestions: [
-						{
-							desc: 'Replace with !_.isNil(foo)',
-							output: '!_.isNil(foo);',
-						},
-					],
-				},
-			],
-		},
-
-		{
-			code: 'const x = Boolean(bar);',
-			errors: [
-				{
-					messageId: 'useIsNil',
-					suggestions: [
-						{
-							desc: 'Replace with !_.isNil(bar)',
-							output: 'const x = !_.isNil(bar);',
-						},
-					],
-				},
-			],
-		},
-
-		{
-			code: '!!value;',
-			errors: [
-				{
-					messageId: 'useIsNil',
-					suggestions: [
-						{
-							desc: 'Replace with !_.isNil(value)',
-							output: '!_.isNil(value);',
-						},
-					],
-				},
-			],
-		},
-
-		{
-			code: 'Boolean([]);',
-			errors: [
-				{
-					messageId: 'useIsEmpty',
-					suggestions: [
-						{
-							desc: 'Replace with !_.isEmpty([])',
-							output: '!_.isEmpty([]);',
-						},
-					],
-				},
-			],
-		},
-	],
-});

package/tests/prefer-is-empty.test.ts

@@ -1,148 +0,0 @@
-const {RuleTester} = require('@typescript-eslint/rule-tester');
-const rule = require('../src/rules/prefer-is-empty');
-
-const ruleTester = new RuleTester({
-	languageOptions: {
-		ecmaVersion: 2020,
-		sourceType: 'module',
-	},
-});
-
-ruleTester.run('prefer-is-empty', rule, {
-	valid: [
-		'_.isEmpty(values);',
-		'!_.isEmpty(values);',
-		'Array.isArray(values);',
-		'values.size > 0;', // Non-length property
-	],
-
-	invalid: [
-		{
-			code: 'values.length === 0;',
-			errors: [
-				{
-					message:
-						'Use _.isEmpty(values) instead of checking values.length === 0',
-					suggestions: [
-						{
-							desc: 'Replace with _.isEmpty(values)',
-							output: '_.isEmpty(values);',
-						},
-					],
-				},
-			],
-		},
-
-		{
-			code: 'values.length < 1;',
-			errors: [
-				{
-					message:
-						'Use _.isEmpty(values) instead of checking values.length < 1',
-					suggestions: [
-						{
-							desc: 'Replace with _.isEmpty(values)',
-							output: '_.isEmpty(values);',
-						},
-					],
-				},
-			],
-		},
-
-		{
-			code: 'values.length <= 0;',
-			errors: [
-				{
-					message:
-						'Use _.isEmpty(values) instead of checking values.length <= 0',
-					suggestions: [
-						{
-							desc: 'Replace with _.isEmpty(values)',
-							output: '_.isEmpty(values);',
-						},
-					],
-				},
-			],
-		},
-
-		{
-			code: 'values.length > 0;',
-			errors: [
-				{
-					message:
-						'Use _.isEmpty(values) instead of checking values.length > 0',
-					suggestions: [
-						{
-							desc: 'Replace with !_.isEmpty(values)',
-							output: '!_.isEmpty(values);',
-						},
-					],
-				},
-			],
-		},
-
-		{
-			code: 'values.length >= 1;',
-			errors: [
-				{
-					message:
-						'Use _.isEmpty(values) instead of checking values.length >= 1',
-					suggestions: [
-						{
-							desc: 'Replace with !_.isEmpty(values)',
-							output: '!_.isEmpty(values);',
-						},
-					],
-				},
-			],
-		},
-
-		{
-			code: 'values.length !== 0;',
-			errors: [
-				{
-					message:
-						'Use _.isEmpty(values) instead of checking values.length !== 0',
-					suggestions: [
-						{
-							desc: 'Replace with !_.isEmpty(values)',
-							output: '!_.isEmpty(values);',
-						},
-					],
-				},
-			],
-		},
-
-		{
-			code: 'if (items.length > 0) {}',
-			errors: [
-				{
-					message:
-						'Use _.isEmpty(items) instead of checking items.length > 0',
-					suggestions: [
-						{
-							desc: 'Replace with !_.isEmpty(items)',
-							output: 'if (!_.isEmpty(items)) {}',
-						},
-					],
-				},
-			],
-		},
-
-		{
-			code: '0 === items.length;',
-			errors: [
-				{
-					message:
-						'Use _.isEmpty(items) instead of checking items.length === 0',
-					suggestions: [
-						{
-							desc: 'Replace with _.isEmpty(items)',
-							output: '_.isEmpty(items);',
-						},
-					],
-				},
-			],
-		},
-	],
-});

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["ESNext"],
-    "module": "esnext",
-    "target": "esnext",
-    "moduleResolution": "bundler",
-    "moduleDetection": "force",
-    "allowImportingTsExtensions": true,
-    "noEmit": true,
-    "composite": true,
-    "strict": true,
-    "downlevelIteration": true,
-    "skipLibCheck": true,
-    "jsx": "react-jsx",
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "allowJs": true,
-    "types": [
-      "bun-types" // add Bun global
-    ]
-  }
-}

package/xo.config.ts

@@ -1,2 +0,0 @@
-
-import {recommended} from 'eslint-plugin-th-rules';