eslint-plugin-th-rules 3.1.8 → 3.2.0

package/dist/plugin.d.ts

@@ -36,6 +36,9 @@ export declare const rules: {
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
+    noExplicitNilCompare: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNull" | "useIsUndefined", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
 };
 declare const plugin: {
     rules: {
@@ -76,6 +79,9 @@ declare const plugin: {
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        noExplicitNilCompare: 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,6 +2,7 @@ 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';
@@ -15,6 +16,7 @@ export const rules = {
     schemasInSchemasFile,
     topLevelFunctions,
     typesInDts,
+    noExplicitNilCompare,
 };
 const plugin = { rules };
 export default plugin;

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.0",
   "description": "A List of custom ESLint rules created by Tomer Horowitz",
   "keywords": [
     "eslint",