eslint-plugin-chai-friendly 1.1.1 → 1.2.1

package/lib/rules/no-unused-expressions.js

@@ -51,6 +51,9 @@ module.exports = {
                     enforceForJSX: {
                         type: "boolean",
                         default: false
+                    },
+                    ignoreDirectives: {
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -66,7 +69,8 @@ module.exports = {
             allowShortCircuit = config.allowShortCircuit || false,
             allowTernary = config.allowTernary || false,
             allowTaggedTemplates = config.allowTaggedTemplates || false,
-            enforceForJSX = config.enforceForJSX || false;
+            enforceForJSX = config.enforceForJSX || false,
+            ignoreDirectives = config.ignoreDirectives || false;
 
         /**
          * @param {ASTNode} node - any node
@@ -101,12 +105,19 @@ module.exports = {
 
         /**
          * @param {ASTNode} node - any node
-         * @param {ASTNode[]} ancestors - the given node's ancestors
+         * @returns {boolean} whether the parser marked this node as a directive
+         */
+        function isParserDirective(node) {
+            return typeof node.directive === "string";
+        }
+
+        /**
+         * @param {ASTNode} node - any node
          * @returns {boolean} whether the given node is considered a directive in its current position
          */
-        function isDirective(node, ancestors) {
-            var parent = ancestors[ancestors.length - 1],
-                grandparent = ancestors[ancestors.length - 2];
+        function isDirective(node) {
+            var parent = node.parent,
+                grandparent = node.parent.parent;
 
             /**
              * https://tc39.es/ecma262/#directive-prologue
@@ -137,7 +148,8 @@ module.exports = {
             ClassExpression: alwaysTrue,
             ConditionalExpression(node) {
                 if (allowTernary) {
-                    return Checker.isDisallowed(node.consequent) || Checker.isDisallowed(node.alternate);
+                    return (Checker.isDisallowed(node.consequent) && !isChaiCall(node.consequent)) ||
+                           (Checker.isDisallowed(node.alternate) && !isChaiCall(node.alternate));
                 }
                 return true;
             },
@@ -152,7 +164,7 @@ module.exports = {
             },
             LogicalExpression(node) {
                 if (allowShortCircuit) {
-                    return Checker.isDisallowed(node.right);
+                    return Checker.isDisallowed(node.right) && !isChaiCall(node.right);
                 }
                 return true;
             },
@@ -167,22 +179,35 @@ module.exports = {
             ThisExpression: alwaysTrue,
             UnaryExpression(node) {
                 return node.operator !== "void" && node.operator !== "delete";
+            },
+
+            // TypeScript-specific node types
+            TSAsExpression(node) {
+                return Checker.isDisallowed(node.expression);
+            },
+            TSTypeAssertion(node) {
+                return Checker.isDisallowed(node.expression);
+            },
+            TSNonNullExpression(node) {
+                return Checker.isDisallowed(node.expression);
+            },
+            TSInstantiationExpression(node) {
+                return Checker.isDisallowed(node.expression);
             }
         });
 
         /**
          * Determines whether or not a given node is a chai's expect statement.
          * e.g. expect(foo).to.eventually.be.true;
-         * @param {ASTNode} node - any node
+         * @param {ASTNode} expressionNode - expression node
          * @returns {boolean} whether the given node is a chai expectation
          */
-        function isChaiExpectCall(node) {
-            let expression = node.expression;
-            if (expression.type !== 'MemberExpression') {
+        function isChaiExpectCall(expressionNode) {
+            if (expressionNode.type !== 'MemberExpression') {
                 return false;
             }
 
-            return Boolean(findExpectCall(expression.object));
+            return Boolean(findExpectCall(expressionNode.object));
         }
 
         /**
@@ -214,19 +239,18 @@ module.exports = {
         /**
          * Determines whether or not a given node is a chai's should statement.
          * e.g. foo.should.eventually.be.true;
-         * @param {ASTNode} node - any node
+         * @param {ASTNode} expressionNode - expression node
          * @returns {boolean} whether the given node is a chai should statement
          */
-        function isChaiShouldCall(node) {
-            let expression = node.expression;
-            if (expression.type === 'ChainExpression') {
-                expression = expression.expression
+        function isChaiShouldCall(expressionNode) {
+            if (expressionNode.type === 'ChainExpression') {
+                expressionNode = expressionNode.expression
             }
-            if (expression.type !== 'MemberExpression') {
+            if (expressionNode.type !== 'MemberExpression') {
                 return false;
             }
 
-            return Boolean(findShouldCall(expression.object));
+            return Boolean(findShouldCall(expressionNode.object));
         }
 
         /**
@@ -255,18 +279,22 @@ module.exports = {
             return null;
         }
 
-        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        /**
+         * Determines whether or not a given node is a chai call.
+         * @param {ASTNode} expressionNode - expression node
+         * @returns {boolean} whether the given node is a chai call
+         */
+        function isChaiCall(expressionNode) {
+            return isChaiExpectCall(expressionNode) || isChaiShouldCall(expressionNode);
+        }
+
         return {
             ExpressionStatement: function(node) {
-                var valid = !Checker.isDisallowed(node.expression)
-                    || isDirective(node,
-                        (sourceCode.getAncestors
-                            ? sourceCode.getAncestors(node)
-                            : context.getAncestors()
-                        ))
-                    || isChaiExpectCall(node)
-                    || isChaiShouldCall(node);
-                if (!valid) {
+                if (Checker.isDisallowed(node.expression)
+                    && !isParserDirective(node)
+                    && !(ignoreDirectives && isDirective(node))
+                    && !isChaiCall(node.expression)
+                ) {
                     context.report({node, messageId: "unusedExpression"});
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-chai-friendly",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "This plugin makes 'no-unused-expressions' rule friendly towards chai expect statements.",
   "keywords": [
     "eslint",
@@ -49,8 +49,9 @@
     "typescript": "^5.8.3"
   },
   "overrides": {
-    "flatted": "3.4.1",
-    "serialize-javascript": "7.0.4",
+    "flatted": "3.4.2",
+    "serialize-javascript": "7.0.5",
+    "brace-expansion": "5.0.5",
     "@istanbuljs/load-nyc-config": {
       "js-yaml": "3.14.2"
     },