@mui/internal-bundle-size-checker 1.0.0

package/src/configLoader.js

@@ -0,0 +1,189 @@
+/**
+ * Utility to load the bundle-size-checker configuration
+ */
+
+import fs from 'fs';
+import path from 'path';
+import envCi from 'env-ci';
+
+/**
+ * Attempts to load and parse a single config file
+ * @param {string} configPath - Path to the configuration file
+ * @returns {Promise<BundleSizeCheckerConfig | null>} The parsed config or null if file doesn't exist
+ * @throws {Error} If the file exists but has invalid format
+ */
+async function loadConfigFile(configPath) {
+  try {
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+
+    // Dynamic import for ESM
+    const configUrl = new URL(`file://${configPath}`);
+    let { default: config } = await import(configUrl.href);
+
+    // Handle configs that might be Promise-returning functions
+    if (config instanceof Promise) {
+      config = await config;
+    } else if (typeof config === 'function') {
+      config = await config();
+    }
+
+    if (!config.entrypoints || !Array.isArray(config.entrypoints)) {
+      throw new Error('Configuration must include an entrypoints array');
+    }
+
+    return config;
+  } catch (error) {
+    console.error(`Error loading config from ${configPath}:`, error);
+    throw error; // Re-throw to indicate failure
+  }
+}
+
+/**
+ * Validates and normalizes an upload configuration object
+ * @param {UploadConfig} uploadConfig - The upload configuration to normalize
+ * @param {Object} ciInfo - CI environment information
+ * @param {string} [ciInfo.branch] - Branch name from CI environment
+ * @param {boolean} [ciInfo.isPr] - Whether this is a pull request from CI environment
+ * @param {string} [ciInfo.prBranch] - PR branch name from CI environment
+ * @param {string} [ciInfo.slug] - Repository slug from CI environment
+ * @returns {NormalizedUploadConfig} - Normalized upload config
+ * @throws {Error} If required fields are missing
+ */
+export function applyUploadConfigDefaults(uploadConfig, ciInfo) {
+  const { slug, branch: ciBranch, isPr, prBranch } = ciInfo;
+
+  // Get repo from config or environment
+  const repo = uploadConfig.repo || slug;
+  if (!repo) {
+    throw new Error(
+      'Missing required field: upload.repo. Please specify a repository (e.g., "mui/material-ui").',
+    );
+  }
+
+  // Get branch from config or environment
+  const branch = uploadConfig.branch || (isPr ? prBranch : ciBranch);
+  if (!branch) {
+    throw new Error('Missing required field: upload.branch. Please specify a branch name.');
+  }
+
+  // Return the normalized config
+  return {
+    repo,
+    branch,
+    isPullRequest:
+      uploadConfig.isPullRequest !== undefined
+        ? Boolean(uploadConfig.isPullRequest)
+        : Boolean(isPr),
+  };
+}
+
+/**
+ * Apply default values to the configuration using CI environment
+ * @param {BundleSizeCheckerConfig} config - The loaded configuration
+ * @returns {NormalizedBundleSizeCheckerConfig} Configuration with defaults applied
+ * @throws {Error} If required fields are missing
+ */
+function applyConfigDefaults(config) {
+  // Get environment CI information
+  /** @type {{ branch?: string, isPr?: boolean, prBranch?: string, slug?: string}} */
+  const ciInfo = envCi();
+
+  // Basic validation to ensure entries have the required structure
+  // More detailed validation will be done in the worker
+  for (const entry of config.entrypoints) {
+    if (typeof entry !== 'string' && (!entry || typeof entry !== 'object')) {
+      throw new Error('Each entry must be either a string or an object');
+    }
+  }
+
+  // Clone the config to avoid mutating the original
+  /** @type {NormalizedBundleSizeCheckerConfig} */
+  const result = {
+    entrypoints: config.entrypoints.map((entry, i) => {
+      if (typeof entry === 'string') {
+        // Transform string entries into object entries
+        const [importSrc, importName] = entry.split('#');
+        if (importName) {
+          // For entries like '@mui/material#Button', create an object with import and importedNames
+          return {
+            id: entry,
+            import: importSrc,
+            importedNames: [importName],
+          };
+        }
+        // For entries like '@mui/material', create an object with import only
+        return {
+          id: entry,
+          import: importSrc,
+        };
+      }
+
+      if (entry && typeof entry === 'object') {
+        // For existing object entries, return them as is
+        return entry;
+      }
+
+      throw new Error(
+        `Invalid entry format config.entrypoints[${i}]. Must be a string or an object.`,
+      );
+    }),
+    upload: null, // Default to disabled
+  };
+
+  // Handle different types of upload value
+  if (typeof config.upload === 'boolean') {
+    // If upload is false, leave as null
+    if (config.upload === false) {
+      return result;
+    }
+
+    // If upload is true, create empty object and apply defaults
+    if (!ciInfo.slug) {
+      throw new Error(
+        'Upload enabled but repository not found in CI environment. Please specify upload.repo in config.',
+      );
+    }
+
+    if (!ciInfo.branch && !(ciInfo.isPr && ciInfo.prBranch)) {
+      throw new Error(
+        'Upload enabled but branch not found in CI environment. Please specify upload.branch in config.',
+      );
+    }
+
+    // Apply defaults to an empty object
+    result.upload = applyUploadConfigDefaults({}, ciInfo);
+  } else if (config.upload) {
+    // It's an object, apply defaults
+    result.upload = applyUploadConfigDefaults(config.upload, ciInfo);
+  }
+
+  return result;
+}
+
+/**
+ * Attempts to load the config file from the given directory
+ * @param {string} rootDir - The directory to search for the config file
+ * @returns {Promise<NormalizedBundleSizeCheckerConfig>} A promise that resolves to the normalized config object
+ */
+export async function loadConfig(rootDir) {
+  const configPaths = [
+    path.join(rootDir, 'bundle-size-checker.config.js'),
+    path.join(rootDir, 'bundle-size-checker.config.mjs'),
+  ];
+
+  for (const configPath of configPaths) {
+    // eslint-disable-next-line no-await-in-loop
+    const config = await loadConfigFile(configPath);
+    if (config) {
+      // Apply defaults and return the config
+      return applyConfigDefaults(config);
+    }
+  }
+
+  // Error out if no config file exists
+  throw new Error(
+    'No bundle-size-checker configuration file found. Please create a bundle-size-checker.config.js or bundle-size-checker.config.mjs file in your project root.',
+  );
+}

package/src/defineConfig.js

@@ -0,0 +1,15 @@
+/**
+ * @typedef {Object} BundleSizeCheckerConfig
+ * @property {string[]} entrypoints - Array of entrypoints to check size for
+ */
+
+/**
+ * Define a configuration for the bundle size checker.
+ * This is just a pass-through function for better TypeScript typing.
+ *
+ * @param {BundleSizeCheckerConfig} config - Configuration object
+ * @returns {BundleSizeCheckerConfig} The configuration object
+ */
+export default function defineConfig(config) {
+  return config;
+}

package/src/fetchSnapshot.js

@@ -0,0 +1,36 @@
+/**
+ *
+ * @param {string} repo - The name of the repository e.g. 'mui/material-ui'
+ * @param {string} sha - The commit SHA
+ * @returns {Promise<import('./sizeDiff').SizeSnapshot>} - The size snapshot data
+ */
+export async function fetchSnapshot(repo, sha) {
+  const urlsToTry = [
+    `https://s3.eu-central-1.amazonaws.com/mui-org-ci/artifacts/${repo}/${sha}/size-snapshot.json`,
+  ];
+
+  if (repo === 'mui/material-ui') {
+    urlsToTry.push(
+      `https://s3.eu-central-1.amazonaws.com/mui-org-ci/artifacts/master/${sha}/size-snapshot.json`,
+    );
+  }
+
+  let lastError;
+  for (const url of urlsToTry) {
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      const response = await fetch(url);
+      if (!response.ok) {
+        lastError = new Error(`Failed to fetch "${url}", HTTP ${response.status}`);
+        continue;
+      }
+
+      return response.json();
+    } catch (error) {
+      lastError = error;
+      continue;
+    }
+  }
+
+  throw new Error(`Failed to fetch snapshot`, { cause: lastError });
+}

package/src/formatUtils.js

@@ -0,0 +1,28 @@
+/**
+ * Format utilities for consistent display of sizes and percentages
+ */
+
+// Formatter for byte sizes (absolute values) - no sign
+export const byteSizeFormatter = new Intl.NumberFormat(undefined, {
+  style: 'unit',
+  unit: 'byte',
+  notation: 'compact',
+  unitDisplay: 'narrow',
+  maximumSignificantDigits: 3,
+  minimumSignificantDigits: 1,
+});
+
+// Formatter for size changes - always show sign
+export const byteSizeChangeFormatter = new Intl.NumberFormat(undefined, {
+  ...byteSizeFormatter.resolvedOptions(),
+  signDisplay: 'exceptZero',
+});
+
+// Formatter for percentage display
+export const displayPercentFormatter = new Intl.NumberFormat(undefined, {
+  style: 'percent',
+  signDisplay: 'exceptZero',
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2,
+  useGrouping: true,
+});

package/src/index.js

@@ -0,0 +1,20 @@
+import defineConfig from './defineConfig.js';
+import { loadConfig } from './configLoader.js';
+import { calculateSizeDiff } from './sizeDiff.js';
+import { renderMarkdownReport, renderMarkdownReportContent } from './renderMarkdownReport.js';
+import { fetchSnapshot } from './fetchSnapshot.js';
+
+export {
+  defineConfig,
+  loadConfig,
+  calculateSizeDiff,
+  renderMarkdownReport,
+  renderMarkdownReportContent,
+  fetchSnapshot,
+};
+
+/**
+ * @typedef {import('./sizeDiff.js').Size} Size
+ * @typedef {import('./sizeDiff.js').SizeSnapshot} SizeSnapshot
+ * @typedef {import('./sizeDiff.js').ComparisonResult} ComparisonResult
+ */

package/src/renderMarkdownReport.js

@@ -0,0 +1,200 @@
+/**
+ * @typedef {import('./sizeDiff.js').Size} Size
+ * @typedef {import('./sizeDiff.js').SizeSnapshot} SizeSnapshot
+ * @typedef {import('./sizeDiff.js').ComparisonResult} ComparisonResult
+ */
+
+import { calculateSizeDiff } from './sizeDiff.js';
+import { fetchSnapshot } from './fetchSnapshot.js';
+import { displayPercentFormatter, byteSizeChangeFormatter } from './formatUtils.js';
+/**
+ *
+ * @param {'▲' | '▼'} symbol
+ * @param {'yellow'|'red'|'blue'|'green'} color
+ * @returns
+ */
+function formatSymbol(symbol, color) {
+  return `<sup>\${\\tiny{\\color{${color}}${symbol}}}$</sup>`;
+}
+
+/**
+ * Generates a symbol based on the relative change value.
+ * @param {number|null} relative - The relative change as a Number
+ * @returns {string} Formatted size change string with symbol
+ */
+function getChangeIcon(relative) {
+  if (relative === null) {
+    return formatSymbol('▲', 'yellow');
+  }
+  if (relative === -1) {
+    return formatSymbol('▼', 'blue');
+  }
+  if (relative < 0) {
+    return formatSymbol('▼', 'green');
+  }
+  if (relative > 0) {
+    return formatSymbol('▲', 'red');
+  }
+  return ' ';
+}
+
+/**
+ * Formats the relative change value for display.
+ * @param {number|null} value - The relative change as a Number
+ * @returns {string} Formatted relative change string
+ */
+function formatRelativeChange(value) {
+  if (value === null) {
+    return 'new';
+  }
+  if (value === -1) {
+    return 'removed';
+  }
+  return displayPercentFormatter.format(value);
+}
+
+/**
+ * Generates a user-readable string from a percentage change.
+ * @param {number} absolute - The absolute change as a Number
+ * @param {number|null} relative - The relative change as a Number
+ * @returns {string} Formatted percentage string with emoji
+ */
+function formatChange(absolute, relative) {
+  const formattedAbsolute = byteSizeChangeFormatter.format(absolute);
+  const formattedChange = formatRelativeChange(relative);
+  return `${getChangeIcon(relative)}${formattedAbsolute}<sup>(${formattedChange})</sup>`;
+}
+
+/**
+ * Generates emphasized change text for a single bundle
+ * @param {Size} entry - Bundle entry
+ * @returns {string} Formatted change text
+ */
+function generateEmphasizedChange({ id: bundle, parsed, gzip }) {
+  // increase might be a bug fix which is a nice thing. reductions are always nice
+  const changeParsed = formatChange(parsed.absoluteDiff, parsed.relativeDiff);
+  const changeGzip = formatChange(gzip.absoluteDiff, gzip.relativeDiff);
+
+  return `**${bundle}**&emsp;**parsed:**${changeParsed} **gzip:**${changeGzip}`;
+}
+
+/**
+ * Generates a Markdown report for bundle size changes
+ * @param {ComparisonResult} comparison - Comparison result from calculateSizeDiff
+ * @param {Object} [options] - Additional options
+ * @param {number} [options.visibleLimit=10] - Number of entries to show before collapsing
+ * @param {number} [options.parsedSizeChangeThreshold=300] - Threshold for parsed size change by which to show the entry
+ * @param {number} [options.gzipSizeChangeThreshold=100] - Threshold for gzipped size change by which to show the entry
+ * @returns {string} Markdown report
+ */
+export function renderMarkdownReportContent(
+  comparison,
+  { visibleLimit = 10, parsedSizeChangeThreshold = 300, gzipSizeChangeThreshold = 100 } = {},
+) {
+  let markdownContent = '';
+
+  markdownContent += `**Total Size Change:**${formatChange(
+    comparison.totals.totalParsed,
+    comparison.totals.totalParsedPercent,
+  )} - **Total Gzip Change:**${formatChange(
+    comparison.totals.totalGzip,
+    comparison.totals.totalGzipPercent,
+  )}\n`;
+
+  markdownContent += `Files: ${comparison.fileCounts.total} total (${
+    comparison.fileCounts.added
+  } added, ${comparison.fileCounts.removed} removed, ${comparison.fileCounts.changed} changed)\n\n`;
+
+  const changedEntries = comparison.entries.filter(
+    (entry) => Math.abs(entry.parsed.absoluteDiff) > 0 || Math.abs(entry.gzip.absoluteDiff) > 0,
+  );
+
+  const visibleEntries = [];
+  const hiddenEntries = [];
+
+  for (const entry of changedEntries) {
+    const { parsed, gzip } = entry;
+    const isSignificantChange =
+      Math.abs(parsed.absoluteDiff) > parsedSizeChangeThreshold ||
+      Math.abs(gzip.absoluteDiff) > gzipSizeChangeThreshold;
+    if (isSignificantChange && visibleEntries.length < visibleLimit) {
+      visibleEntries.push(entry);
+    } else {
+      hiddenEntries.push(entry);
+    }
+  }
+
+  const importantChanges = visibleEntries.map(generateEmphasizedChange);
+  const hiddenChanges = hiddenEntries.map(generateEmphasizedChange);
+
+  // Add important changes to markdown
+  if (importantChanges.length > 0) {
+    // Show the most significant changes first, up to the visible limit
+    const visibleChanges = importantChanges.slice(0, visibleLimit);
+    markdownContent += `${visibleChanges.join('\n')}`;
+  }
+
+  // If there are more changes, add them in a collapsible details section
+  if (hiddenChanges.length > 0) {
+    markdownContent += `\n<details>\n<summary>Show ${hiddenChanges.length} more bundle changes</summary>\n\n`;
+    markdownContent += `${hiddenChanges.join('\n')}\n\n`;
+    markdownContent += `</details>`;
+  }
+
+  return markdownContent;
+}
+
+/**
+ *
+ * @param {PrInfo} prInfo
+ * @param {string} [circleciBuildNumber] - The CircleCI build number
+ * @returns {URL}
+ */
+function getDetailsUrl(prInfo, circleciBuildNumber) {
+  const detailedComparisonUrl = new URL(
+    `https://frontend-public.mui.com/size-comparison/${prInfo.base.repo.full_name}/diff`,
+  );
+  detailedComparisonUrl.searchParams.set('prNumber', String(prInfo.number));
+  detailedComparisonUrl.searchParams.set('baseRef', prInfo.base.ref);
+  detailedComparisonUrl.searchParams.set('baseCommit', prInfo.base.sha);
+  detailedComparisonUrl.searchParams.set('headCommit', prInfo.head.sha);
+  if (circleciBuildNumber) {
+    detailedComparisonUrl.searchParams.set('circleCIBuildNumber', circleciBuildNumber);
+  }
+  return detailedComparisonUrl;
+}
+
+/**
+ *
+ * @param {PrInfo} prInfo
+ * @param {string} [circleciBuildNumber] - The CircleCI build number
+ * @returns {Promise<string>} Markdown report
+ */
+export async function renderMarkdownReport(prInfo, circleciBuildNumber) {
+  let markdownContent = '';
+
+  const baseCommit = prInfo.base.sha;
+  const prCommit = prInfo.head.sha;
+  const repo = prInfo.base.repo.full_name;
+  const [baseSnapshot, prSnapshot] = await Promise.all([
+    fetchSnapshot(repo, baseCommit).catch((error) => {
+      console.error(`Error fetching base snapshot: ${error}`);
+      return null;
+    }),
+    fetchSnapshot(repo, prCommit),
+  ]);
+
+  if (!baseSnapshot) {
+    markdownContent += `_:no_entry_sign: No bundle size snapshot found for base commit ${baseCommit}._\n\n`;
+  }
+
+  const sizeDiff = calculateSizeDiff(baseSnapshot ?? {}, prSnapshot);
+
+  const report = renderMarkdownReportContent(sizeDiff);
+
+  markdownContent += report;
+
+  markdownContent += `\n\n[Details of bundle changes](${getDetailsUrl(prInfo, circleciBuildNumber)})`;
+
+  return markdownContent;
+}

package/src/sizeDiff.js

@@ -0,0 +1,199 @@
+/**
+ * @description Represents a single bundle size entry
+ * @typedef {Object} SizeSnapshotEntry
+ * @property {number} parsed
+ * @property {number} gzip
+ *
+ * @description Represents a single bundle size snapshot
+ * @typedef {Object.<string, SizeSnapshotEntry>} SizeSnapshot
+ *
+ * @description Represents a single bundle size comparison
+ * @typedef {Object} Size
+ * @property {string} id - Bundle identifier
+ * @property {Object} parsed - Parsed size information
+ * @property {number} parsed.previous - Previous parsed size
+ * @property {number} parsed.current - Current parsed size
+ * @property {number} parsed.absoluteDiff - Absolute difference in parsed size
+ * @property {number|null} parsed.relativeDiff - Relative difference in parsed size
+ * @property {Object} gzip - Gzipped size information
+ * @property {number} gzip.previous - Previous gzipped size
+ * @property {number} gzip.current - Current gzipped size
+ * @property {number} gzip.absoluteDiff - Absolute difference in gzipped size
+ * @property {number|null} gzip.relativeDiff - Relative difference in gzipped size
+ *
+ * @description Represents the comparison results
+ * @typedef {Object} ComparisonResult
+ * @property {Size[]} entries - Size entries for each bundle
+ * @property {Object} totals - Total size information
+ * @property {number} totals.totalParsed - Total parsed size difference
+ * @property {number} totals.totalGzip - Total gzipped size difference
+ * @property {number} totals.totalParsedPercent - Total parsed size percentage difference
+ * @property {number} totals.totalGzipPercent - Total gzipped size percentage difference
+ * @property {Object} fileCounts - File count information
+ * @property {number} fileCounts.added - Number of added files
+ * @property {number} fileCounts.removed - Number of removed files
+ * @property {number} fileCounts.changed - Number of changed files
+ * @property {number} fileCounts.total - Total number of files
+ */
+
+const nullSnapshot = { parsed: 0, gzip: 0 };
+
+/**
+ * Calculates size difference between two snapshots
+ *
+ * @param {SizeSnapshot} baseSnapshot - Base snapshot (previous)
+ * @param {SizeSnapshot} targetSnapshot - Target snapshot (current)
+ * @returns {ComparisonResult} Comparison result with entries, totals, and file counts
+ */
+export function calculateSizeDiff(baseSnapshot, targetSnapshot) {
+  const bundleKeys = Object.keys({ ...baseSnapshot, ...targetSnapshot });
+  /** @type {Size[]} */
+  const results = [];
+
+  // Track totals
+  let totalParsed = 0;
+  let totalGzip = 0;
+  let totalParsedPrevious = 0;
+  let totalGzipPrevious = 0;
+
+  // Track file counts
+  let addedFiles = 0;
+  let removedFiles = 0;
+  let changedFiles = 0;
+
+  bundleKeys.forEach((bundle) => {
+    const isNewBundle = !baseSnapshot[bundle];
+    const isRemovedBundle = !targetSnapshot[bundle];
+    const currentSize = targetSnapshot[bundle] || nullSnapshot;
+    const previousSize = baseSnapshot[bundle] || nullSnapshot;
+
+    // Update file counts
+    if (isNewBundle) {
+      addedFiles += 1;
+    } else if (isRemovedBundle) {
+      removedFiles += 1;
+    } else if (
+      currentSize.parsed !== previousSize.parsed ||
+      currentSize.gzip !== previousSize.gzip
+    ) {
+      changedFiles += 1;
+    }
+
+    const parsedDiff = currentSize.parsed - previousSize.parsed;
+    const gzipDiff = currentSize.gzip - previousSize.gzip;
+
+    // Calculate relative diffs with appropriate handling of new/removed bundles
+    let parsedRelativeDiff;
+    if (isNewBundle) {
+      parsedRelativeDiff = null;
+    } else if (isRemovedBundle) {
+      parsedRelativeDiff = -1;
+    } else if (previousSize.parsed) {
+      parsedRelativeDiff = currentSize.parsed / previousSize.parsed - 1;
+    } else {
+      parsedRelativeDiff = 0;
+    }
+
+    let gzipRelativeDiff;
+    if (isNewBundle) {
+      gzipRelativeDiff = null;
+    } else if (isRemovedBundle) {
+      gzipRelativeDiff = -1;
+    } else if (previousSize.gzip) {
+      gzipRelativeDiff = currentSize.gzip / previousSize.gzip - 1;
+    } else {
+      gzipRelativeDiff = 0;
+    }
+
+    const entry = {
+      id: bundle,
+      parsed: {
+        previous: previousSize.parsed,
+        current: currentSize.parsed,
+        absoluteDiff: parsedDiff,
+        relativeDiff: parsedRelativeDiff,
+      },
+      gzip: {
+        previous: previousSize.gzip,
+        current: currentSize.gzip,
+        absoluteDiff: gzipDiff,
+        relativeDiff: gzipRelativeDiff,
+      },
+    };
+
+    results.push(entry);
+
+    // Update totals
+    totalParsed += parsedDiff;
+    totalGzip += gzipDiff;
+    totalParsedPrevious += previousSize.parsed;
+    totalGzipPrevious += previousSize.gzip;
+  });
+
+  // Calculate percentage changes
+  const totalParsedPercent = totalParsedPrevious > 0 ? totalParsed / totalParsedPrevious : 0;
+  const totalGzipPercent = totalGzipPrevious > 0 ? totalGzip / totalGzipPrevious : 0;
+
+  // Sort the results
+  // Custom sorting:
+  // 1. Existing bundles that increased in size (larger increases first)
+  // 2. New bundles (larger sizes first)
+  // 3. Existing bundles that decreased in size (larger decreases first)
+  // 4. Removed bundles (larger sizes first)
+  // 5. Unchanged bundles (alphabetically)
+  results.sort((entryA, entryB) => {
+    // Helper function to determine bundle category (for sorting)
+    /** @type {(entry: Size) => number} */
+    const getCategory = (entry) => {
+      if (entry.parsed.relativeDiff === null) {
+        return 2; // New bundle
+      }
+      if (entry.parsed.relativeDiff === -1) {
+        return 4; // Removed bundle
+      }
+      if (entry.parsed.relativeDiff > 0) {
+        return 1; // Increased
+      }
+      if (entry.parsed.relativeDiff < 0) {
+        return 3; // Decreased
+      }
+      return 5; // Unchanged
+    };
+
+    // Get categories for both bundles
+    const categoryA = getCategory(entryA);
+    const categoryB = getCategory(entryB);
+
+    // Sort by category first
+    if (categoryA !== categoryB) {
+      return categoryA - categoryB;
+    }
+
+    // Within the same category, sort by absolute diff (largest first)
+    const diffA = Math.abs(entryA.parsed.absoluteDiff);
+    const diffB = Math.abs(entryB.parsed.absoluteDiff);
+
+    if (diffA !== diffB) {
+      return diffB - diffA;
+    }
+
+    // If diffs are the same, sort by name
+    return entryA.id.localeCompare(entryB.id);
+  });
+
+  return {
+    entries: results,
+    totals: {
+      totalParsed,
+      totalGzip,
+      totalParsedPercent,
+      totalGzipPercent,
+    },
+    fileCounts: {
+      added: addedFiles,
+      removed: removedFiles,
+      changed: changedFiles,
+      total: bundleKeys.length,
+    },
+  };
+}