feat: enhance member expression handling and add TypeScript support

Author: waynzh

lib/rules/no-async-in-computed-properties.js

@@ -38,24 +38,35 @@ function isTimedFunction(node) {
   )
 }
 
+/**
+ * @param {*} node
+ * @returns {*}
+ */
+function skipWrapper(node) {
+  while (node && node.expression) {
+    node = node.expression
+  }
+  return node
+}
+
 /**
  * Get the root object name from a member expression chain
  * @param {MemberExpression} memberExpr
  * @returns {string|null}
  */
 function getRootObjectName(memberExpr) {
-  let current = memberExpr.object
+  let current = skipWrapper(memberExpr.object)
 
   while (current) {
     switch (current.type) {
       case 'MemberExpression': {
-        current = utils.skipChainExpression(current.object)
+        current = skipWrapper(current.object)
         break
       }
       case 'CallExpression': {
-        const calleeExpr = utils.skipChainExpression(current.callee)
+        const calleeExpr = skipWrapper(current.callee)
         if (calleeExpr.type === 'MemberExpression') {
-          current = calleeExpr.object
+          current = skipWrapper(calleeExpr.object)
         } else if (calleeExpr.type === 'Identifier') {
           return calleeExpr.name
         } else {
@@ -75,6 +86,22 @@ function getRootObjectName(memberExpr) {
   return null
 }
 
+/**
+ * @param {string} name
+ * @param {*} callee
+ * @returns {boolean}
+ */
+function isPromiseMethod(name, callee) {
+  return (
+    // hello.PROMISE_FUNCTION()
+    PROMISE_FUNCTIONS.has(name) ||
+    // Promise.PROMISE_METHOD()
+    (callee.object.type === 'Identifier' &&
+      callee.object.name === 'Promise' &&
+      PROMISE_METHODS.has(name))
+  )
+}
+
 /**
  * @param {CallExpression} node
  * @param {Set<string>} ignoredObjectNames
@@ -83,15 +110,7 @@ function isPromise(node, ignoredObjectNames) {
   const callee = utils.skipChainExpression(node.callee)
   if (callee.type === 'MemberExpression') {
     const name = utils.getStaticPropertyName(callee)
-    if (
-      !name ||
-      (!PROMISE_FUNCTIONS.has(name) &&
-        !(
-          callee.object.type === 'Identifier' &&
-          callee.object.name === 'Promise' &&
-          PROMISE_METHODS.has(name)
-        ))
-    ) {
+    if (!name || !isPromiseMethod(name, callee)) {
       return false
     }
 

tests/lib/rules/no-async-in-computed-properties.js

@@ -363,13 +363,34 @@ ruleTester.run('no-async-in-computed-properties', rule, {
         export default {
           computed: {
             foo: function () {
-              return z.a.b.c.d.e.f.method().catch(err => err).finally(() => {})
+              return z.a?.['b'].[c].d.method().catch(err => err).finally(() => {})
             }
           }
         }
       `,
       options: [{ ignoredObjectNames: ['z'] }],
-      languageOptions
+      languageOptions: {
+        parser,
+        sourceType: 'module',
+        ecmaVersion: 2020
+      }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      import { computed } from 'vue'
+      import { z } from 'zod'
+
+      const foo = computed(() => z.a?.['b'].c!.d.method().catch(err => err).finally(() => {}))
+      </script>`,
+      options: [{ ignoredObjectNames: ['z'] }],
+      languageOptions: {
+        parser: require('vue-eslint-parser'),
+        parserOptions: {
+          parser: require.resolve('@typescript-eslint/parser')
+        }
+      }
     }
   ],