eslint-plugin-playwright 2.10.0 → 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,
@@ -392,8 +398,21 @@ function findParent(node, type) {
 function dig(node, identifier) {
   return node.type === "MemberExpression" ? dig(node.property, identifier) : node.type === "CallExpression" ? dig(node.callee, identifier) : node.type === "Identifier" ? isIdentifier(node, identifier) : false;
 }
+var pageFrameFullPattern = /(^(page|frame)|(Page|Frame)$)/;
+var pageFramePrefixPattern = /^(page|frame)/;
 function isPageMethod(node, name) {
-  return node.callee.type === "MemberExpression" && dig(node.callee.object, /(^(page|frame)|(Page|Frame)$)/) && isPropertyAccessor(node.callee, name);
+  if (node.callee.type !== "MemberExpression") {
+    return false;
+  }
+  if (!isPropertyAccessor(node.callee, name)) {
+    return false;
+  }
+  const obj = node.callee.object;
+  if (obj.type === "MemberExpression") {
+    const pattern = obj.object.type === "ThisExpression" ? pageFrameFullPattern : pageFramePrefixPattern;
+    return isIdentifier(obj.property, pattern);
+  }
+  return dig(obj, pageFrameFullPattern);
 }
 function isFunction(node) {
   return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
@@ -849,6 +868,9 @@ var max_nested_describe_default = createRule({
 
 // src/rules/missing-playwright-await.ts
 var validTypes = /* @__PURE__ */ new Set(["AwaitExpression", "ReturnStatement", "ArrowFunctionExpression"]);
+function isArrayLike(node) {
+  return node.type === "ArrayExpression" || node.type === "NewExpression" && isIdentifier(node.callee, "Array") || node.type === "CallExpression" && node.callee.type === "MemberExpression" && isIdentifier(node.callee.object, "Array");
+}
 var waitForMethods = [
   "waitForConsoleMessage",
   "waitForDownload",
@@ -1042,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;
@@ -1109,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;
     }
@@ -1128,7 +1159,7 @@ var missing_playwright_await_default = createRule({
         }
         if (includePageLocatorMethods && node.callee.type === "MemberExpression") {
           const methodName = getStringValue(node.callee.property);
-          const isPlaywrightMethod = locatorMethods.has(methodName) || pageMethods.has(methodName) && isPageMethod(node, methodName);
+          const isPlaywrightMethod = !isArrayLike(node.callee.object) && (locatorMethods.has(methodName) || pageMethods.has(methodName) && isPageMethod(node, methodName));
           if (isPlaywrightMethod) {
             if (!checkValidity(node, /* @__PURE__ */ new Set())) {
               context.report({
@@ -4545,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);
             }
@@ -4567,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.0",
+  "version": "2.10.2",
   "description": "ESLint plugin for Playwright testing.",
   "license": "MIT",
   "author": "Mark Skelton <mark@mskelton.dev>",