@jsenv/file-size-impact 10.0.1 → 11.0.0

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}

package/src/reportFileSizeImpact.js

@@ -1,9 +1,21 @@
-import { assertAndNormalizeDirectoryUrl, resolveUrl } from "@jsenv/util"
+import { Worker } from "node:worker_threads"
+import {
+  assertAndNormalizeDirectoryUrl,
+  fileSystemPathToUrl,
+  isFileSystemPath,
+  resolveUrl,
+  urlToFileSystemPath,
+} from "@jsenv/filesystem"
 import { commentGitHubPullRequestImpact } from "@jsenv/github-pull-request-impact"
 
 import { formatComment } from "./internal/formatComment.js"
 import { jsenvCommentParameters } from "./internal/jsenvCommentParameters.js"
 
+const workerFileUrl = resolveUrl(
+  "./internal/worker_generating_file_size_report.js",
+  import.meta.url,
+)
+
 export const reportFileSizeImpact = async ({
   logLevel,
   commandLogs,
@@ -17,19 +29,18 @@ export const reportFileSizeImpact = async ({
   pullRequestNumber,
   installCommand = "npm install",
   buildCommand = "npm run-script build",
-  moduleGeneratingFileSizeReportRelativeUrl,
+  fileSizeModulePath,
 
   // We could just to ...jsenvCommentParameters but explicitely passing params
   // helps autocompletion in vscode for dev using the function.
   filesOrdering = jsenvCommentParameters.filesOrdering,
-  maxRowsPerTable = jsenvCommentParameters.maxRowsPerTable,
+  maxFilesPerGroup = jsenvCommentParameters.maxFilesPerGroup,
   fileRelativeUrlMaxLength = jsenvCommentParameters.fileRelativeUrlMaxLength,
   formatGroupSummary = jsenvCommentParameters.formatGroupSummary,
-  formatHiddenImpactSummary = jsenvCommentParameters.formatHiddenImpactSummary,
   formatFileRelativeUrl = jsenvCommentParameters.formatFileRelativeUrl,
   formatFileCell = jsenvCommentParameters.formatFileCell,
   formatFileSizeImpactCell = jsenvCommentParameters.formatFileSizeImpactCell,
-  formatGroupSizeImpactCell = jsenvCommentParameters.formatGroupSizeImpactCell,
+  formatEmojiCell = jsenvCommentParameters.formatEmojiCell,
   shouldOpenGroupByDefault = jsenvCommentParameters.shouldOpenGroupByDefault,
 
   catchError,
@@ -48,16 +59,14 @@ export const reportFileSizeImpact = async ({
     throw new TypeError(`buildCommand must be a string but received ${buildCommand}`)
   }
 
-  if (typeof moduleGeneratingFileSizeReportRelativeUrl !== "string") {
-    throw new TypeError(
-      `moduleGeneratingFileSizeReportRelativeUrl must be a string but received ${moduleGeneratingFileSizeReportRelativeUrl}`,
-    )
+  if (typeof fileSizeModulePath !== "string") {
+    throw new TypeError(`fileSizeModulePath must be a string but received ${fileSizeModulePath}`)
   }
   projectDirectoryUrl = assertAndNormalizeDirectoryUrl(projectDirectoryUrl)
-  const moduleGeneratingFileSizeReportUrl = resolveUrl(
-    moduleGeneratingFileSizeReportRelativeUrl,
-    projectDirectoryUrl,
-  )
+  const fileSizeModuleUrl = isFileSystemPath(fileSizeModulePath)
+    ? fileSystemPathToUrl(fileSizeModulePath)
+    : resolveUrl(fileSizeModulePath, projectDirectoryUrl)
+  const workerFilePath = urlToFileSystemPath(workerFileUrl)
 
   return commentGitHubPullRequestImpact({
     logLevel,
@@ -75,15 +84,12 @@ export const reportFileSizeImpact = async ({
       if (installCommand) await execCommandInProjectDirectory(installCommand)
       if (buildCommand) await execCommandInProjectDirectory(buildCommand)
 
-      const { generateFileSizeReport } = await import(
-        `${moduleGeneratingFileSizeReportUrl}?cache_busting=${Date.now()}`
-      )
-      if (typeof generateFileSizeReport !== "function") {
-        throw new TypeError(
-          `generateFileSizeReport export must be a function, got ${generateFileSizeReport}`,
-        )
-      }
-      const fileSizeReport = await generateFileSizeReport()
+      const worker = new Worker(workerFilePath)
+      const { fileSizeReport } = await new Promise((resolve, reject) => {
+        worker.postMessage({ fileSizeModuleUrl })
+        worker.on("message", resolve)
+        worker.on("error", reject)
+      })
 
       return { version: 1, data: fileSizeReport }
     },
@@ -102,14 +108,13 @@ export const reportFileSizeImpact = async ({
         afterMergeFileSizeReport: afterMergeData,
 
         filesOrdering,
-        maxRowsPerTable,
+        maxFilesPerGroup,
         fileRelativeUrlMaxLength,
         formatGroupSummary,
-        formatHiddenImpactSummary,
         formatFileRelativeUrl,
         formatFileCell,
         formatFileSizeImpactCell,
-        formatGroupSizeImpactCell,
+        formatEmojiCell,
         shouldOpenGroupByDefault,
       })
     },

package/src/internal/getSizeMaps.js

@@ -1,43 +0,0 @@
-export const getSizeMaps = ({ beforeMerge, afterMerge }) => {
-  // added
-  if (!beforeMerge) {
-    const sizeMapBeforeMerge = null
-    const sizeMapAfterMerge = afterMerge.sizeMap
-    const sizeImpactMap = {}
-    Object.keys(sizeMapAfterMerge).forEach((sizeName) => {
-      sizeImpactMap[sizeName] = sizeMapAfterMerge[sizeName]
-    })
-    return {
-      sizeMapBeforeMerge,
-      sizeMapAfterMerge,
-      sizeImpactMap,
-    }
-  }
-
-  // deleted
-  if (!afterMerge) {
-    const sizeMapBeforeMerge = beforeMerge.sizeMap
-    const sizeMapAfterMerge = null
-    const sizeImpactMap = {}
-    Object.keys(sizeMapBeforeMerge).forEach((sizeName) => {
-      sizeImpactMap[sizeName] = -sizeMapBeforeMerge[sizeName]
-    })
-    return {
-      sizeMapBeforeMerge,
-      sizeMapAfterMerge,
-      sizeImpactMap,
-    }
-  }
-
-  const sizeMapBeforeMerge = beforeMerge.sizeMap
-  const sizeMapAfterMerge = afterMerge.sizeMap
-  const sizeImpactMap = {}
-  Object.keys(sizeMapAfterMerge).forEach((sizeName) => {
-    sizeImpactMap[sizeName] = sizeMapAfterMerge[sizeName] - sizeMapBeforeMerge[sizeName]
-  })
-  return {
-    sizeMapBeforeMerge,
-    sizeMapAfterMerge,
-    sizeImpactMap,
-  }
-}