perf(weapp-tailwindcss): 复用 eval 选项并收紧替换扫描

Author: sonofmagic

packages/weapp-tailwindcss/src/js/evalTransforms.ts

@@ -7,6 +7,12 @@ import { jsStringEscape } from '@ast-core/escape'
 
 export type EvalHandler = (source: string, opts: IJsHandlerOptions) => JsHandlerResult
 
+const evalHandlerOptionsCache = new WeakMap<IJsHandlerOptions, {
+  stringLiteralOptions?: IJsHandlerOptions
+  templateLiteralOptions?: IJsHandlerOptions
+}>()
+const EVAL_SCOPE_ERROR_REGEXP = /pass a scope and parentPath|traversing a Program\/File/i
+
 export function isEvalPath(path: NodePath<Node>) {
   if (path.isCallExpression()) {
     const calleePath = path.get('callee')
@@ -60,15 +66,11 @@ function createEvalReplacementToken(
 
 function handleEvalStringLiteral(
   path: NodePath<StringLiteral>,
-  options: IJsHandlerOptions,
+  handlerOptions: IJsHandlerOptions,
   updater: JsTokenUpdater,
   handler: EvalHandler,
 ) {
-  const { code } = handler(path.node.value, {
-    ...options,
-    needEscaped: false,
-    generateMap: false,
-  })
+  const { code } = handler(path.node.value, handlerOptions)
 
   if (!code) {
     return
@@ -82,14 +84,11 @@ function handleEvalStringLiteral(
 
 function handleEvalTemplateElement(
   path: NodePath<TemplateElement>,
-  options: IJsHandlerOptions,
+  handlerOptions: IJsHandlerOptions,
   updater: JsTokenUpdater,
   handler: EvalHandler,
 ) {
-  const { code } = handler(path.node.value.raw, {
-    ...options,
-    generateMap: false,
-  })
+  const { code } = handler(path.node.value.raw, handlerOptions)
 
   if (!code) {
     return
@@ -101,29 +100,74 @@ function handleEvalTemplateElement(
   }
 }
 
+function getEvalStringHandlerOptions(options: IJsHandlerOptions) {
+  if (options.needEscaped === false && options.generateMap === false) {
+    return options
+  }
+
+  let cached = evalHandlerOptionsCache.get(options)
+  if (!cached) {
+    cached = {}
+    evalHandlerOptionsCache.set(options, cached)
+  }
+
+  if (!cached.stringLiteralOptions) {
+    cached.stringLiteralOptions = {
+      ...options,
+      needEscaped: false,
+      generateMap: false,
+    }
+  }
+
+  return cached.stringLiteralOptions
+}
+
+function getEvalTemplateHandlerOptions(options: IJsHandlerOptions) {
+  if (options.generateMap === false) {
+    return options
+  }
+
+  let cached = evalHandlerOptionsCache.get(options)
+  if (!cached) {
+    cached = {}
+    evalHandlerOptionsCache.set(options, cached)
+  }
+
+  if (!cached.templateLiteralOptions) {
+    cached.templateLiteralOptions = {
+      ...options,
+      generateMap: false,
+    }
+  }
+
+  return cached.templateLiteralOptions
+}
+
 export function walkEvalExpression(
   path: NodePath<CallExpression>,
   options: IJsHandlerOptions,
   updater: JsTokenUpdater,
   handler: EvalHandler,
 ) {
+  const stringHandlerOptions = getEvalStringHandlerOptions(options)
+  const templateHandlerOptions = getEvalTemplateHandlerOptions(options)
   // 优先走 NodePath 的 traverse（测试桩会用到），若因 noScope 缺少作用域报错则降级到手工参数遍历。
   const maybeTraverse = (path as any)?.traverse as ((v: any) => void) | undefined
   if (typeof maybeTraverse === 'function') {
     try {
       return maybeTraverse.call(path, {
         StringLiteral(innerPath: NodePath<StringLiteral>) {
-          handleEvalStringLiteral(innerPath, options, updater, handler)
+          handleEvalStringLiteral(innerPath, stringHandlerOptions, updater, handler)
         },
         TemplateElement(innerPath: NodePath<TemplateElement>) {
-          handleEvalTemplateElement(innerPath, options, updater, handler)
+          handleEvalTemplateElement(innerPath, templateHandlerOptions, updater, handler)
         },
       })
     }
     catch (error) {
       // 若是因为缺少 scope/parentPath 的错误，则继续走手工参数遍历；其他错误透出。
       const msg = (error as Error)?.message ?? ''
-      const scopeError = /pass a scope and parentPath|traversing a Program\/File/i.test(msg)
+      const scopeError = EVAL_SCOPE_ERROR_REGEXP.test(msg)
       if (!scopeError) {
         throw error
       }
@@ -135,12 +179,12 @@ export function walkEvalExpression(
   if (Array.isArray(getArgs)) {
     for (const arg of getArgs as Array<NodePath<Node>>) {
       if ((arg as any)?.isStringLiteral?.()) {
-        handleEvalStringLiteral(arg as unknown as NodePath<StringLiteral>, options, updater, handler)
+        handleEvalStringLiteral(arg as unknown as NodePath<StringLiteral>, stringHandlerOptions, updater, handler)
         continue
       }
       if ((arg as any)?.isTemplateLiteral?.()) {
         for (const quasi of (arg as any).get('quasis') as Array<NodePath<TemplateElement>>) {
-          handleEvalTemplateElement(quasi, options, updater, handler)
+          handleEvalTemplateElement(quasi, templateHandlerOptions, updater, handler)
         }
       }
     }
@@ -156,15 +200,15 @@ export function walkEvalExpression(
           node: n as StringLiteral,
           isStringLiteral: () => true,
         } as unknown as NodePath<StringLiteral>
-        handleEvalStringLiteral(stub, options, updater, handler)
+        handleEvalStringLiteral(stub, stringHandlerOptions, updater, handler)
       }
       else if (n?.type === 'TemplateLiteral' && Array.isArray(n.quasis)) {
         for (const q of n.quasis as any[]) {
           const stub = {
             node: q as TemplateElement,
             isTemplateElement: () => true,
           } as unknown as NodePath<TemplateElement>
-          handleEvalTemplateElement(stub, options, updater, handler)
+          handleEvalTemplateElement(stub, templateHandlerOptions, updater, handler)
         }
       }
     }

packages/weapp-tailwindcss/src/js/sourceAnalysis.ts

@@ -47,6 +47,20 @@ export function collectModuleSpecifierReplacementTokens(
   analysis: SourceAnalysis,
   replacements: Record<string, string>,
 ) {
+  const replacementKeys = Object.keys(replacements)
+  if (replacementKeys.length === 0) {
+    return []
+  }
+
+  if (
+    analysis.importDeclarations.size === 0
+    && analysis.exportDeclarations.size === 0
+    && analysis.requireCallPaths.length === 0
+    && analysis.walker.imports.length === 0
+  ) {
+    return []
+  }
+
   const tokens: JsToken[] = []
 
   const applyReplacement = (path: NodePath<StringLiteral>) => {

packages/weapp-tailwindcss/test/js/evalTransforms.test.ts

@@ -2,7 +2,7 @@ import type { NodePath } from '@babel/traverse'
 import type { CallExpression, Node } from '@babel/types'
 import type { IJsHandlerOptions, JsHandlerResult } from '@/types'
 import MagicString from 'magic-string'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import { parse, traverse } from '@/babel'
 import { isEvalPath, walkEvalExpression } from '@/js/evalTransforms'
 import { JsTokenUpdater } from '@/js/JsTokenUpdater'
@@ -54,6 +54,21 @@ describe('evalTransforms', () => {
     expect(rewritten).toBe('eval(`foo bar`);')
   })
 
+  it('reuses cached handler options for repeated eval string literals', () => {
+    const source = 'eval("foo", "bar")'
+    const updater = new JsTokenUpdater()
+    const handler = vi.fn((input: string): JsHandlerResult => ({ code: input.toUpperCase() }))
+
+    walkEvalExpression(getEvalCall(source), baseOptions, updater, handler)
+
+    expect(handler).toHaveBeenCalledTimes(2)
+    expect(handler.mock.calls[0]?.[1]).toBe(handler.mock.calls[1]?.[1])
+    expect(handler.mock.calls[0]?.[1]).toMatchObject({
+      needEscaped: false,
+      generateMap: false,
+    })
+  })
+
   it('detects eval calls via isEvalPath helper', () => {
     const ast = parse('eval("foo"); other("bar")', { sourceType: 'module' as const })
     const calls: NodePath<CallExpression>[] = []

packages/weapp-tailwindcss/test/js/sourceAnalysis.test.ts

@@ -81,4 +81,18 @@ describe('sourceAnalysis helpers', () => {
     expect(reExports).toHaveLength(1)
     expect(reExports[0]!.source).toBe('./foo?transformed')
   })
+
+  it('returns early when no replacement entries are provided', () => {
+    const source = `import foo from './foo'`
+    const ast = babelParse(source, { sourceType: 'module' as const })
+    const analysis = analyzeSource(ast, {})
+    const originalImports = analysis.walker.imports
+    const originalImportCount = analysis.walker.imports.size
+
+    const tokens = collectModuleSpecifierReplacementTokens(analysis, {})
+
+    expect(tokens).toEqual([])
+    expect(analysis.walker.imports).toBe(originalImports)
+    expect(analysis.walker.imports.size).toBe(originalImportCount)
+  })
 })