perf(coverage-v8): skip unnecessary coverage conversion (#1298)

Author: 9aoy

knip.jsonc

@@ -94,9 +94,15 @@
         "tests/**/*.ts",
       ],
     },
+    "packages/coverage-v8": {
+      "entry": [
+        // Test files
+        "tests/**/*.ts",
+      ],
+    },
     // No explicit entry needed for the following packages — knip auto-infers from package.json exports:
-    // packages/browser-react, packages/adapter-rslib,
-    // packages/adapter-rsbuild, packages/adapter-rspack
+    // packages/browser-react, packages/adapter-rslib, packages/adapter-rsbuild,
+    // packages/adapter-rspack
 
     "packages/vscode": {
       "entry": [

packages/coverage-v8/package.json

@@ -15,6 +15,7 @@
   ],
   "scripts": {
     "build": "rslib build",
+    "test": "rstest",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {

packages/coverage-v8/rstest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from '@rstest/core';
+import { withRslibConfig } from '../adapter-rslib/src';
+
+export default defineConfig({
+  extends: withRslibConfig({
+    cwd: __dirname,
+  }),
+  name: 'coverage-v8',
+  setupFiles: ['../../scripts/rstest.setup.ts'],
+  include: ['<rootDir>/tests/**/*.test.ts'],
+  globals: true,
+  source: {
+    tsconfigPath: './tests/tsconfig.json',
+  },
+  tools: {
+    rspack: {
+      watchOptions: {
+        ignored: /test-temp-.*/,
+      },
+    },
+  },
+});

packages/coverage-v8/src/provider.ts

@@ -33,6 +33,10 @@ export class CoverageProvider implements RstestCoverageProvider {
   private isMatch: (filePath: string) => boolean;
   private isIncluded: (filePath: string) => boolean;
   private isExcluded: (filePath: string) => boolean;
+  private dictLookupCache = new WeakMap<
+    Record<string, string>,
+    Map<string, string>
+  >();
 
   constructor(
     public options: NormalizedCoverageOptions,
@@ -94,21 +98,33 @@ export class CoverageProvider implements RstestCoverageProvider {
     if (!dict) return undefined;
     if (dict[filePath]) return dict[filePath];
 
-    for (const [key, value] of Object.entries(dict)) {
-      const normalizedKey = key.replace(/\\/g, '/');
-      if (normalizedKey === filePath) return value;
-      if (
-        filePath.startsWith('/private/') &&
-        normalizedKey === filePath.slice('/private'.length)
-      ) {
-        return value;
-      }
-      if (normalizedKey.toLowerCase() === filePath.toLowerCase()) {
-        return value;
+    let lookup = this.dictLookupCache.get(dict);
+    if (!lookup) {
+      lookup = new Map();
+      for (const [key, value] of Object.entries(dict)) {
+        const normalizedKey = key.replace(/\\/g, '/');
+        if (!lookup.has(normalizedKey)) {
+          lookup.set(normalizedKey, value);
+        }
+
+        const lowerKey = normalizedKey.toLowerCase();
+        if (!lookup.has(lowerKey)) {
+          lookup.set(lowerKey, value);
+        }
       }
+      this.dictLookupCache.set(dict, lookup);
+    }
+
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const directMatch = lookup.get(normalizedPath);
+    if (directMatch) return directMatch;
+
+    if (filePath.startsWith('/private/')) {
+      const privateMatch = lookup.get(filePath.slice('/private'.length));
+      if (privateMatch) return privateMatch;
     }
 
-    return undefined;
+    return lookup.get(normalizedPath.toLowerCase());
   }
 
   private isNodeModulesPath(filePath: string): boolean {
@@ -177,6 +193,20 @@ export class CoverageProvider implements RstestCoverageProvider {
     );
   }
 
+  private hasInlineSourceMap(code: string): boolean {
+    return /[#@]\s*sourceMappingURL\s*=\s*data:application\/json(?:;[^'",\s]*)*,/i.test(
+      code,
+    );
+  }
+
+  private async hasInlineSourceMapOnDisk(filePath: string): Promise<boolean> {
+    try {
+      return this.hasInlineSourceMap(await fs.readFile(filePath, 'utf-8'));
+    } catch (_err) {
+      return false;
+    }
+  }
+
   private async getTransformedSource(
     filePath: string,
     options?: {
@@ -312,11 +342,27 @@ export class CoverageProvider implements RstestCoverageProvider {
 
         if (!this.isMatch(filePath)) return;
 
-        const hasSourceMap = Boolean(
-          this.findInDict(options?.sourceMaps, filePath),
+        const sourceMapStr = this.findInDict(options?.sourceMaps, filePath);
+        const assetSource = this.findInDict(options?.assetFiles, filePath);
+        let hasSourceMap = Boolean(
+          sourceMapStr || (assetSource && this.hasInlineSourceMap(assetSource)),
         );
 
-        if (!this.shouldProcessEntry(filePath) && !hasSourceMap) return;
+        if (!this.shouldProcessEntry(filePath) && !hasSourceMap) {
+          hasSourceMap = await this.hasInlineSourceMapOnDisk(filePath);
+          if (!hasSourceMap) return;
+        }
+
+        if (!hasSourceMap) {
+          const originalTestPath = this.toProjectRelativePath(filePath);
+          if (
+            this.isExcluded(originalTestPath) ||
+            !this.isIncluded(originalTestPath)
+          ) {
+            hasSourceMap = await this.hasInlineSourceMapOnDisk(filePath);
+            if (!hasSourceMap) return;
+          }
+        }
 
         try {
           const istanbulData = await this.convertWithAst(