fix: use typescript-eslint instead of babel

Author: zhiyuanzmj

eslint.config.js

@@ -4,5 +4,6 @@ export default sxzz({
   rules: {
     'unused-imports/no-unused-vars': 'off',
     'unused-imports/no-unused-imports': 'off',
+    'import/no-default-export': 'off',
   },
 })

package.json

@@ -52,6 +52,26 @@
       "require": "./dist/volar.cjs",
       "import": "./dist/volar.js"
     },
+    "./raw": {
+      "require": "./dist/raw.cjs",
+      "import": "./dist/raw.js"
+    },
+    "./rolldown": {
+      "require": "./dist/rolldown.cjs",
+      "import": "./dist/rolldown.js"
+    },
+    "./rspack": {
+      "require": "./dist/rspack.cjs",
+      "import": "./dist/rspack.js"
+    },
+    "./nuxt": {
+      "require": "./dist/nuxt.cjs",
+      "import": "./dist/nuxt.js"
+    },
+    "./astro": {
+      "require": "./dist/astro.cjs",
+      "import": "./dist/astro.js"
+    },
     "./*": "./*"
   },
   "typesVersions": {
@@ -76,9 +96,9 @@
     "prepublishOnly": "pnpm run build"
   },
   "dependencies": {
-    "@babel/parser": "^7.27.0",
-    "@babel/plugin-transform-typescript": "^7.27.0",
-    "@babel/traverse": "^7.27.0",
+    "@nuxt/kit": "^3.16.2",
+    "@typescript-eslint/scope-manager": "^8.30.1",
+    "@typescript-eslint/typescript-estree": "^8.30.1",
     "@vue-macros/common": "3.0.0-beta.8",
     "ts-macro": "^0.1.25",
     "unplugin": "^2.3.2"
@@ -89,6 +109,7 @@
     "@sxzz/prettier-config": "^2.0.2",
     "@types/babel__traverse": "^7.20.7",
     "@types/node": "^20.14.11",
+    "@typescript-eslint/types": "^8.30.1",
     "@vue-macros/reactivity-transform": "^0.4.6",
     "@vue-macros/test-utils": "^1.4.0",
     "bumpp": "^9.4.1",

pnpm-lock.yaml

@@ -0,0 +1,12 @@
+import unplugin from '.'
+import type { Options } from './core/options'
+
+export default (options: Options) => ({
+  name: 'unplugin-vue-reactivity-function',
+  hooks: {
+    'astro:config:setup': (astro: any) => {
+      astro.config.vite.plugins ||= []
+      astro.config.vite.plugins.push(unplugin.vite(options))
+    },
+  },
+})

src/astro.ts

@@ -0,0 +1,79 @@
+import type { Reference, Scope } from '@typescript-eslint/scope-manager'
+import type { TSESTree } from '@typescript-eslint/typescript-estree'
+
+export function getReferences(
+  scope: Scope,
+  id: TSESTree.Identifier,
+): Reference[] {
+  return scope.childScopes.reduce(
+    (acc, scope) => (acc.push(...getReferences(scope, id)), acc),
+    scope.references.filter(
+      (ref) => ref.identifier !== id && ref.resolved?.identifiers.includes(id),
+    ),
+  )
+}
+
+export function getMemberExpression(node: TSESTree.Node) {
+  if (!node.parent) return node
+  if (
+    node.parent.type === 'MemberExpression' ||
+    node.parent.type === 'ChainExpression' ||
+    (node.parent.type === 'CallExpression' && node.parent?.callee === node)
+  ) {
+    return getMemberExpression(node.parent)
+  }
+  return node
+}
+
+export function transformArguments(
+  argument: TSESTree.Node,
+  refs: TSESTree.Node[],
+) {
+  if (
+    [
+      'Identifier',
+      'CallExpression',
+      'MemberExpression',
+      'ChainExpression',
+      'TSInstantiationExpression',
+    ].includes(argument.type)
+  ) {
+    refs.push(argument)
+  } else if (
+    argument.type === 'FunctionExpression' ||
+    argument.type === 'ArrowFunctionExpression'
+  ) {
+    transformFunctionReturn(argument, refs)
+  } else if (argument.type === 'ArrayExpression') {
+    argument.elements.forEach((arg) => {
+      transformArguments(arg!, refs)
+    })
+  } else if (argument.type === 'ObjectExpression') {
+    argument.properties.forEach((prop) => {
+      if (prop.type === 'Property') {
+        transformArguments(prop.value, refs)
+      }
+    })
+  }
+}
+
+export function transformFunctionReturn(
+  node: TSESTree.Node,
+  refs: TSESTree.Node[],
+) {
+  if (
+    node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression' ||
+    node.type === 'ArrowFunctionExpression'
+  ) {
+    if (node.body.type !== 'BlockStatement') {
+      transformArguments(node.body, refs)
+    } else {
+      node.body.body?.forEach((statement) => {
+        if (statement.type === 'ReturnStatement' && statement.argument) {
+          transformArguments(statement.argument, refs)
+        }
+      })
+    }
+  }
+}