@jsenv/file-size-impact 10.0.1 → 11.0.0

package/src/internal/formatComment.js

@@ -1,8 +1,8 @@
 import { compareTwoFileSizeReports } from "./compareTwoFileSizeReports.js"
-import { getSizeMaps } from "./getSizeMaps.js"
 import { isAdded, isModified, isDeleted } from "./helper.js"
 import { renderImpactTable } from "./renderImpactTable.js"
 import { orderBySizeImpact } from "./orderBySizeImpact.js"
+import { getSizeMapsOneFile, getSizeMapsForManyFiles } from "./size_map.js"
 
 export const formatComment = ({
   pullRequestBase,
@@ -11,14 +11,13 @@ export const formatComment = ({
   afterMergeFileSizeReport,
 
   filesOrdering,
-  maxRowsPerTable,
+  maxFilesPerGroup,
   fileRelativeUrlMaxLength,
   formatGroupSummary,
-  formatHiddenImpactSummary,
   formatFileRelativeUrl,
   formatFileCell,
   formatFileSizeImpactCell,
-  formatGroupSizeImpactCell,
+  formatEmojiCell,
   shouldOpenGroupByDefault,
 }) => {
   const warnings = []
@@ -40,14 +39,13 @@ export const formatComment = ({
     reportComparison,
 
     filesOrdering,
-    maxRowsPerTable,
+    maxFilesPerGroup,
     fileRelativeUrlMaxLength,
     formatGroupSummary,
-    formatHiddenImpactSummary,
     formatFileRelativeUrl,
     formatFileCell,
     formatFileSizeImpactCell,
-    formatGroupSizeImpactCell,
+    formatEmojiCell,
     shouldOpenGroupByDefault,
   })
 
@@ -64,199 +62,110 @@ const renderCommentBody = ({
   reportComparison,
 
   filesOrdering,
+  maxFilesPerGroup,
   fileRelativeUrlMaxLength,
-  maxRowsPerTable,
   formatGroupSummary,
-  formatHiddenImpactSummary,
   formatFileRelativeUrl,
   formatFileCell,
   formatFileSizeImpactCell,
-  formatGroupSizeImpactCell,
+  formatEmojiCell,
   shouldOpenGroupByDefault,
 }) => {
-  const overallImpactInfo = {}
+  const { groups, transformationKeys } = reportComparison
 
-  const renderGroup = (
-    groupMessage,
-    {
-      groupName,
-      groupComparison,
-      groupFileCount,
-      groupImpactCount,
-      fileByFileImpact,
-      groupHiddenImpactCount,
-      fileByFileImpactHidden,
-    },
-  ) => {
-    const groupSummary = formatGroupSummary({
-      groupName,
-      groupImpactCount,
-      groupFileCount,
-    })
-    const groupShouldBeOpenByDefault = shouldOpenGroupByDefault({
-      groupName,
-      groupComparison,
-      groupFileCount,
-      groupImpactCount,
-      fileByFileImpact,
-      groupHiddenImpactCount,
-      fileByFileImpactHidden,
-    })
-
-    return renderDetails({
-      open: groupShouldBeOpenByDefault,
-      summary: groupSummary,
-      content: groupMessage,
-    })
-  }
-
-  const { transformationKeys } = reportComparison
-  const groupMessages = Object.keys(reportComparison.groups).map((groupName) => {
-    const groupComparison = reportComparison.groups[groupName]
+  const groupMessages = Object.keys(groups).map((groupName) => {
+    const groupComparison = groups[groupName]
     const groupFileImpactMap = groupComparison.fileImpactMap
-    const groupFileCount = Object.keys(groupFileImpactMap).length
     let fileByFileImpact = {}
-    let fileByFileImpactHidden = {}
-    if (groupFileCount === 0) {
-      return renderGroup(
-        formulateEmptyGroupContent({
-          groupName,
-          groupConfig: groupComparison.tracking,
-        }),
-        {
-          groupName,
-          groupComparison,
-          groupFileCount,
-          groupImpactCount: 0,
-          fileByFileImpact,
-          groupHiddenImpactCount: 0,
-          fileByFileImpactHidden,
-        },
-      )
-    }
+    const files = Object.keys(groupFileImpactMap)
 
-    const addImpact = (fileRelativeUrl, { event, beforeMerge, afterMerge }) => {
+    files.forEach((fileRelativeUrl) => {
+      const { beforeMerge, afterMerge } = groupFileImpactMap[fileRelativeUrl]
+      const event = isAdded({ beforeMerge, afterMerge })
+        ? "added"
+        : isDeleted({ beforeMerge, afterMerge })
+        ? "deleted"
+        : isModified({ beforeMerge, afterMerge })
+        ? "modified"
+        : "none"
       const meta = event === "deleted" ? beforeMerge.meta : afterMerge.meta
-      const impact = {
-        event,
+
+      const { sizeMapBeforeMerge, sizeMapAfterMerge, sizeImpactMap } = getSizeMapsOneFile({
+        sizeNames: transformationKeys,
         beforeMerge,
         afterMerge,
-      }
-
-      const data = metaToData(meta, { fileRelativeUrl, event, beforeMerge, afterMerge })
-      if (data.showSizeImpact) {
-        if (!overallImpactInfo.hasOwnProperty(fileRelativeUrl)) {
-          overallImpactInfo[fileRelativeUrl] = groupName
-        }
-
-        fileByFileImpact[fileRelativeUrl] = { ...impact, ...data }
-      } else {
-        fileByFileImpactHidden[fileRelativeUrl] = { ...impact, ...data }
-      }
-    }
-
-    Object.keys(groupFileImpactMap).forEach((fileRelativeUrl) => {
-      const { beforeMerge, afterMerge } = groupFileImpactMap[fileRelativeUrl]
-
-      if (isAdded({ beforeMerge, afterMerge })) {
-        addImpact(fileRelativeUrl, {
-          event: "added",
-          beforeMerge,
-          afterMerge,
-        })
-        return
-      }
-
-      if (isDeleted({ beforeMerge, afterMerge })) {
-        addImpact(fileRelativeUrl, {
-          event: "deleted",
-          beforeMerge,
-          afterMerge,
-        })
-        return
-      }
-
-      if (isModified({ beforeMerge, afterMerge })) {
-        addImpact(fileRelativeUrl, {
-          event: "modified",
-          beforeMerge,
-          afterMerge,
-        })
+      })
+      const { showSizeImpact, formatFileRelativeUrl } = metaToData(meta, {
+        fileRelativeUrl,
+        sizeBeforeMerge: sizeMapBeforeMerge[0],
+        sizeAfterMerge: sizeMapAfterMerge[0],
+        sizeImpactMap,
+      })
+      fileByFileImpact[fileRelativeUrl] = {
+        event,
+        manifestKeyBeforeMerge: beforeMerge ? beforeMerge.manifestKey : undefined,
+        manifestKeyAfterMerge: afterMerge ? afterMerge.manifestKey : undefined,
+        relativeUrlBeforeMerge: beforeMerge ? beforeMerge.relativeUrl : undefined,
+        relativeUrlAfterMerge: afterMerge ? afterMerge.relativeUrl : undefined,
+        sizeMapBeforeMerge,
+        sizeMapAfterMerge,
+        sizeImpactMap,
+        showSizeImpact,
+        formatFileRelativeUrl,
       }
     })
-
     if (filesOrdering === "size_impact") {
-      fileByFileImpact = orderBySizeImpact(fileByFileImpact, reportComparison.transformationKeys)
-      fileByFileImpactHidden = orderBySizeImpact(
-        fileByFileImpactHidden,
-        reportComparison.transformationKeys,
-      )
+      fileByFileImpact = orderBySizeImpact(fileByFileImpact, transformationKeys)
     }
 
-    const groupImpactCount = Object.keys(fileByFileImpact).length
-    const groupHiddenImpactCount = Object.keys(fileByFileImpactHidden).length
-    if (groupImpactCount === 0 && groupHiddenImpactCount === 0) {
-      return renderGroup(`<p>No impact on files in ${groupName} group.</p>`, {
-        groupName,
-        groupComparison,
-        groupFileCount,
-        groupImpactCount,
-        fileByFileImpact,
-        groupHiddenImpactCount,
-        fileByFileImpactHidden,
-      })
-    }
+    const groupSizeMaps = getSizeMapsForManyFiles({
+      sizeNames: transformationKeys,
+      fileByFileImpact,
+      files,
+    })
+    const groupSizeMapBeforeMerge = groupSizeMaps.sizeMapBeforeMerge
+    const groupSizeMapAfterMerge = groupSizeMaps.sizeMapAfterMerge
+    const groupIsEmpty = Object.keys(fileByFileImpact).length === 0
 
-    const elements = [
-      ...(groupImpactCount > 0
-        ? [
-            renderImpactTable(fileByFileImpact, {
-              groupFileImpactMap,
-              transformationKeys,
-              fileRelativeUrlMaxLength,
-              maxRowsPerTable,
-              formatFileRelativeUrl,
-              formatFileCell,
-              formatFileSizeImpactCell,
-              formatGroupSizeImpactCell,
-            }),
-          ]
-        : []),
-      ...(groupHiddenImpactCount > 0
-        ? [
-            renderDetails({
-              summary: formatHiddenImpactSummary({ groupName, groupHiddenImpactCount }),
-              content: renderImpactTable(fileByFileImpactHidden, {
-                groupFileImpactMap,
-                transformationKeys,
-                fileRelativeUrlMaxLength,
-                maxRowsPerTable,
-                formatFileRelativeUrl,
-                formatFileCell,
-                formatFileSizeImpactCell,
-                formatGroupSizeImpactCell,
-              }),
-            }),
-          ]
-        : []),
-    ]
+    const groupSummary = formatGroupSummary({
+      groupName,
+      groupSizeMapBeforeMerge,
+      groupSizeMapAfterMerge,
+      sizeNames: transformationKeys,
+      fileByFileImpact,
+    })
+    const groupShouldBeOpenByDefault = shouldOpenGroupByDefault({
+      groupName,
+      groupSizeMapBeforeMerge,
+      groupSizeMapAfterMerge,
+      sizeNames: transformationKeys,
+      fileByFileImpact,
+    })
 
-    return renderGroup(
-      elements.join(`
-`),
-      {
-        groupName,
-        groupComparison,
-        groupFileCount,
-        groupImpactCount,
-        fileByFileImpact,
-        groupHiddenImpactCount,
-        fileByFileImpactHidden,
-      },
-    )
+    return renderDetails({
+      open: groupShouldBeOpenByDefault,
+      summary: groupSummary,
+      content: groupIsEmpty
+        ? renderEmptyGroupContent({
+            groupName,
+            groupConfig: groupComparison.tracking,
+          })
+        : renderImpactTable({
+            fileByFileImpact,
+            transformationKeys,
+            fileRelativeUrlMaxLength,
+            maxFilesPerGroup,
+            formatFileRelativeUrl,
+            formatFileCell,
+            formatFileSizeImpactCell,
+            formatEmojiCell,
+            groupSizeMapBeforeMerge,
+            groupSizeMapAfterMerge,
+          }),
+    })
   })
 
-  const mergeImpact = formulateMergeImpact({ pullRequestHead, pullRequestBase, overallImpactInfo })
+  const mergeImpact = formulateMergeImpact({ pullRequestHead, pullRequestBase })
   if (groupMessages.length === 0) {
     return mergeImpact
   }
@@ -267,43 +176,20 @@ ${groupMessages.join(`
 `)}`
 }
 
-const formulateMergeImpact = ({ pullRequestBase, pullRequestHead, overallImpactInfo }) => {
-  const overallImpact = formulateOverallImpact(overallImpactInfo)
-  return `<p>Merging <em>${pullRequestHead}</em> into <em>${pullRequestBase}</em> will ${overallImpact}.</p>`
-}
-
-const formulateOverallImpact = (overallImpactInfo) => {
-  let impactedFileCount = 0
-  let impactedGroupCount = 0
-  const impactedGroups = []
-  Object.keys(overallImpactInfo).forEach((relativeUrl) => {
-    const groupName = overallImpactInfo[relativeUrl]
-    if (groupName) {
-      impactedFileCount++
-      if (!impactedGroups.includes(groupName)) {
-        impactedGroups.push(groupName)
-        impactedGroupCount++
-      }
-    }
-  })
-
-  if (impactedFileCount === 0) {
-    return `not impact files in any group`
-  }
-  return `impact ${formulateFileQuantity(impactedFileCount)} in ${formulateGroupQuantity(
-    impactedGroupCount,
-  )}`
-}
+const renderEmptyGroupContent = ({ groupName, groupConfig }) => {
+  return `<p>No file in ${groupName} group (see config below).</p>
 
-const formulateFileQuantity = (count) => {
-  return count === 1 ? `1 file` : `${count} files`
+\`\`\`json
+${JSON.stringify(groupConfig, null, "  ")}
+\`\`\`
+`
 }
 
-const formulateGroupQuantity = (count) => {
-  return count === 1 ? `1 group` : `${count} groups`
+const formulateMergeImpact = ({ pullRequestBase, pullRequestHead }) => {
+  return `<p>Merging <em>${pullRequestHead}</em> into <em>${pullRequestBase}</em> impact files as follow:</p>`
 }
 
-const metaToData = (meta, { fileRelativeUrl, event, beforeMerge, afterMerge }) => {
+const metaToData = (meta, { fileRelativeUrl, sizeBeforeMerge, sizeAfterMerge, sizeImpactMap }) => {
   if (typeof meta === "boolean") {
     return {
       showSizeImpact: true,
@@ -313,9 +199,9 @@ const metaToData = (meta, { fileRelativeUrl, event, beforeMerge, afterMerge }) =
   if (typeof meta === "object") {
     const showSizeImpact = showSizeImpactGetter(meta, {
       fileRelativeUrl,
-      event,
-      beforeMerge,
-      afterMerge,
+      sizeBeforeMerge,
+      sizeAfterMerge,
+      sizeImpactMap,
     })
     const { formatFileRelativeUrl } = meta
     return {
@@ -330,7 +216,10 @@ const metaToData = (meta, { fileRelativeUrl, event, beforeMerge, afterMerge }) =
   }
 }
 
-const showSizeImpactGetter = (meta, { fileRelativeUrl, event, beforeMerge, afterMerge }) => {
+const showSizeImpactGetter = (
+  meta,
+  { fileRelativeUrl, sizeBeforeMerge, sizeAfterMerge, sizeImpactMap },
+) => {
   const { showSizeImpact } = meta
 
   if (typeof showSizeImpact === "undefined") {
@@ -344,8 +233,9 @@ const showSizeImpactGetter = (meta, { fileRelativeUrl, event, beforeMerge, after
   if (typeof showSizeImpact === "function") {
     return showSizeImpact({
       fileRelativeUrl,
-      event,
-      ...getSizeMaps({ beforeMerge, afterMerge }),
+      sizeBeforeMerge,
+      sizeAfterMerge,
+      sizeImpactMap,
     })
   }
 
@@ -355,15 +245,6 @@ const showSizeImpactGetter = (meta, { fileRelativeUrl, event, beforeMerge, after
   return true
 }
 
-const formulateEmptyGroupContent = ({ groupName, groupConfig }) => {
-  return `<p>No file in ${groupName} group (see config below).</p>
-
-\`\`\`json
-${JSON.stringify(groupConfig, null, "  ")}
-\`\`\`
-`
-}
-
 const renderDetails = ({ summary, content, open = false, indent = 0 }) => {
   return `${" ".repeat(indent)}<details${open ? " open" : ""}>
 ${" ".repeat(indent + 2)}<summary>${summary}</summary>

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]
-}