eslint-plugin-th-rules 3.2.1 → 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/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,QAAQ,CAAC;AAQhD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,eAAO,MAAM,OAAO;;;;;CAKnB,CAAC;AAEF,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE1E,QAAA,MAAM,KAAK,EAAoC;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC;AACpI,eAAe,KAAK,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,QAAQ,CAAC;AAQhD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,eAAO,MAAM,OAAO;;;;;CAKnB,CAAC;AAEF,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE1E,QAAA,MAAM,KAAK,EAAoC;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC;AACpI,eAAe,KAAK,CAAC"}

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", [], 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", [], 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-boolean-coercion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-boolean-coercion.d.ts","sourceRoot":"","sources":["../../src/rules/no-boolean-coercion.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAQtF,QAAA,MAAM,iBAAiB;;CAmGrB,CAAC;AAEH,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"no-boolean-coercion.d.ts","sourceRoot":"","sources":["../../src/rules/no-boolean-coercion.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAStF,QAAA,MAAM,iBAAiB;;CAyHrB,CAAC;AAEH,eAAe,iBAAiB,CAAC"}

package/dist/rules/no-boolean-coercion.js

@@ -1,7 +1,7 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable new-cap */
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
 import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
 const createRule = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-boolean-coercion.md');
 const LODASH_MODULE = 'lodash';
 const LODASH_IDENT = '_';
@@ -11,7 +11,7 @@ const noBooleanCoercion = createRule({
         type: 'problem',
         fixable: 'code',
         docs: {
-            description: 'Disallow Boolean(value) or !!value. Enforce explicit checks: !_.isNil(value) for scalars and !_.isEmpty(value) for strings, arrays, and objects.',
+            description: '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.',
         },
         schema: [],
         messages: {
@@ -43,6 +43,14 @@ const noBooleanCoercion = createRule({
         function isDoubleNegation(node) {
             return node.type === AST_NODE_TYPES.UnaryExpression && node.operator === '!' && node.argument.type === AST_NODE_TYPES.UnaryExpression && node.argument.operator === '!';
         }
+        function isBooleanByTS(node) {
+            const tsNode = services.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; // eslint-disable-line no-bitwise
+        }
         function isCollectionLikeByTS(node) {
             const tsNode = services.esTreeNodeToTSNodeMap.get(node);
             if (!tsNode) {
@@ -56,6 +64,16 @@ const noBooleanCoercion = createRule({
             return node.type === AST_NODE_TYPES.ArrayExpression || node.type === AST_NODE_TYPES.ObjectExpression || (node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string');
         }
         function report(node, valueNode) {
+            if (isBooleanByTS(valueNode)) {
+                context.report({
+                    node,
+                    messageId: 'useIsNil',
+                    fix(fixer) {
+                        return fixer.replaceText(node, context.sourceCode.getText(valueNode));
+                    },
+                });
+                return;
+            }
             const isCollection = isCollectionLikeBySyntax(valueNode) || isCollectionLikeByTS(valueNode);
             const fnName = isCollection ? 'isEmpty' : 'isNil';
             const replacement = `!${LODASH_IDENT}.${fnName}(${context.sourceCode.getText(valueNode)})`;

package/dist/rules/no-default-export.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-default-export.d.ts","sourceRoot":"","sources":["../../src/rules/no-default-export.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAEtE,QAAA,MAAM,eAAe;;CA2DnB,CAAC;AACH,eAAe,eAAe,CAAC"}
+{"version":3,"file":"no-default-export.d.ts","sourceRoot":"","sources":["../../src/rules/no-default-export.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAEtE,QAAA,MAAM,eAAe;;CA2DnB,CAAC;AACH,eAAe,eAAe,CAAC"}

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

@@ -1,4 +1,6 @@
+/* eslint-disable new-cap */
 import * as path from 'node:path';
+import _ from 'lodash';
 import { ESLintUtils } from '@typescript-eslint/utils';
 const noDefaultExport = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-default-export.md')({
     name: 'no-default-export',
@@ -18,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;
@@ -29,7 +31,7 @@ const noDefaultExport = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
                 if (node.declaration.type === 'Identifier') {
                     return;
                 }
-                if ('id' in node.declaration && node.declaration.id != null) {
+                if ('id' in node.declaration && !_.isNull(node.declaration.id)) {
                     return;
                 }
                 const fileName = context.getFilename();

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

@@ -1,5 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-declare const preferIsEmpty: ESLintUtils.RuleModule<"useIsEmpty", [], 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":"AAGA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAEtF,QAAA,MAAM,aAAa;;CAoFjB,CAAC;AACH,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

@@ -1,76 +1,188 @@
+/* eslint-disable th-rules/types-in-dts */
 /* eslint-disable new-cap */
 /* eslint-disable complexity */
+import _ from 'lodash';
 import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
 const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/prefer-is-empty.md')({
     name: 'prefer-is-empty',
     meta: {
         type: 'problem',
         docs: {
-            description: 'Require _.isEmpty instead of length comparisons.',
+            description: 'Require _.isEmpty instead of length comparisons or boolean checks on .length.',
         },
-        hasSuggestions: true,
+        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: [],
     create(context) {
+        const { sourceCode } = context;
+        function ensureLodashImport(fixer) {
+            const imports = sourceCode.ast.body.filter((node) => node.type === AST_NODE_TYPES.ImportDeclaration);
+            const hasLodash = imports.some((imp) => imp.source.value === 'lodash' && imp.specifiers.some((s) => s.type === AST_NODE_TYPES.ImportDefaultSpecifier || s.type === AST_NODE_TYPES.ImportNamespaceSpecifier));
+            if (hasLodash)
+                return null;
+            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 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 node?.type === AST_NODE_TYPES.Literal && typeof node.value === 'number';
+            return !_.isNil(node) && node.type === AST_NODE_TYPES.Literal && typeof node.value === 'number';
         }
-        function report(node, collectionNode, operator, value, isEmptyCheck) {
-            const collectionText = context.sourceCode.getText(collectionNode.object);
-            const replacement = isEmptyCheck ? `_.isEmpty(${collectionText})` : `!_.isEmpty(${collectionText})`;
+        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})`;
             context.report({
                 node,
                 messageId: 'useIsEmpty',
-                data: {
-                    collection: collectionText,
-                    operator,
-                    value,
+                data: { collection, operator, value },
+                fix(fixer) {
+                    const fixes = [fixer.replaceText(node, replacement)];
+                    const importFix = ensureLodashImport(fixer);
+                    if (importFix)
+                        fixes.push(importFix);
+                    return fixes;
+                },
+            });
+        }
+        function reportUnary(node, lengthNode) {
+            const collection = sourceCode.getText(lengthNode.object);
+            context.report({
+                node,
+                messageId: 'useIsEmptyUnary',
+                data: { collection },
+                fix(fixer) {
+                    const fixes = [fixer.replaceText(node, `_.isEmpty(${collection})`)];
+                    const importFix = ensureLodashImport(fixer);
+                    if (importFix)
+                        fixes.push(importFix);
+                    return fixes;
+                },
+            });
+        }
+        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;
                 },
-                suggest: [
-                    {
-                        messageId: 'useIsEmpty',
-                        data: {
-                            collection: collectionText,
-                            operator,
-                            value,
-                        },
-                        fix(fixer) {
-                            return fixer.replaceText(node, replacement);
-                        },
-                    },
-                ],
             });
         }
         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)) {
-                        report(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)) {
-                        report(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)) {
-                        report(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)) {
-                        report(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.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 (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/dist/rules/types-in-dts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types-in-dts.d.ts","sourceRoot":"","sources":["../../src/rules/types-in-dts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAStE,QAAA,MAAM,UAAU;;;;;CAuFd,CAAC;AACH,eAAe,UAAU,CAAC"}
+{"version":3,"file":"types-in-dts.d.ts","sourceRoot":"","sources":["../../src/rules/types-in-dts.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAEtE,QAAA,MAAM,UAAU;;;;;CAkFd,CAAC;AACH,eAAe,UAAU,CAAC"}

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

@@ -1,3 +1,4 @@
+/* eslint-disable new-cap */
 import { ESLintUtils } from '@typescript-eslint/utils';
 const typesInDts = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/types-in-dts.md')({
     name: 'types-in-dts',
@@ -27,8 +28,6 @@ const typesInDts = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/
         },
     ],
     create(context, [options]) {
-        const allowEnums = Boolean(options.allowEnums);
-        const allowDeclare = Boolean(options.allowDeclare);
         function isDtsFile(filename) {
             if (!filename || filename === '<input>') {
                 return false;
@@ -43,11 +42,10 @@ const typesInDts = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/
             return modifiers.some((m) => m?.type === 'TSDeclareKeyword');
         }
         function reportIfNotDts(node) {
-            const filename = context.getFilename();
-            if (isDtsFile(filename)) {
+            if (isDtsFile(context.filename)) {
                 return;
             }
-            if (allowDeclare && hasDeclareModifier(node)) {
+            if (options.allowDeclare && hasDeclareModifier(node)) {
                 return;
             }
             context.report({
@@ -63,7 +61,7 @@ const typesInDts = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/
                 reportIfNotDts(node);
             },
             TSEnumDeclaration(node) {
-                if (allowEnums) {
+                if (options.allowEnums) {
                     return;
                 }
                 reportIfNotDts(node);

package/package.json

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