Function resolveDependencyTree

server/utils/dependency-resolver.ts:115–200

(
  rootName: string,
  rootVersion: string,
  options: { trackDepth?: boolean } = {},
)

 * Uses level-by-level BFS to ensure correct depth assignment when trackDepth is enabled.
 */
export async function resolveDependencyTree(
  rootName: string,
  rootVersion: string,
  options: { trackDepth?: boolean } = {},
): Promise<Map<string, ResolvedPackage>> {
  const resolved = new Map<string, ResolvedPackage>()
  const seen = new Set<string>()

  // Process level by level for correct depth tracking
  // Each entry includes the path of package names leading to this dependency
  let currentLevel = new Map<string, { range: string; optional: boolean; path: string[] }>([
    [rootName, { range: rootVersion, optional: false, path: [] }],
  ])
  let level = 0

  while (currentLevel.size > 0) {
    const nextLevel = new Map<string, { range: string; optional: boolean; path: string[] }>()

    // Mark all packages in current level as seen before processing
    for (const name of currentLevel.keys()) {
      seen.add(name)
    }

    // Process current level with concurrency limit
    const entries = [...currentLevel.entries()]
    await mapWithConcurrency(
      entries,
      async ([name, { range, optional, path }]) => {
        const packument = await fetchPackument(name)
        if (!packument) return

        const versions = Object.keys(packument.versions)
        const version = resolveVersion(range, versions)
        if (!version) return

        const versionData = packument.versions[version]
        if (!versionData) return

        if (!matchesPlatform(versionData)) return

        const size = (versionData.dist as { unpackedSize?: number })?.unpackedSize ?? 0
        const tarballUrl = versionData.dist?.tarball ?? ''
        const key = `${name}@${version}`

        // Build path for this package (path to parent + this package with version)
        const currentPath = [...path, `${name}@${version}`]

        if (!resolved.has(key)) {
          const pkg: ResolvedPackage = { name, version, size, tarballUrl, optional }
          if (options.trackDepth) {
            pkg.depth = level === 0 ? 'root' : level === 1 ? 'direct' : 'transitive'
            pkg.path = currentPath
          }
          if (versionData.deprecated) {
            pkg.deprecated = versionData.deprecated
          }
          resolved.set(key, pkg)
        }