eslint-plugin-playwright 2.10.1 → 2.10.2

package/dist/index.cjs

@@ -324,8 +324,14 @@ function parse(context, node) {
     return null;
   }
   let type = group;
-  if ((name === "test" || name === "describe") && (node.arguments.length < 2 || !isFunction(node.arguments.at(-1)))) {
-    type = "config";
+  if (name === "describe") {
+    if (!isFunction(node.arguments.at(-1))) {
+      type = "config";
+    }
+  } else if (name === "test") {
+    if (node.arguments.length < 2 || !isFunction(node.arguments.at(-1))) {
+      type = "config";
+    }
   }
   return {
     ...parsedFnCall,
@@ -1058,29 +1064,26 @@ var missing_playwright_await_default = createRule({
       // Add any custom matchers to the set
       ...options.customMatchers || []
     ]);
-    function isVariableConsumed(declarator, checkValidity2, validTypes2, visited) {
-      const variables = context.sourceCode.getDeclaredVariables(declarator);
-      for (const variable of variables) {
-        for (const ref of variable.references) {
-          if (!ref.isRead()) {
-            continue;
-          }
-          const refParent = ref.identifier.parent;
-          if (visited.has(refParent)) {
-            continue;
-          }
-          if (validTypes2.has(refParent.type)) {
-            return true;
-          }
-          if (refParent.type === "VariableDeclarator") {
-            if (checkValidity2(ref.identifier, visited)) {
-              return true;
-            }
-            continue;
-          }
-          if (checkValidity2(refParent, visited)) {
+    function isVariableConsumed(variable, visited) {
+      for (const ref of variable.references) {
+        if (!ref.isRead()) {
+          continue;
+        }
+        const refParent = ref.identifier.parent;
+        if (!refParent || visited.has(refParent)) {
+          continue;
+        }
+        if (validTypes.has(refParent.type)) {
+          return true;
+        }
+        if (refParent.type === "VariableDeclarator") {
+          if (checkValidity(ref.identifier, visited)) {
             return true;
           }
+          continue;
+        }
+        if (checkValidity(refParent, visited)) {
+          return true;
         }
       }
       return false;
@@ -1125,7 +1128,19 @@ var missing_playwright_await_default = createRule({
         return checkValidity(parent, visited);
       }
       if (parent.type === "VariableDeclarator") {
-        return isVariableConsumed(parent, checkValidity, validTypes, visited);
+        return context.sourceCode.getDeclaredVariables(parent).some((v) => isVariableConsumed(v, visited));
+      }
+      if (parent.type === "AssignmentExpression" && parent.right === node && parent.left.type === "Identifier") {
+        const parentName = parent.left.name;
+        let scope = context.sourceCode.getScope(node);
+        while (scope) {
+          const variable = scope.variables.find((v) => v.name === parentName);
+          if (variable) {
+            return isVariableConsumed(variable, visited);
+          }
+          scope = scope.upper;
+        }
+        return false;
       }
       return false;
     }
@@ -4561,8 +4576,8 @@ var valid_test_tags_default = createRule({
         }
         if (node.arguments.length > 0) {
           const titleArg = node.arguments[0];
-          if (titleArg && titleArg.type === "Literal" && typeof titleArg.value === "string") {
-            const titleTags = extractTagsFromTitle(titleArg.value);
+          if (titleArg) {
+            const titleTags = extractTagsFromTitle(getStringValue(titleArg));
             for (const tag of titleTags) {
               validateTag(tag, node);
             }
@@ -4583,21 +4598,27 @@ var valid_test_tags_default = createRule({
           return;
         }
         const tagValue = tagProperty.value;
-        if (tagValue.type === "Literal") {
-          if (typeof tagValue.value !== "string") {
+        if (tagValue.type === "Literal" || tagValue.type === "TemplateLiteral") {
+          if (tagValue.type === "Literal" && typeof tagValue.value !== "string") {
             context.report({
               messageId: "invalidTagValue",
               node
             });
             return;
           }
-          validateTag(tagValue.value, node);
+          validateTag(getStringValue(tagValue), node);
         } else if (tagValue.type === "ArrayExpression") {
           for (const element of tagValue.elements) {
-            if (!element || element.type !== "Literal" || typeof element.value !== "string") {
+            if (!element) {
+              return;
+            }
+            if (element.type !== "Literal" && element.type !== "TemplateLiteral") {
+              return;
+            }
+            if (element.type === "Literal" && typeof element.value !== "string") {
               return;
             }
-            validateTag(element.value, node);
+            validateTag(getStringValue(element), node);
           }
         } else {
           context.report({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-playwright",
-  "version": "2.10.1",
+  "version": "2.10.2",
   "description": "ESLint plugin for Playwright testing.",
   "license": "MIT",
   "author": "Mark Skelton <mark@mskelton.dev>",