eslint-plugin-th-rules 3.3.2 → 3.4.0

package/README.md

@@ -166,17 +166,18 @@ Do not edit below this line.
 🎲 Set in the `recommendedTypescriptReact` configuration.\
 🔧 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.                                                                                                            | ✅ ⚛️ 🟦 🎲 |    |
+| 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-explicit-nil-check](docs/rules/prefer-explicit-nil-check.md) | Disallow implicit truthy/falsy checks in boolean-test positions. Prefer explicit _.isNil(value) or _.isEmpty(value) (depending on the value type).                                                 | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [prefer-is-empty](docs/rules/prefer-is-empty.md)                     | Require _.isEmpty instead of length comparisons or boolean checks on .length.                                                                                                                      | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [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

@@ -20,7 +20,7 @@ export declare const rules: {
     'no-explicit-nil-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNull" | "useIsUndefined", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    'no-explicit-nil-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNil", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    'prefer-explicit-nil-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNil", [], 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> & {
@@ -42,6 +42,9 @@ export declare const rules: {
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
+    'no-isnil-isempty-on-boolean': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noBoolean", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
 };
 declare const plugin: {
     rules: {
@@ -66,7 +69,7 @@ declare const plugin: {
         'no-explicit-nil-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNull" | "useIsUndefined", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-explicit-nil-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNil", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'prefer-explicit-nil-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNil", [], 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> & {
@@ -88,6 +91,9 @@ declare const plugin: {
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'no-isnil-isempty-on-boolean': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noBoolean", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
     };
 };
 export default plugin;

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWjB,CAAC;AAEF,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAY,CAAC;AACzB,eAAe,MAAM,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYjB,CAAC;AAEF,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAY,CAAC;AACzB,eAAe,MAAM,CAAC"}

package/dist/plugin.js

@@ -8,17 +8,19 @@ import preferIsEmpty from './rules/prefer-is-empty.js';
 import schemasInSchemasFile from './rules/schemas-in-schemas-file.js';
 import topLevelFunctions from './rules/top-level-functions.js';
 import typesInDts from './rules/types-in-dts.js';
+import noIsNilOrIsEmptyOnBoolean from './rules/no-isnil-isempty-on-boolean.js';
 export const rules = {
     'no-boolean-coercion': noBooleanCoercion,
     'no-comments': noComments,
     'no-default-export': noDefaultExport,
     'no-destructuring': noDestructuring,
     'no-explicit-nil-compare': noExplicitNilCompare,
-    'no-explicit-nil-check': preferExplicitNilCheck,
+    'prefer-explicit-nil-check': preferExplicitNilCheck,
     'prefer-is-empty': preferIsEmpty,
     'schemas-in-schemas-file': schemasInSchemasFile,
     'top-level-functions': topLevelFunctions,
     'types-in-dts': typesInDts,
+    'no-isnil-isempty-on-boolean': noIsNilOrIsEmptyOnBoolean,
 };
 const plugin = { rules };
 export default plugin;

package/dist/rules/no-isnil-isempty-on-boolean.d.ts

@@ -0,0 +1,6 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const noIsNilOrIsEmptyOnBoolean: ESLintUtils.RuleModule<"noBoolean", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default noIsNilOrIsEmptyOnBoolean;
+//# sourceMappingURL=no-isnil-isempty-on-boolean.d.ts.map

package/dist/rules/no-isnil-isempty-on-boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-isnil-isempty-on-boolean.d.ts","sourceRoot":"","sources":["../../src/rules/no-isnil-isempty-on-boolean.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAQtF,QAAA,MAAM,yBAAyB;;CA+H7B,CAAC;AAEH,eAAe,yBAAyB,CAAC"}

package/dist/rules/no-isnil-isempty-on-boolean.js

@@ -0,0 +1,122 @@
+/* eslint-disable no-bitwise */
+/* eslint-disable new-cap */
+import _ from 'lodash';
+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-isnil-isempty-on-boolean.md');
+const LODASH_IDENT = '_';
+const DISALLOWED_METHODS = new Set(['isNil', 'isEmpty']);
+const noIsNilOrIsEmptyOnBoolean = createRule({
+    name: 'no-isnil-isempty-on-boolean',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow _.isNil(...) / _.isEmpty(...) when the argument type is boolean or a union containing boolean (e.g., boolean | undefined, boolean | X).',
+        },
+        schema: [],
+        messages: {
+            noBoolean: 'Do not use _.{{method}}(...) on boolean or unions containing boolean. Use explicit boolean checks/comparisons instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        function unwrapChainExpression(node) {
+            return node.type === AST_NODE_TYPES.ChainExpression ? node.expression : node;
+        }
+        function getTypeFromSymbolAnnotation(symbol) {
+            const decl = symbol.valueDeclaration ?? symbol.declarations?.[0];
+            if (_.isNil(decl))
+                return null;
+            if ('type' in decl) {
+                const typeNode = decl.type;
+                if (!_.isNil(typeNode)) {
+                    return checker.getTypeFromTypeNode(typeNode);
+                }
+            }
+            return null;
+        }
+        function getTsTypeForCheck(node) {
+            const unwrapped = unwrapChainExpression(node);
+            const tsNode = services.esTreeNodeToTSNodeMap.get(unwrapped);
+            if (_.isNil(tsNode))
+                return null;
+            let type;
+            if (unwrapped.type === AST_NODE_TYPES.Identifier) {
+                const symbol = checker.getSymbolAtLocation(tsNode);
+                const annotated = _.isNil(symbol) ? null : getTypeFromSymbolAnnotation(symbol);
+                type = annotated ?? checker.getTypeAtLocation(tsNode);
+            }
+            else {
+                type = checker.getTypeAtLocation(tsNode);
+            }
+            return checker.getWidenedType(type);
+        }
+        function isNullableFlag(flags) {
+            return (flags & ts.TypeFlags.Null) !== 0 || (flags & ts.TypeFlags.Undefined) !== 0;
+        }
+        function isBooleanLikeFlag(flags) {
+            return (flags & ts.TypeFlags.BooleanLike) !== 0;
+        }
+        /**
+         * Returns true if the type is boolean-like, or a union containing any boolean-like
+         * non-nullish constituent.
+         */
+        function hasBooleanInType(node) {
+            const type = getTsTypeForCheck(node);
+            if (_.isNil(type))
+                return false;
+            if (!type.isUnion()) {
+                const flags = type.getFlags();
+                if (isNullableFlag(flags))
+                    return false;
+                return isBooleanLikeFlag(flags);
+            }
+            for (const t of type.types) {
+                const flags = t.getFlags();
+                if (isNullableFlag(flags))
+                    continue;
+                if (isBooleanLikeFlag(flags))
+                    return true;
+            }
+            return false;
+        }
+        function isTargetLodashCall(node) {
+            if (node.callee.type !== AST_NODE_TYPES.MemberExpression)
+                return null;
+            const { callee } = node;
+            if (callee.object.type !== AST_NODE_TYPES.Identifier)
+                return null;
+            if (callee.object.name !== LODASH_IDENT)
+                return null;
+            if (callee.property.type !== AST_NODE_TYPES.Identifier)
+                return null;
+            const method = callee.property.name;
+            if (!DISALLOWED_METHODS.has(method))
+                return null;
+            return { method: method };
+        }
+        return {
+            CallExpression(node) {
+                const target = isTargetLodashCall(node);
+                if (_.isNil(target))
+                    return;
+                const [arg] = node.arguments;
+                if (_.isNil(arg))
+                    return;
+                if (arg.type === AST_NODE_TYPES.SpreadElement)
+                    return;
+                const expr = arg;
+                if (!hasBooleanInType(expr))
+                    return;
+                context.report({
+                    node,
+                    messageId: 'noBoolean',
+                    data: { method: target.method },
+                });
+            },
+        };
+    },
+});
+export default noIsNilOrIsEmptyOnBoolean;

package/dist/rules/prefer-explicit-nil-check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-explicit-nil-check.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-explicit-nil-check.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAWtF,QAAA,MAAM,sBAAsB;;CA4X1B,CAAC;AAEH,eAAe,sBAAsB,CAAC"}
+{"version":3,"file":"prefer-explicit-nil-check.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-explicit-nil-check.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAWtF,QAAA,MAAM,sBAAsB;;CA0Z1B,CAAC;AAEH,eAAe,sBAAsB,CAAC"}

package/dist/rules/prefer-explicit-nil-check.js

@@ -65,6 +65,27 @@ const preferExplicitNilCheck = createRule({
         function isBooleanLikeFlag(flags) {
             return (flags & ts.TypeFlags.BooleanLike) !== 0;
         }
+        function isAnyOrUnknownFlag(flags) {
+            return (flags & ts.TypeFlags.Any) !== 0 || (flags & ts.TypeFlags.Unknown) !== 0;
+        }
+        /**
+         * Skip when the type is `any` or `unknown` (including union constituents),
+         * because we can't safely decide whether to prefer isNil/isEmpty without
+         * risking semantic changes.
+         */
+        function isAnyOrUnknownByTS(node) {
+            const type = getTsType(node);
+            if (_.isNil(type))
+                return false;
+            if (!type.isUnion()) {
+                return isAnyOrUnknownFlag(type.getFlags());
+            }
+            for (const t of type.types) {
+                if (isAnyOrUnknownFlag(t.getFlags()))
+                    return true;
+            }
+            return false;
+        }
         /**
          * Returns true iff the expression type is effectively:
          *   string | null | undefined
@@ -176,6 +197,8 @@ const preferExplicitNilCheck = createRule({
             });
         }
         function transformTruthy(node) {
+            if (isAnyOrUnknownByTS(node))
+                return;
             if (isNumberByTS(node))
                 return;
             const text = context.sourceCode.getText(node);
@@ -187,6 +210,8 @@ const preferExplicitNilCheck = createRule({
         }
         function transformFalsyUnary(node) {
             const arg = node.argument;
+            if (isAnyOrUnknownByTS(arg))
+                return;
             if (isNumberByTS(arg))
                 return;
             const text = context.sourceCode.getText(arg);
@@ -277,6 +302,8 @@ const preferExplicitNilCheck = createRule({
                         return;
                     }
                     if (isImplicitOperand(arg)) {
+                        if (isAnyOrUnknownByTS(arg))
+                            return;
                         if (isBooleanByTS(arg))
                             return;
                         if (isNumberByTS(arg))
@@ -293,6 +320,8 @@ const preferExplicitNilCheck = createRule({
                 }
                 default: {
                     if (mode === 'test' && isImplicitOperand(node)) {
+                        if (isAnyOrUnknownByTS(node))
+                            return;
                         if (isBooleanByTS(node))
                             return;
                         if (isNumberByTS(node))

package/package.json

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