@jsenv/file-size-impact 10.0.4 → 11.0.0

package/src/internal/jsenvCommentParameters.js

@@ -1,19 +1,31 @@
 import { formatSize } from "./formatSize.js"
 
-const jsenvFormatGroupSummary = ({ groupName, groupImpactCount, groupFileCount }) => {
-  return `${groupName} (${groupImpactCount}/${groupFileCount})`
-}
+const jsenvFormatGroupSummary = ({
+  groupName,
+  groupSizeMapBeforeMerge,
+  groupSizeMapAfterMerge,
+  sizeNames,
+}) => {
+  const firstSizeName = sizeNames[0]
+  const groupSizeBeforeMerge = groupSizeMapBeforeMerge[firstSizeName]
+  const groupSizeAfterMerge = groupSizeMapAfterMerge[firstSizeName]
+
+  if (groupSizeBeforeMerge === groupSizeAfterMerge) {
+    return `${groupName} (no impact)`
+  }
 
-const jsenvFormatHiddenImpactSummary = ({ groupHiddenImpactCount }) => {
-  return `Hidden (${groupHiddenImpactCount})`
+  return `${groupName} (${formatSizeImpactAsPercentage({
+    sizeBeforeMerge: groupSizeBeforeMerge,
+    sizeAfterMerge: groupSizeAfterMerge,
+  })})`
 }
 
 const jsenvFormatFileRelativeUrl = (fileRelativeUrl) => {
   return fileRelativeUrl
 }
 
-const jsenvFormatFileCell = ({ fileRelativeUrlDisplayed, event }) => {
-  if (event === "deleted") {
+const jsenvFormatFileCell = ({ fileRelativeUrlDisplayed, sizeAfterMerge }) => {
+  if (sizeAfterMerge === undefined) {
     return `<del>${fileRelativeUrlDisplayed}</del>`
   }
   return fileRelativeUrlDisplayed
@@ -27,92 +39,84 @@ const jsenvFormatFileCell = ({ fileRelativeUrlDisplayed, event }) => {
  * - deleted
  *   0 (-100b)
  */
-const jsenvFormatFileSizeImpactCell = (fileImpact, sizeName) => {
-  const { beforeMerge, afterMerge } = fileImpact
-
-  // added
-  if (!beforeMerge) {
-    const sizeBeforeMerge = 0
-    const sizeAfterMerge = afterMerge.sizeMap[sizeName]
-    return formatSizeImpact({
-      sizeBeforeMerge,
-      sizeAfterMerge,
-      // +100 % of something that was not here
-      // makes no sense
-      showDiff: false,
-    })
+const jsenvFormatFileSizeImpactCell = ({ sizeBeforeMerge, sizeAfterMerge }) => {
+  // The file is new
+  // it makes sense to display
+  // "100B"
+  // but it would make no sense to compare with something that does not exists like
+  // "100 B (+100B / +100%)
+  if (sizeBeforeMerge === undefined) {
+    const sizeAfterMergeFormatted = formatSize(sizeAfterMerge)
+    return sizeAfterMergeFormatted
   }
 
-  // deleted
-  if (!afterMerge) {
-    const sizeBeforeMerge = beforeMerge.sizeMap[sizeName]
-    const sizeAfterMerge = 0
-    return formatSizeImpact({
-      sizeBeforeMerge,
-      sizeAfterMerge,
-      // -100% of the file kinda makes sense
-      showDiffPercentage: false,
-    })
+  // The file is deleted, it makes sense to display
+  // "deleted (-100 B)"
+  // to indicate the new file size is 0 and was 100 bytes
+  // but it would be redundant to add the percentage
+  // "deleted (-100 B / -100%)"
+  if (sizeAfterMerge === undefined) {
+    const sizeDiff = -sizeBeforeMerge
+    const sizeDiffFormatted = formatSize(sizeDiff, { diff: true })
+    return `deleted (${sizeDiffFormatted})`
   }
 
-  const sizeBeforeMerge = beforeMerge.sizeMap[sizeName]
-  const sizeAfterMerge = afterMerge.sizeMap[sizeName]
-  return formatSizeImpact({
+  const sizeAfterMergeFormatted = formatSize(sizeAfterMerge)
+  const sizeDiff = sizeAfterMerge - sizeBeforeMerge
+  const sizeDiffFormatted = formatSize(sizeDiff, { diff: true })
+  const sizeDiffAsPercentageFormatted = formatSizeImpactAsPercentage({
     sizeBeforeMerge,
     sizeAfterMerge,
   })
+  return `${sizeAfterMergeFormatted} (${sizeDiffFormatted} / ${sizeDiffAsPercentageFormatted})`
 }
 
-const jsenvFormatGroupSizeImpactCell = ({ groupSizeAfterMerge, groupSizeBeforeMerge }) => {
-  return formatSizeImpact({
-    sizeBeforeMerge: groupSizeBeforeMerge,
-    sizeAfterMerge: groupSizeAfterMerge,
-  })
-}
-
-const formatSizeImpact = ({
-  sizeBeforeMerge,
-  sizeAfterMerge,
-  showDiff = true,
-  showDiffPercentage = true,
-}) => {
-  const sizeAfterMergeFormatted = formatSize(sizeAfterMerge)
-  if (!showDiff) {
-    return sizeAfterMergeFormatted
+export const jsenvFormatEmojiCell = ({ sizeBeforeMerge, sizeAfterMerge }) => {
+  if (sizeBeforeMerge === undefined) {
+    return ":baby:"
   }
 
-  const sizeDiff = sizeAfterMerge - sizeBeforeMerge
-  const sizeDiffFormatted = formatSize(sizeDiff, { diff: true })
-
-  if (!showDiffPercentage) {
-    return `${sizeAfterMergeFormatted} (${sizeDiffFormatted})`
+  if (sizeAfterMerge === undefined) {
+    return ""
   }
 
-  const sizeDiffRatio =
-    sizeBeforeMerge === 0 ? 1 : sizeAfterMerge === 0 ? -1 : sizeDiff / sizeBeforeMerge
-  const sizeDiffAsPercentage = sizeDiffRatio * 100
-  const sizeDiffAsPercentageFormatted = `${sizeDiffAsPercentage < 0 ? `-` : "+"}${Math.abs(
-    limitDecimals(sizeDiffAsPercentage, 2),
-  )}%`
+  const delta = sizeAfterMerge - sizeBeforeMerge
+  if (delta === 0) {
+    return ":ghost:"
+  }
 
-  return `${sizeAfterMergeFormatted} (${sizeDiffFormatted} / ${sizeDiffAsPercentageFormatted})`
-}
+  if (delta > 0) {
+    return ":arrow_upper_right:"
+  }
 
-const limitDecimals = (number, decimalCount = 2) => {
-  const multiplier = Math.pow(10, decimalCount)
-  return Math.round(number * multiplier) / multiplier
+  return ":arrow_lower_right:"
 }
 
 export const jsenvCommentParameters = {
   filesOrdering: "size_impact",
-  maxRowsPerTable: 600,
+  maxFilesPerGroup: 600,
   fileRelativeUrlMaxLength: 100,
   formatGroupSummary: jsenvFormatGroupSummary,
-  formatHiddenImpactSummary: jsenvFormatHiddenImpactSummary,
   formatFileRelativeUrl: jsenvFormatFileRelativeUrl,
 
   formatFileCell: jsenvFormatFileCell,
   formatFileSizeImpactCell: jsenvFormatFileSizeImpactCell,
-  formatGroupSizeImpactCell: jsenvFormatGroupSizeImpactCell,
+  formatEmojiCell: jsenvFormatEmojiCell,
   shouldOpenGroupByDefault: () => false,
 }
+
+const formatSizeImpactAsPercentage = ({ sizeBeforeMerge, sizeAfterMerge }) => {
+  const sizeDiff = sizeAfterMerge - sizeBeforeMerge
+  const sizeDiffRatio =
+    sizeBeforeMerge === 0 ? 1 : sizeAfterMerge === 0 ? -1 : sizeDiff / sizeBeforeMerge
+  const sizeDiffAsPercentage = sizeDiffRatio * 100
+  const sizeDiffAsPercentageFormatted = `${sizeDiffAsPercentage < 0 ? `-` : "+"}${Math.abs(
+    limitDecimals(sizeDiffAsPercentage, 2),
+  )}%`
+  return sizeDiffAsPercentageFormatted
+}
+
+const limitDecimals = (number, decimalCount = 2) => {
+  const multiplier = Math.pow(10, decimalCount)
+  return Math.round(number * multiplier) / multiplier
+}

package/src/internal/orderBySizeImpact.js

@@ -1,10 +1,10 @@
 export const orderBySizeImpact = (fileByFileImpact, sizeNames) => {
   const impactOrderedBySizeImpact = {}
   const files = Object.keys(fileByFileImpact)
-  const lastSizeName = sizeNames[sizeNames.length - 1]
+  const firstSizeName = sizeNames[0]
   files.sort((leftFile, rightFile) => {
-    const leftFileSizeImpact = sizeImpactFromFileImpact(fileByFileImpact[leftFile], lastSizeName)
-    const rightFileSizeImpact = sizeImpactFromFileImpact(fileByFileImpact[rightFile], lastSizeName)
+    const leftFileSizeImpact = fileByFileImpact[leftFile].sizeImpactMap[firstSizeName]
+    const rightFileSizeImpact = fileByFileImpact[rightFile].sizeImpactMap[firstSizeName]
     if (leftFileSizeImpact === 0) {
       return 1
     }
@@ -24,14 +24,3 @@ export const orderBySizeImpact = (fileByFileImpact, sizeNames) => {
   })
   return impactOrderedBySizeImpact
 }
-
-const sizeImpactFromFileImpact = (fileImpact, sizeName) => {
-  const { event } = fileImpact
-  if (event === "added") {
-    return fileImpact.afterMerge.sizeMap[sizeName]
-  }
-  if (event === "modified") {
-    return fileImpact.afterMerge.sizeMap[sizeName] - fileImpact.beforeMerge.sizeMap[sizeName]
-  }
-  return -fileImpact.beforeMerge.sizeMap[sizeName]
-}

package/src/internal/renderImpactTable.js

@@ -1,35 +1,41 @@
-export const renderImpactTable = (
+import { getSizeMapsForManyFiles } from "./size_map.js"
+
+export const renderImpactTable = ({
   fileByFileImpact,
-  {
-    groupFileImpactMap,
-    transformationKeys,
-    fileRelativeUrlMaxLength,
-    maxRowsPerTable,
-    formatFileRelativeUrl,
-    formatFileCell,
-    formatFileSizeImpactCell,
-    formatGroupSizeImpactCell,
-  },
-) => {
+  transformationKeys,
+  fileRelativeUrlMaxLength,
+  maxFilesPerGroup,
+  formatFileRelativeUrl,
+  formatFileCell,
+  formatFileSizeImpactCell,
+  formatEmojiCell,
+  groupSizeMapBeforeMerge,
+  groupSizeMapAfterMerge,
+}) => {
   const table = `<table>
     <thead>
       ${renderSizeImpactTableHeader(transformationKeys)}
     </thead>
     <tbody>
-      ${renderSizeImpactTableBody(fileByFileImpact, {
+      ${renderSizeImpactTableBody({
+        fileByFileImpact,
         transformationKeys,
-        maxRowsPerTable,
+        maxFilesPerGroup,
         fileRelativeUrlMaxLength,
         formatFileRelativeUrl,
         formatFileCell,
         formatFileSizeImpactCell,
+        formatEmojiCell,
       })}
     </tbody>
     <tfoot>
-      ${renderSizeImpactTableFooter(fileByFileImpact, {
-        groupFileImpactMap,
+      ${renderSizeImpactTableFooter({
+        fileByFileImpact,
         transformationKeys,
-        formatGroupSizeImpactCell,
+        formatFileSizeImpactCell,
+        formatEmojiCell,
+        groupSizeMapBeforeMerge,
+        groupSizeMapAfterMerge,
       })}
     </tfoot>
   </table>`
@@ -40,7 +46,7 @@ export const renderImpactTable = (
 const renderSizeImpactTableHeader = (transformationKeys) => {
   const lines = []
   const headerLine = [
-    `<th nowrap>File</th>`,
+    `<th nowrap>Files</th>`,
     ...transformationKeys.map(
       (sizeName) => `<th nowrap>${sizeName === "raw" ? `new size` : `new ${sizeName} size`}</th>`,
     ),
@@ -51,35 +57,37 @@ const renderSizeImpactTableHeader = (transformationKeys) => {
   return renderTableLines(lines)
 }
 
-const renderSizeImpactTableBody = (
+const renderSizeImpactTableBody = ({
   fileByFileImpact,
-  {
-    transformationKeys,
-    maxRowsPerTable,
-    fileRelativeUrlMaxLength,
-    formatFileRelativeUrl,
-    formatFileCell,
-    formatFileSizeImpactCell,
-  },
-) => {
+  transformationKeys,
+  maxFilesPerGroup,
+  fileRelativeUrlMaxLength,
+  formatFileRelativeUrl,
+  formatFileCell,
+  formatFileSizeImpactCell,
+  formatEmojiCell,
+}) => {
   const lines = []
   const sizeNames = transformationKeys
+  const firstSizeName = sizeNames[0]
 
-  const renderDiffCell = (fileImpact, sizeName) => {
-    const fileSizeImpactCellFormatted = formatFileSizeImpactCell(fileImpact, sizeName)
-    return fileSizeImpactCellFormatted
-  }
-
-  const files = Object.keys(fileByFileImpact)
-  const fileCount = files.length
-  let filesShown
-  if (fileCount > maxRowsPerTable) {
-    filesShown = files.slice(0, maxRowsPerTable)
-  } else {
-    filesShown = files
-  }
-  filesShown.forEach((fileRelativeUrl) => {
+  let remainingFilesToDisplay = maxFilesPerGroup
+  const truncateds = []
+  const unmodifieds = []
+  Object.keys(fileByFileImpact).forEach((fileRelativeUrl) => {
     const fileImpact = fileByFileImpact[fileRelativeUrl]
+
+    if (fileImpact.event === "none") {
+      unmodifieds.push(fileRelativeUrl)
+      return
+    }
+
+    if (remainingFilesToDisplay === 0) {
+      truncateds.push(fileRelativeUrl)
+      return
+    }
+
+    remainingFilesToDisplay--
     const fileAbstractRelativeUrl = fileAbstractRelativeUrlFromFileImpact(fileImpact)
     const fileRelativeUrlFormatted = (fileImpact.formatFileRelativeUrl || formatFileRelativeUrl)(
       fileAbstractRelativeUrl,
@@ -88,151 +96,146 @@ const renderSizeImpactTableBody = (
       fileRelativeUrlFormatted,
       fileRelativeUrlMaxLength,
     )
+    const { sizeMapBeforeMerge, sizeMapAfterMerge } = fileByFileImpact[fileRelativeUrl]
     const fileCellFormatted = formatFileCell({
       fileRelativeUrl,
       fileRelativeUrlDisplayed,
-      ...fileImpact,
+      sizeBeforeMerge: sizeMapBeforeMerge[firstSizeName],
+      sizeAfterMerge: sizeMapAfterMerge[firstSizeName],
     })
+
     const line = [
       `<td nowrap>${fileCellFormatted}</td>`,
-      ...sizeNames.map((sizeName) => `<td nowrap>${renderDiffCell(fileImpact, sizeName)}</td>`),
-      `<td>${renderEmojiCellContent(fileImpact)}</td>`,
+      ...sizeNames.map((sizeName) => {
+        return `<td nowrap>${formatFileSizeImpactCell({
+          sizeBeforeMerge: sizeMapBeforeMerge[sizeName],
+          sizeAfterMerge: sizeMapAfterMerge[sizeName],
+          sizeName,
+        })}</td>`
+      }),
+      ...(formatEmojiCell
+        ? [
+            `<td>${formatEmojiCell({
+              sizeBeforeMerge: sizeMapBeforeMerge[firstSizeName],
+              sizeAfterMerge: sizeMapAfterMerge[firstSizeName],
+            })}</td>`,
+          ]
+        : []),
     ]
     lines.push(line)
   })
-  if (filesShown !== files) {
-    const columnCount =
-      // file name
-      1 +
-      // all sizes
-      sizeNames.length +
-      // emoji column
-      1
-    lines.push([
-      `<td colspan="${columnCount}" align="center">... ${
-        fileCount - maxRowsPerTable
-      } more ...</td>`,
-    ])
-  }
 
-  return renderTableLines(lines)
-}
-
-const renderEmojiCellContent = (fileImpact) => {
-  const { event } = fileImpact
-
-  if (event === "added") {
-    return ":baby:"
-  }
-
-  if (event === "deleted") {
-    return ""
-  }
-
-  const { afterMerge, beforeMerge } = fileImpact
-  const afterMergeSizeMap = afterMerge.sizeMap
-  const beforeMergeSizeMap = beforeMerge.sizeMap
-  const sizeNames = Object.keys(afterMergeSizeMap)
-  const sizeName = sizeNames[sizeNames.length - 1]
-  const afterMergeSize = afterMergeSizeMap[sizeName]
-  const beforeMergeSize = beforeMergeSizeMap[sizeName]
-  const delta = afterMergeSize - beforeMergeSize
-  if (delta === 0) {
-    return ":ghost:"
-  }
-
-  if (delta > 0) {
-    return ":arrow_upper_right:"
-  }
-
-  return ":arrow_lower_right:"
-}
-
-const renderGroupEmojiCellContent = ({ groupSizeAfterMerge, groupSizeBeforeMerge }) => {
-  const delta = groupSizeAfterMerge - groupSizeBeforeMerge
-  if (delta === 0) {
-    return ":ghost:"
+  const truncatedCount = truncateds.length
+  if (truncatedCount > 0) {
+    const { sizeMapBeforeMerge, sizeMapAfterMerge } = getSizeMapsForManyFiles({
+      sizeNames,
+      fileByFileImpact,
+      files: truncateds,
+    })
+    const lineForTruncatedFiles = [
+      `<td nowrap><i>Truncated (${truncatedCount})</i></td>`,
+      ...sizeNames.map((sizeName) => {
+        return `<td nowrap>${formatFileSizeImpactCell({
+          sizeBeforeMerge: sizeMapBeforeMerge[sizeName],
+          sizeAfterMerge: sizeMapAfterMerge[sizeName],
+          sizeName,
+        })}</td>`
+      }),
+      ...(formatEmojiCell
+        ? [
+            `<td>${formatEmojiCell({
+              sizeBeforeMerge: sizeMapBeforeMerge[firstSizeName],
+              sizeAfterMerge: sizeMapAfterMerge[firstSizeName],
+            })}</td>`,
+          ]
+        : []),
+    ]
+    lines.push(lineForTruncatedFiles)
   }
 
-  if (delta > 0) {
-    return ":arrow_upper_right:"
+  const unmodifiedCount = unmodifieds.length
+  if (unmodifiedCount > 0) {
+    const { sizeMapBeforeMerge, sizeMapAfterMerge } = getSizeMapsForManyFiles({
+      sizeNames,
+      fileByFileImpact,
+      files: unmodifieds,
+    })
+    const lineForUnmodifiedFiles = [
+      `<td nowrap><i>Unmodified (${unmodifiedCount})</i></td>`,
+      ...sizeNames.map((sizeName) => {
+        return `<td nowrap>${formatFileSizeImpactCell({
+          sizeBeforeMerge: sizeMapBeforeMerge[sizeName],
+          sizeAfterMerge: sizeMapAfterMerge[sizeName],
+          sizeName,
+        })}</td>`
+      }),
+      ...(formatEmojiCell
+        ? [
+            `<td>${formatEmojiCell({
+              sizeBeforeMerge: sizeMapBeforeMerge[firstSizeName],
+              sizeAfterMerge: sizeMapAfterMerge[firstSizeName],
+            })}</td>`,
+          ]
+        : []),
+    ]
+    lines.push(lineForUnmodifiedFiles)
   }
 
-  return ":arrow_lower_right:"
+  return renderTableLines(lines)
 }
 
-const fileAbstractRelativeUrlFromFileImpact = ({ beforeMerge, afterMerge }) => {
-  if (afterMerge) {
-    return afterMerge.manifestKey || afterMerge.relativeUrl
-  }
-  return beforeMerge.manifestKey || beforeMerge.relativeUrl
+const fileAbstractRelativeUrlFromFileImpact = ({
+  manifestKeyBeforeMerge,
+  relativeUrlBeforeMerge,
+  manifestKeyAfterMerge,
+  relativeUrlAfterMerge,
+}) => {
+  return (
+    manifestKeyAfterMerge ||
+    relativeUrlAfterMerge ||
+    manifestKeyBeforeMerge ||
+    relativeUrlBeforeMerge
+  )
 }
 
-const renderSizeImpactTableFooter = (
+const renderSizeImpactTableFooter = ({
   fileByFileImpact,
-  { groupFileImpactMap, transformationKeys, formatGroupSizeImpactCell },
-) => {
+  transformationKeys,
+  formatFileSizeImpactCell,
+  formatEmojiCell,
+  groupSizeMapBeforeMerge,
+  groupSizeMapAfterMerge,
+}) => {
   const footerLines = []
 
+  const fileCount = Object.keys(fileByFileImpact).length
   const sizeNames = transformationKeys
-  const lastSizeName = sizeNames[sizeNames.length - 1]
-
-  const groupImpacts = {}
-  sizeNames.forEach((sizeName) => {
-    groupImpacts[sizeName] = computeGroupImpact(groupFileImpactMap, sizeName)
-  })
+  const firstSizeName = sizeNames[0]
 
   const groupSizeImpactLine = [
-    `<td nowrap><strong>Whole group</strong></td>`,
+    `<td nowrap><strong>Total (${fileCount})</strong></td>`,
     ...sizeNames.map(
-      (sizeName) => `<td nowrap>${formatGroupSizeImpactCell(groupImpacts[sizeName])}</td>`,
+      (sizeName) =>
+        `<td nowrap>${formatFileSizeImpactCell({
+          sizeBeforeMerge: groupSizeMapBeforeMerge[sizeName],
+          sizeAfterMerge: groupSizeMapAfterMerge[sizeName],
+          sizeName,
+        })}</td>`,
     ),
-    `<td>${renderGroupEmojiCellContent(groupImpacts[lastSizeName])}</td>`,
+    ...(formatEmojiCell
+      ? [
+          `<td>${formatEmojiCell({
+            sizeBeforeMerge: groupSizeMapBeforeMerge[firstSizeName],
+            sizeAfterMerge: groupSizeMapAfterMerge[firstSizeName],
+          })}</td>`,
+        ]
+      : []),
   ]
   footerLines.push(groupSizeImpactLine)
 
   return renderTableLines(footerLines)
 }
 
-const computeGroupImpact = (groupFileImpactMap, sizeName) => {
-  const groupImpact = Object.keys(groupFileImpactMap).reduce(
-    (previous, fileRelativeUrl) => {
-      const fileImpact = groupFileImpactMap[fileRelativeUrl]
-      const { beforeMerge, afterMerge } = fileImpact
-      // added
-      if (!beforeMerge) {
-        const sizeAfterMerge = afterMerge.sizeMap[sizeName]
-        return {
-          groupSizeBeforeMerge: previous.groupSizeBeforeMerge,
-          groupSizeAfterMerge: previous.groupSizeAfterMerge + sizeAfterMerge,
-        }
-      }
-
-      // removed
-      if (!afterMerge) {
-        const sizeBeforeMerge = beforeMerge.sizeMap[sizeName]
-        return {
-          groupSizeBeforeMerge: previous.groupSizeBeforeMerge + sizeBeforeMerge,
-          groupSizeAfterMerge: previous.groupSizeAfterMerge,
-        }
-      }
-
-      // modified or not, does not matter
-      const sizeBeforeMerge = beforeMerge.sizeMap[sizeName]
-      const sizeAfterMerge = afterMerge.sizeMap[sizeName]
-      return {
-        groupSizeBeforeMerge: previous.groupSizeBeforeMerge + sizeBeforeMerge,
-        groupSizeAfterMerge: previous.groupSizeAfterMerge + sizeAfterMerge,
-      }
-    },
-    {
-      groupSizeBeforeMerge: 0,
-      groupSizeAfterMerge: 0,
-    },
-  )
-  return groupImpact
-}
-
 const truncateFileRelativeUrl = (fileRelativeUrl, fileRelativeUrlMaxLength) => {
   const length = fileRelativeUrl.length
   const extraLength = length - fileRelativeUrlMaxLength

package/src/internal/size_map.js

@@ -0,0 +1,49 @@
+export const getSizeMapsOneFile = ({ sizeNames, beforeMerge, afterMerge }) => {
+  const sizeMapBeforeMerge = {}
+  const sizeMapAfterMerge = {}
+  const sizeImpactMap = {}
+
+  sizeNames.forEach((sizeName) => {
+    if (beforeMerge === null) {
+      sizeMapBeforeMerge[sizeName] = undefined
+      sizeMapAfterMerge[sizeName] = afterMerge.sizeMap[sizeName]
+      sizeImpactMap[sizeName] = afterMerge.sizeMap[sizeName]
+    } else if (afterMerge === null) {
+      sizeMapBeforeMerge[sizeName] = beforeMerge.sizeMap[sizeName]
+      sizeMapAfterMerge[sizeName] = undefined
+      sizeImpactMap[sizeName] = -beforeMerge.sizeMap[sizeName]
+    } else {
+      sizeMapBeforeMerge[sizeName] = beforeMerge.sizeMap[sizeName]
+      sizeMapAfterMerge[sizeName] = afterMerge.sizeMap[sizeName]
+      sizeImpactMap[sizeName] = afterMerge.sizeMap[sizeName] - beforeMerge.sizeMap[sizeName]
+    }
+  })
+
+  return {
+    sizeMapBeforeMerge,
+    sizeMapAfterMerge,
+    sizeImpactMap,
+  }
+}
+
+export const getSizeMapsForManyFiles = ({ sizeNames, fileByFileImpact, files }) => {
+  const sizeMapBeforeMerge = {}
+  const sizeMapAfterMerge = {}
+
+  sizeNames.forEach((sizeName) => {
+    let sizeBeforeMerge = 0
+    let sizeAfterMerge = 0
+    files.forEach((fileRelativeUrl) => {
+      const { sizeMapBeforeMerge, sizeMapAfterMerge } = fileByFileImpact[fileRelativeUrl]
+      sizeBeforeMerge += sizeMapBeforeMerge[sizeName] || 0
+      sizeAfterMerge += sizeMapAfterMerge[sizeName] || 0
+    })
+    sizeMapBeforeMerge[sizeName] = sizeBeforeMerge
+    sizeMapAfterMerge[sizeName] = sizeAfterMerge
+  })
+
+  return {
+    sizeMapBeforeMerge,
+    sizeMapAfterMerge,
+  }
+}

package/src/internal/worker_generating_file_size_report.js

@@ -0,0 +1,17 @@
+import { parentPort } from "node:worker_threads"
+
+parentPort.on("message", async ({ fileSizeModuleUrl }) => {
+  const { generateFileSizeReport } = await import(fileSizeModuleUrl)
+
+  if (typeof generateFileSizeReport !== "function") {
+    throw new TypeError(
+      `generateFileSizeReport export must be a function, got ${generateFileSizeReport}`,
+    )
+  }
+
+  const fileSizeReport = await generateFileSizeReport()
+
+  parentPort.postMessage({
+    fileSizeReport,
+  })
+})

package/src/logFileSizeReport.js

@@ -17,7 +17,7 @@ export const logFileSizeReport = (fileSizeReport) => {
       const sizesFormatted = sizeNames.map((sizeName) => {
         return `${sizeName}: ${formatSize(sizeMap[sizeName])}`
       })
-      return `${fileRelativeUrl}: { ${sizesFormatted.join(`,`)} }`
+      return `${fileRelativeUrl}: { ${sizesFormatted.join(`, `)} }`
     })
 
     return `${groupName}