@jsenv/file-size-impact 14.1.1 → 14.1.3

package/bin/filesize.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
-import { pathToFileURL } from "node:url"
-import { generateFileSizeReport } from "@jsenv/file-size-impact"
+import { pathToFileURL } from "node:url";
+import { generateFileSizeReport } from "@jsenv/file-size-impact";
 
-const cwdUrl = `${pathToFileURL(process.cwd())}/`
-const argv = process.argv.slice(2)
-const dirname = argv[0] || "dist"
+const cwdUrl = `${pathToFileURL(process.cwd())}/`;
+const argv = process.argv.slice(2);
+const dirname = argv[0] || "dist";
 
 await generateFileSizeReport({
   log: true,
@@ -16,4 +16,4 @@ await generateFileSizeReport({
       [`${dirname}/**/*.map`]: false,
     },
   },
-})
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/file-size-impact",
-  "version": "14.1.1",
+  "version": "14.1.3",
   "description": "Add files size impact into pull requests",
   "license": "MIT",
   "repository": {
@@ -35,9 +35,9 @@
   },
   "dependencies": {
     "@jsenv/dynamic-import-worker": "1.1.0",
-    "@jsenv/filesystem": "4.2.3",
-    "@jsenv/github-pull-request-impact": "1.7.2",
-    "@jsenv/log": "3.3.4",
-    "@jsenv/urls": "2.0.0"
+    "@jsenv/filesystem": "4.3.2",
+    "@jsenv/github-pull-request-impact": "1.7.3",
+    "@jsenv/log": "3.4.1",
+    "@jsenv/urls": "2.2.1"
   }
 }

package/readme.md

@@ -17,8 +17,8 @@ Screenshot + explanation on pull request comment.
 | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
 | "remaining files (+4.71%)"     | There is a group of files named "remaining files" and pull request has an overall impact of _+4.71%_ on these files.          |
 | "21.6 kB (+4.11 kB / +23.55%)" | The size after merge is _21.6 kB_. Pull request adds _4.11 kB_ representing an increase of _23.55%_ of the size before merge. |
-| "_Unmodified (4)_"             | Sum files in "remaining files" group not impacted by the pull request.                                                        |
-| _Total (5)_                    | Sum files in "remaining files" group.                                                                                         |
+| "_Unmodified (4)_"             | Sum of files in that group that are not impacted by the pull request.                                                         |
+| _Total (5)_                    | Sum of files in that group.                                                                                                   |
 
 # Installation
 
@@ -31,7 +31,7 @@ npm install --save-dev @jsenv/file-size-impact
 _file_size.mjs_
 
 ```js
-import { generateFileSizeReport } from "@jsenv/file-size-impact"
+import { generateFileSizeReport } from "@jsenv/file-size-impact";
 
 export const fileSizeReport = await generateFileSizeReport({
   log: process.argv.includes("--log"),
@@ -42,7 +42,7 @@ export const fileSizeReport = await generateFileSizeReport({
       "./dist/**/*.map": false,
     },
   },
-})
+});
 ```
 
 At this stage, you could generate a file size report on your machine with the following command.
@@ -85,7 +85,7 @@ jobs:
       - name: Setup npm
         run: npm install
       - name: Report file size impact
-        run: node ./file_size.mjs
+        run: node ./report_file_size_impact.mjs
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 ```
@@ -103,13 +103,13 @@ _report_file_size_impact.mjs_
 import {
   reportFileSizeImpactInGitHubPullRequest,
   readGitHubWorkflowEnv,
-} from "@jsenv/file-size-impact"
+} from "@jsenv/file-size-impact";
 
 await reportFileSizeImpactInGitHubPullRequest({
   ...readGitHubWorkflowEnv(),
   buildCommand: "npm run dist",
   fileSizeReportUrl: new URL("./file_size.mjs#fileSizeReport", import.meta.url),
-})
+});
 ```
 
 **Notes**:
@@ -179,7 +179,7 @@ In order to analyse the impact of a pull request on file size the following step
 _generateFileSizeReport_ is an async function scanning filesystem to compute a list of file sizes and return these infos into an object.
 
 ```js
-import { generateFileSizeReport, raw, gzip } from "@jsenv/file-size-impact"
+import { generateFileSizeReport, raw, gzip } from "@jsenv/file-size-impact";
 
 const fileSizeReport = await generateFileSizeReport({
   rootDirectoryUrl: new URL("./", import.meta.url),
@@ -189,7 +189,7 @@ const fileSizeReport = await generateFileSizeReport({
     },
   },
   transformations: { raw, gzip },
-})
+});
 ```
 
 ## trackingConfig
@@ -202,7 +202,7 @@ _trackingConfig_ values are objects associating a pattern to a value. This objec
 For example you can create two groups named _"critical files"_ and _"remaining files"_ like this:
 
 ```js
-import { generateFileSizeReport } from "@jsenv/file-size-impact"
+import { generateFileSizeReport } from "@jsenv/file-size-impact";
 
 await generateFileSizeReport({
   trackingConfig: {
@@ -217,7 +217,7 @@ await generateFileSizeReport({
       "./dist/main.css": false,
     },
   },
-})
+});
 ```
 
 ![screenshot of pull request comment where groups are highlighted](./docs/comment_group_highlighted.png)
@@ -234,11 +234,11 @@ import {
   raw,
   gzip,
   brotli,
-} from "@jsenv/file-size-impact"
+} from "@jsenv/file-size-impact";
 
 await generateFileSizeReport({
   transformations: { raw, gzip, brotli },
-})
+});
 ```
 
 ![screenshot of pull request comment with gzip and brotli](./docs/comment_compression.png)
@@ -248,7 +248,7 @@ _raw_, _gzip_ and _brotli_ compression can be enabled this way.
 It's also possible to control compression level.
 
 ```js
-import { generateFileSizeReport, raw, gzip } from "@jsenv/file-size-impact"
+import { generateFileSizeReport, raw, gzip } from "@jsenv/file-size-impact";
 
 await generateFileSizeReport({
   transformations: {
@@ -256,7 +256,7 @@ await generateFileSizeReport({
     gzip7: (buffer) => gzip(buffer, { level: 7 }),
     gzip9: (buffer) => gzip(buffer, { level: 9 }),
   },
-})
+});
 ```
 
 Finally _transformations_ can be used to add custom _transformations_.
@@ -267,14 +267,14 @@ import {
   raw,
   gzip,
   brotli,
-} from "@jsenv/file-size-impact"
+} from "@jsenv/file-size-impact";
 
 await generateFileSizeReport({
   transformations: {
     raw,
     trim: (buffer) => String(buffer).trim(),
   },
-})
+});
 ```
 
 ## manifestConfig
@@ -284,25 +284,25 @@ _manifestConfig_ parameter is an object used to configure the location of an opt
 This parameter reuses the shape of [trackingConfig](#trackingConfig) (associating pattern + value).
 
 ```js
-import { reportFileSizeImpactInGitHubPullRequest } from "@jsenv/file-size-impact"
+import { reportFileSizeImpactInGitHubPullRequest } from "@jsenv/file-size-impact";
 
 await reportFileSizeImpactInGitHubPullRequest({
   manifestConfig: {
     "./dist/**/manifest.json": true,
   },
-})
+});
 ```
 
 You can disable manifest files handling by passing `null`.
 
 ```js
-import { reportFileSizeImpactInGitHubPullRequest } from "@jsenv/file-size-impact"
+import { reportFileSizeImpactInGitHubPullRequest } from "@jsenv/file-size-impact";
 
 await reportFileSizeImpactInGitHubPullRequest({
   manifestConfig: {
     "./dist/**/manifest.json": null,
   },
-})
+});
 ```
 
 In that case _manifest.json_ will be handled as a regular file.
@@ -315,7 +315,7 @@ _reportFileSizeImpactInGitHubPullRequest_ is an async function that will analyse
 import {
   reportFileSizeImpactInGitHubPullRequest,
   raw,
-} from "@jsenv/file-size-impact"
+} from "@jsenv/file-size-impact";
 
 await reportFileSizeImpactInGitHubPullRequest({
   logLevel: "info",
@@ -330,7 +330,7 @@ await reportFileSizeImpactInGitHubPullRequest({
   buildCommand: "npm run build",
   fileSizeReportUrl: new URL("./file_size.mjs#fileSizeReport", import.meta.url),
   filesOrdering: "size_impact",
-})
+});
 ```
 
 ## logLevel
@@ -375,14 +375,14 @@ This parameter is returned by [readGitHubWorkflowEnv](#readGitHubWorkflowEnv) me
 Inside an other workflow, you can pass your own _runLink_. As in the example below where it is assumed that script is runned by jenkins.
 
 ```js
-import { reportFileSizeImpactInGitHubPullRequest } from "@jsenv/file-size-impact"
+import { reportFileSizeImpactInGitHubPullRequest } from "@jsenv/file-size-impact";
 
 await reportFileSizeImpactInGitHubPullRequest({
   runLink: {
     url: process.env.BUILD_URL,
     text: `${process.env.JOB_NAME}#${process.env.BUILD_ID}`,
   },
-})
+});
 ```
 
 # commitInGeneratedByInfo
@@ -399,13 +399,13 @@ _readGitHubWorkflowEnv_ is a function meant to be runned inside a GitHub workflo
 import {
   reportFileSizeImpactInGitHubPullRequest,
   readGitHubWorkflowEnv,
-} from "@jsenv/file-size-impact"
+} from "@jsenv/file-size-impact";
 
-const gitHubWorkflowEnv = readGitHubWorkflowEnv()
+const gitHubWorkflowEnv = readGitHubWorkflowEnv();
 
 await reportFileSizeImpactInGitHubPullRequest({
   ...gitHubWorkflowEnv,
-})
+});
 ```
 
 _gitHubWorkflowEnv_ object looks like this:
@@ -421,7 +421,7 @@ const gitHubWorkflowEnv = {
     url: "https://github.com/jsenv/repository-name/actions/runs/34",
     text: "workflow-name#34",
   },
-}
+};
 ```
 
 # File with dynamic names

package/src/brotliTransformation.js

@@ -1,6 +1,6 @@
-import { brotliCompress, constants } from "node:zlib"
+import { brotliCompress, constants } from "node:zlib";
 
-export const name = "brotli"
+export const name = "brotli";
 
 export const transform = (
   value,
@@ -23,11 +23,11 @@ export const transform = (
       },
       (error, buffer) => {
         if (error) {
-          reject(error)
+          reject(error);
         } else {
-          resolve(buffer)
+          resolve(buffer);
         }
       },
-    )
-  })
-}
+    );
+  });
+};

package/src/generateFileSizeReport.js

@@ -1,15 +1,15 @@
-import { fileURLToPath } from "node:url"
+import { fileURLToPath } from "node:url";
 import {
   assertAndNormalizeDirectoryUrl,
   bufferToEtag,
   readFile,
-} from "@jsenv/filesystem"
-import { createDetailedMessage, createLogger } from "@jsenv/log"
+} from "@jsenv/filesystem";
+import { createDetailedMessage, createLogger } from "@jsenv/log";
 
-import { transform as rawTransform } from "./rawTransformation.js"
-import { jsenvTrackingConfig } from "./jsenvTrackingConfig.js"
-import { applyTrackingConfig } from "./internal/applyTrackingConfig.js"
-import { formatFileSizeReportForLog } from "./internal/formatFileSizeReportForLog.js"
+import { transform as rawTransform } from "./rawTransformation.js";
+import { jsenvTrackingConfig } from "./jsenvTrackingConfig.js";
+import { applyTrackingConfig } from "./internal/applyTrackingConfig.js";
+import { formatFileSizeReportForLog } from "./internal/formatFileSizeReportForLog.js";
 
 export const generateFileSizeReport = async ({
   cancellationToken,
@@ -22,30 +22,30 @@ export const generateFileSizeReport = async ({
   },
   transformations = { raw: rawTransform },
 }) => {
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
 
-  const logger = createLogger({ logLevel })
+  const logger = createLogger({ logLevel });
 
-  const trackingNames = Object.keys(trackingConfig)
+  const trackingNames = Object.keys(trackingConfig);
   if (trackingNames.length === 0) {
-    logger.warn(`trackingConfig is empty`)
+    logger.warn(`trackingConfig is empty`);
   }
 
   const groupTrackingResults = await applyTrackingConfig(trackingConfig, {
     cancellationToken,
     rootDirectoryUrl,
     manifestConfig,
-  })
-  const groupNames = Object.keys(groupTrackingResults)
-  const groups = {}
+  });
+  const groupNames = Object.keys(groupTrackingResults);
+  const groups = {};
 
   // ensure keys order is the same as trackingConfig (despite Promise.all below)
   groupNames.forEach((groupName) => {
-    groups[groupName] = null
-  })
+    groups[groupName] = null;
+  });
   await Promise.all(
     groupNames.map(async (groupName) => {
-      const groupTrackingResult = groupTrackingResults[groupName]
+      const groupTrackingResult = groupTrackingResults[groupName];
       const groupReport = await groupTrackingResultToGroupReport(
         groupTrackingResult,
         {
@@ -54,40 +54,40 @@ export const generateFileSizeReport = async ({
           tracking: trackingConfig[groupName],
           transformations,
         },
-      )
-      groups[groupName] = groupReport
+      );
+      groups[groupName] = groupReport;
     }),
-  )
+  );
 
   const fileSizeReport = {
     transformationKeys: Object.keys(transformations),
     groups,
-  }
+  };
 
   if (log) {
-    logger.info(formatFileSizeReportForLog(fileSizeReport))
+    logger.info(formatFileSizeReportForLog(fileSizeReport));
   }
 
-  return fileSizeReport
-}
+  return fileSizeReport;
+};
 
 const groupTrackingResultToGroupReport = async (
   groupTrackingResult,
   { logger, rootDirectoryUrl, tracking, transformations },
 ) => {
-  const manifestMap = {}
-  const { manifestMetaMap } = groupTrackingResult
-  const manifestRelativeUrls = Object.keys(manifestMetaMap)
+  const manifestMap = {};
+  const { manifestMetaMap } = groupTrackingResult;
+  const manifestRelativeUrls = Object.keys(manifestMetaMap);
   await Promise.all(
     manifestRelativeUrls.map(async (manifestRelativeUrl) => {
       const manifestFileUrl = new URL(manifestRelativeUrl, rootDirectoryUrl)
-        .href
+        .href;
       const manifestFileContent = await readFile(manifestFileUrl, {
         as: "string",
-      })
-      let manifest
+      });
+      let manifest;
       try {
-        manifest = JSON.parse(manifestFileContent)
+        manifest = JSON.parse(manifestFileContent);
       } catch (e) {
         if (e.name === "SyntaxError") {
           logger.error(
@@ -98,55 +98,55 @@ const groupTrackingResultToGroupReport = async (
                 "manifest file": fileURLToPath(manifestFileUrl),
               },
             ),
-          )
-          return
+          );
+          return;
         }
-        throw e
+        throw e;
       }
-      manifestMap[manifestRelativeUrl] = manifest
+      manifestMap[manifestRelativeUrl] = manifest;
     }),
-  )
+  );
 
-  const fileMap = {}
-  const { trackedMetaMap } = groupTrackingResult
-  const trackedRelativeUrls = Object.keys(trackedMetaMap)
+  const fileMap = {};
+  const { trackedMetaMap } = groupTrackingResult;
+  const trackedRelativeUrls = Object.keys(trackedMetaMap);
   // we use reduce and not Promise.all() because transformation can be expensive (gzip, brotli)
   // so we won't benefit from concurrency (it might even make things worse)
   await trackedRelativeUrls.reduce(async (previous, fileRelativeUrl) => {
-    await previous
-    const fileUrl = new URL(fileRelativeUrl, rootDirectoryUrl).href
-    const fileBuffer = await readFile(fileUrl, { as: "buffer" })
+    await previous;
+    const fileUrl = new URL(fileRelativeUrl, rootDirectoryUrl).href;
+    const fileBuffer = await readFile(fileUrl, { as: "buffer" });
     const sizeMap = await getFileSizeMap(fileBuffer, {
       transformations,
       logger,
       fileUrl,
-    })
-    const hash = bufferToEtag(fileBuffer)
+    });
+    const hash = bufferToEtag(fileBuffer);
     fileMap[fileRelativeUrl] = {
       sizeMap,
       hash,
       meta: trackedMetaMap[fileRelativeUrl],
-    }
-  }, Promise.resolve())
+    };
+  }, Promise.resolve());
 
   return {
     tracking,
     manifestMap,
     fileMap,
-  }
-}
+  };
+};
 
 const getFileSizeMap = async (
   fileBuffer,
   { transformations, logger, fileUrl },
 ) => {
-  const sizeMap = {}
+  const sizeMap = {};
   await Object.keys(transformations).reduce(async (previous, sizeName) => {
-    await previous
-    const transform = transformations[sizeName]
+    await previous;
+    const transform = transformations[sizeName];
     try {
-      const transformResult = await transform(fileBuffer)
-      sizeMap[sizeName] = Buffer.from(transformResult).length
+      const transformResult = await transform(fileBuffer);
+      sizeMap[sizeName] = Buffer.from(transformResult).length;
     } catch (e) {
       logger.error(
         createDetailedMessage(
@@ -155,9 +155,9 @@ const getFileSizeMap = async (
             "error stack": e.stack,
           },
         ),
-      )
-      sizeMap[sizeName] = "error"
+      );
+      sizeMap[sizeName] = "error";
     }
-  }, Promise.resolve())
-  return sizeMap
-}
+  }, Promise.resolve());
+  return sizeMap;
+};

package/src/gzipTransformation.js

@@ -1,6 +1,6 @@
-import { gzip, constants } from "node:zlib"
+import { gzip, constants } from "node:zlib";
 
-export const name = "gzip"
+export const name = "gzip";
 
 export const transform = (
   value,
@@ -9,10 +9,10 @@ export const transform = (
   return new Promise((resolve, reject) => {
     gzip(value, { level, ...rest }, (error, buffer) => {
       if (error) {
-        reject(error)
+        reject(error);
       } else {
-        resolve(buffer)
+        resolve(buffer);
       }
-    })
-  })
-}
+    });
+  });
+};

package/src/internal/applyTrackingConfig.js

@@ -1,34 +1,34 @@
-import { fileURLToPath } from "node:url"
-import { collectDirectoryMatchReport } from "@jsenv/filesystem"
+import { fileURLToPath } from "node:url";
+import { collectDirectoryMatchReport } from "@jsenv/filesystem";
 
 export const applyTrackingConfig = async (
   trackingConfig,
   { rootDirectoryUrl, manifestConfig },
 ) => {
-  const result = {}
-  const trackingNames = Object.keys(trackingConfig)
+  const result = {};
+  const trackingNames = Object.keys(trackingConfig);
   // ensure keys order is the same as trackingConfig (despite Promise.all below)
   trackingNames.forEach((trackingName) => {
-    result[trackingName] = null
-  })
+    result[trackingName] = null;
+  });
   await Promise.all(
     trackingNames.map(async (trackingName) => {
-      const tracking = trackingConfig[trackingName]
+      const tracking = trackingConfig[trackingName];
       const groupTrackingResult = await applyTracking(tracking, {
         rootDirectoryUrl,
         manifestConfig,
-      })
-      result[trackingName] = groupTrackingResult
+      });
+      result[trackingName] = groupTrackingResult;
     }),
-  )
-  return result
-}
+  );
+  return result;
+};
 
 const applyTracking = async (
   tracking,
   { rootDirectoryUrl, manifestConfig },
 ) => {
-  let directoryMatchReport
+  let directoryMatchReport;
   try {
     directoryMatchReport = await collectDirectoryMatchReport({
       directoryUrl: rootDirectoryUrl,
@@ -37,35 +37,35 @@ const applyTracking = async (
         ...(manifestConfig ? { manifest: manifestConfig } : {}),
       },
       predicate: (meta) => Boolean(meta.track) || Boolean(meta.manifest),
-    })
+    });
   } catch (e) {
-    const directoryPath = fileURLToPath(rootDirectoryUrl)
+    const directoryPath = fileURLToPath(rootDirectoryUrl);
     if (e.code === "ENOENT" && e.path === directoryPath) {
-      console.warn(`${directoryPath} does not exists`)
-      return []
+      console.warn(`${directoryPath} does not exists`);
+      return [];
     }
-    throw e
+    throw e;
   }
 
-  const { matchingArray, ignoredArray } = directoryMatchReport
+  const { matchingArray, ignoredArray } = directoryMatchReport;
 
-  const trackedMetaMap = {}
-  const ignoredMetaMap = {}
-  const manifestMetaMap = {}
+  const trackedMetaMap = {};
+  const ignoredMetaMap = {};
+  const manifestMetaMap = {};
   ignoredArray.forEach(({ relativeUrl }) => {
-    ignoredMetaMap[relativeUrl] = null
-  })
+    ignoredMetaMap[relativeUrl] = null;
+  });
   matchingArray.forEach(({ relativeUrl, meta }) => {
     if (meta.manifest) {
-      manifestMetaMap[relativeUrl] = meta.manifest
+      manifestMetaMap[relativeUrl] = meta.manifest;
     } else {
-      trackedMetaMap[relativeUrl] = meta.track
+      trackedMetaMap[relativeUrl] = meta.track;
     }
-  })
+  });
 
   return {
     trackedMetaMap,
     ignoredMetaMap,
     manifestMetaMap,
-  }
-}
+  };
+};