Function extractSnapshot

packages/tools/api-diff/src/Snapshot.ts:722–844

(
  options: ExtractSnapshotOptions,
  discovered: DiscoveryResult,
  path: Path.Path
)

  })

const extractSnapshot = (
  options: ExtractSnapshotOptions,
  discovered: DiscoveryResult,
  path: Path.Path
): ApiSnapshot => {
  const diagnostics: Array<SnapshotDiagnostic> = discovered.missing.map((module) => ({
    code: "missing-entrypoint",
    message: `Consumer-visible declaration entrypoint not found: ${module}`,
    module
  }))
  if (diagnostics.length > 0) {
    throw snapshotExtractionError(diagnostics)
  }
  const program = ts.createProgram({
    rootNames: discovered.entrypoints.map((entrypoint) => entrypoint.declarationFile),
    options: {
      module: ts.ModuleKind.NodeNext,
      moduleResolution: ts.ModuleResolutionKind.NodeNext,
      target: ts.ScriptTarget.ESNext,
      skipLibCheck: true,
      types: [],
      noEmit: true
    }
  })
  // The declarations were already checked by the branch-native build. Re-checking
  // them with the pinned extractor compiler would introduce lib-version drift.
  const compilerDiagnostics = program.getSyntacticDiagnostics()
    .filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)
  if (compilerDiagnostics.length > 0) {
    throw snapshotExtractionError(compilerDiagnostics.map((diagnostic) => ({
      code: `typescript-${diagnostic.code}`,
      message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
      source: diagnostic.file === undefined
        ? undefined
        : sourceLocation(path, options.repoRoot, diagnostic.file)
    })))
  }
  const checker = program.getTypeChecker()
  const pending = new Map<string, PendingEntity>()
  for (const entrypoint of discovered.entrypoints) {
    const source = program.getSourceFile(entrypoint.declarationFile)
    const symbol = source === undefined ? undefined : checker.getSymbolAtLocation(source)
    if (source === undefined || symbol === undefined) {
      diagnostics.push({
        code: "missing-module-symbol",
        message: `Could not load module symbol for ${entrypoint.module}`,
        module: entrypoint.module
      })
      continue
    }
    collectExports(checker, symbol, entrypoint, pending)
  }

  const entities: Array<ApiEntity> = []
  const publicSymbols = new Map<string, string>()
  for (const [key, pendingEntity] of pending) {
    const route = canonicalRoute(pendingEntity.routes)
    publicSymbols.set(key, `${route.module}#${route.path.join(".")}#${pendingEntity.bucket}`)