eslint-plugin-th-rules 3.2.2 → 3.2.3

package/README.md

@@ -164,19 +164,19 @@ Do not edit below this line.
 ⚛️ Set in the `recommendedReact` configuration.\
 🟦 Set in the `recommendedTypescript` configuration.\
 🎲 Set in the `recommendedTypescriptReact` configuration.\
-🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
-💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
-
-| Name                                                       | Description                                                                                                                                      | 💼         | 🔧 | 💡 |
-| :--------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------- | :--------- | :- | :- |
-| [noBooleanCoercion](docs/rules/noBooleanCoercion.md)       | Disallow Boolean(value) or !!value. Enforce explicit checks: !_.isNil(value) for scalars and !_.isEmpty(value) for strings, arrays, and objects. | ✅ ⚛️ 🟦 🎲 |    | 💡 |
-| [noComments](docs/rules/noComments.md)                     | Disallow comments except for specified allowed patterns.                                                                                         | ✅ ⚛️ 🟦 🎲 | 🔧 |    |
-| [noDefaultExport](docs/rules/noDefaultExport.md)           | Convert unnamed default exports to named default exports based on the file name.                                                                 | ✅ ⚛️ 🟦 🎲 | 🔧 |    |
-| [noDestructuring](docs/rules/noDestructuring.md)           | Disallow destructuring that does not meet certain conditions.                                                                                    | ✅ ⚛️ 🟦 🎲 |    |    |
-| [preferIsEmpty](docs/rules/preferIsEmpty.md)               | Require _.isEmpty instead of length comparisons.                                                                                                 | ✅ ⚛️ 🟦 🎲 |    | 💡 |
-| [schemasInSchemasFile](docs/rules/schemasInSchemasFile.md) | Require Zod schema declarations to be placed in a .schemas.ts file.                                                                              | ✅ ⚛️ 🟦 🎲 |    |    |
-| [topLevelFunctions](docs/rules/topLevelFunctions.md)       | Require all top-level functions to be named regular functions.                                                                                   | ✅ ⚛️ 🟦 🎲 | 🔧 |    |
-| [typesInDts](docs/rules/typesInDts.md)                     | Require TypeScript type declarations (type/interface/enum) to be placed in .d.ts files.                                                          | ✅ ⚛️ 🟦 🎲 |    |    |
+🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).
+
+| Name                                                             | Description                                                                                                                                                                                        | 💼         | 🔧 |
+| :--------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- | :- |
+| [no-boolean-coercion](docs/rules/no-boolean-coercion.md)         | Disallow Boolean(value) or !!value. Enforce explicit checks: !_.isNil(value) for scalars and !_.isEmpty(value) for strings, arrays, and objects. If the value is already boolean, remove coercion. | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [no-comments](docs/rules/no-comments.md)                         | Disallow comments except for specified allowed patterns.                                                                                                                                           | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [no-default-export](docs/rules/no-default-export.md)             | Convert unnamed default exports to named default exports based on the file name.                                                                                                                   | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [no-destructuring](docs/rules/no-destructuring.md)               | Disallow destructuring that does not meet certain conditions.                                                                                                                                      | ✅ ⚛️ 🟦 🎲 |    |
+| [no-explicit-nil-compare](docs/rules/no-explicit-nil-compare.md) | Disallow direct comparisons to null or undefined. Use _.isNull(x) / _.isUndefined(x) instead.                                                                                                      | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [prefer-is-empty](docs/rules/prefer-is-empty.md)                 | Require _.isEmpty instead of length comparisons or !x.length checks.                                                                                                                               | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [schemas-in-schemas-file](docs/rules/schemas-in-schemas-file.md) | Require Zod schema declarations to be placed in a .schemas.ts file.                                                                                                                                | ✅ ⚛️ 🟦 🎲 |    |
+| [top-level-functions](docs/rules/top-level-functions.md)         | Require all top-level functions to be named regular functions.                                                                                                                                     | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [types-in-dts](docs/rules/types-in-dts.md)                       | Require TypeScript type declarations (type/interface/enum) to be placed in .d.ts files.                                                                                                            | ✅ ⚛️ 🟦 🎲 |    |
 
 <!-- end auto-generated rules list -->
 

package/dist/plugin.d.ts

@@ -17,7 +17,10 @@ export declare const rules: {
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    'prefer-is-empty': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty" | "useIsEmptyUnary", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    'no-explicit-nil-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNull" | "useIsUndefined", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
+    'prefer-is-empty': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty" | "useIsEmptyUnary" | "useIsEmptyBoolean", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
     'schemas-in-schemas-file': import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveSchema", [{
@@ -36,9 +39,6 @@ export declare const rules: {
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    'no-explicit-nil-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNull" | "useIsUndefined", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
-        name: string;
-    };
 };
 declare const plugin: {
     rules: {
@@ -60,7 +60,10 @@ declare const plugin: {
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'prefer-is-empty': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty" | "useIsEmptyUnary", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'no-explicit-nil-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNull" | "useIsUndefined", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        'prefer-is-empty': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty" | "useIsEmptyUnary" | "useIsEmptyBoolean", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         'schemas-in-schemas-file': import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveSchema", [{
@@ -79,9 +82,6 @@ declare const plugin: {
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-explicit-nil-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNull" | "useIsUndefined", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
-            name: string;
-        };
     };
 };
 export default plugin;

package/dist/plugin.js

@@ -12,11 +12,11 @@ export const rules = {
     'no-comments': noComments,
     'no-default-export': noDefaultExport,
     'no-destructuring': noDestructuring,
+    'no-explicit-nil-compare': noExplicitNilCompare,
     'prefer-is-empty': preferIsEmpty,
     'schemas-in-schemas-file': schemasInSchemasFile,
     'top-level-functions': topLevelFunctions,
     'types-in-dts': typesInDts,
-    'no-explicit-nil-compare': noExplicitNilCompare,
 };
 const plugin = { rules };
 export default plugin;

package/dist/rules/no-default-export.js

@@ -20,7 +20,7 @@ const noDefaultExport = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
         function generateExportNameFromFileName(fileName) {
             const cleaned = fileName.replaceAll(/[^a-zA-Z\d]+/g, ' ');
             const parts = cleaned.trim().split(/\s+/g).filter(Boolean);
-            if (parts.length === 0) {
+            if (_.isEmpty(parts)) {
                 return 'defaultExport';
             }
             const [first, ...rest] = parts;

package/dist/rules/prefer-is-empty.d.ts

@@ -1,5 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-declare const preferIsEmpty: ESLintUtils.RuleModule<"useIsEmpty" | "useIsEmptyUnary", [], unknown, ESLintUtils.RuleListener> & {
+declare const preferIsEmpty: ESLintUtils.RuleModule<"useIsEmpty" | "useIsEmptyUnary" | "useIsEmptyBoolean", [], unknown, ESLintUtils.RuleListener> & {
     name: string;
 };
 export default preferIsEmpty;

package/dist/rules/prefer-is-empty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-is-empty.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-is-empty.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,WAAW,EAAgC,MAAM,0BAA0B,CAAC;AAIrG,QAAA,MAAM,aAAa;;CAiHjB,CAAC;AAEH,eAAe,aAAa,CAAC"}
+{"version":3,"file":"prefer-is-empty.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-is-empty.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,WAAW,EAAgC,MAAM,0BAA0B,CAAC;AAIrG,QAAA,MAAM,aAAa;;CA2NjB,CAAC;AAEH,eAAe,aAAa,CAAC"}

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

@@ -8,13 +8,14 @@ const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh20
     meta: {
         type: 'problem',
         docs: {
-            description: 'Require _.isEmpty instead of length comparisons or !x.length checks.',
+            description: 'Require _.isEmpty instead of length comparisons or boolean checks on .length.',
         },
         fixable: 'code',
         schema: [],
         messages: {
             useIsEmpty: 'Use _.isEmpty({{collection}}) instead of checking {{collection}}.length {{operator}} {{value}}.',
             useIsEmptyUnary: 'Use _.isEmpty({{collection}}) instead of negating {{collection}}.length.',
+            useIsEmptyBoolean: 'Use _.isEmpty({{collection}}) instead of boolean checking {{collection}}.length.',
         },
     },
     defaultOptions: [],
@@ -28,12 +29,54 @@ const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh20
             const firstImport = imports[0];
             return firstImport ? fixer.insertTextBefore(firstImport, `import _ from 'lodash';\n`) : fixer.insertTextBeforeRange([0, 0], `import _ from 'lodash';\n`);
         }
+        function unwrapChain(node) {
+            return node?.type === AST_NODE_TYPES.ChainExpression ? node.expression : node;
+        }
         function isLengthAccess(node) {
-            return !_.isNil(node) && node.type === AST_NODE_TYPES.MemberExpression && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === 'length' && !node.computed;
+            const unwrapped = unwrapChain(node);
+            return (!_.isNil(unwrapped) &&
+                unwrapped.type === AST_NODE_TYPES.MemberExpression &&
+                unwrapped.property.type === AST_NODE_TYPES.Identifier &&
+                unwrapped.property.name === 'length' &&
+                !unwrapped.computed);
+        }
+        function getLengthMember(node) {
+            return unwrapChain(node);
         }
         function isNumericLiteral(node) {
             return !_.isNil(node) && node.type === AST_NODE_TYPES.Literal && typeof node.value === 'number';
         }
+        function isDoubleNegationLength(node) {
+            return node.operator === '!' && node.argument.type === AST_NODE_TYPES.UnaryExpression && node.argument.operator === '!' && isLengthAccess(node.argument.argument);
+        }
+        function isBooleanContext(node) {
+            const { parent } = node;
+            if (!parent)
+                return false;
+            switch (parent.type) {
+                case AST_NODE_TYPES.IfStatement:
+                case AST_NODE_TYPES.WhileStatement:
+                case AST_NODE_TYPES.DoWhileStatement:
+                case AST_NODE_TYPES.ForStatement: {
+                    return parent.test === node;
+                }
+                case AST_NODE_TYPES.UnaryExpression: {
+                    return parent.operator === '!';
+                }
+                case AST_NODE_TYPES.LogicalExpression: {
+                    return parent.operator === '&&' || parent.operator === '||';
+                }
+                case AST_NODE_TYPES.ConditionalExpression: {
+                    return parent.test === node;
+                }
+                case AST_NODE_TYPES.CallExpression: {
+                    return parent.callee.type === AST_NODE_TYPES.Identifier && parent.callee.name === 'Boolean' && parent.arguments.length === 1 && parent.arguments[0] === node;
+                }
+                default: {
+                    return false;
+                }
+            }
+        }
         function reportBinary(node, lengthNode, operator, value, isEmptyCheck) {
             const collection = sourceCode.getText(lengthNode.object);
             const replacement = isEmptyCheck ? `_.isEmpty(${collection})` : `!_.isEmpty(${collection})`;
@@ -65,34 +108,79 @@ const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh20
                 },
             });
         }
+        function reportBoolean(node, lengthNode) {
+            const collection = sourceCode.getText(lengthNode.object);
+            context.report({
+                node,
+                messageId: 'useIsEmptyBoolean',
+                data: { collection },
+                fix(fixer) {
+                    const fixes = [fixer.replaceText(node, `!_.isEmpty(${collection})`)];
+                    const importFix = ensureLodashImport(fixer);
+                    if (importFix)
+                        fixes.push(importFix);
+                    return fixes;
+                },
+            });
+        }
         return {
             BinaryExpression(node) {
                 if (isLengthAccess(node.left) && isNumericLiteral(node.right)) {
-                    if ((node.operator === '===' && node.right.value === 0) || (node.operator === '<=' && node.right.value === 0) || (node.operator === '<' && node.right.value === 1)) {
-                        reportBinary(node, node.left, node.operator, node.right.value, true);
+                    const right = node.right.value;
+                    if ((node.operator === '===' && right === 0) || (node.operator === '<=' && right === 0) || (node.operator === '<' && right === 1)) {
+                        reportBinary(node, getLengthMember(node.left), node.operator, right, true);
                         return;
                     }
-                    if ((node.operator === '>' && node.right.value === 0) ||
-                        (node.operator === '>=' && node.right.value === 1) ||
-                        ((node.operator === '!=' || node.operator === '!==') && node.right.value === 0)) {
-                        reportBinary(node, node.left, node.operator, node.right.value, false);
+                    if ((node.operator === '>' && right === 0) || (node.operator === '>=' && right === 1) || ((node.operator === '!=' || node.operator === '!==') && right === 0)) {
+                        reportBinary(node, getLengthMember(node.left), node.operator, right, false);
+                        return;
                     }
                 }
                 if (isNumericLiteral(node.left) && isLengthAccess(node.right)) {
-                    if ((node.operator === '===' && node.left.value === 0) || (node.operator === '>=' && node.left.value === 0) || (node.operator === '>' && node.left.value === 0)) {
-                        reportBinary(node, node.right, node.operator, node.left.value, true);
+                    const left = node.left.value;
+                    if ((node.operator === '===' && left === 0) || (node.operator === '>=' && left === 0) || (node.operator === '<=' && left === 0)) {
+                        reportBinary(node, getLengthMember(node.right), node.operator, left, true);
                         return;
                     }
-                    if ((node.operator === '<' && node.left.value === 1) || (node.operator === '<=' && node.left.value === 0)) {
-                        reportBinary(node, node.right, node.operator, node.left.value, false);
+                    if (node.operator === '<' && left === 0) {
+                        reportBinary(node, getLengthMember(node.right), node.operator, left, false);
                     }
                 }
             },
             UnaryExpression(node) {
-                if (node.operator !== '!')
+                if (node.parent?.type === AST_NODE_TYPES.UnaryExpression && node.parent.operator === '!' && isLengthAccess(node.argument)) {
+                    return;
+                }
+                if (isDoubleNegationLength(node)) {
+                    const inner = node.argument;
+                    const lengthNode = getLengthMember(inner.argument);
+                    reportBoolean(node, lengthNode);
+                    return;
+                }
+                const arg = unwrapChain(node.argument);
+                if (!isLengthAccess(arg))
                     return;
-                if (isLengthAccess(node.argument)) {
-                    reportUnary(node, node.argument);
+                if (isBooleanContext(node)) {
+                    reportBoolean(node, getLengthMember(arg));
+                    return;
+                }
+                if (node.operator === '!') {
+                    reportUnary(node, getLengthMember(arg));
+                }
+            },
+            ConditionalExpression(node) {
+                if (isLengthAccess(node.test) && isBooleanContext(node.test)) {
+                    reportBoolean(node.test, getLengthMember(node.test));
+                }
+            },
+            LogicalExpression(node) {
+                if ((node.operator === '&&' || node.operator === '||') && isLengthAccess(node.left)) {
+                    reportBoolean(node.left, getLengthMember(node.left));
+                }
+            },
+            IfStatement(node) {
+                if (isLengthAccess(node.test)) {
+                    reportBoolean(node.test, getLengthMember(node.test));
                 }
             },
         };

package/package.json

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