@jsenv/file-size-impact 14.1.1 → 14.1.2

package/src/internal/compareTwoFileSizeReports.js

@@ -1,39 +1,42 @@
-import { comparePathnames } from "@jsenv/filesystem"
+import { comparePathnames } from "@jsenv/filesystem";
 
-import { manifestToMappings, manifestKeyFromRelativeUrl } from "./manifest.js"
+import { manifestToMappings, manifestKeyFromRelativeUrl } from "./manifest.js";
 
 export const compareTwoFileSizeReports = ({
   afterMergeFileSizeReport,
   beforeMergeFileSizeReport,
 }) => {
-  const groupComparison = {}
-  const afterMergeGroups = afterMergeFileSizeReport.groups
-  const beforeMergeGroups = beforeMergeFileSizeReport.groups
+  const groupComparison = {};
+  const afterMergeGroups = afterMergeFileSizeReport.groups;
+  const beforeMergeGroups = beforeMergeFileSizeReport.groups;
   Object.keys(afterMergeGroups).forEach((group) => {
     // || {} exists in case group was not tracked in base branch
     // and is now tracked in head branch.
     // compareTwoGroups will handle the empty object and consider everything as added
-    const beforeMergeGroup = beforeMergeGroups[group] || {}
-    const afterMergeGroup = afterMergeGroups[group]
-    groupComparison[group] = compareTwoGroups(beforeMergeGroup, afterMergeGroup)
-  })
+    const beforeMergeGroup = beforeMergeGroups[group] || {};
+    const afterMergeGroup = afterMergeGroups[group];
+    groupComparison[group] = compareTwoGroups(
+      beforeMergeGroup,
+      afterMergeGroup,
+    );
+  });
 
   const comparison = {
     transformationKeys: afterMergeFileSizeReport.transformationKeys,
     groups: groupComparison,
-  }
+  };
 
-  return comparison
-}
+  return comparison;
+};
 
 const compareTwoGroups = (beforeMergeGroup, afterMergeGroup) => {
-  const groupComparison = {}
-  const beforeMergeManifestMap = beforeMergeGroup.manifestMap || {}
-  const beforeMergeFileMap = beforeMergeGroup.fileMap || {}
-  const beforeMergeMappings = manifestToMappings(beforeMergeManifestMap)
-  const afterMergeManifestMap = afterMergeGroup.manifestMap || {}
-  const afterMergeFileMap = afterMergeGroup.fileMap || {}
-  const afterMergeMappings = manifestToMappings(afterMergeManifestMap)
+  const groupComparison = {};
+  const beforeMergeManifestMap = beforeMergeGroup.manifestMap || {};
+  const beforeMergeFileMap = beforeMergeGroup.fileMap || {};
+  const beforeMergeMappings = manifestToMappings(beforeMergeManifestMap);
+  const afterMergeManifestMap = afterMergeGroup.manifestMap || {};
+  const afterMergeFileMap = afterMergeGroup.fileMap || {};
+  const afterMergeMappings = manifestToMappings(afterMergeManifestMap);
 
   const getAddInfo = ({ afterMergeRelativeUrl }) => {
     return {
@@ -47,8 +50,8 @@ const compareTwoGroups = (beforeMergeGroup, afterMergeGroup) => {
           ) || null,
         ...afterMergeFileMap[afterMergeRelativeUrl],
       },
-    }
-  }
+    };
+  };
   const getUpdateInfo = ({ beforeMergeRelativeUrl, afterMergeRelativeUrl }) => {
     return {
       beforeMerge: {
@@ -69,8 +72,8 @@ const compareTwoGroups = (beforeMergeGroup, afterMergeGroup) => {
           ) || null,
         ...afterMergeFileMap[afterMergeRelativeUrl],
       },
-    }
-  }
+    };
+  };
   const getRemoveInfo = ({ beforeMergeRelativeUrl }) => {
     return {
       beforeMerge: {
@@ -82,73 +85,74 @@ const compareTwoGroups = (beforeMergeGroup, afterMergeGroup) => {
         ...beforeMergeFileMap[beforeMergeRelativeUrl],
       },
       afterMerge: null,
-    }
-  }
+    };
+  };
 
   Object.keys(afterMergeFileMap).forEach((afterMergeRelativeUrl) => {
     const afterMergeManifestKey = manifestKeyFromRelativeUrl(
       afterMergeRelativeUrl,
       afterMergeMappings,
-    )
+    );
 
     if (afterMergeManifestKey) {
       const existsInBeforeMergeManifest = Object.keys(
         beforeMergeMappings,
-      ).includes(afterMergeManifestKey)
+      ).includes(afterMergeManifestKey);
       if (existsInBeforeMergeManifest) {
         // the manifest key also appears in the manifest before merge.
         // It means that even if both file have different relative urls,
         // they are considered the same.
         // This is to support file generated with a dynamic name
         const beforeMergeRelativeUrl =
-          beforeMergeMappings[afterMergeManifestKey]
-        const beforeMerge = beforeMergeFileMap[beforeMergeRelativeUrl]
+          beforeMergeMappings[afterMergeManifestKey];
+        const beforeMerge = beforeMergeFileMap[beforeMergeRelativeUrl];
         if (beforeMerge) {
           groupComparison[afterMergeRelativeUrl] = getUpdateInfo({
             beforeMergeRelativeUrl,
             afterMergeRelativeUrl,
-          })
-          return
+          });
+          return;
         }
       }
     }
 
-    const beforeMerge = beforeMergeFileMap[afterMergeRelativeUrl]
+    const beforeMerge = beforeMergeFileMap[afterMergeRelativeUrl];
     groupComparison[afterMergeRelativeUrl] = beforeMerge
       ? getUpdateInfo({
           beforeMergeRelativeUrl: afterMergeRelativeUrl,
           afterMergeRelativeUrl,
         })
-      : getAddInfo({ afterMergeRelativeUrl })
-  })
+      : getAddInfo({ afterMergeRelativeUrl });
+  });
   Object.keys(beforeMergeFileMap).forEach((beforeMergeRelativeUrl) => {
     // if the file is not in the after merge, it got deleted
     // except if it is remapped, in this case it can be ignored
     const beforeMergeManifestKey = manifestKeyFromRelativeUrl(
       beforeMergeRelativeUrl,
       beforeMergeMappings,
-    )
+    );
     if (beforeMergeManifestKey) {
       const existsInAfterMergeManifest = Object.keys(
         afterMergeMappings,
-      ).includes(beforeMergeManifestKey)
+      ).includes(beforeMergeManifestKey);
       if (existsInAfterMergeManifest) {
         // file also referenced in after merge manifest
         // let's first see if the file still exists
-        const afterMergeRelativeUrl = afterMergeMappings[beforeMergeManifestKey]
-        const afterMerge = afterMergeFileMap[afterMergeRelativeUrl]
+        const afterMergeRelativeUrl =
+          afterMergeMappings[beforeMergeManifestKey];
+        const afterMerge = afterMergeFileMap[afterMergeRelativeUrl];
         if (afterMerge) {
           // there is a file for this mapping, file was already
           // detected and considered as an update during afterMergeFileMap loop above
-          return
+          return;
         }
       }
     }
 
-    const afterMerge = afterMergeFileMap[beforeMergeRelativeUrl]
+    const afterMerge = afterMergeFileMap[beforeMergeRelativeUrl];
     if (afterMerge) {
       // there is a file
-      return
+      return;
     }
 
     // at this point there is no file for an eventual file mapping from manifest
@@ -156,23 +160,23 @@ const compareTwoGroups = (beforeMergeGroup, afterMergeGroup) => {
     // -> the file is gone
     groupComparison[beforeMergeRelativeUrl] = getRemoveInfo({
       beforeMergeRelativeUrl,
-    })
-  })
+    });
+  });
 
-  const fileImpactMap = sortFileStructure(groupComparison)
+  const fileImpactMap = sortFileStructure(groupComparison);
 
   return {
     tracking: afterMergeGroup.tracking,
     fileImpactMap,
-  }
-}
+  };
+};
 
 const sortFileStructure = (fileStructure) => {
   const relativeUrlSortedArray =
-    Object.keys(fileStructure).sort(comparePathnames)
-  const fileStructureSorted = {}
+    Object.keys(fileStructure).sort(comparePathnames);
+  const fileStructureSorted = {};
   relativeUrlSortedArray.forEach((relativeUrl) => {
-    fileStructureSorted[relativeUrl] = fileStructure[relativeUrl]
-  })
-  return fileStructureSorted
-}
+    fileStructureSorted[relativeUrl] = fileStructure[relativeUrl];
+  });
+  return fileStructureSorted;
+};

package/src/internal/formatComment.js

@@ -1,8 +1,8 @@
-import { compareTwoFileSizeReports } from "./compareTwoFileSizeReports.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"
+import { compareTwoFileSizeReports } from "./compareTwoFileSizeReports.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,
@@ -20,17 +20,17 @@ export const formatComment = ({
   formatEmojiCell,
   shouldOpenGroupByDefault,
 }) => {
-  const warnings = []
+  const warnings = [];
   const reportComparison = compareTwoFileSizeReports({
     afterMergeFileSizeReport,
     beforeMergeFileSizeReport,
-  })
-  const groupCount = Object.keys(reportComparison.groups).length
+  });
+  const groupCount = Object.keys(reportComparison.groups).length;
 
   if (groupCount === 0) {
     warnings.push(
       `**Warning:** Nothing is tracked. It happens when tracking config is an empty object.`,
-    )
+    );
   }
 
   let body = renderCommentBody({
@@ -47,14 +47,14 @@ export const formatComment = ({
     formatFileSizeImpactCell,
     formatEmojiCell,
     shouldOpenGroupByDefault,
-  })
+  });
 
   body = `<h4 id="file-size-impact">File size impact</h4>
 
-${body}`
+${body}`;
 
-  return { warnings, body }
-}
+  return { warnings, body };
+};
 
 const renderCommentBody = ({
   pullRequestBase,
@@ -71,37 +71,37 @@ const renderCommentBody = ({
   formatEmojiCell,
   shouldOpenGroupByDefault,
 }) => {
-  const { groups, transformationKeys } = reportComparison
+  const { groups, transformationKeys } = reportComparison;
 
   const groupMessages = Object.keys(groups).map((groupName) => {
-    const groupComparison = groups[groupName]
-    const groupFileImpactMap = groupComparison.fileImpactMap
-    let fileByFileImpact = {}
-    const files = Object.keys(groupFileImpactMap)
+    const groupComparison = groups[groupName];
+    const groupFileImpactMap = groupComparison.fileImpactMap;
+    let fileByFileImpact = {};
+    const files = Object.keys(groupFileImpactMap);
 
     files.forEach((fileRelativeUrl) => {
-      const { beforeMerge, afterMerge } = groupFileImpactMap[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
+        : "none";
+      const meta = event === "deleted" ? beforeMerge.meta : afterMerge.meta;
 
       const { sizeMapBeforeMerge, sizeMapAfterMerge, sizeImpactMap } =
         getSizeMapsOneFile({
           sizeNames: transformationKeys,
           beforeMerge,
           afterMerge,
-        })
+        });
       const { showSizeImpact, formatFileRelativeUrl } = metaToData(meta, {
         fileRelativeUrl,
         sizeBeforeMerge: sizeMapBeforeMerge[0],
         sizeAfterMerge: sizeMapAfterMerge[0],
         sizeImpactMap,
-      })
+      });
       fileByFileImpact[fileRelativeUrl] = {
         event,
         manifestKeyBeforeMerge: beforeMerge
@@ -117,20 +117,23 @@ const renderCommentBody = ({
         sizeImpactMap,
         showSizeImpact,
         formatFileRelativeUrl,
-      }
-    })
+      };
+    });
     if (filesOrdering === "size_impact") {
-      fileByFileImpact = orderBySizeImpact(fileByFileImpact, transformationKeys)
+      fileByFileImpact = orderBySizeImpact(
+        fileByFileImpact,
+        transformationKeys,
+      );
     }
 
     const groupSizeMaps = getSizeMapsForManyFiles({
       sizeNames: transformationKeys,
       fileByFileImpact,
       files,
-    })
-    const groupSizeMapBeforeMerge = groupSizeMaps.sizeMapBeforeMerge
-    const groupSizeMapAfterMerge = groupSizeMaps.sizeMapAfterMerge
-    const groupIsEmpty = Object.keys(fileByFileImpact).length === 0
+    });
+    const groupSizeMapBeforeMerge = groupSizeMaps.sizeMapBeforeMerge;
+    const groupSizeMapAfterMerge = groupSizeMaps.sizeMapAfterMerge;
+    const groupIsEmpty = Object.keys(fileByFileImpact).length === 0;
 
     const groupSummary = formatGroupSummary({
       groupName,
@@ -138,14 +141,14 @@ const renderCommentBody = ({
       groupSizeMapAfterMerge,
       sizeNames: transformationKeys,
       fileByFileImpact,
-    })
+    });
     const groupShouldBeOpenByDefault = shouldOpenGroupByDefault({
       groupName,
       groupSizeMapBeforeMerge,
       groupSizeMapAfterMerge,
       sizeNames: transformationKeys,
       fileByFileImpact,
-    })
+    });
 
     return renderDetails({
       open: groupShouldBeOpenByDefault,
@@ -167,19 +170,22 @@ const renderCommentBody = ({
             groupSizeMapBeforeMerge,
             groupSizeMapAfterMerge,
           }),
-    })
-  })
+    });
+  });
 
-  const mergeImpact = formulateMergeImpact({ pullRequestHead, pullRequestBase })
+  const mergeImpact = formulateMergeImpact({
+    pullRequestHead,
+    pullRequestBase,
+  });
   if (groupMessages.length === 0) {
-    return mergeImpact
+    return mergeImpact;
   }
 
   return `${mergeImpact}
 ${groupMessages.join(`
 
-`)}`
-}
+`)}`;
+};
 
 const renderEmptyGroupContent = ({ groupName, groupConfig }) => {
   return `<p>No file in ${groupName} group (see config below).</p>
@@ -187,12 +193,12 @@ const renderEmptyGroupContent = ({ groupName, groupConfig }) => {
 \`\`\`json
 ${JSON.stringify(groupConfig, null, "  ")}
 \`\`\`
-`
-}
+`;
+};
 
 const formulateMergeImpact = ({ pullRequestBase, pullRequestHead }) => {
-  return `<p>Impact on file sizes when merging <em>${pullRequestHead}</em> into <em>${pullRequestBase}</em>.</p>`
-}
+  return `<p>Impact on file sizes when merging <em>${pullRequestHead}</em> into <em>${pullRequestBase}</em>.</p>`;
+};
 
 const metaToData = (
   meta,
@@ -201,7 +207,7 @@ const metaToData = (
   if (typeof meta === "boolean") {
     return {
       showSizeImpact: true,
-    }
+    };
   }
 
   if (typeof meta === "object") {
@@ -210,34 +216,34 @@ const metaToData = (
       sizeBeforeMerge,
       sizeAfterMerge,
       sizeImpactMap,
-    })
-    const { formatFileRelativeUrl } = meta
+    });
+    const { formatFileRelativeUrl } = meta;
     return {
       showSizeImpact,
       formatFileRelativeUrl,
-    }
+    };
   }
 
   console.warn(
     `meta must be a boolean or an object, received ${meta} for ${fileRelativeUrl}`,
-  )
+  );
   return {
     showSizeImpact: Boolean(meta),
-  }
-}
+  };
+};
 
 const showSizeImpactGetter = (
   meta,
   { fileRelativeUrl, sizeBeforeMerge, sizeAfterMerge, sizeImpactMap },
 ) => {
-  const { showSizeImpact } = meta
+  const { showSizeImpact } = meta;
 
   if (typeof showSizeImpact === "undefined") {
-    return true
+    return true;
   }
 
   if (typeof showSizeImpact === "boolean") {
-    return showSizeImpact
+    return showSizeImpact;
   }
 
   if (typeof showSizeImpact === "function") {
@@ -246,18 +252,18 @@ const showSizeImpactGetter = (
       sizeBeforeMerge,
       sizeAfterMerge,
       sizeImpactMap,
-    })
+    });
   }
 
   console.warn(
     `showSizeImpact must be a boolean or a function, received ${showSizeImpact} for ${fileRelativeUrl}`,
-  )
-  return true
-}
+  );
+  return true;
+};
 
 const renderDetails = ({ summary, content, open = false, indent = 0 }) => {
   return `${" ".repeat(indent)}<details${open ? " open" : ""}>
 ${" ".repeat(indent + 2)}<summary>${summary}</summary>
 ${" ".repeat(indent + 2)}${content}
-${" ".repeat(indent)}</details>`
-}
+${" ".repeat(indent)}</details>`;
+};

package/src/internal/formatFileSizeReportForLog.js

@@ -1,40 +1,41 @@
-import { formatSize } from "./formatSize.js"
-import { manifestToMappings, manifestKeyFromRelativeUrl } from "./manifest.js"
+import { formatSize } from "./formatSize.js";
+import { manifestToMappings, manifestKeyFromRelativeUrl } from "./manifest.js";
 
 export const formatFileSizeReportForLog = (fileSizeReport) => {
-  const { groups } = fileSizeReport
+  const { groups } = fileSizeReport;
 
   const groupMessages = Object.keys(groups).map((groupName) => {
-    const { fileMap, manifestMap } = groups[groupName]
+    const { fileMap, manifestMap } = groups[groupName];
 
-    const mappings = manifestToMappings(manifestMap)
+    const mappings = manifestToMappings(manifestMap);
     const fileMessages = Object.keys(fileMap).map((fileRelativeUrl) => {
       const fileDisplayed =
-        manifestKeyFromRelativeUrl(fileRelativeUrl, mappings) || fileRelativeUrl
-      const file = fileMap[fileRelativeUrl]
-      const { sizeMap } = file
-      const sizeNames = Object.keys(sizeMap)
+        manifestKeyFromRelativeUrl(fileRelativeUrl, mappings) ||
+        fileRelativeUrl;
+      const file = fileMap[fileRelativeUrl];
+      const { sizeMap } = file;
+      const sizeNames = Object.keys(sizeMap);
       if (sizeNames.length === 1) {
-        return `${fileDisplayed}: ${formatSize(sizeMap[sizeNames[0]])}`
+        return `${fileDisplayed}: ${formatSize(sizeMap[sizeNames[0]])}`;
       }
 
       const sizesFormatted = sizeNames.map((sizeName) => {
-        return `${sizeName}: ${formatSize(sizeMap[sizeName])}`
-      })
-      return `${fileDisplayed}: { ${sizesFormatted.join(`, `)} }`
-    })
+        return `${sizeName}: ${formatSize(sizeMap[sizeName])}`;
+      });
+      return `${fileDisplayed}: { ${sizesFormatted.join(`, `)} }`;
+    });
 
     return `${groupName}
 ---------------------
 ${fileMessages.join(`
-`)}`
-  })
+`)}`;
+  });
 
   const message = `
 ${groupMessages.join(`
 
 `)}
-`
+`;
 
-  return message
-}
+  return message;
+};

package/src/internal/formatSize.js

@@ -1,14 +1,14 @@
-import { byteAsFileSize } from "@jsenv/log"
+import { byteAsFileSize } from "@jsenv/log";
 
 export const formatSize = (sizeNumber, { diff = false } = {}) => {
-  const sizeNumberAbsolute = Math.abs(sizeNumber)
-  let sizeString = byteAsFileSize(sizeNumberAbsolute)
+  const sizeNumberAbsolute = Math.abs(sizeNumber);
+  let sizeString = byteAsFileSize(sizeNumberAbsolute);
   if (diff) {
     if (sizeNumber < 0) {
-      sizeString = `-${sizeString}`
+      sizeString = `-${sizeString}`;
     } else if (sizeNumber > 0) {
-      sizeString = `+${sizeString}`
+      sizeString = `+${sizeString}`;
     }
   }
-  return sizeString
-}
+  return sizeString;
+};

package/src/internal/format_percentage.js

@@ -1,8 +1,8 @@
-import { setRoundedPrecision } from "@jsenv/log"
+import { setRoundedPrecision } from "@jsenv/log";
 
 export const formatPercentage = (number) => {
   return `${number < 0 ? `-` : "+"}${setRoundedPrecision(Math.abs(number), {
     decimals: 0,
     decimalsWhenSmall: 1,
-  })}%`
-}
+  })}%`;
+};

package/src/internal/helper.js

@@ -1,12 +1,12 @@
 // https://gist.github.com/borekb/f83e48479aceaafa43108e021600f7e3
 export const anchor = (text, id) => {
-  return `<a href="#user-content-${id.replace()}">${text}<a>`
-}
+  return `<a href="#user-content-${id.replace()}">${text}<a>`;
+};
 
-export const isAdded = ({ beforeMerge }) => !beforeMerge
+export const isAdded = ({ beforeMerge }) => !beforeMerge;
 
 export const isDeleted = ({ beforeMerge, afterMerge }) =>
-  beforeMerge && !afterMerge
+  beforeMerge && !afterMerge;
 
 export const isModified = ({ beforeMerge, afterMerge }) =>
-  beforeMerge && afterMerge && beforeMerge.hash !== afterMerge.hash
+  beforeMerge && afterMerge && beforeMerge.hash !== afterMerge.hash;