@jsenv/file-size-impact 11.0.2 → 12.1.2

package/{index.js → main.js}

@@ -1,10 +1,8 @@
-export { readGitHubWorkflowEnv } from "@jsenv/github-pull-request-impact"
-
 export { jsenvTrackingConfig } from "./src/jsenvTrackingConfig.js"
 export { transform as raw } from "./src/rawTransformation.js"
 export { transform as gzip } from "./src/gzipTransformation.js"
 export { transform as brotli } from "./src/brotliTransformation.js"
+export { generateFileSizeReport } from "./src/generateFileSizeReport.js"
 
-export { getFileSizeReport } from "./src/getFileSizeReport.js"
-export { logFileSizeReport } from "./src/logFileSizeReport.js"
+export { readGitHubWorkflowEnv } from "@jsenv/github-pull-request-impact"
 export { reportFileSizeImpact } from "./src/reportFileSizeImpact.js"

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@jsenv/file-size-impact",
-  "version": "11.0.2",
+  "version": "12.1.2",
   "description": "Add files size impact into pull requests",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsenv/file-size-impact"
+    "url": "https://github.com/jsenv/workflow",
+    "directory": "packages/jsenv-file-size-impact"
   },
   "engines": {
     "node": ">=14.17.0"
@@ -17,49 +18,39 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": "./index.js"
+      "import": "./main.js"
     },
     "./*": "./*"
   },
+  "main": "./main.js",
   "files": [
     "/src/",
-    "/index.js"
+    "/main.js"
   ],
   "scripts": {
-    "eslint-check": "node ./node_modules/eslint/bin/eslint.js . --ext=.js,.mjs",
-    "generate-importmap": "node ./script/importmap/generate_importmap.mjs",
-    "measure-file-sizes": "node ./script/file_size/generate_file_size_report.mjs --local",
-    "generate-comment-snapshot-file": "node ./test/comment/generate_comment_snapshot_file.mjs",
+    "eslint": "npx eslint . --ext=.js,.mjs",
+    "importmap": "node ./script/importmap/importmap.mjs",
+    "snapshot": "node ./test/comment/generate_comment_snapshot_file.mjs",
     "test": "node ./script/test/test.mjs",
     "test-with-coverage": "npm run test -- --coverage",
-    "prettier-format": "node ./script/prettier/prettier_format.mjs",
-    "prettier-format-stage": "npm run prettier-format -- --staged",
-    "prettier-check": "npm run prettier-format -- --dry-run",
-    "prepublishOnly": "node ./script/publish/remove_postinstall.mjs",
-    "postpublish": "node ./script/publish/restore_postinstall.mjs"
+    "file-size": "node ./script/file_size/file_size.mjs --log",
+    "prettier": "prettier --write ."
   },
   "dependencies": {
-    "@jsenv/github-pull-request-impact": "1.6.4",
+    "@jsenv/dynamic-import-worker": "1.0.0",
+    "@jsenv/filesystem": "2.7.1",
+    "@jsenv/github-pull-request-impact": "1.6.6",
     "@jsenv/logger": "4.0.1",
-    "@jsenv/filesystem": "2.2.0",
     "pretty-bytes": "5.6.0"
   },
   "devDependencies": {
-    "@babel/core": "7.15.8",
-    "@babel/eslint-parser": "7.15.8",
-    "@jsenv/assert": "2.3.2",
-    "@jsenv/cancellation": "3.0.0",
-    "@jsenv/codecov-upload": "3.5.0",
-    "@jsenv/core": "23.0.2",
-    "@jsenv/eslint-config": "16.0.8",
-    "@jsenv/filesystem": "2.2.0",
-    "@jsenv/github-release-package": "1.2.3",
-    "@jsenv/importmap-eslint-resolver": "5.1.2",
-    "@jsenv/importmap-node-module": "2.4.1",
-    "@jsenv/package-publish": "1.6.2",
-    "@jsenv/prettier-check-project": "5.6.1",
-    "eslint": "7.32.0",
-    "eslint-plugin-import": "2.25.2",
-    "prettier": "2.4.1"
+    "@jsenv/assert": "2.4.1",
+    "@jsenv/core": "25.3.0",
+    "@jsenv/eslint-config": "16.0.9",
+    "@jsenv/importmap-eslint-resolver": "5.2.5",
+    "@jsenv/importmap-node-module": "5.1.3",
+    "eslint": "8.7.0",
+    "eslint-plugin-import": "2.25.4",
+    "prettier": "2.5.1"
   }
 }

package/readme.md

@@ -44,22 +44,25 @@ npm install --save-dev @jsenv/file-size-impact
 _generate_file_size_report.mjs_
 
 ```js
-import { getFileSizeReport } from "@jsenv/file-size-impact"
-
-export const generateFileSizeReport = async () => {
-  return getFileSizeReport({
-    projectDirectoryUrl: new URL("./", import.meta.url),
-    trackingConfig: {
-      dist: {
-        "./dist/**/*": true,
-        "./dist/**/*.map": false,
-      },
+import { generateFileSizeReport } from "@jsenv/file-size-impact"
+
+export const filesizeReport = await generateFileSizeReport({
+  log: process.argv.includes("--log"),
+  projectDirectoryUrl: new URL("./", import.meta.url),
+  trackingConfig: {
+    dist: {
+      "./dist/**/*": true,
+      "./dist/**/*.map": false,
     },
-  })
-}
+  },
+})
 ```
 
-At this stage, you could generate a file size report on your machine. For an example, see [script/file_size/generate_file_size_report.mjs#L14](./script/file_size/generate_file_size_report.mjs#L14).
+At this stage, you could generate a file size report on your machine with the following command.
+
+```console
+node ./generate_file_size_report.mjs --log
+```
 
 Now it's time to configure a workflow to compare file size reports before and after merging a pull request.
 
@@ -176,14 +179,14 @@ In order to analyse the impact of a pull request on file size the following step
 7. Analyse differences between the two file size reports
 8. Post or update comment in the pull request
 
-# getFileSizeReport
+# generateFileSizeReport
 
-_getFileSizeReport_ is an async function scanning filesystem to compute a list of file sizes and return these infos into an object.
+_generateFileSizeReport_ is an async function scanning filesystem to compute a list of file sizes and return these infos into an object.
 
 ```js
-import { getFileSizeReport, raw, gzip } from "@jsenv/file-size-impact"
+import { generateFileSizeReport, raw, gzip } from "@jsenv/file-size-impact"
 
-const fileSizeReport = await getFileSizeReport({
+const fileSizeReport = await generateFileSizeReport({
   projectDirectoryUrl: new URL("./", import.meta.url),
   trackingConfig: {
     dist: {
@@ -204,9 +207,9 @@ _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 { getFileSizeReport } from "@jsenv/file-size-impact"
+import { generateFileSizeReport } from "@jsenv/file-size-impact"
 
-await getFileSizeReport({
+await generateFileSizeReport({
   trackingConfig: {
     "critical files": {
       "./dist/main.js": true,
@@ -231,9 +234,9 @@ _transformations_ parameter is an object used to transform files content before
 You can use this parameter to track file size after gzip compression.
 
 ```js
-import { getFileSizeReport, raw, gzip, brotli } from "@jsenv/file-size-impact"
+import { generateFileSizeReport, raw, gzip, brotli } from "@jsenv/file-size-impact"
 
-await getFileSizeReport({
+await generateFileSizeReport({
   transformations: { raw, gzip, brotli },
 })
 ```
@@ -245,9 +248,9 @@ _raw_, _gzip_ and _brotli_ compression can be enabled this way.
 It's also possible to control compression level.
 
 ```js
-import { getFileSizeReport, raw, gzip } from "@jsenv/file-size-impact"
+import { generateFileSizeReport, raw, gzip } from "@jsenv/file-size-impact"
 
-await getFileSizeReport({
+await generateFileSizeReport({
   transformations: {
     raw,
     gzip7: (buffer) => gzip(buffer, { level: 7 }),
@@ -259,9 +262,9 @@ await getFileSizeReport({
 Finally _transformations_ can be used to add custom _transformations_.
 
 ```js
-import { getFileSizeReport, raw, gzip, brotli } from "@jsenv/file-size-impact"
+import { generateFileSizeReport, raw, gzip, brotli } from "@jsenv/file-size-impact"
 
-await getFileSizeReport({
+await generateFileSizeReport({
   transformations: {
     raw,
     trim: (buffer) => String(buffer).trim(),

package/src/brotliTransformation.js

@@ -1,10 +1,14 @@
-import { brotliCompress, constants } from "zlib"
+import { brotliCompress, constants } from "node:zlib"
 
 export const name = "brotli"
 
 export const transform = (
   value,
-  { quality = constants.BROTLI_MAX_QUALITY, size = Buffer.from(value).length, ...rest } = {},
+  {
+    quality = constants.BROTLI_MAX_QUALITY,
+    size = Buffer.from(value).length,
+    ...rest
+  } = {},
 ) => {
   return new Promise((resolve, reject) => {
     brotliCompress(
@@ -12,7 +16,8 @@ export const transform = (
       {
         params: {
           [constants.BROTLI_PARAM_QUALITY]: quality,
-          [constants.BROTLI_PARAM_SIZE_HINT]: typeof size === "number" ? size : 0,
+          [constants.BROTLI_PARAM_SIZE_HINT]:
+            typeof size === "number" ? size : 0,
           ...rest,
         },
       },

package/src/{getFileSizeReport.js → generateFileSizeReport.js}

@@ -1,4 +1,3 @@
-import { createDetailedMessage, createLogger } from "@jsenv/logger"
 import {
   assertAndNormalizeDirectoryUrl,
   bufferToEtag,
@@ -6,13 +5,16 @@ import {
   readFile,
   urlToFileSystemPath,
 } from "@jsenv/filesystem"
+import { createDetailedMessage, createLogger } from "@jsenv/logger"
 
 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 getFileSizeReport = async ({
+export const generateFileSizeReport = async ({
   cancellationToken,
+  log,
   logLevel,
   projectDirectoryUrl,
   trackingConfig = jsenvTrackingConfig,
@@ -45,12 +47,15 @@ export const getFileSizeReport = async ({
   await Promise.all(
     groupNames.map(async (groupName) => {
       const groupTrackingResult = groupTrackingResults[groupName]
-      const groupReport = await groupTrackingResultToGroupReport(groupTrackingResult, {
-        logger,
-        projectDirectoryUrl,
-        tracking: trackingConfig[groupName],
-        transformations,
-      })
+      const groupReport = await groupTrackingResultToGroupReport(
+        groupTrackingResult,
+        {
+          logger,
+          projectDirectoryUrl,
+          tracking: trackingConfig[groupName],
+          transformations,
+        },
+      )
       groups[groupName] = groupReport
     }),
   )
@@ -60,6 +65,10 @@ export const getFileSizeReport = async ({
     groups,
   }
 
+  if (log) {
+    logger.info(formatFileSizeReportForLog(fileSizeReport))
+  }
+
   return fileSizeReport
 }
 
@@ -72,18 +81,26 @@ const groupTrackingResultToGroupReport = async (
   const manifestRelativeUrls = Object.keys(manifestMetaMap)
   await Promise.all(
     manifestRelativeUrls.map(async (manifestRelativeUrl) => {
-      const manifestFileUrl = resolveUrl(manifestRelativeUrl, projectDirectoryUrl)
-      const manifestFileContent = await readFile(manifestFileUrl, { as: "string" })
+      const manifestFileUrl = resolveUrl(
+        manifestRelativeUrl,
+        projectDirectoryUrl,
+      )
+      const manifestFileContent = await readFile(manifestFileUrl, {
+        as: "string",
+      })
       let manifest
       try {
         manifest = JSON.parse(manifestFileContent)
       } catch (e) {
         if (e.name === "SyntaxError") {
           logger.error(
-            createDetailedMessage(`JSON.parse error while trying to parse a manifest file`, {
-              "error stack": e.stack,
-              "manifest file": urlToFileSystemPath(manifestFileUrl),
-            }),
+            createDetailedMessage(
+              `JSON.parse error while trying to parse a manifest file`,
+              {
+                "error stack": e.stack,
+                "manifest file": urlToFileSystemPath(manifestFileUrl),
+              },
+            ),
           )
           return
         }
@@ -103,7 +120,11 @@ const groupTrackingResultToGroupReport = async (
     const fileUrl = resolveUrl(fileRelativeUrl, projectDirectoryUrl)
     const fileContent = await readFile(fileUrl)
     const fileBuffer = Buffer.from(fileContent)
-    const sizeMap = await getFileSizeMap(fileBuffer, { transformations, logger, fileUrl })
+    const sizeMap = await getFileSizeMap(fileBuffer, {
+      transformations,
+      logger,
+      fileUrl,
+    })
     const hash = bufferToEtag(fileBuffer)
     fileMap[fileRelativeUrl] = {
       sizeMap,
@@ -119,7 +140,10 @@ const groupTrackingResultToGroupReport = async (
   }
 }
 
-const getFileSizeMap = async (fileBuffer, { transformations, logger, fileUrl }) => {
+const getFileSizeMap = async (
+  fileBuffer,
+  { transformations, logger, fileUrl },
+) => {
   const sizeMap = {}
   await Object.keys(transformations).reduce(async (previous, sizeName) => {
     await previous
@@ -129,9 +153,12 @@ const getFileSizeMap = async (fileBuffer, { transformations, logger, fileUrl })
       sizeMap[sizeName] = Buffer.from(transformResult).length
     } catch (e) {
       logger.error(
-        createDetailedMessage(`error while transforming ${fileUrl} with ${sizeName}`, {
-          "error stack": e.stack,
-        }),
+        createDetailedMessage(
+          `error while transforming ${fileUrl} with ${sizeName}`,
+          {
+            "error stack": e.stack,
+          },
+        ),
       )
       sizeMap[sizeName] = "error"
     }

package/src/gzipTransformation.js

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

package/src/internal/applyTrackingConfig.js

@@ -1,9 +1,11 @@
-import { urlToFileSystemPath, collectDirectoryMatchReport } from "@jsenv/filesystem"
-import { createCancellationToken } from "@jsenv/cancellation"
+import {
+  urlToFileSystemPath,
+  collectDirectoryMatchReport,
+} from "@jsenv/filesystem"
 
 export const applyTrackingConfig = async (
   trackingConfig,
-  { cancellationToken = createCancellationToken(), projectDirectoryUrl, manifestConfig },
+  { projectDirectoryUrl, manifestConfig },
 ) => {
   const result = {}
   const trackingNames = Object.keys(trackingConfig)
@@ -19,13 +21,15 @@ export const applyTrackingConfig = async (
         manifestConfig,
       })
       result[trackingName] = groupTrackingResult
-      cancellationToken.throwIfRequested()
     }),
   )
   return result
 }
 
-const applyTracking = async (tracking, { projectDirectoryUrl, manifestConfig }) => {
+const applyTracking = async (
+  tracking,
+  { projectDirectoryUrl, manifestConfig },
+) => {
   const structuredMetaMap = {
     track: tracking,
     ...(manifestConfig ? { manifest: manifestConfig } : {}),

package/src/internal/compareTwoFileSizeReports.js

@@ -1,4 +1,6 @@
-import { resolveUrl, comparePathnames, urlToRelativeUrl } from "@jsenv/filesystem"
+import { comparePathnames } from "@jsenv/filesystem"
+
+import { manifestToMappings, manifestKeyFromRelativeUrl } from "./manifest.js"
 
 export const compareTwoFileSizeReports = ({
   afterMergeFileSizeReport,
@@ -146,37 +148,6 @@ const compareTwoGroups = (beforeMergeGroup, afterMergeGroup) => {
   }
 }
 
-const ABSTRACT_DIRECTORY_URL = "file:///directory/"
-
-const manifestToMappings = (manifestMap) => {
-  const mappings = {}
-  Object.keys(manifestMap).forEach((manifestRelativeUrl) => {
-    const manifest = manifestMap[manifestRelativeUrl]
-    const manifestAbstractUrl = resolveUrl(manifestRelativeUrl, ABSTRACT_DIRECTORY_URL)
-    Object.keys(manifest).forEach((manifestKey) => {
-      const manifestValue = manifest[manifestKey]
-      const manifestKeyAsAbstractUrl = resolveUrl(manifestKey, manifestAbstractUrl)
-      const manifestValueAsAbstractUrl = resolveUrl(manifestValue, manifestAbstractUrl)
-      const manifestKeyAsRelativeUrl = urlToRelativeUrl(
-        manifestKeyAsAbstractUrl,
-        ABSTRACT_DIRECTORY_URL,
-      )
-      const manifestValueAsRelativeUrl = urlToRelativeUrl(
-        manifestValueAsAbstractUrl,
-        ABSTRACT_DIRECTORY_URL,
-      )
-      mappings[manifestKeyAsRelativeUrl] = manifestValueAsRelativeUrl
-    })
-  })
-  return mappings
-}
-
-const manifestKeyFromRelativeUrl = (relativeUrl, mappings) => {
-  return Object.keys(mappings).find((keyCandidate) => {
-    return mappings[keyCandidate] === relativeUrl
-  })
-}
-
 const sortFileStructure = (fileStructure) => {
   const relativeUrlSortedArray = Object.keys(fileStructure).sort(comparePathnames)
   const fileStructureSorted = {}

package/src/{logFileSizeReport.js → internal/formatFileSizeReportForLog.js}

@@ -1,23 +1,26 @@
-import { formatSize } from "./internal/formatSize.js"
+import { formatSize } from "./formatSize.js"
+import { manifestToMappings, manifestKeyFromRelativeUrl } from "./manifest.js"
 
-export const logFileSizeReport = (fileSizeReport) => {
+export const formatFileSizeReportForLog = (fileSizeReport) => {
   const { groups } = fileSizeReport
 
   const groupMessages = Object.keys(groups).map((groupName) => {
-    const { fileMap } = groups[groupName]
+    const { fileMap, manifestMap } = groups[groupName]
 
+    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)
       if (sizeNames.length === 1) {
-        return `${fileRelativeUrl}: ${formatSize(sizeMap[sizeNames[0]])}`
+        return `${fileDisplayed}: ${formatSize(sizeMap[sizeNames[0]])}`
       }
 
       const sizesFormatted = sizeNames.map((sizeName) => {
         return `${sizeName}: ${formatSize(sizeMap[sizeName])}`
       })
-      return `${fileRelativeUrl}: { ${sizesFormatted.join(`, `)} }`
+      return `${fileDisplayed}: { ${sizesFormatted.join(`, `)} }`
     })
 
     return `${groupName}
@@ -32,5 +35,5 @@ ${groupMessages.join(`
 `)}
 `
 
-  console.log(message)
+  return message
 }

package/src/internal/formatSize.js

@@ -1,4 +1,4 @@
-import { createRequire } from "module"
+import { createRequire } from "node:module"
 
 const require = createRequire(import.meta.url)
 

package/src/internal/manifest.js

@@ -0,0 +1,32 @@
+import { resolveUrl, urlToRelativeUrl } from "@jsenv/filesystem"
+
+export const manifestToMappings = (manifestMap) => {
+  const mappings = {}
+  Object.keys(manifestMap).forEach((manifestRelativeUrl) => {
+    const manifest = manifestMap[manifestRelativeUrl]
+    const manifestAbstractUrl = resolveUrl(manifestRelativeUrl, ABSTRACT_DIRECTORY_URL)
+    Object.keys(manifest).forEach((manifestKey) => {
+      const manifestValue = manifest[manifestKey]
+      const manifestKeyAsAbstractUrl = resolveUrl(manifestKey, manifestAbstractUrl)
+      const manifestValueAsAbstractUrl = resolveUrl(manifestValue, manifestAbstractUrl)
+      const manifestKeyAsRelativeUrl = urlToRelativeUrl(
+        manifestKeyAsAbstractUrl,
+        ABSTRACT_DIRECTORY_URL,
+      )
+      const manifestValueAsRelativeUrl = urlToRelativeUrl(
+        manifestValueAsAbstractUrl,
+        ABSTRACT_DIRECTORY_URL,
+      )
+      mappings[manifestKeyAsRelativeUrl] = manifestValueAsRelativeUrl
+    })
+  })
+  return mappings
+}
+
+const ABSTRACT_DIRECTORY_URL = "file:///directory/"
+
+export const manifestKeyFromRelativeUrl = (relativeUrl, mappings) => {
+  return Object.keys(mappings).find((keyCandidate) => {
+    return mappings[keyCandidate] === relativeUrl
+  })
+}

package/src/reportFileSizeImpact.js

@@ -1,21 +1,10 @@
-import { Worker } from "node:worker_threads"
-import {
-  assertAndNormalizeDirectoryUrl,
-  fileSystemPathToUrl,
-  isFileSystemPath,
-  resolveUrl,
-  urlToFileSystemPath,
-} from "@jsenv/filesystem"
 import { commentGitHubPullRequestImpact } from "@jsenv/github-pull-request-impact"
+import { assertAndNormalizeDirectoryUrl, resolveUrl } from "@jsenv/filesystem"
+import { importOneExportFromFile } from "@jsenv/dynamic-import-worker"
 
 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,
@@ -29,7 +18,7 @@ export const reportFileSizeImpact = async ({
   pullRequestNumber,
   installCommand = "npm install",
   buildCommand = "npm run-script build",
-  fileSizeModulePath,
+  fileSizeReportModulePath,
 
   // We could just to ...jsenvCommentParameters but explicitely passing params
   // helps autocompletion in vscode for dev using the function.
@@ -50,23 +39,29 @@ export const reportFileSizeImpact = async ({
   if (installCommand === null) {
     // a null installCommand means there is no need to install anything
   } else if (typeof installCommand !== "string") {
-    throw new TypeError(`installCommand must be a string but received ${installCommand}`)
+    throw new TypeError(
+      `installCommand must be a string but received ${installCommand}`,
+    )
   }
 
   if (buildCommand === null) {
     // a null buildCommand means there is no need to build anything
   } else if (typeof buildCommand !== "string") {
-    throw new TypeError(`buildCommand must be a string but received ${buildCommand}`)
+    throw new TypeError(
+      `buildCommand must be a string but received ${buildCommand}`,
+    )
   }
 
-  if (typeof fileSizeModulePath !== "string") {
-    throw new TypeError(`fileSizeModulePath must be a string but received ${fileSizeModulePath}`)
+  if (typeof fileSizeReportModulePath !== "string") {
+    throw new TypeError(
+      `fileSizeReportModulePath must be a string but received ${fileSizeReportModulePath}`,
+    )
   }
   projectDirectoryUrl = assertAndNormalizeDirectoryUrl(projectDirectoryUrl)
-  const fileSizeModuleUrl = isFileSystemPath(fileSizeModulePath)
-    ? fileSystemPathToUrl(fileSizeModulePath)
-    : resolveUrl(fileSizeModulePath, projectDirectoryUrl)
-  const workerFilePath = urlToFileSystemPath(workerFileUrl)
+  const fileSizeReportModuleUrl = resolveUrl(
+    fileSizeReportModulePath,
+    projectDirectoryUrl,
+  )
 
   return commentGitHubPullRequestImpact({
     logLevel,
@@ -83,14 +78,9 @@ export const reportFileSizeImpact = async ({
     collectInfo: async ({ execCommandInProjectDirectory }) => {
       if (installCommand) await execCommandInProjectDirectory(installCommand)
       if (buildCommand) await execCommandInProjectDirectory(buildCommand)
-
-      const worker = new Worker(workerFilePath)
-      const { fileSizeReport } = await new Promise((resolve, reject) => {
-        worker.postMessage({ fileSizeModuleUrl })
-        worker.on("message", resolve)
-        worker.on("error", reject)
-      })
-
+      const fileSizeReport = await importOneExportFromFile(
+        fileSizeReportModuleUrl,
+      )
       return { version: 1, data: fileSizeReport }
     },
     commentIdentifier: `<!-- Generated by @jsenv/file-size-impact -->`,

package/src/internal/worker_generating_file_size_report.js

@@ -1,17 +0,0 @@
-import { parentPort } from "node:worker_threads"
-
-parentPort.once("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,
-  })
-})