eslint-plugin-th-rules 3.2.3 → 3.3.1

package/dist/plugin.d.ts

@@ -20,6 +20,9 @@ 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> & {
+        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;
     };
@@ -63,6 +66,9 @@ 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> & {
+            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;
         };

package/dist/plugin.d.ts.map

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

package/dist/plugin.js

@@ -3,6 +3,7 @@ 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 preferExplicitNilCheck from './rules/prefer-explicit-nil-check.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';
@@ -13,6 +14,7 @@ export const rules = {
     'no-default-export': noDefaultExport,
     'no-destructuring': noDestructuring,
     'no-explicit-nil-compare': noExplicitNilCompare,
+    'no-explicit-nil-check': preferExplicitNilCheck,
     'prefer-is-empty': preferIsEmpty,
     'schemas-in-schemas-file': schemasInSchemasFile,
     'top-level-functions': topLevelFunctions,

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":"AAEA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAStF,QAAA,MAAM,iBAAiB;;CAyHrB,CAAC;AAEH,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;AAStF,QAAA,MAAM,iBAAiB;;CAyHrB,CAAC;AAEH,eAAe,iBAAiB,CAAC"}

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

@@ -1,5 +1,5 @@
 /* eslint-disable new-cap */
-/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+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-boolean-coercion.md');
@@ -32,7 +32,7 @@ const noBooleanCoercion = createRule({
             }
             const firstNode = context.sourceCode.ast.body[0];
             const importText = `import ${LODASH_IDENT} from '${LODASH_MODULE}';\n`;
-            if (!firstNode) {
+            if (_.isNil(firstNode)) {
                 return fixer.insertTextAfterRange([0, 0], importText);
             }
             return fixer.insertTextBefore(firstNode, importText);
@@ -45,7 +45,7 @@ const noBooleanCoercion = createRule({
         }
         function isBooleanByTS(node) {
             const tsNode = services.esTreeNodeToTSNodeMap.get(node);
-            if (!tsNode) {
+            if (_.isNil(tsNode)) {
                 return false;
             }
             const type = checker.getTypeAtLocation(tsNode);
@@ -53,7 +53,7 @@ const noBooleanCoercion = createRule({
         }
         function isCollectionLikeByTS(node) {
             const tsNode = services.esTreeNodeToTSNodeMap.get(node);
-            if (!tsNode) {
+            if (_.isNil(tsNode)) {
                 return false;
             }
             const type = checker.getTypeAtLocation(tsNode);
@@ -83,7 +83,7 @@ const noBooleanCoercion = createRule({
                 fix(fixer) {
                     const fixes = [fixer.replaceText(node, replacement)];
                     const importFix = getLodashImportFixer(fixer);
-                    if (importFix) {
+                    if (!_.isNil(importFix)) {
                         fixes.push(importFix);
                     }
                     return fixes;

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":"AAEA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAItF,QAAA,MAAM,eAAe;;;;;CAyInB,CAAC;AACH,eAAe,eAAe,CAAC"}
+{"version":3,"file":"no-destructuring.d.ts","sourceRoot":"","sources":["../../src/rules/no-destructuring.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAItF,QAAA,MAAM,eAAe;;;;;CAyInB,CAAC;AACH,eAAe,eAAe,CAAC"}

package/dist/rules/no-destructuring.js

@@ -1,5 +1,6 @@
 /* eslint-disable new-cap */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import _ from 'lodash';
 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')({
@@ -35,7 +36,7 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
         const MAX_VARIABLES = options.maximumDestructuredVariables ?? 2;
         const MAX_LINE_LENGTH = options.maximumLineLength ?? 100;
         function reportIfNeeded(patternNode, reportNode = patternNode) {
-            if (patternNode?.type !== AST_NODE_TYPES.ObjectPattern || !patternNode.loc) {
+            if (patternNode?.type !== AST_NODE_TYPES.ObjectPattern || _.isNil(patternNode.loc)) {
                 return;
             }
             const startLine = patternNode.loc.start.line;
@@ -81,7 +82,7 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
         }
         function checkParameters(parameters) {
             for (const p of parameters || []) {
-                if (!p) {
+                if (_.isNil(p)) {
                     continue;
                 }
                 if (p.type === AST_NODE_TYPES.AssignmentPattern) {
@@ -105,12 +106,12 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
                 checkParameters(node.params);
             },
             MethodDefinition(node) {
-                if (node.value?.params) {
+                if (!_.isNil(node.value?.params)) {
                     checkParameters(node.value.params);
                 }
             },
             TSDeclareFunction(node) {
-                if (node.params) {
+                if (!_.isNil(node.params)) {
                     checkParameters(node.params);
                 }
             },

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

@@ -23,7 +23,7 @@ const noExplicitNilCompare = createRule({
         /** 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)
+            if (!_.isNil(existingImport))
                 return null;
             return fixer.insertTextBeforeRange([0, 0], `import _ from 'lodash';\n`);
         }
@@ -51,7 +51,7 @@ const noExplicitNilCompare = createRule({
             else if (isUndefinedIdentifier(left)) {
                 targetNode = right;
             }
-            if (!targetNode)
+            if (_.isNil(targetNode))
                 return;
             const text = context.sourceCode.getText(targetNode);
             const positive = isNull ? `_.isNull(${text})` : `_.isUndefined(${text})`;
@@ -63,7 +63,7 @@ const noExplicitNilCompare = createRule({
                 fix(fixer) {
                     const fixes = [];
                     const importFix = ensureLodashImport(fixer);
-                    if (importFix)
+                    if (!_.isNil(importFix))
                         fixes.push(importFix);
                     fixes.push(fixer.replaceText(node, replacement));
                     return fixes;

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

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

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

@@ -0,0 +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;;CAoW1B,CAAC;AAEH,eAAe,sBAAsB,CAAC"}

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

@@ -0,0 +1,309 @@
+/* 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/prefer-explicit-nil-check.md');
+const LODASH_MODULE = 'lodash';
+const LODASH_IDENT = '_';
+const preferExplicitNilCheck = createRule({
+    name: 'prefer-explicit-nil-check',
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Disallow implicit truthy/falsy checks in boolean-test positions. Prefer explicit _.isNil(value) or _.isEmpty(value) (depending on the value type).',
+        },
+        schema: [],
+        messages: {
+            useIsNil: 'Implicit truthy/falsy checks are not allowed. Use _.isNil(value) / !_.isNil(value) or _.isEmpty(value) / !_.isEmpty(value).',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        const reported = new WeakSet();
+        let lodashImportFixAdded = false;
+        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;
+            if (lodashImportFixAdded)
+                return null;
+            lodashImportFixAdded = true;
+            const firstNode = context.sourceCode.ast.body[0];
+            const importText = `import ${LODASH_IDENT} from '${LODASH_MODULE}';\n`;
+            if (_.isNil(firstNode)) {
+                return fixer.insertTextAfterRange([0, 0], importText);
+            }
+            return fixer.insertTextBefore(firstNode, importText);
+        }
+        function unwrapChainExpression(node) {
+            if (node.type === AST_NODE_TYPES.ChainExpression)
+                return node.expression;
+            return node;
+        }
+        function getTsType(node) {
+            const unwrapped = unwrapChainExpression(node);
+            const tsNode = services.esTreeNodeToTSNodeMap.get(unwrapped);
+            if (_.isNil(tsNode))
+                return null;
+            return checker.getTypeAtLocation(tsNode);
+        }
+        function isNullableFlag(flags) {
+            return (flags & ts.TypeFlags.Null) !== 0 || (flags & ts.TypeFlags.Undefined) !== 0;
+        }
+        function isStringLikeFlag(flags) {
+            return (flags & ts.TypeFlags.String) !== 0 || (flags & ts.TypeFlags.StringLiteral) !== 0;
+        }
+        function isNumberLikeFlag(flags) {
+            return (flags & ts.TypeFlags.Number) !== 0 || (flags & ts.TypeFlags.NumberLiteral) !== 0;
+        }
+        /**
+         * Returns true iff the expression type is effectively:
+         *   string | null | undefined
+         * (i.e., all non-nullish constituents are string/string-literal).
+         */
+        function isStringByTS(node) {
+            const type = getTsType(node);
+            if (_.isNil(type))
+                return false;
+            if (!type.isUnion()) {
+                const flags = type.getFlags();
+                return isStringLikeFlag(flags);
+            }
+            let sawNonNullish = false;
+            for (const t of type.types) {
+                const flags = t.getFlags();
+                if (isNullableFlag(flags))
+                    continue;
+                sawNonNullish = true;
+                if (!isStringLikeFlag(flags))
+                    return false;
+            }
+            return sawNonNullish;
+        }
+        /**
+         * Returns true iff the expression type is effectively:
+         *   number | null | undefined
+         *
+         * We intentionally DO NOT auto-fix numeric truthy/falsy checks because
+         * converting `if (n)` into `!_.isNil(n)` changes semantics for `0`.
+         */
+        function isNumberByTS(node) {
+            const type = getTsType(node);
+            if (_.isNil(type))
+                return false;
+            if (!type.isUnion()) {
+                const flags = type.getFlags();
+                return isNumberLikeFlag(flags);
+            }
+            let sawNonNullish = false;
+            for (const t of type.types) {
+                const flags = t.getFlags();
+                if (isNullableFlag(flags))
+                    continue;
+                sawNonNullish = true;
+                if (!isNumberLikeFlag(flags))
+                    return false;
+            }
+            return sawNonNullish;
+        }
+        function isBooleanByTS(node) {
+            const type = getTsType(node);
+            if (_.isNil(type))
+                return false;
+            const flags = type.getFlags();
+            return (flags & ts.TypeFlags.Boolean) !== 0 || (flags & ts.TypeFlags.BooleanLiteral) !== 0;
+        }
+        function isAlreadyExplicitCheck(node) {
+            return (node.type === AST_NODE_TYPES.CallExpression &&
+                node.callee.type === AST_NODE_TYPES.MemberExpression &&
+                node.callee.object.type === AST_NODE_TYPES.Identifier &&
+                node.callee.object.name === LODASH_IDENT &&
+                node.callee.property.type === AST_NODE_TYPES.Identifier &&
+                (node.callee.property.name === 'isNil' || node.callee.property.name === 'isEmpty'));
+        }
+        function isImplicitOperand(node) {
+            if (node.type === AST_NODE_TYPES.Identifier)
+                return true;
+            if (node.type === AST_NODE_TYPES.MemberExpression)
+                return true;
+            if (node.type === AST_NODE_TYPES.ChainExpression) {
+                return node.expression.type === AST_NODE_TYPES.MemberExpression;
+            }
+            return false;
+        }
+        function reportFull(node, replacement) {
+            if (reported.has(node))
+                return;
+            reported.add(node);
+            context.report({
+                node,
+                messageId: 'useIsNil',
+                fix(fixer) {
+                    const fixes = [fixer.replaceText(node, replacement)];
+                    const importFix = getLodashImportFixer(fixer);
+                    if (!_.isNil(importFix))
+                        fixes.push(importFix);
+                    return fixes;
+                },
+            });
+        }
+        function transformTruthy(node) {
+            if (isNumberByTS(node))
+                return;
+            const text = context.sourceCode.getText(node);
+            if (isStringByTS(node)) {
+                reportFull(node, `!${LODASH_IDENT}.isEmpty(${text})`);
+                return;
+            }
+            reportFull(node, `!${LODASH_IDENT}.isNil(${text})`);
+        }
+        function transformFalsyUnary(node) {
+            const arg = node.argument;
+            if (isNumberByTS(arg))
+                return;
+            const text = context.sourceCode.getText(arg);
+            if (isStringByTS(arg)) {
+                reportFull(node, `${LODASH_IDENT}.isEmpty(${text})`);
+                return;
+            }
+            reportFull(node, `${LODASH_IDENT}.isNil(${text})`);
+        }
+        function expressionHasSideEffects(node) {
+            switch (node.type) {
+                case AST_NODE_TYPES.CallExpression:
+                case AST_NODE_TYPES.NewExpression:
+                case AST_NODE_TYPES.AssignmentExpression:
+                case AST_NODE_TYPES.UpdateExpression:
+                case AST_NODE_TYPES.AwaitExpression:
+                case AST_NODE_TYPES.YieldExpression:
+                case AST_NODE_TYPES.ImportExpression:
+                case AST_NODE_TYPES.TaggedTemplateExpression: {
+                    return true;
+                }
+                case AST_NODE_TYPES.SequenceExpression: {
+                    return node.expressions.some(expressionHasSideEffects);
+                }
+                case AST_NODE_TYPES.UnaryExpression: {
+                    return node.operator === 'delete';
+                }
+                case AST_NODE_TYPES.ConditionalExpression: {
+                    return expressionHasSideEffects(node.test) || expressionHasSideEffects(node.consequent) || expressionHasSideEffects(node.alternate);
+                }
+                case AST_NODE_TYPES.LogicalExpression: {
+                    return expressionHasSideEffects(node.left) || expressionHasSideEffects(node.right);
+                }
+                case AST_NODE_TYPES.ChainExpression: {
+                    return expressionHasSideEffects(node.expression);
+                }
+                default: {
+                    return false;
+                }
+            }
+        }
+        /**
+         * Inspect an expression for truthy/falsy coercions.
+         *
+         * mode:
+         * - 'test': expression is in a boolean-test position (must enforce)
+         * - 'shortCircuit': expression-statement short-circuit control flow (must enforce gating)
+         * - 'value': value context (must NOT rewrite operands)
+         */
+        function inspectExpression(node, mode) {
+            if (isAlreadyExplicitCheck(node))
+                return;
+            switch (node.type) {
+                case AST_NODE_TYPES.ChainExpression: {
+                    inspectExpression(node.expression, mode);
+                    return;
+                }
+                case AST_NODE_TYPES.LogicalExpression: {
+                    if (node.operator === '??') {
+                        inspectExpression(node.left, 'value');
+                        inspectExpression(node.right, 'value');
+                        return;
+                    }
+                    if (node.operator === '&&' || node.operator === '||') {
+                        if (mode === 'test') {
+                            inspectExpression(node.left, 'test');
+                            inspectExpression(node.right, 'test');
+                            return;
+                        }
+                        if (mode === 'shortCircuit') {
+                            inspectExpression(node.left, 'test');
+                            inspectExpression(node.right, 'shortCircuit');
+                            return;
+                        }
+                        inspectExpression(node.left, 'value');
+                        inspectExpression(node.right, 'value');
+                        return;
+                    }
+                    inspectExpression(node.left, 'value');
+                    inspectExpression(node.right, 'value');
+                    return;
+                }
+                case AST_NODE_TYPES.UnaryExpression: {
+                    if (node.operator !== '!')
+                        return;
+                    const arg = node.argument;
+                    if (arg.type === AST_NODE_TYPES.UnaryExpression && arg.operator === '!') {
+                        return;
+                    }
+                    if (isImplicitOperand(arg)) {
+                        if (isBooleanByTS(arg))
+                            return;
+                        if (isNumberByTS(arg))
+                            return;
+                        transformFalsyUnary(node);
+                        return;
+                    }
+                    inspectExpression(arg, 'test');
+                    return;
+                }
+                case AST_NODE_TYPES.ConditionalExpression: {
+                    inspectExpression(node.test, 'test');
+                    return;
+                }
+                default: {
+                    if (mode === 'test' && isImplicitOperand(node)) {
+                        if (isBooleanByTS(node))
+                            return;
+                        if (isNumberByTS(node))
+                            return;
+                        transformTruthy(node);
+                    }
+                }
+            }
+        }
+        return {
+            IfStatement(node) {
+                inspectExpression(node.test, 'test');
+            },
+            WhileStatement(node) {
+                inspectExpression(node.test, 'test');
+            },
+            DoWhileStatement(node) {
+                inspectExpression(node.test, 'test');
+            },
+            ForStatement(node) {
+                if (!_.isNil(node.test))
+                    inspectExpression(node.test, 'test');
+            },
+            ConditionalExpression(node) {
+                inspectExpression(node.test, 'test');
+            },
+            ExpressionStatement(node) {
+                const expr = node.expression;
+                if (expr.type === AST_NODE_TYPES.LogicalExpression && (expr.operator === '&&' || expr.operator === '||') && expressionHasSideEffects(expr.right)) {
+                    inspectExpression(expr, 'shortCircuit');
+                }
+            },
+        };
+    },
+});
+export default preferExplicitNilCheck;

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

@@ -27,7 +27,7 @@ const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh20
             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`);
+            return _.isNil(firstImport) ? fixer.insertTextBeforeRange([0, 0], `import _ from 'lodash';\n`) : fixer.insertTextBefore(firstImport, `import _ from 'lodash';\n`);
         }
         function unwrapChain(node) {
             return node?.type === AST_NODE_TYPES.ChainExpression ? node.expression : node;
@@ -51,7 +51,7 @@ const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh20
         }
         function isBooleanContext(node) {
             const { parent } = node;
-            if (!parent)
+            if (_.isNil(parent))
                 return false;
             switch (parent.type) {
                 case AST_NODE_TYPES.IfStatement:
@@ -87,7 +87,7 @@ const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh20
                 fix(fixer) {
                     const fixes = [fixer.replaceText(node, replacement)];
                     const importFix = ensureLodashImport(fixer);
-                    if (importFix)
+                    if (!_.isNil(importFix))
                         fixes.push(importFix);
                     return fixes;
                 },
@@ -102,7 +102,7 @@ const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh20
                 fix(fixer) {
                     const fixes = [fixer.replaceText(node, `_.isEmpty(${collection})`)];
                     const importFix = ensureLodashImport(fixer);
-                    if (importFix)
+                    if (!_.isNil(importFix))
                         fixes.push(importFix);
                     return fixes;
                 },
@@ -117,7 +117,7 @@ const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh20
                 fix(fixer) {
                     const fixes = [fixer.replaceText(node, `!_.isEmpty(${collection})`)];
                     const importFix = ensureLodashImport(fixer);
-                    if (importFix)
+                    if (!_.isNil(importFix))
                         fixes.push(importFix);
                     return fixes;
                 },

package/dist/rules/schemas-in-schemas-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas-in-schemas-file.d.ts","sourceRoot":"","sources":["../../src/rules/schemas-in-schemas-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAEtF,QAAA,MAAM,oBAAoB;;;;;;CAmIxB,CAAC;AAEH,eAAe,oBAAoB,CAAC"}
+{"version":3,"file":"schemas-in-schemas-file.d.ts","sourceRoot":"","sources":["../../src/rules/schemas-in-schemas-file.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAEtF,QAAA,MAAM,oBAAoB;;;;;;CAmIxB,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

package/dist/rules/schemas-in-schemas-file.js

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
 /* eslint-disable new-cap */
+import _ from 'lodash';
 import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
 const schemasInSchemasFile = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/schemas-in-schemas-file.md')({
     name: 'schemas-in-schemas-file',
@@ -41,7 +42,7 @@ const schemasInSchemasFile = ESLintUtils.RuleCreator(() => 'https://github.com/t
         };
         const zodIdentifiers = new Set();
         function filenameAllowed(filename) {
-            if (!filename || filename === '<input>') {
+            if (_.isNil(filename) || filename === '<input>') {
                 return false;
             }
             if (options.allowInTests && /\.(test|spec)\.[jt]sx?$/.test(filename)) {

package/dist/rules/top-level-functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"top-level-functions.d.ts","sourceRoot":"","sources":["../../src/rules/top-level-functions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAEtE,QAAA,MAAM,iBAAiB;;CA4JrB,CAAC;AACH,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"top-level-functions.d.ts","sourceRoot":"","sources":["../../src/rules/top-level-functions.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAEtF,QAAA,MAAM,iBAAiB;;CA4JrB,CAAC;AACH,eAAe,iBAAiB,CAAC"}

package/dist/rules/top-level-functions.js

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+import _ from 'lodash';
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
 const topLevelFunctions = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/top-level-functions.md')({
     name: 'top-level-functions',
     meta: {
@@ -62,7 +63,7 @@ const topLevelFunctions = ESLintUtils.RuleCreator(() => 'https://github.com/tome
             VariableDeclarator(node) {
                 const declParent = node.parent;
                 const grandParent = declParent?.parent;
-                if (!grandParent) {
+                if (_.isNil(grandParent)) {
                     return;
                 }
                 const topLevel = grandParent.type === 'Program' || grandParent.type === 'ExportNamedDeclaration' || grandParent.type === 'ExportDefaultDeclaration';
@@ -70,11 +71,11 @@ const topLevelFunctions = ESLintUtils.RuleCreator(() => 'https://github.com/tome
                     return;
                 }
                 const isExport = grandParent.type === 'ExportNamedDeclaration' || grandParent.type === 'ExportDefaultDeclaration';
-                if (!node.init) {
+                if (_.isNil(node.init)) {
                     return;
                 }
                 const functionName = node.id.type === 'Identifier' ? node.id.name : null;
-                if (!functionName) {
+                if (_.isNil(functionName)) {
                     return;
                 }
                 if (node.init.type === 'ArrowFunctionExpression') {
@@ -88,7 +89,7 @@ const topLevelFunctions = ESLintUtils.RuleCreator(() => 'https://github.com/tome
                         },
                     });
                 }
-                if (node.init.type === 'FunctionExpression') {
+                if (node.init.type === AST_NODE_TYPES.FunctionExpression) {
                     const funcExpr = node.init;
                     context.report({
                         node: funcExpr,
@@ -101,7 +102,7 @@ const topLevelFunctions = ESLintUtils.RuleCreator(() => 'https://github.com/tome
                 }
             },
             FunctionDeclaration(node) {
-                if (node.id) {
+                if (!_.isNil(node.id)) {
                     return;
                 }
                 if (!isTopLevel(node)) {

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":"AACA,OAAO,EAAE,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAEtE,QAAA,MAAM,UAAU;;;;;CAkFd,CAAC;AACH,eAAe,UAAU,CAAC"}
+{"version":3,"file":"types-in-dts.d.ts","sourceRoot":"","sources":["../../src/rules/types-in-dts.ts"],"names":[],"mappings":"AAEA,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,4 +1,5 @@
 /* eslint-disable new-cap */
+import _ from 'lodash';
 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',
@@ -29,7 +30,7 @@ const typesInDts = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/
     ],
     create(context, [options]) {
         function isDtsFile(filename) {
-            if (!filename || filename === '<input>') {
+            if (_.isNil(filename) || filename === '<input>') {
                 return false;
             }
             return filename.endsWith('.d.ts');

package/package.json

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