rolldown-get-packages.ts

import type { PackageInfo } from '../../../shared/types'
import type { RolldownEventsReader } from '../../rolldown/events-reader'
import { readProjectManifestOnly } from '@pnpm/read-project-manifest'
import { defineRpcFunction } from '@vitejs/devtools-kit'
import { getPackageDirPath, isNodeModulePath } from '../../../shared/utils/filepath'
import { getLogsManager } from '../utils'

export async function getPackagesManifest(reader: RolldownEventsReader) {
  const modulesMap = reader.manager.modules
  const chunks = Array.from(reader.manager.chunks.values())
  const packagesManifest = new Map<string, PackageInfo>()

  const getImporters = (path: string, packageDir: string, visited = new Set<string>()): string[] => {
    const importers = modulesMap.get(path)?.importers || []
    const result: string[] = []

    for (const importer of importers) {
      if (visited.has(importer))
        continue

      visited.add(importer)
      const module = modulesMap.get(importer)
      const imports = module?.imports?.map(i => i.module_id) || []

      if (imports.some(i => getPackageDirPath(i) === packageDir)) {
        result.push(importer)
      }

      result.push(...getImporters(importer, packageDir, visited))
    }

    return result
  }

  const packages = chunks.map(chunk => chunk.modules.map(module => module)).flat().filter(isNodeModulePath).map((p) => {
    const module = modulesMap.get(p)
    const moduleBuildMetrics = module?.build_metrics
    return {
      path: p,
      dir: getPackageDirPath(p),
      transformedCodeSize: moduleBuildMetrics?.transforms[moduleBuildMetrics?.transforms.length - 1]?.transformed_code_size ?? 0,
    }
  })
  await Promise.all(packages.map(async (p) => {
    let packageKey = ''
    let manifest = null

    try {
      manifest = await readProjectManifestOnly(p.dir)
      packageKey = `${manifest.name!}@${manifest.version!}`
    }
    catch (err: any) {
      if (err?.code === 'ERR_PNPM_NO_IMPORTER_MANIFEST_FOUND') {
        packageKey = `${p.dir}`
      }
      else {
        throw err
      }
    }
    const packageInfo = packagesManifest.get(packageKey)
    const importers = getImporters(p.path, p.dir).map(i => ({ path: i, version: '' }))
    if (packageInfo) {
      packagesManifest.set(packageKey, {
        ...packageInfo,
        files: [...packageInfo.files, {
          path: p.path,
          transformedCodeSize: p.transformedCodeSize,
          importers,
        }],
        transformedCodeSize: packageInfo.transformedCodeSize + p.transformedCodeSize,
      })
    }
    else {
      packagesManifest.set(packageKey, {
        name: manifest?.name || p.dir,
        version: manifest?.version || '(unknown)',
        dir: p.dir,
        files: [{
          path: p.path,
          transformedCodeSize: p.transformedCodeSize,
          importers,
        }],
        transformedCodeSize: p.transformedCodeSize,
      })
    }
  }))
  return packagesManifest
}

export const rolldownGetPackages = defineRpcFunction({
  name: 'vite:rolldown:get-packages',
  type: 'query',
  jsonSerializable: true,
  cacheable: true,
  setup: (context) => {
    const manager = getLogsManager(context)
    return {
      handler: async ({ session }: { session: string }) => {
        const reader = await manager.loadSession(session)
        const modulesMap = reader.manager.modules
        const duplicatePackagesMap = new Map<string, number>()
        const packagesManifest = await getPackagesManifest(reader)

        const normalizedPackages = await Promise.all(
          Array.from<PackageInfo>(packagesManifest.values())
            .map((p) => {
              duplicatePackagesMap.set(p.name, (duplicatePackagesMap.get(p.name) ?? 0) + 1)
              return {
                ...p,
                type: p.files.some(f => modulesMap.get(f.path)?.importers?.some(i => i.includes(reader.meta!.cwd))) ? 'direct' : 'transitive',
              }
            })
            .map(async (p) => {
              const duplicated = duplicatePackagesMap.get(p.name)! > 1
              let files = p.files
              if (duplicated) {
                files = await Promise.all(files.map(async (f) => {
                  const importers = await Promise.all(f.importers.map(async (i) => {
                    let manifest = null
                    try {
                      if (isNodeModulePath(i.path)) {
                        manifest = await readProjectManifestOnly(getPackageDirPath(i.path))
                      }
                    }
                    catch (err: any) {
                      if (err?.code !== 'ERR_PNPM_NO_IMPORTER_MANIFEST_FOUND') {
                        throw err
                      }
                    }
                    return { ...i, version: manifest?.version ?? '' }
                  }))
                  return { ...f, importers }
                }))
              }
              return {
                ...p,
                duplicated,
                files,
              }
            }),
        )
        return normalizedPackages.filter(i => !!i.transformedCodeSize)
      },
    }
  },
})