eslint-plugin-th-rules 2.5.0 → 2.6.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [2.6.0](https://github.com/tomerh2001/eslint-plugin-th-rules/compare/v2.5.1...v2.6.0) (2026-01-14)
+
+
+### Features
+
+* add prefer-explicit-nil-or-empty-check rule and update dependencies ([c8fb3da](https://github.com/tomerh2001/eslint-plugin-th-rules/commit/c8fb3da5be98caf0c31a50fa72f16b07e410eff6))
+
+## [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.6.0",
   "description": "A List of custom ESLint rules created by Tomer Horowitz",
   "keywords": [
     "eslint",
@@ -51,6 +51,7 @@
     "@types/lodash": "^4",
     "@types/requireindex": "^1.2.4",
     "@types/xo": "^0.39.9",
+    "@typescript-eslint/rule-tester": "^8.53.0",
     "bun-types": "latest",
     "eslint": "^9.39.2",
     "eslint-doc-generator": "^3.0.2",

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',
@@ -114,6 +115,7 @@ plugin.configs['recommended-typescript'] = flatConfigs(
 			},
 		},
 		rules: {
+			'th-rules/prefer-explicit-nil-or-empty-check': 'off',
 			'@typescript-eslint/consistent-type-definitions': 'off',
 			'@typescript-eslint/no-extraneous-class': 'off',
 			'@typescript-eslint/no-duplicate-type-constituents': 'off',

package/src/rules/prefer-explicit-nil-or-empty-check.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const ts = require('typescript');
+
+const meta = {
+	type: 'problem',
+	docs: {
+		description:
+			'Disallow implicit truthy/falsy checks on non-boolean values; require _.isNil or _.isEmpty',
+		category: 'Best Practices',
+		recommended: true,
+		url: 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/prefer-explicit-nil-or-empty-check.md',
+	},
+	hasSuggestions: true,
+	schema: [],
+	requiresTypeChecking: true,
+};
+
+function create(context) {
+	const sourceCode = context.getSourceCode();
+	const {parserServices} = context;
+
+	// Safety: rule is disabled if type info is unavailable
+	if (!parserServices?.program || !parserServices.esTreeNodeToTSNodeMap) {
+		return {};
+	}
+
+	const checker = parserServices.program.getTypeChecker();
+
+	function isImplicitTruthyTarget(node) {
+		return (
+			node.type === 'Identifier'
+			|| node.type === 'MemberExpression'
+		);
+	}
+
+	function isBooleanType(node) {
+		const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+		if (!tsNode) {
+			return false;
+		}
+
+		const type = checker.getTypeAtLocation(tsNode);
+
+		return (
+			(type.flags & ts.TypeFlags.Boolean) !== 0
+			|| (type.flags & ts.TypeFlags.BooleanLiteral) !== 0
+		);
+	}
+
+	function report(node, testedNode, negated) {
+		const text = sourceCode.getText(testedNode);
+
+		const isNilExpr = negated
+			? `!_.isNil(${text})`
+			: `_.isNil(${text})`;
+
+		const isEmptyExpr = negated
+			? `!_.isEmpty(${text})`
+			: `_.isEmpty(${text})`;
+
+		context.report({
+			node,
+			message:
+				'Avoid implicit truthy/falsy checks on non-boolean values; use _.isNil or _.isEmpty instead',
+			suggest: [
+				{
+					desc: `Replace with ${isNilExpr}`,
+					fix(fixer) {
+						return fixer.replaceText(node, isNilExpr);
+					},
+				},
+				{
+					desc: `Replace with ${isEmptyExpr}`,
+					fix(fixer) {
+						return fixer.replaceText(node, isEmptyExpr);
+					},
+				},
+			],
+		});
+	}
+
+	return {
+		IfStatement(node) {
+			const {test} = node;
+
+			// If (!value)
+			if (test.type === 'UnaryExpression' && test.operator === '!') {
+				const arg = test.argument;
+
+				if (!isImplicitTruthyTarget(arg)) {
+					return;
+				}
+
+				if (isBooleanType(arg)) {
+					return;
+				}
+
+				report(test, arg, true);
+				return;
+			}
+
+			// If (value)
+			if (isImplicitTruthyTarget(test)) {
+				if (isBooleanType(test)) {
+					return;
+				}
+
+				report(test, test, false);
+			}
+		},
+	};
+}
+
+module.exports = {meta, create};

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/no-boolean-coercion.test.ts

@@ -1,4 +1,4 @@
-const {RuleTester} = require('eslint');
+const {RuleTester} = require('@typescript-eslint/rule-tester');
 const rule = require('../src/rules/no-boolean-coercion');
 
 const ruleTester = new RuleTester({});

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

@@ -1,4 +1,4 @@
-const {RuleTester} = require('eslint');
+const {RuleTester} = require('@typescript-eslint/rule-tester');
 const rule = require('../src/rules/prefer-is-empty');
 
 const ruleTester = new RuleTester({});
@@ -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);',
+						},
+					],
 				},
 			],
 		},