Function CheckPackages

src/api/check.ts:17–59

(options: CheckOptions, callbacks: CheckEventCallbacks = {})

}

export async function CheckPackages(options: CheckOptions, callbacks: CheckEventCallbacks = {}) {
  if (!options.force)
    await loadCache()

  // packages loading
  const packages = await loadPackages(options)
  callbacks.afterPackagesLoaded?.(packages)

  const privatePackageNames = packages
    .filter(i => i.private)
    .map(i => i.name)
    .filter(i => i)

  // to filter out private dependency in monorepo
  const filter = (dep: RawDep) => !privatePackageNames.includes(dep.name)

  let resolvedCount = 0
  const onDependencyResolved: DependencyResolvedCallback = (pkgName, name, progress, total) => {
    resolvedCount++
    callbacks.onDependencyResolved?.(pkgName, name, resolvedCount, total)
  }

  const queue = newQueue(options.concurrency || 10)

  await queueContext.run(queue, () => {
    // run all CheckSingleProject in parallel
    // the actual resolveDependencies within CheckSingleProject -> resolvePackage -> resolveDependencies is
    // actually limited by the queueContext/queue, so it won't overwhelm the npm meta server.
    return Promise.all(packages.map(async (pkg) => {
      callbacks.beforePackageStart?.(pkg)
      await CheckSingleProject(pkg, options, filter, { ...callbacks, onDependencyResolved })
      callbacks.afterPackageEnd?.(pkg)
    }))
  })

  callbacks.afterPackagesEnd?.(packages)

  await dumpCache()

  return {
    packages,
  }
}

async function CheckSingleProject(pkg: PackageMeta, options: CheckOptions, filter: DependencyFilter = () => true, callbacks: CheckEventCallbacks = {}) {
  await resolvePackage(pkg, options, filter, callbacks.onDependencyResolved)