chore: 清理冗余代码模块；调整模块结构

Author: Vanisper

src/common/AsyncComponents.ts

@@ -4,6 +4,7 @@ import process from 'node:process'
 import { logger } from '../common/Logger'
 import {
   COMPONENT_PLACEHOLDER,
+  DEFINE_COMPONENT,
   DEFINE_OPTIONS,
   filterMacro,
   getComponentPlaceholder,
@@ -67,14 +68,14 @@ export function AsyncComponentProcessor(enableLogger: boolean): Plugin {
 
       if (scriptAst) {
         // 有些是使用 defineComponent 声明的
-        const macroNodes = filterMacro(scriptAst.body, 'defineComponent')
+        const macroNodes = filterMacro(scriptAst.body, DEFINE_COMPONENT)
         collectPlaceholder(macroNodes?.[0]?.arguments?.[0])
         const [defaultExport] = getDefaultExports(scriptAst)
         collectPlaceholder(defaultExport?.declaration)
       }
       if (setupAst) {
-        const macroNodes = filterMacro(setupAst.body)
-        if (macroNodes.length > 1) {
+        const macroNodes = filterMacro(setupAst.body, DEFINE_OPTIONS)
+        if (macroNodes.length > 1) { // 多个 defineOptions 宏是不允许的
           throw new SyntaxError(`duplicate ${DEFINE_OPTIONS}() call`)
         }
         collectPlaceholder(macroNodes?.[0]?.arguments?.[0])

src/common/AsyncImports.ts

@@ -0,0 +1,163 @@
+import type { ExportDefaultDeclaration, Node, ObjectExpression, Program, TemplateLiteral } from '@babel/types'
+import { walkAST } from 'ast-kit'
+
+export function getDefaultExports(program: Program) {
+  const defaultExports: ExportDefaultDeclaration[] = []
+
+  walkAST(program, {
+    enter(node) {
+      // 匹配 export default
+      // 虽然标准语法中只支持一个默认导出，但是这里支持多个默认导出节点的收集
+      if (node.type === 'ExportDefaultDeclaration') {
+        defaultExports.push(node)
+      }
+      // export 只能出现在顶层，遇到块级作用域直接跳过
+      if (node.type === 'BlockStatement' || node.type === 'FunctionDeclaration') {
+        this.skip()
+      }
+    },
+  })
+
+  return defaultExports
+}
+
+export function serializeObjectExpression(node: ObjectExpression) {
+  // 确保传入的是对象表达式
+  if (node.type !== 'ObjectExpression') {
+    throw new Error('Not an ObjectExpression')
+  }
+
+  const result: Record<string, unknown> = {}
+
+  node.properties.forEach((prop) => {
+    // 处理常见的属性（Property），排除 SpreadElement（如 ...obj）
+    if (prop.type === 'ObjectProperty') {
+      let key
+
+      // 处理 key (例如 { a: 1 } 或 { "a": 1 })
+      if (prop.computed) {
+        // 如果是计算属性 [key]: value，简单静态处理可能拿不到值，这里通常抛错或跳过
+        console.warn('Computed properties are not supported in static serialization')
+        return
+      }
+      else {
+        // 处理 Identifier (a) 或 StringLiteral ("a")
+        // @ts-expect-error ignore
+        key = prop.key.name || prop.key.value
+      }
+
+      // 处理 value (递归解析)
+      // 如果存在相同 key，则将会记录到最后一项
+      result[key] = parseValue(prop.value)
+    }
+  })
+
+  return result
+}
+
+export function parseValue(node?: Node | null): unknown {
+  if (!node)
+    return node
+
+  switch (node.type) {
+    case 'StringLiteral':
+    case 'NumericLiteral':
+    case 'BooleanLiteral':
+      return node.value
+    case 'NullLiteral':
+      return null
+    case 'BigIntLiteral':
+      return BigInt(node.value)
+    case 'RegExpLiteral':
+      return new RegExp(node.pattern, node.flags)
+    case 'ObjectExpression':
+      return serializeObjectExpression(node)
+    case 'ArrayExpression':
+      return node.elements.map((el) => {
+        return el ? parseValue(el) : null
+      })
+    case 'BinaryExpression': {
+      const left = parseValue(node.left)
+      const right = parseValue(node.right)
+
+      // 如果左右任一端无法静态解析（例如引用了变量），则整体返回 undefined 或占位符
+      if ((typeof left === 'string' && left.startsWith('[')) || (typeof right === 'string' && right.startsWith('['))) {
+        return `[BinaryExpression: ${node.operator}]`
+      }
+
+      switch (node.operator) {
+        case '+': return (left as any) + (right as any)
+        case '-': return (left as any) - (right as any)
+        case '*': return (left as any) * (right as any)
+        case '/': return (left as any) / (right as any)
+        case '%': return (left as any) % (right as any)
+        case '**': return (left as any) ** (right as any)
+          // eslint-disable-next-line eqeqeq
+        case '==': return left == right
+        case '===': return left === right
+          // eslint-disable-next-line eqeqeq
+        case '!=': return left != right
+        case '!==': return left !== right
+        case '>': return (left as any) > (right as any)
+        case '<': return (left as any) < (right as any)
+        default: return `[Unsupported Operator: ${node.operator}]`
+      }
+    }
+    // 逻辑表达式
+    case 'LogicalExpression': {
+      const left = parseValue(node.left)
+      // 模拟 JS 的短路逻辑
+      if (node.operator === '&&')
+        return left && parseValue(node.right)
+      if (node.operator === '||')
+        return left || parseValue(node.right)
+      if (node.operator === '??')
+        return left ?? parseValue(node.right)
+      return undefined
+    }
+    case 'TemplateLiteral':
+      // 如果是没有变量的模板字符串
+      return parseTemplateLiteral(node)
+    case 'UnaryExpression': {
+      const { operator, argument } = node
+      const value = parseValue(argument) // 递归获取参数值
+
+      // 如果参数无法解析出静态值，则整体无法解析
+      if (value === undefined)
+        return undefined
+
+      switch (operator) {
+        case '-': return -(value as any)
+        case '+': return +(value as any)
+        case '!': return !value
+        case '~': return ~(value as any)
+        case 'void': return undefined
+        default: return `[${operator}: ${value}]` // 其余如 typeof, delete 无法静态化
+      }
+    }
+    case 'Identifier':
+      // 如果遇到变量引用，静态环境下无法得知具体值，通常返回变量名字符串或占位符
+      return `[Identifier: ${node.name}]`
+    default:
+      return `[Unhandled: ${node.type}]`
+  }
+}
+
+/**
+ * 模版字符串 ast 转成文本
+ * @param node TemplateLiteral
+ */
+export function parseTemplateLiteral(node: TemplateLiteral) {
+  let result = ''
+  const quasis = node.quasis
+  const expressions = node.expressions
+
+  for (let i = 0; i < quasis.length; i++) {
+    result += quasis[i].value.cooked
+
+    if (i < expressions.length) {
+      result += `\${${expressions[i].type}}`
+    }
+  }
+  return result
+}

src/plugin/async-component-processor.ts

@@ -0,0 +1,27 @@
+import type { ObjectExpression } from '@babel/types'
+import { serializeObjectExpression } from './common'
+import { COMPONENT_PLACEHOLDER } from './constant'
+
+export function hasComponentPlaceholder(node: ObjectExpression): boolean {
+  return node.properties.some(
+    prop =>
+      (prop.type === 'ObjectProperty' || prop.type === 'ObjectMethod')
+      && prop.key.type === 'Identifier'
+      && (prop.key.name === COMPONENT_PLACEHOLDER),
+  )
+}
+
+export function getComponentPlaceholder(node: ObjectExpression) {
+  if (node?.type !== 'ObjectExpression') {
+    return
+  }
+  if (!hasComponentPlaceholder(node)) {
+    return
+  }
+
+  // 序列化 ast 为对象
+  const obj = serializeObjectExpression(node)
+  if (COMPONENT_PLACEHOLDER in obj && typeof obj[COMPONENT_PLACEHOLDER] === 'object') {
+    return obj[COMPONENT_PLACEHOLDER] as typeof obj
+  }
+}

src/utils/ast/common.ts

@@ -0,0 +1,3 @@
+export const DEFINE_OPTIONS = 'defineOptions'
+export const DEFINE_COMPONENT = 'defineComponent'
+export const COMPONENT_PLACEHOLDER = 'componentPlaceholder'