eslint-plugin-th-rules 3.3.0 → 3.3.2

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;;CA2P1B,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;;CA4X1B,CAAC;AAEH,eAAe,sBAAsB,CAAC"}

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

@@ -12,11 +12,11 @@ const preferExplicitNilCheck = createRule({
         type: 'problem',
         fixable: 'code',
         docs: {
-            description: 'Disallow implicit truthy/falsy checks anywhere. Require explicit _.isNil(value).',
+            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) or !_.isNil(value).',
+            useIsNil: 'Implicit truthy/falsy checks are not allowed. Use _.isNil(value) / !_.isNil(value) or _.isEmpty(value) / !_.isEmpty(value).',
         },
     },
     defaultOptions: [],
@@ -41,12 +41,105 @@ const preferExplicitNilCheck = createRule({
             }
             return fixer.insertTextBefore(firstNode, importText);
         }
-        function isBooleanByTS(node) {
-            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+        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.StringLike) !== 0;
+        }
+        function isNumberLikeFlag(flags) {
+            return (flags & ts.TypeFlags.NumberLike) !== 0;
+        }
+        function isBooleanLikeFlag(flags) {
+            return (flags & ts.TypeFlags.BooleanLike) !== 0;
+        }
+        /**
+         * Returns true iff the expression type is effectively:
+         *   string | null | undefined
+         * (i.e., all non-nullish constituents are string/string-like).
+         */
+        function isStringByTS(node) {
+            const type = getTsType(node);
+            if (_.isNil(type))
+                return false;
+            if (!type.isUnion()) {
+                return isStringLikeFlag(type.getFlags());
+            }
+            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()) {
+                return isNumberLikeFlag(type.getFlags());
+            }
+            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;
+        }
+        /**
+         * Returns true iff the expression type is effectively:
+         *   boolean | null | undefined
+         * (i.e., all non-nullish constituents are boolean/boolean-literal).
+         *
+         * This ensures we do NOT rewrite checks like:
+         * - boolean | undefined
+         * - boolean | null
+         * - boolean | null | undefined
+         */
+        function isBooleanByTS(node) {
+            const type = getTsType(node);
+            if (_.isNil(type))
                 return false;
-            const type = checker.getTypeAtLocation(tsNode);
-            return (type.flags & ts.TypeFlags.Boolean) !== 0 || (type.flags & ts.TypeFlags.BooleanLiteral) !== 0;
+            if (!type.isUnion()) {
+                return isBooleanLikeFlag(type.getFlags());
+            }
+            let sawNonNullish = false;
+            for (const t of type.types) {
+                const flags = t.getFlags();
+                if (isNullableFlag(flags))
+                    continue;
+                sawNonNullish = true;
+                if (!isBooleanLikeFlag(flags))
+                    return false;
+            }
+            return sawNonNullish;
         }
         function isAlreadyExplicitCheck(node) {
             return (node.type === AST_NODE_TYPES.CallExpression &&
@@ -62,8 +155,7 @@ const preferExplicitNilCheck = createRule({
             if (node.type === AST_NODE_TYPES.MemberExpression)
                 return true;
             if (node.type === AST_NODE_TYPES.ChainExpression) {
-                const inner = node.expression;
-                return inner.type === AST_NODE_TYPES.MemberExpression;
+                return node.expression.type === AST_NODE_TYPES.MemberExpression;
             }
             return false;
         }
@@ -84,12 +176,24 @@ const preferExplicitNilCheck = createRule({
             });
         }
         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) {
@@ -175,6 +279,8 @@ const preferExplicitNilCheck = createRule({
                     if (isImplicitOperand(arg)) {
                         if (isBooleanByTS(arg))
                             return;
+                        if (isNumberByTS(arg))
+                            return;
                         transformFalsyUnary(node);
                         return;
                     }
@@ -189,6 +295,8 @@ const preferExplicitNilCheck = createRule({
                     if (mode === 'test' && isImplicitOperand(node)) {
                         if (isBooleanByTS(node))
                             return;
+                        if (isNumberByTS(node))
+                            return;
                         transformTruthy(node);
                     }
                 }

package/package.json

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