eslint-plugin-th-rules 2.5.0 → 2.5.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [2.5.1](https://github.com/tomerh2001/eslint-plugin-th-rules/compare/v2.5.0...v2.5.1) (2026-01-14)
+
+
+### Bug Fixes
+
+* add prefer-is-empty rule to enforce _.isEmpty over length comparisons and update documentation ([06ee673](https://github.com/tomerh2001/eslint-plugin-th-rules/commit/06ee673a0fde79b7cc2af1f72807d9716576310c))
+
 # [2.5.0](https://github.com/tomerh2001/eslint-plugin-th-rules/compare/v2.4.0...v2.5.0) (2026-01-14)
 
 

package/package.json

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

package/src/index.js

@@ -66,6 +66,7 @@ const baseRecommended = {
 		'th-rules/schemas-in-schemas-file': 'error',
 		'th-rules/types-in-dts': 'error',
 		'th-rules/no-boolean-coercion': 'error',
+		'th-rules/prefer-is-empty': 'error',
 		'unicorn/filename-case': 'off',
 		'unicorn/no-array-callback-reference': 'off',
 		'import/extensions': 'off',

package/src/rules/prefer-is-empty.js

@@ -6,10 +6,13 @@ const meta = {
 		recommended: true,
 		url: 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/prefer-is-empty.md',
 	},
+	hasSuggestions: true,
 	schema: [],
 };
 
 function create(context) {
+	const sourceCode = context.getSourceCode();
+
 	function isLengthAccess(node) {
 		return (
 			node
@@ -20,21 +23,27 @@ function create(context) {
 		);
 	}
 
-	function isZeroOrOneLiteral(node) {
-		return (
-			node
-			&& node.type === 'Literal'
-			&& (node.value === 0 || node.value === 1)
-		);
+	function isNumericLiteral(node) {
+		return node && node.type === 'Literal' && typeof node.value === 'number';
 	}
 
-	function report(node, collectionNode, operator, literalValue) {
-		const sourceCode = context.getSourceCode();
+	function report(node, collectionNode, operator, value, isEmptyCheck) {
 		const collectionText = sourceCode.getText(collectionNode.object);
+		const replacement = isEmptyCheck
+			? `_.isEmpty(${collectionText})`
+			: `!_.isEmpty(${collectionText})`;
 
 		context.report({
 			node,
-			message: `Use _.isEmpty(${collectionText}) instead of checking ${collectionText}.length ${operator} ${literalValue}`,
+			message: `Use _.isEmpty(${collectionText}) instead of checking ${collectionText}.length ${operator} ${value}`,
+			suggest: [
+				{
+					desc: `Replace with ${replacement}`,
+					fix(fixer) {
+						return fixer.replaceText(node, replacement);
+					},
+				},
+			],
 		});
 	}
 
@@ -42,22 +51,51 @@ function create(context) {
 		BinaryExpression(node) {
 			const {left, right, operator} = node;
 
-			if (
-				(operator === '>' || operator === '>=')
-				&& isLengthAccess(left)
-				&& isZeroOrOneLiteral(right)
-			) {
-				report(node, left, operator, right.value);
-				return;
+			// Values.length <op> N
+			if (isLengthAccess(left) && isNumericLiteral(right)) {
+				const {value} = right;
+
+				// EMPTY checks
+				if (
+					(operator === '===' && value === 0)
+					|| (operator === '<=' && value === 0)
+					|| (operator === '<' && value === 1)
+				) {
+					report(node, left, operator, value, true);
+					return;
+				}
+
+				// NOT EMPTY checks
+				if (
+					(operator === '>' && value === 0)
+					|| (operator === '>=' && value === 1)
+					|| ((operator === '!=' || operator === '!==') && value === 0)
+				) {
+					report(node, left, operator, value, false);
+				}
 			}
 
-			if (
-				(operator === '!=' || operator === '!==')
-				&& isLengthAccess(left)
-				&& right?.type === 'Literal'
-				&& right.value === 0
-			) {
-				report(node, left, operator, 0);
+			// N <op> values.length (reversed)
+			if (isNumericLiteral(left) && isLengthAccess(right)) {
+				const {value} = left;
+
+				// EMPTY checks
+				if (
+					(operator === '===' && value === 0)
+					|| (operator === '>=' && value === 0)
+					|| (operator === '>' && value === 0)
+				) {
+					report(node, right, operator, value, true);
+					return;
+				}
+
+				// NOT EMPTY checks
+				if (
+					(operator === '<' && value === 1)
+					|| (operator === '<=' && value === 0)
+				) {
+					report(node, right, operator, value, false);
+				}
 			}
 		},
 	};

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

@@ -7,40 +7,87 @@ ruleTester.run('prefer-is-empty', rule, {
 	valid: [
 		'_.isEmpty(values);',
 		'!_.isEmpty(values);',
-		'values.length === 0;',
-		'values.length <= 0;',
-		'values.length < 1;',
 		'Array.isArray(values);',
 		'values.size > 0;', // Non-length property
 	],
 
 	invalid: [
 		{
-			code: 'values.length > 0;',
+			code: 'values.length === 0;',
 			errors: [
 				{
 					message:
-						'Use _.isEmpty(values) instead of checking values.length > 0',
+						'Use _.isEmpty(values) instead of checking values.length === 0',
+					suggestions: [
+						{
+							desc: 'Replace with _.isEmpty(values)',
+							output: '_.isEmpty(values);',
+						},
+					],
 				},
 			],
 		},
 
 		{
-			code: 'values.length >= 1;',
+			code: 'values.length < 1;',
 			errors: [
 				{
 					message:
-						'Use _.isEmpty(values) instead of checking values.length >= 1',
+						'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 != 0;',
+			code: 'values.length >= 1;',
 			errors: [
 				{
 					message:
-						'Use _.isEmpty(values) instead of checking values.length != 0',
+						'Use _.isEmpty(values) instead of checking values.length >= 1',
+					suggestions: [
+						{
+							desc: 'Replace with !_.isEmpty(values)',
+							output: '!_.isEmpty(values);',
+						},
+					],
 				},
 			],
 		},
@@ -51,6 +98,12 @@ ruleTester.run('prefer-is-empty', rule, {
 				{
 					message:
 						'Use _.isEmpty(values) instead of checking values.length !== 0',
+					suggestions: [
+						{
+							desc: 'Replace with !_.isEmpty(values)',
+							output: '!_.isEmpty(values);',
+						},
+					],
 				},
 			],
 		},
@@ -61,6 +114,28 @@ ruleTester.run('prefer-is-empty', rule, {
 				{
 					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);',
+						},
+					],
 				},
 			],
 		},