eslint-plugin-th-rules 3.4.0 → 3.4.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;;CA0Z1B,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;;CA0d1B,CAAC;AAEH,eAAe,sBAAsB,CAAC"}

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

@@ -46,12 +46,33 @@ const preferExplicitNilCheck = createRule({
                 return node.expression;
             return 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 getTsType(node) {
             const unwrapped = unwrapChainExpression(node);
             const tsNode = services.esTreeNodeToTSNodeMap.get(unwrapped);
             if (_.isNil(tsNode))
                 return null;
-            return checker.getTypeAtLocation(tsNode);
+            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;
@@ -86,6 +107,38 @@ const preferExplicitNilCheck = createRule({
             }
             return false;
         }
+        /**
+         * Returns true when the type is a union that includes boolean-like AND also
+         * includes some other non-nullish, non-boolean-like constituent.
+         *
+         * Example: string | object | null | boolean | number
+         *
+         * In these cases we avoid rewriting `if (x)` / `if (!x)` because the intent
+         * may be genuine boolean gating (or semantic-preserving rewrite isn't clear).
+         */
+        function isPartialBooleanUnionByTS(node) {
+            const type = getTsType(node);
+            if (_.isNil(type))
+                return false;
+            if (!type.isUnion())
+                return false;
+            let sawBoolean = false;
+            let sawOtherNonNullish = false;
+            for (const t of type.types) {
+                const flags = t.getFlags();
+                if (isNullableFlag(flags))
+                    continue;
+                if (isBooleanLikeFlag(flags)) {
+                    sawBoolean = true;
+                }
+                else {
+                    sawOtherNonNullish = true;
+                }
+                if (sawBoolean && sawOtherNonNullish)
+                    return true;
+            }
+            return false;
+        }
         /**
          * Returns true iff the expression type is effectively:
          *   string | null | undefined
@@ -201,6 +254,8 @@ const preferExplicitNilCheck = createRule({
                 return;
             if (isNumberByTS(node))
                 return;
+            if (isPartialBooleanUnionByTS(node))
+                return;
             const text = context.sourceCode.getText(node);
             if (isStringByTS(node)) {
                 reportFull(node, `!${LODASH_IDENT}.isEmpty(${text})`);
@@ -214,6 +269,8 @@ const preferExplicitNilCheck = createRule({
                 return;
             if (isNumberByTS(arg))
                 return;
+            if (isPartialBooleanUnionByTS(arg))
+                return;
             const text = context.sourceCode.getText(arg);
             if (isStringByTS(arg)) {
                 reportFull(node, `${LODASH_IDENT}.isEmpty(${text})`);
@@ -306,6 +363,8 @@ const preferExplicitNilCheck = createRule({
                             return;
                         if (isBooleanByTS(arg))
                             return;
+                        if (isPartialBooleanUnionByTS(arg))
+                            return;
                         if (isNumberByTS(arg))
                             return;
                         transformFalsyUnary(node);
@@ -324,6 +383,8 @@ const preferExplicitNilCheck = createRule({
                             return;
                         if (isBooleanByTS(node))
                             return;
+                        if (isPartialBooleanUnionByTS(node))
+                            return;
                         if (isNumberByTS(node))
                             return;
                         transformTruthy(node);

package/package.json

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