Function scoreReport

packages/utils/src/lib/reports/scoring.ts:20–77

(report: Report)

}

export function scoreReport(report: Report): ScoredReport {
  const allScoredAuditsAndGroups = new Map<string, AuditReport | ScoredGroup>();

  const scoredPlugins = report.plugins.map(plugin => {
    const { groups, ...pluginProps } = plugin;

    plugin.audits.forEach(audit => {
      allScoredAuditsAndGroups.set(`${plugin.slug}-${audit.slug}-audit`, audit);
    });

    function groupScoreFn(ref: GroupRef) {
      const score = allScoredAuditsAndGroups.get(
        `${plugin.slug}-${ref.slug}-audit`,
      )?.score;
      if (score == null) {
        throw new GroupRefInvalidError(ref.slug, plugin.slug);
      }
      return score;
    }

    const scoredGroups =
      groups?.map(group => ({
        ...group,
        score: calculateScore(group.refs, groupScoreFn),
      })) ?? [];

    scoredGroups.forEach(group => {
      allScoredAuditsAndGroups.set(`${plugin.slug}-${group.slug}-group`, group);
    });

    return {
      ...pluginProps,
      ...(scoredGroups.length > 0 && { groups: scoredGroups }),
    };
  });

  function catScoreFn(ref: CategoryRef) {
    const key = `${ref.plugin}-${ref.slug}-${ref.type}`;
    const item = allScoredAuditsAndGroups.get(key);
    if (!item) {
      throw new Error(
        `Category has invalid ref - ${ref.type} with slug ${key} not found in ${ref.plugin} plugin`,
      );
    }
    return item.score;
  }

  const scoredCategories = report.categories?.map(category => ({
    ...category,
    score: calculateScore(category.refs, catScoreFn),
  }));

  return {
    ...deepClone(report),
    plugins: scoredPlugins,
    categories: scoredCategories,
  };
}