eslint-plugin-cypress 4.3.0 → 5.0.1

package/lib/rules/no-async-tests.js

@@ -15,31 +15,31 @@ module.exports = {
     },
   },
 
-  create (context) {
-    function isTestBlock (callExpressionNode) {
+  create(context) {
+    function isTestBlock(callExpressionNode) {
       const { type, name } = callExpressionNode.callee
 
       return type === 'Identifier'
-                && name === 'it' || name === 'test'
+        && (name === 'it' || name === 'test')
     }
 
-    function isTestAsync (node) {
+    function isTestAsync(node) {
       return node.arguments
-                && node.arguments.length >= 2
-                && node.arguments[1].async === true
+        && node.arguments.length >= 2
+        && node.arguments[1].async === true
     }
     const sourceCode = context.sourceCode ?? context.getSourceCode()
 
     return {
-      Identifier (node) {
+      Identifier(node) {
         if (node.name === 'cy' || node.name === 'Cypress') {
           const ancestors = sourceCode.getAncestors
             ? sourceCode.getAncestors(node)
             : context.getAncestors()
           const asyncTestBlocks = ancestors
-          .filter((n) => n.type === 'CallExpression')
-          .filter(isTestBlock)
-          .filter(isTestAsync)
+            .filter((n) => n.type === 'CallExpression')
+            .filter(isTestBlock)
+            .filter(isTestAsync)
 
           if (asyncTestBlocks.length >= 1) {
             asyncTestBlocks.forEach((node) => {

package/lib/rules/no-chained-get.js

@@ -1,8 +1,8 @@
-'use strict';
+'use strict'
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 // Rule Definition
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
@@ -23,55 +23,55 @@ module.exports = {
   create(context) {
     const isRootCypress = (node) => {
       if (
-        node.type !== 'CallExpression' ||
-        node.callee.type !== 'MemberExpression'
+        node.type !== 'CallExpression'
+        || node.callee.type !== 'MemberExpression'
       ) {
-        return false;
+        return false
       }
 
       if (
-        node.callee.object.type === 'Identifier' &&
-        node.callee.object.name === 'cy'
+        node.callee.object.type === 'Identifier'
+        && node.callee.object.name === 'cy'
       ) {
-        return true;
+        return true
       }
 
-      return isRootCypress(node.callee.object);
-    };
+      return isRootCypress(node.callee.object)
+    }
 
     const hasChainedGet = (node) => {
       // Check if this node is a get() call
-      const isGetCall =
-        node.callee &&
-        node.callee.type === 'MemberExpression' &&
-        node.callee.property &&
-        node.callee.property.type === 'Identifier' &&
-        node.callee.property.name === 'get';
+      const isGetCall
+        = node.callee
+          && node.callee.type === 'MemberExpression'
+          && node.callee.property
+          && node.callee.property.type === 'Identifier'
+          && node.callee.property.name === 'get'
 
       if (!isGetCall) {
-        return false;
+        return false
       }
 
-      const obj = node.callee.object;
+      const obj = node.callee.object
 
       if (obj.type === 'CallExpression') {
-        const objCallee = obj.callee;
+        const objCallee = obj.callee
 
         if (
-          objCallee &&
-          objCallee.type === 'MemberExpression' &&
-          objCallee.property &&
-          objCallee.property.type === 'Identifier' &&
-          objCallee.property.name === 'get'
+          objCallee
+          && objCallee.type === 'MemberExpression'
+          && objCallee.property
+          && objCallee.property.type === 'Identifier'
+          && objCallee.property.name === 'get'
         ) {
-          return true;
+          return true
         }
 
-        return hasChainedGet(obj);
+        return hasChainedGet(obj)
       }
 
-      return false;
-    };
+      return false
+    }
 
     return {
       CallExpression(node) {
@@ -79,9 +79,9 @@ module.exports = {
           context.report({
             node,
             messageId: 'unexpected',
-          });
+          })
         }
       },
-    };
+    }
   },
-};
+}

package/lib/rules/no-debug.js

@@ -1,8 +1,8 @@
 'use strict'
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 // Rule Definition
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
 module.exports = {
   meta: {
@@ -20,37 +20,36 @@ module.exports = {
     },
   },
 
-  create (context) {
-
+  create(context) {
     // variables should be defined here
 
-    //----------------------------------------------------------------------
+    // ----------------------------------------------------------------------
     // Helpers
-    //----------------------------------------------------------------------
-    function isCallingDebug (node) {
-      return node.callee &&
-        node.callee.property &&
-        node.callee.property.type === 'Identifier' &&
-        node.callee.property.name === 'debug'
+    // ----------------------------------------------------------------------
+    function isCallingDebug(node) {
+      return node.callee
+        && node.callee.property
+        && node.callee.property.type === 'Identifier'
+        && node.callee.property.name === 'debug'
     }
 
-    function isCypressCall (node) {
+    function isCypressCall(node) {
       if (!node.callee || node.callee.type !== 'MemberExpression') {
-        return false;
+        return false
       }
       if (node.callee.object.type === 'Identifier' && node.callee.object.name === 'cy') {
-        return true;
+        return true
       }
-      return isCypressCall(node.callee.object);
+      return isCypressCall(node.callee.object)
     }
-    
-    //----------------------------------------------------------------------
+
+    // ----------------------------------------------------------------------
     // Public
-    //----------------------------------------------------------------------
+    // ----------------------------------------------------------------------
 
     return {
 
-      CallExpression (node) {
+      CallExpression(node) {
         if (isCypressCall(node) && isCallingDebug(node)) {
           context.report({ node, messageId: 'unexpected' })
         }

package/lib/rules/no-force.js

@@ -1,8 +1,8 @@
 'use strict'
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 // Rule Definition
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
 module.exports = {
   meta: {
@@ -20,39 +20,36 @@ module.exports = {
     },
   },
 
-  create (context) {
-
+  create(context) {
     // variables should be defined here
 
-    //----------------------------------------------------------------------
+    // ----------------------------------------------------------------------
     // Helpers
-    //----------------------------------------------------------------------
-    function isCallingClickOrType (node) {
+    // ----------------------------------------------------------------------
+    function isCallingClickOrType(node) {
       const allowedMethods = ['click', 'dblclick', 'type', 'trigger', 'check', 'rightclick', 'focus', 'select']
 
-      return node.property && node.property.type === 'Identifier' &&
-             allowedMethods.includes(node.property.name)
+      return node.property && node.property.type === 'Identifier'
+        && allowedMethods.includes(node.property.name)
     }
 
-    function isCypressCall (node) {
-      return node.callee.type === 'MemberExpression' &&
-        node.callee.object.type === 'Identifier' &&
-        node.callee.object.name === 'cy'
+    function isCypressCall(node) {
+      return node.callee.type === 'MemberExpression'
+        && node.callee.object.type === 'Identifier'
+        && node.callee.object.name === 'cy'
     }
 
-    function hasOptionForce (node) {
-
-      return node.arguments && node.arguments.length &&
-      node.arguments.some((arg) => {
-        return arg.type === 'ObjectExpression' && arg.properties.some((propNode) => propNode.key && propNode.key.name === 'force')
-      })
+    function hasOptionForce(node) {
+      return node.arguments && node.arguments.length
+        && node.arguments.some((arg) => {
+          return arg.type === 'ObjectExpression' && arg.properties.some((propNode) => propNode.key && propNode.key.name === 'force')
+        })
     }
 
-    function deepCheck (node, checkFunc) {
+    function deepCheck(node, checkFunc) {
       let currentNode = node
 
       while (currentNode.parent) {
-
         if (checkFunc(currentNode.parent)) {
           return true
         }
@@ -63,13 +60,13 @@ module.exports = {
       return false
     }
 
-    //----------------------------------------------------------------------
+    // ----------------------------------------------------------------------
     // Public
-    //----------------------------------------------------------------------
+    // ----------------------------------------------------------------------
 
     return {
 
-      CallExpression (node) {
+      CallExpression(node) {
         if (isCypressCall(node) && deepCheck(node, isCallingClickOrType) && deepCheck(node, hasOptionForce)) {
           context.report({ node, messageId: 'unexpected' })
         }

package/lib/rules/no-pause.js

@@ -1,8 +1,8 @@
 'use strict'
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 // Rule Definition
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
 module.exports = {
   meta: {
@@ -20,37 +20,36 @@ module.exports = {
     },
   },
 
-  create (context) {
-
+  create(context) {
     // variables should be defined here
 
-    //----------------------------------------------------------------------
+    // ----------------------------------------------------------------------
     // Helpers
-    //----------------------------------------------------------------------
-    function isCallingPause (node) {
-      return node.callee &&
-        node.callee.property &&
-        node.callee.property.type === 'Identifier' &&
-        node.callee.property.name === 'pause'
+    // ----------------------------------------------------------------------
+    function isCallingPause(node) {
+      return node.callee
+        && node.callee.property
+        && node.callee.property.type === 'Identifier'
+        && node.callee.property.name === 'pause'
     }
 
-    function isCypressCall (node) {
+    function isCypressCall(node) {
       if (!node.callee || node.callee.type !== 'MemberExpression') {
-        return false;
+        return false
       }
       if (node.callee.object.type === 'Identifier' && node.callee.object.name === 'cy') {
-        return true;
+        return true
       }
-      return isCypressCall(node.callee.object);
+      return isCypressCall(node.callee.object)
     }
-    
-    //----------------------------------------------------------------------
+
+    // ----------------------------------------------------------------------
     // Public
-    //----------------------------------------------------------------------
+    // ----------------------------------------------------------------------
 
     return {
 
-      CallExpression (node) {
+      CallExpression(node) {
         if (isCypressCall(node) && isCallingPause(node)) {
           context.report({ node, messageId: 'unexpected' })
         }

package/lib/rules/no-unnecessary-waiting.js

@@ -14,11 +14,11 @@ module.exports = {
       unexpected: 'Do not wait for arbitrary time periods',
     },
   },
-  create (context) {
+  create(context) {
     const sourceCode = context.sourceCode ?? context.getSourceCode()
 
     return {
-      CallExpression (node) {
+      CallExpression(node) {
         if (isCallingCyWait(node)) {
           const scope = sourceCode.getScope
             ? sourceCode.getScope(node)
@@ -33,7 +33,7 @@ module.exports = {
   },
 }
 
-function nodeIsCalledByCy (node) {
+function nodeIsCalledByCy(node) {
   if (node.type === 'Identifier' && node.name === 'cy') return true
 
   if (typeof node.callee === 'undefined' || typeof node.callee.object === 'undefined') {
@@ -43,20 +43,20 @@ function nodeIsCalledByCy (node) {
   return nodeIsCalledByCy(node.callee.object)
 }
 
-function isCallingCyWait (node) {
-  return node.callee.type === 'MemberExpression' &&
-         nodeIsCalledByCy(node) &&
-         node.callee.property.type === 'Identifier' &&
-         node.callee.property.name === 'wait'
+function isCallingCyWait(node) {
+  return node.callee.type === 'MemberExpression'
+    && nodeIsCalledByCy(node)
+    && node.callee.property.type === 'Identifier'
+    && node.callee.property.name === 'wait'
 }
 
-function isNumberArgument (node) {
-  return node.arguments.length > 0 &&
-         node.arguments[0].type === 'Literal' &&
-         typeof (node.arguments[0].value) === 'number'
+function isNumberArgument(node) {
+  return node.arguments.length > 0
+    && node.arguments[0].type === 'Literal'
+    && typeof (node.arguments[0].value) === 'number'
 }
 
-function isIdentifierNumberConstArgument (node, scope) {
+function isIdentifierNumberConstArgument(node, scope) {
   if (node.arguments.length === 0) return false
 
   if (node.arguments[0].type !== 'Identifier') return false

package/lib/rules/no-xpath.js

@@ -6,7 +6,7 @@ module.exports = {
     docs: {
       description: 'disallow using `cy.xpath()` calls',
       recommended: false,
-      url: 'https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-xpath.md'
+      url: 'https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-xpath.md',
     },
     fixable: null, // Or `code` or `whitespace`
     schema: [], // Add a schema if the rule has options
@@ -15,21 +15,21 @@ module.exports = {
     },
   },
 
-  create (context) {
+  create(context) {
     return {
-      CallExpression (node) {
+      CallExpression(node) {
         if (isCallingCyXpath(node)) {
           context.report({ node, messageId: 'unexpected' })
         }
       },
     }
   },
-};
+}
 
-function isCallingCyXpath (node) {
-  return node.callee.type === 'MemberExpression' &&
-         node.callee.object.type === 'Identifier' &&
-         node.callee.object.name === 'cy' &&
-         node.callee.property.type === 'Identifier' &&
-         node.callee.property.name === 'xpath'
+function isCallingCyXpath(node) {
+  return node.callee.type === 'MemberExpression'
+    && node.callee.object.type === 'Identifier'
+    && node.callee.object.name === 'cy'
+    && node.callee.property.type === 'Identifier'
+    && node.callee.property.name === 'xpath'
 }

package/lib/rules/require-data-selectors.js

@@ -15,9 +15,9 @@ module.exports = {
     },
   },
 
-  create (context) {
+  create(context) {
     return {
-      CallExpression (node) {
+      CallExpression(node) {
         if (isCallingCyGet(node) && !isDataArgument(node)) {
           context.report({ node, messageId: 'unexpected' })
         }
@@ -26,23 +26,23 @@ module.exports = {
   },
 }
 
-function isCallingCyGet (node) {
-  return node.callee.type === 'MemberExpression' &&
-         node.callee.object.type === 'Identifier' &&
-         node.callee.object.name === 'cy' &&
-         node.callee.property.type === 'Identifier' &&
-         node.callee.property.name === 'get'
+function isCallingCyGet(node) {
+  return node.callee.type === 'MemberExpression'
+    && node.callee.object.type === 'Identifier'
+    && node.callee.object.name === 'cy'
+    && node.callee.property.type === 'Identifier'
+    && node.callee.property.name === 'get'
 }
 
-function isDataArgument (node) {
-  return node.arguments.length > 0 &&
-    (
-      (node.arguments[0].type === 'Literal' && isAliasOrDataSelector(String(node.arguments[0].value))) ||
-      (node.arguments[0].type === 'TemplateLiteral' && isAliasOrDataSelector(String(node.arguments[0].quasis[0].value.cooked)))
+function isDataArgument(node) {
+  return node.arguments.length > 0
+    && (
+      (node.arguments[0].type === 'Literal' && isAliasOrDataSelector(String(node.arguments[0].value)))
+      || (node.arguments[0].type === 'TemplateLiteral' && isAliasOrDataSelector(String(node.arguments[0].quasis[0].value.cooked)))
     )
 }
 
-function isAliasOrDataSelector (selector) {
+function isAliasOrDataSelector(selector) {
   return ['[data-', '@'].some(function (validValue) {
     return selector.startsWith(validValue)
   })

package/lib/rules/unsafe-to-chain-command.js

@@ -82,15 +82,15 @@ module.exports = {
         'It is unsafe to chain further commands that rely on the subject after this command. It is best to split the chain, chaining again from `cy.` in a next command line.',
     },
   },
-  create (context) {
+  create(context) {
     const { methods } = getDefaultOptions(context)
 
     return {
-      CallExpression (node) {
+      CallExpression(node) {
         if (
-          isRootCypress(node) &&
-          isActionUnsafeToChain(node, methods) &&
-          node.parent.type === 'MemberExpression'
+          isRootCypress(node)
+          && isActionUnsafeToChain(node, methods)
+          && node.parent.type === 'MemberExpression'
         ) {
           context.report({
             node,
@@ -108,15 +108,15 @@ module.exports = {
  */
 const isRootCypress = (node) => {
   if (
-    node.type !== 'CallExpression' ||
-    node.callee.type !== 'MemberExpression'
+    node.type !== 'CallExpression'
+    || node.callee.type !== 'MemberExpression'
   ) {
     return false
   }
 
   if (
-    node.callee.object.type === 'Identifier' &&
-    node.callee.object.name === 'cy'
+    node.callee.object.type === 'Identifier'
+    && node.callee.object.name === 'cy'
   ) {
     return true
   }
@@ -135,9 +135,9 @@ const isActionUnsafeToChain = (node, additionalMethods = []) => {
   ].join('|'))
 
   return (
-    node.callee &&
-    node.callee.property &&
-    node.callee.property.type === 'Identifier' &&
-    unsafeActionsRegex.test(node.callee.property.name)
+    node.callee
+    && node.callee.property
+    && node.callee.property.type === 'Identifier'
+    && unsafeActionsRegex.test(node.callee.property.name)
   )
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "eslint-plugin-cypress",
-  "version": "4.3.0",
+  "version": "5.0.1",
   "description": "An ESLint plugin for projects using Cypress",
-  "main": "legacy.js",
+  "main": "./lib/flat.js",
   "exports": {
-    ".": "./legacy.js",
+    ".": "./lib/flat.js",
     "./flat": "./lib/flat.js"
   },
   "author": "Cypress-io",
@@ -26,24 +26,22 @@
     "eslint": ">=9"
   },
   "dependencies": {
-    "globals": "^15.15.0"
+    "globals": "^16.2.0"
   },
   "devDependencies": {
-    "eslint": "^9.24.0",
+    "@stylistic/eslint-plugin": "^4.4.0",
+    "eslint": "^9.27.0",
     "eslint-plugin-eslint-plugin": "^6.4.0",
-    "eslint-plugin-mocha": "^10.5.0",
+    "eslint-plugin-mocha": "^11.1.0",
     "husky": "^9.1.7",
-    "jest": "^29.7.0",
-    "semantic-release": "24.2.3"
+    "semantic-release": "24.2.5",
+    "vitest": "^3.1.4"
   },
   "scripts": {
-    "lint": "eslint \"*.js\" \"**/**/*.js\"",
-    "lint-fix": "npm run lint -- --fix",
+    "lint": "eslint",
+    "lint-fix": "eslint --fix",
     "semantic-release": "semantic-release",
-    "start": "npm run test-watch",
-    "test": "jest",
-    "test:legacy": "jest --config jest.config-legacy.js",
-    "test-watch": "jest --watchAll",
+    "test": "vitest run",
     "prepare": "husky"
   }
 }

package/test-project/eslint-configs/eslint.default-deprecated.mjs

@@ -0,0 +1,11 @@
+// eslint-plugin-cypress/flat is deprecated and is identical to
+// eslint-plugin-cypress
+import pluginCypress from 'eslint-plugin-cypress/flat'
+export default [
+  pluginCypress.configs.recommended,
+  {
+    rules: {
+      'cypress/no-unnecessary-waiting': 'off'
+    }
+  }
+]

package/test-project/eslint-configs/eslint.default.mjs

@@ -1,4 +1,4 @@
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 export default [
   pluginCypress.configs.recommended,
   {

package/test-project/eslint-configs/eslint.globals.mjs

@@ -1,4 +1,4 @@
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 export default [
   pluginCypress.configs.globals
 ]

package/test-project/eslint-configs/eslint.recommended.mjs

@@ -1,4 +1,4 @@
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 export default [
   pluginCypress.configs.recommended,
   {