eslint-plugin-th-rules 3.1.8 → 3.2.1

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"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"}

package/dist/plugin.d.ts

@@ -1,81 +1,87 @@
 export declare const rules: {
-    noBooleanCoercion: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty" | "useIsNil", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    'no-boolean-coercion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty" | "useIsNil", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    noComments: import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentNotAllowed", [({
+    'no-comments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentNotAllowed", [({
         allow?: string[];
         disallow?: string[];
     } | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    noDefaultExport: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnamed", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    'no-default-export': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnamed", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    noDestructuring: import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong", [{
+    'no-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong", [{
         maximumDestructuredVariables: number;
         maximumLineLength: number;
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    preferIsEmpty: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    'prefer-is-empty': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    schemasInSchemasFile: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveSchema", [{
+    'schemas-in-schemas-file': import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveSchema", [{
         allowedSuffixes: string[];
         onlyWhenAssigned: boolean;
         allowInTests: boolean;
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    topLevelFunctions: import("@typescript-eslint/utils/ts-eslint").RuleModule<"arrow" | "funcExpr" | "anonDecl", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    'top-level-functions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"arrow" | "funcExpr" | "anonDecl", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    typesInDts: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveToDts", [{
+    'types-in-dts': import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveToDts", [{
         allowEnums: boolean;
         allowDeclare: boolean;
     }], 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: {
-        noBooleanCoercion: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty" | "useIsNil", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'no-boolean-coercion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty" | "useIsNil", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        noComments: import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentNotAllowed", [({
+        'no-comments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentNotAllowed", [({
             allow?: string[];
             disallow?: string[];
         } | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        noDefaultExport: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnamed", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'no-default-export': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnamed", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        noDestructuring: import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong", [{
+        'no-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong", [{
             maximumDestructuredVariables: number;
             maximumLineLength: number;
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        preferIsEmpty: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'prefer-is-empty': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        schemasInSchemasFile: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveSchema", [{
+        'schemas-in-schemas-file': import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveSchema", [{
             allowedSuffixes: string[];
             onlyWhenAssigned: boolean;
             allowInTests: boolean;
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        topLevelFunctions: import("@typescript-eslint/utils/ts-eslint").RuleModule<"arrow" | "funcExpr" | "anonDecl", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'top-level-functions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"arrow" | "funcExpr" | "anonDecl", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        typesInDts: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveToDts", [{
+        'types-in-dts': import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveToDts", [{
             allowEnums: boolean;
             allowDeclare: boolean;
         }], 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.d.ts.map

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

package/dist/plugin.js

@@ -2,19 +2,21 @@ import noBooleanCoercion from './rules/no-boolean-coercion.js';
 import noComments from './rules/no-comments.js';
 import noDefaultExport from './rules/no-default-export.js';
 import noDestructuring from './rules/no-destructuring.js';
+import noExplicitNilCompare from './rules/no-explicit-nil-compare.js';
 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';
 export const rules = {
-    noBooleanCoercion,
-    noComments,
-    noDefaultExport,
-    noDestructuring,
-    preferIsEmpty,
-    schemasInSchemasFile,
-    topLevelFunctions,
-    typesInDts,
+    'no-boolean-coercion': noBooleanCoercion,
+    'no-comments': noComments,
+    'no-default-export': noDefaultExport,
+    'no-destructuring': noDestructuring,
+    '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":"AAAA,OAAO,EAAE,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAItE,QAAA,MAAM,iBAAiB;;CAwFrB,CAAC;AACH,eAAe,iBAAiB,CAAC"}
+{"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"}

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

@@ -1,13 +1,18 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+/* 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';
 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 = '_';
 const noBooleanCoercion = createRule({
     name: 'no-boolean-coercion',
     meta: {
         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.',
         },
-        hasSuggestions: true,
         schema: [],
         messages: {
             useIsEmpty: 'Boolean coercion is not allowed. Use !_.isEmpty(value) for strings, arrays, and objects.',
@@ -16,62 +21,67 @@ const noBooleanCoercion = createRule({
     },
     defaultOptions: [],
     create(context) {
-        const { sourceCode } = context;
         const services = ESLintUtils.getParserServices(context);
-        const checker = services?.program?.getTypeChecker?.();
+        const checker = services.program.getTypeChecker();
+        function hasLodashImport() {
+            return context.sourceCode.ast.body.some((node) => node.type === AST_NODE_TYPES.ImportDeclaration && node.source.value === LODASH_MODULE);
+        }
+        function getLodashImportFixer(fixer) {
+            if (hasLodashImport()) {
+                return null;
+            }
+            const firstNode = context.sourceCode.ast.body[0];
+            const importText = `import ${LODASH_IDENT} from '${LODASH_MODULE}';\n`;
+            if (!firstNode) {
+                return fixer.insertTextAfterRange([0, 0], importText);
+            }
+            return fixer.insertTextBefore(firstNode, importText);
+        }
         function isBooleanCall(node) {
-            return node.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === 'Boolean' && node.arguments.length === 1;
+            return node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === 'Boolean' && node.arguments.length === 1;
         }
         function isDoubleNegation(node) {
-            return node.type === 'UnaryExpression' && node.operator === '!' && node.argument.type === 'UnaryExpression' && node.argument.operator === '!';
+            return node.type === AST_NODE_TYPES.UnaryExpression && node.operator === '!' && node.argument.type === AST_NODE_TYPES.UnaryExpression && node.argument.operator === '!';
         }
         function isCollectionLikeByTS(node) {
-            if (!checker || !services.esTreeNodeToTSNodeMap) {
-                return false;
-            }
             const tsNode = services.esTreeNodeToTSNodeMap.get(node);
             if (!tsNode) {
                 return false;
             }
             const type = checker.getTypeAtLocation(tsNode);
             const typeString = checker.typeToString(type);
-            return typeString.includes('[]') || typeString === 'string' || typeString === 'object' || typeString.startsWith('Array<') || typeString.startsWith('ReadonlyArray<');
+            return typeString === 'string' || typeString === 'object' || typeString.includes('[]') || typeString.startsWith('Array<') || typeString.startsWith('ReadonlyArray<');
         }
         function isCollectionLikeBySyntax(node) {
-            return node.type === 'ArrayExpression' || node.type === 'ObjectExpression' || (node.type === 'Literal' && typeof node.value === 'string');
+            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) {
             const isCollection = isCollectionLikeBySyntax(valueNode) || isCollectionLikeByTS(valueNode);
-            const suggestedFn = isCollection ? '_.isEmpty' : '_.isNil';
-            const replacement = `!${suggestedFn}(${sourceCode.getText(valueNode)})`;
+            const fnName = isCollection ? 'isEmpty' : 'isNil';
+            const replacement = `!${LODASH_IDENT}.${fnName}(${context.sourceCode.getText(valueNode)})`;
             context.report({
                 node,
                 messageId: isCollection ? 'useIsEmpty' : 'useIsNil',
-                suggest: [
-                    {
-                        messageId: isCollection ? 'useIsEmpty' : 'useIsNil',
-                        fix(fixer) {
-                            return fixer.replaceText(node, replacement);
-                        },
-                    },
-                ],
+                fix(fixer) {
+                    const fixes = [fixer.replaceText(node, replacement)];
+                    const importFix = getLodashImportFixer(fixer);
+                    if (importFix) {
+                        fixes.push(importFix);
+                    }
+                    return fixes;
+                },
             });
         }
         return {
             CallExpression(node) {
                 if (isBooleanCall(node)) {
-                    const arg = node.arguments[0];
-                    if (arg) {
-                        report(node, arg);
-                    }
+                    report(node, node.arguments[0]);
                 }
             },
             UnaryExpression(node) {
                 if (isDoubleNegation(node)) {
                     const valueNode = node.argument.argument;
-                    if (valueNode) {
-                        report(node, valueNode);
-                    }
+                    report(node, valueNode);
                 }
             },
         };

package/dist/rules/no-destructuring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-destructuring.d.ts","sourceRoot":"","sources":["../../src/rules/no-destructuring.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAItE,QAAA,MAAM,eAAe;;;;;CA2InB,CAAC;AACH,eAAe,eAAe,CAAC"}
+{"version":3,"file":"no-destructuring.d.ts","sourceRoot":"","sources":["../../src/rules/no-destructuring.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAItF,QAAA,MAAM,eAAe;;;;;CAyInB,CAAC;AACH,eAAe,eAAe,CAAC"}

package/dist/rules/no-destructuring.js

@@ -1,4 +1,6 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+/* eslint-disable new-cap */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
 const MAX_TAB_COUNT = 3;
 const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-destructuring.md')({
     name: 'no-destructuring',
@@ -32,19 +34,18 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
     create(context, [options]) {
         const MAX_VARIABLES = options.maximumDestructuredVariables ?? 2;
         const MAX_LINE_LENGTH = options.maximumLineLength ?? 100;
-        const sourceCode = context.getSourceCode();
         function reportIfNeeded(patternNode, reportNode = patternNode) {
-            if (patternNode?.type !== 'ObjectPattern' || !patternNode.loc) {
+            if (patternNode?.type !== AST_NODE_TYPES.ObjectPattern || !patternNode.loc) {
                 return;
             }
             const startLine = patternNode.loc.start.line;
             const endLine = patternNode.loc.end.line;
-            const lineText = sourceCode.lines[startLine - 1] ?? '';
+            const lineText = context.sourceCode.lines[startLine - 1] ?? '';
             const indentCount = lineText.search(/\S|$/);
             const propertyCount = patternNode.properties?.length ?? 0;
             let maxSpannedLineLength = 0;
             for (let i = startLine; i <= endLine; i++) {
-                const t = sourceCode.lines[i - 1] ?? '';
+                const t = context.sourceCode.lines[i - 1] ?? '';
                 if (t.length > maxSpannedLineLength) {
                     maxSpannedLineLength = t.length;
                 }
@@ -83,7 +84,7 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
                 if (!p) {
                     continue;
                 }
-                if (p.type === 'AssignmentPattern') {
+                if (p.type === AST_NODE_TYPES.AssignmentPattern) {
                     reportIfNeeded(p.left, p);
                     continue;
                 }

package/dist/rules/no-explicit-nil-compare.d.ts

@@ -0,0 +1,6 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const noExplicitNilCompare: ESLintUtils.RuleModule<"useIsNull" | "useIsUndefined", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default noExplicitNilCompare;
+//# sourceMappingURL=no-explicit-nil-compare.d.ts.map

package/dist/rules/no-explicit-nil-compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-explicit-nil-compare.d.ts","sourceRoot":"","sources":["../../src/rules/no-explicit-nil-compare.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAItF,QAAA,MAAM,oBAAoB;;CAmFxB,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

package/dist/rules/no-explicit-nil-compare.js

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable new-cap */
+import _ from 'lodash';
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+const createRule = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-explicit-nil-compare.md');
+const noExplicitNilCompare = createRule({
+    name: 'no-explicit-nil-compare',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow direct comparisons to null or undefined. Use _.isNull(x) / _.isUndefined(x) instead.',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useIsNull: 'Use _.isNull({{value}}) instead of comparing directly to null.',
+            useIsUndefined: 'Use _.isUndefined({{value}}) instead of comparing directly to undefined.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        /** Ensure lodash default import exists */
+        function ensureLodashImport(fixer) {
+            const existingImport = context.sourceCode.ast.body.find((node) => node.type === AST_NODE_TYPES.ImportDeclaration && node.source.value === 'lodash');
+            if (existingImport)
+                return null;
+            return fixer.insertTextBeforeRange([0, 0], `import _ from 'lodash';\n`);
+        }
+        function isNullLiteral(node) {
+            return node.type === AST_NODE_TYPES.Literal && _.isNull(node.value);
+        }
+        function isUndefinedIdentifier(node) {
+            return node.type === AST_NODE_TYPES.Identifier && node.name === 'undefined';
+        }
+        function reportComparison(node, left, right) {
+            let targetNode;
+            let isNull = false;
+            const isNegated = node.operator === '!=' || node.operator === '!==';
+            if (isNullLiteral(right)) {
+                targetNode = left;
+                isNull = true;
+            }
+            else if (isNullLiteral(left)) {
+                targetNode = right;
+                isNull = true;
+            }
+            else if (isUndefinedIdentifier(right)) {
+                targetNode = left;
+            }
+            else if (isUndefinedIdentifier(left)) {
+                targetNode = right;
+            }
+            if (!targetNode)
+                return;
+            const text = context.sourceCode.getText(targetNode);
+            const positive = isNull ? `_.isNull(${text})` : `_.isUndefined(${text})`;
+            const replacement = isNegated ? `!${positive}` : positive;
+            context.report({
+                node,
+                messageId: isNull ? 'useIsNull' : 'useIsUndefined',
+                data: { value: text },
+                fix(fixer) {
+                    const fixes = [];
+                    const importFix = ensureLodashImport(fixer);
+                    if (importFix)
+                        fixes.push(importFix);
+                    fixes.push(fixer.replaceText(node, replacement));
+                    return fixes;
+                },
+            });
+        }
+        return {
+            BinaryExpression(node) {
+                if (!['==', '===', '!=', '!=='].includes(node.operator))
+                    return;
+                reportComparison(node, node.left, node.right);
+            },
+        };
+    },
+});
+export default noExplicitNilCompare;

package/package.json

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