Function diffSnapshots

packages/tools/api-diff/src/Diff.ts:399–504

(base: ApiSnapshot, head: ApiSnapshot)

}

export const diffSnapshots = (base: ApiSnapshot, head: ApiSnapshot): ApiDiff => {
  const unmatchedBase = new Map(base.entities.map((entity) => [entity.id, entity]))
  const unmatchedHead = new Map(head.entities.map((entity) => [entity.id, entity]))
  const matches: Array<Match> = []
  const suggestedMatches: Array<Match> = []

  const addMatch = (
    baseEntity: ApiEntity | undefined,
    headEntity: ApiEntity | undefined,
    details: Omit<Match, "base" | "head">
  ): boolean => {
    if (
      baseEntity === undefined || headEntity === undefined ||
      !unmatchedBase.has(baseEntity.id) || !unmatchedHead.has(headEntity.id)
    ) {
      return false
    }
    unmatchedBase.delete(baseEntity.id)
    unmatchedHead.delete(headEntity.id)
    matches.push({ base: baseEntity, head: headEntity, ...details })
    return true
  }

  for (const baseEntity of unmatchedBase.values()) {
    addMatch(baseEntity, unmatchedHead.get(baseEntity.id), {
      confidence: 1,
      authoritative: true
    })
  }

  const headGroups = groupEntities(unmatchedHead.values())
  for (const baseGroup of groupEntities(unmatchedBase.values())) {
    const ranked = headGroups
      .filter((group) =>
        groupName(group) === groupName(baseGroup) ||
        group.module === baseGroup.module ||
        baseGroup.entities.some((baseEntity) =>
          group.entities.some((headEntity) =>
            baseEntity.bucket === headEntity.bucket &&
            baseEntity.fingerprint === headEntity.fingerprint
          )
        )
      )
      .map((group) => ({ group, score: groupSimilarity(baseGroup, group) }))
      .filter(({ score }) => score > 0)
      .sort((left, right) =>
        right.score - left.score ||
        left.group.module.localeCompare(right.group.module) ||
        left.group.path.join(".").localeCompare(right.group.path.join("."))
      )
    const best = ranked[0]
    const next = ranked[1]
    if (best === undefined || best.score < 0.5 || (next !== undefined && best.score - next.score < 0.05)) {
      continue
    }
    for (const baseEntity of baseGroup.entities) {
      const headEntity = best.group.entities.find((candidate) => candidate.bucket === baseEntity.bucket)
      if (headEntity !== undefined) {