perf: cleanup context for non-eager build

sxzz · sxzz · commit a0b44b30b3f3 · 2025-06-09T01:34:19.000+08:00
diff --git a/.gitignore b/.gitignore
@@ -4,5 +4,6 @@ dist
 *.log
 .DS_Store
 .eslintcache
+*.tgz
 
 temp
diff --git a/package.json b/package.json
@@ -38,6 +38,7 @@
     "typecheck": "tsc --noEmit",
     "format": "prettier --cache --write .",
     "release": "bumpp && pnpm publish",
+    "prepack": "pnpm run build",
     "prepublishOnly": "pnpm run build"
   },
   "peerDependencies": {
diff --git a/src/generate.ts b/src/generate.ts
@@ -16,7 +16,7 @@ import {
   RE_VUE,
 } from './filename.ts'
 import type { OptionsResolved } from './options.ts'
-import type { TscOptions, TscResult } from './tsc/index.ts'
+import type { TscContext, TscOptions, TscResult } from './tsc/index.ts'
 import type { TscFunctions } from './tsc/worker.ts'
 import type { Plugin, SourceMapInput } from 'rolldown'
 
@@ -80,7 +80,8 @@ export function createGeneratePlugin({
 
   let childProcess: ChildProcess | undefined
   let rpc: BirpcReturn<TscFunctions> | undefined
-  let tscEmit: (options: TscOptions) => TscResult
+  let tscModule: typeof import('./tsc/index.ts')
+  let tscContext: TscContext | undefined
   let tsgoDist: string | undefined
 
   if (!tsgo && parallel) {
@@ -123,7 +124,8 @@ export function createGeneratePlugin({
           { stdio: 'inherit' },
         )
       } else if (!parallel && (!isolatedDeclarations || vue)) {
-        ;({ tscEmit } = await import('./tsc/index.ts'))
+        tscModule = await import('./tsc/index.ts')
+        tscContext = eager ? undefined : tscModule.createContext()
       }
 
       if (!Array.isArray(options.input)) {
@@ -257,12 +259,13 @@ export function createGeneratePlugin({
             entries,
             id,
             vue,
+            context: tscContext,
           }
           let result: TscResult
           if (parallel) {
             result = await rpc!.tscEmit(options)
           } else {
-            result = tscEmit(options)
+            result = tscModule.tscEmit(options)
           }
           if (result.error) {
             return this.error(result.error)
@@ -297,8 +300,8 @@ export function createGeneratePlugin({
       childProcess?.kill()
       if (tsgoDist) {
         await rm(tsgoDist, { recursive: true, force: true }).catch(() => {})
-        tsgoDist = undefined
       }
+      tscContext = tsgoDist = undefined
     },
   }
 }
diff --git a/src/tsc/index.ts b/src/tsc/index.ts
@@ -1,15 +1,42 @@
 import path from 'node:path'
 import Debug from 'debug'
 import ts from 'typescript'
-import { fsSystem, memorySystem } from './system.ts'
+import { createFsSystem, createMemorySystem } from './system.ts'
 import { createVueProgramFactory } from './vue.ts'
 import type { TsConfigJson } from 'get-tsconfig'
 import type { SourceMapInput } from 'rolldown'
 
+export interface TscContext {
+  programs: ts.Program[]
+  files: Map<string, string>
+}
+
+export interface TscModule {
+  program: ts.Program
+  file: ts.SourceFile
+}
+
+export interface TscOptions {
+  tsconfig?: string
+  tsconfigRaw: TsConfigJson
+  cwd: string
+  incremental: boolean
+  entries?: string[]
+  id: string
+  vue?: boolean
+  context?: TscContext
+}
+
 const debug = Debug('rolldown-plugin-dts:tsc')
 debug(`loaded typescript: ${ts.version}`)
 
-const programs: ts.Program[] = []
+export function createContext(): TscContext {
+  const programs: ts.Program[] = []
+  const files = new Map<string, string>()
+  return { programs, files }
+}
+
+const globalContext: TscContext = createContext()
 
 const formatHost: ts.FormatDiagnosticsHost = {
   getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
@@ -32,24 +59,9 @@ const defaultCompilerOptions: ts.CompilerOptions = {
   moduleResolution: ts.ModuleResolutionKind.Bundler,
 }
 
-export interface TscModule {
-  program: ts.Program
-  file: ts.SourceFile
-}
-
-export interface TscOptions {
-  tsconfig?: string
-  tsconfigRaw: TsConfigJson
-  cwd: string
-  incremental: boolean
-  entries?: string[]
-  id: string
-  vue?: boolean
-}
-
 function createOrGetTsModule(options: TscOptions): TscModule {
-  const { id, entries } = options
-  const program = programs.find((program) => {
+  const { id, entries, context = globalContext } = options
+  const program = context.programs.find((program) => {
     const roots = program.getRootFileNames()
     if (entries) {
       return entries.every((entry) => roots.includes(entry))
@@ -67,7 +79,7 @@ function createOrGetTsModule(options: TscOptions): TscModule {
   const module = createTsProgram(options)
   debug(`created program for module: ${id}`)
 
-  programs.push(module.program)
+  context.programs.push(module.program)
   return module
 }
 
@@ -80,9 +92,15 @@ function createOrGetTsModule(options: TscOptions): TscModule {
  * changes) the build will be super fast. If `incremental` is `false`, the
  * `.tsbuildinfo` file will only be written to the memory.
  */
-function buildSolution(tsconfig: string, incremental: boolean) {
+function buildSolution(
+  tsconfig: string,
+  incremental: boolean,
+  context: TscContext,
+) {
   debug(`building projects for ${tsconfig} with incremental: ${incremental}`)
-  const system = incremental ? fsSystem : memorySystem
+  const system = (incremental ? createFsSystem : createMemorySystem)(
+    context.files,
+  )
 
   const host = ts.createSolutionBuilderHost(system)
   const builder = ts.createSolutionBuilder(host, [tsconfig], {
@@ -105,7 +123,9 @@ function createTsProgram({
   incremental,
   vue,
   cwd,
+  context = globalContext,
 }: TscOptions): TscModule {
+  const fsSystem = createFsSystem(context.files)
   const parsedCmd = ts.parseJsonConfigFileContent(
     tsconfigRaw,
     fsSystem,
@@ -114,7 +134,7 @@ function createTsProgram({
 
   // If the tsconfig has project references, build the project tree.
   if (tsconfig && parsedCmd.projectReferences?.length) {
-    buildSolution(tsconfig, incremental)
+    buildSolution(tsconfig, incremental, context)
   }
 
   const compilerOptions: ts.CompilerOptions = {
diff --git a/src/tsc/system.ts b/src/tsc/system.ts
@@ -3,71 +3,75 @@ import ts from 'typescript'
 
 const debug = Debug('rolldown-plugin-dts:tsc-system')
 
-const files: Map<string, string> = new Map()
+/**
+ * A system that writes files to both memory and disk. It will try read files
+ * from memory firstly and fallback to disk if not found.
+ */
+export function createFsSystem(files: Map<string, string>): ts.System {
+  return {
+    ...ts.sys,
 
-// A system that writes files to both memory and disk. It will try read files
-// from memory firstly and fallback to disk if not found.ƒ
-export const fsSystem: ts.System = {
-  ...ts.sys,
+    // Hide the output of tsc by default
+    write(message: string): void {
+      debug(message)
+    },
 
-  // Hide the output of tsc by default
-  write(message: string): void {
-    debug(message)
-  },
+    // Copied from
+    // https://github.com/microsoft/TypeScript-Website/blob/b0e9a5c0/packages/typescript-vfs/src/index.ts#L571-L574
+    resolvePath(path) {
+      if (files.has(path)) {
+        return path
+      }
+      return ts.sys.resolvePath(path)
+    },
 
-  // Copied from
-  // https://github.com/microsoft/TypeScript-Website/blob/b0e9a5c0/packages/typescript-vfs/src/index.ts#L571C5-L574C7
-  resolvePath(path) {
-    if (files.has(path)) {
-      return path
-    }
-    return ts.sys.resolvePath(path)
-  },
+    // Copied from
+    // https://github.com/microsoft/TypeScript-Website/blob/b0e9a5c0/packages/typescript-vfs/src/index.ts#L532C1-L534C8
+    directoryExists(directory) {
+      if (Array.from(files.keys()).some((path) => path.startsWith(directory))) {
+        return true
+      }
+      return ts.sys.directoryExists(directory)
+    },
 
-  // Copied from
-  // https://github.com/microsoft/TypeScript-Website/blob/b0e9a5c0/packages/typescript-vfs/src/index.ts#L532C1-L534C8
-  directoryExists(directory) {
-    if (Array.from(files.keys()).some((path) => path.startsWith(directory))) {
-      return true
-    }
-    return ts.sys.directoryExists(directory)
-  },
+    fileExists(fileName) {
+      if (files.has(fileName)) {
+        return true
+      }
+      return ts.sys.fileExists(fileName)
+    },
 
-  fileExists(fileName) {
-    if (files.has(fileName)) {
-      return true
-    }
-    return ts.sys.fileExists(fileName)
-  },
+    readFile(fileName, ...args) {
+      if (files.has(fileName)) {
+        return files.get(fileName)
+      }
+      return ts.sys.readFile(fileName, ...args)
+    },
 
-  readFile(fileName, ...args) {
-    if (files.has(fileName)) {
-      return files.get(fileName)
-    }
-    return ts.sys.readFile(fileName, ...args)
-  },
+    writeFile(path, data, ...args) {
+      files.set(path, data)
+      ts.sys.writeFile(path, data, ...args)
+    },
 
-  writeFile(path, data, ...args) {
-    files.set(path, data)
-    ts.sys.writeFile(path, data, ...args)
-  },
-
-  deleteFile(fileName, ...args) {
-    files.delete(fileName)
-    ts.sys.deleteFile?.(fileName, ...args)
-  },
+    deleteFile(fileName, ...args) {
+      files.delete(fileName)
+      ts.sys.deleteFile?.(fileName, ...args)
+    },
+  }
 }
 
 // A system that only writes files to memory. It will read files from both
 // memory and disk.
-export const memorySystem: ts.System = {
-  ...fsSystem,
+export function createMemorySystem(files: Map<string, string>): ts.System {
+  return {
+    ...createFsSystem(files),
 
-  writeFile(path, data) {
-    files.set(path, data)
-  },
+    writeFile(path, data) {
+      files.set(path, data)
+    },
 
-  deleteFile(fileName) {
-    files.delete(fileName)
-  },
+    deleteFile(fileName) {
+      files.delete(fileName)
+    },
+  }
 }
diff --git a/tests/tsc.test.ts b/tests/tsc.test.ts
@@ -99,12 +99,12 @@ describe('tsc', () => {
       cwd: tempDir,
       absolute: false,
     })
-    expect(tsBuildInfoFiles).toMatchInlineSnapshot(`
-    [
-      "dir1/tsconfig.1.tsbuildinfo",
-      "dir2/tsconfig.2.tsbuildinfo",
-    ]
-  `)
+    expect(tsBuildInfoFiles.sort()).toMatchInlineSnapshot(`
+      [
+        "dir1/tsconfig.1.tsbuildinfo",
+        "dir2/tsconfig.2.tsbuildinfo",
+      ]
+    `)
   })
 
   test('vue-sfc w/ ts-compiler', async () => {
