@jsenv/core 24.5.7 → 24.6.3

package/src/internal/building/rollup_plugin_jsenv.js

@@ -17,6 +17,7 @@ import {
 } from "@jsenv/filesystem"
 import { UNICODE } from "@jsenv/log"
 
+import { transformJs } from "@jsenv/core/src/internal/compiling/js-compilation-service/transformJs.js"
 import { createUrlConverter } from "@jsenv/core/src/internal/url_conversion.js"
 import { createUrlFetcher } from "@jsenv/core/src/internal/building/url_fetcher.js"
 import { createUrlLoader } from "@jsenv/core/src/internal/building/url_loader.js"
@@ -48,7 +49,7 @@ import { getDefaultImportMap } from "../import-resolution/importmap-default.js"
 import { injectSourcemapInRollupBuild } from "./rollup_build_sourcemap.js"
 import { createBuildStats } from "./build_stats.js"
 
-export const createJsenvRollupPlugin = async ({
+export const createRollupPlugins = async ({
   buildOperation,
   logger,
 
@@ -72,7 +73,6 @@ export const createJsenvRollupPlugin = async ({
   format,
   systemJsUrl,
   babelPluginMap,
-  transformTopLevelAwait,
   node,
   importAssertionsSupport,
 
@@ -239,8 +239,40 @@ export const createJsenvRollupPlugin = async ({
   let minifyJs
   let minifyHtml
 
-  const jsenvRollupPlugin = {}
-
+  const rollupPlugins = []
+  // rollup add async/await that might be unsupported by the runtime
+  // in that case we have to transform the rollup output
+  if (babelPluginMap["transform-async-to-promises"]) {
+    rollupPlugins.push({
+      name: "jsenv_fix_async_await",
+      async renderChunk(code, chunk) {
+        let map = chunk.map
+        const result = await transformJs({
+          code,
+          url: chunk.facadeModuleId
+            ? asOriginalUrl(chunk.facadeModuleId)
+            : resolveUrl(chunk.fileName, buildDirectoryUrl),
+          projectDirectoryUrl,
+          babelPluginMap: {
+            "transform-async-to-promises":
+              babelPluginMap["transform-async-to-promises"],
+          },
+          babelHelpersInjectionAsImport: false,
+          transformGenerator: false,
+          moduleOutFormat:
+            // pass undefined when format is "systemjs" to avoid
+            // re-wrapping the code in systemjs format
+            format === "systemjs" ? undefined : format,
+        })
+        code = result.code
+        map = result.map
+        return {
+          code,
+          map,
+        }
+      },
+    })
+  }
   if (minify) {
     const methodHooks = {
       minifyJs: async (...args) => {
@@ -271,27 +303,29 @@ export const createJsenvRollupPlugin = async ({
       return methodHooks.minifyHtml(html, minifyHtmlOptions)
     }
 
-    jsenvRollupPlugin.renderChunk = async (code, chunk) => {
-      let map = chunk.map
-      const result = await minifyJs({
-        url: chunk.facadeModuleId
-          ? asOriginalUrl(chunk.facadeModuleId)
-          : resolveUrl(chunk.fileName, buildDirectoryUrl),
-        code,
-        map,
-        ...(format === "global" ? { toplevel: false } : { toplevel: true }),
-      })
+    rollupPlugins.push({
+      name: "jsenv_minifier",
+      async renderChunk(code, chunk) {
+        let map = chunk.map
+        const result = await minifyJs({
+          url: chunk.facadeModuleId
+            ? asOriginalUrl(chunk.facadeModuleId)
+            : resolveUrl(chunk.fileName, buildDirectoryUrl),
+          code,
+          map,
+          ...(format === "global" ? { toplevel: false } : { toplevel: true }),
+        })
 
-      code = result.code
-      map = result.map
-      return {
-        code,
-        map,
-      }
-    }
+        code = result.code
+        map = result.map
+        return {
+          code,
+          map,
+        }
+      },
+    })
   }
-
-  Object.assign(jsenvRollupPlugin, {
+  rollupPlugins.unshift({
     name: "jsenv",
 
     async buildStart() {
@@ -1105,8 +1139,8 @@ export const createJsenvRollupPlugin = async ({
 
     async generateBundle(outputOptions, rollupResult) {
       const jsChunks = {}
-      // rollupResult can be mutated by late asset emission
-      // howeverl late chunk (js module) emission is not possible
+      // To keep in mind: rollupResult object can be mutated by late asset emission
+      // however late chunk (js module) emission is not possible
       // as rollup rightfully prevent late js emission
       Object.keys(rollupResult).forEach((fileName) => {
         const file = rollupResult[fileName]
@@ -1137,10 +1171,6 @@ export const createJsenvRollupPlugin = async ({
           jsChunks[fileName] = fileCopy
         }
       })
-      await ensureTopLevelAwaitTranspilationIfNeeded({
-        format,
-        transformTopLevelAwait,
-      })
 
       const jsModuleBuild = {}
       Object.keys(jsChunks).forEach((fileName) => {
@@ -1152,10 +1182,12 @@ export const createJsenvRollupPlugin = async ({
           !file.isEntry
 
         if (file.url in inlineModuleScripts && format === "systemjs") {
-          const magicString = new MagicString(file.code)
+          const code = file.code
+          const systemRegisterIndex = code.indexOf("System.register([")
+          const magicString = new MagicString(code)
           magicString.overwrite(
-            0,
-            "System.register([".length,
+            systemRegisterIndex,
+            systemRegisterIndex + "System.register([".length,
             `System.register("${fileName}", [`,
           )
           file.code = magicString.toString()
@@ -1366,7 +1398,7 @@ export const createJsenvRollupPlugin = async ({
   }
 
   return {
-    jsenvRollupPlugin,
+    rollupPlugins,
     getLastErrorMessage: () => lastErrorMessage,
     getResult: () => {
       return {
@@ -1386,26 +1418,6 @@ export const createJsenvRollupPlugin = async ({
   }
 }
 
-const ensureTopLevelAwaitTranspilationIfNeeded = async ({
-  format,
-  transformTopLevelAwait,
-}) => {
-  if (!transformTopLevelAwait) {
-    return
-  }
-
-  if (format === "esmodule") {
-    // transform-async-to-promises won't be able to transform top level await
-    // for "esmodule", so it would be useless
-    return
-  }
-
-  if (format === "systemjs") {
-    // top level await is an async function for systemjs
-    return
-  }
-}
-
 const prepareEntryPoints = async (
   entryPointMap,
   {

package/src/internal/compiling/js-compilation-service/jsenvTransform.js

@@ -52,6 +52,9 @@ export const jsenvTransform = async ({
     parserOpts: {
       allowAwaitOutsideFunction: allowTopLevelAwait,
     },
+    generatorOpts: {
+      compact: false,
+    },
   }
 
   const babelHelperName = filePathToBabelHelperName(inputPath)

package/src/internal/compiling/js-compilation-service/transformJs.js

@@ -11,7 +11,7 @@ export const transformJs = async ({
   babelPluginMap,
   moduleOutFormat = "esmodule",
   importMetaFormat = moduleOutFormat,
-  babelHelpersInjectionAsImport = true,
+  babelHelpersInjectionAsImport = moduleOutFormat === "esmodule",
   allowTopLevelAwait = true,
   transformTopLevelAwait = true,
   transformGenerator = true,
@@ -33,6 +33,11 @@ export const transformJs = async ({
   if (typeof url !== "string") {
     throw new TypeError(`url must be a string, got ${url}`)
   }
+  if (babelHelpersInjectionAsImport && moduleOutFormat !== "esmodule") {
+    throw new Error(
+      `babelHelpersInjectionAsImport can be enabled only when "moduleOutFormat" is "esmodule"`,
+    )
+  }
 
   const transformResult = await jsenvTransform({
     code,

package/src/internal/executing/createSummaryLog.js

@@ -1,16 +1,17 @@
 import { ANSI } from "@jsenv/log"
 
 import { msAsDuration } from "../logs/msAsDuration.js"
+import { formatByte } from "../logs/byte.js"
 import { EXECUTION_COLORS } from "./execution_colors.js"
 
 export const createSummaryLog = (
   summary,
 ) => `-------------- summary -----------------
-${createSummaryMessage(summary)}
+${createAllExecutionsSummary(summary)}
 total duration: ${msAsDuration(summary.duration)}
 ----------------------------------------`
 
-const createSummaryMessage = ({
+const createAllExecutionsSummary = ({
   executionCount,
   abortedCount,
   timedoutCount,
@@ -24,7 +25,7 @@ const createSummaryMessage = ({
 
   const executionLabel =
     executionCount === 1 ? `1 execution` : `${executionCount} executions`
-  return `${executionLabel}: ${createSummaryDetails({
+  return `${executionLabel}: ${createStatusSummary({
     executionCount,
     abortedCount,
     timedoutCount,
@@ -34,7 +35,32 @@ const createSummaryMessage = ({
   })}`
 }
 
-export const createSummaryDetails = ({
+export const createIntermediateSummary = ({
+  executionCount,
+  abortedCount,
+  timedoutCount,
+  erroredCount,
+  completedCount,
+  cancelledCount,
+  memoryHeap,
+}) => {
+  let intermediateSummary = createStatusSummary({
+    executionCount,
+    abortedCount,
+    timedoutCount,
+    erroredCount,
+    completedCount,
+    cancelledCount,
+  })
+
+  if (memoryHeap) {
+    intermediateSummary += ` / memory heap: ${formatByte(memoryHeap)}`
+  }
+
+  return intermediateSummary
+}
+
+const createStatusSummary = ({
   executionCount,
   abortedCount,
   timedoutCount,

package/src/internal/executing/executeConcurrently.js

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs"
+import { memoryUsage } from "node:process"
 import wrapAnsi from "wrap-ansi"
 import cuid from "cuid"
 import { loggerToLevels } from "@jsenv/logger"
@@ -17,6 +18,7 @@ import { launchAndExecute } from "../executing/launchAndExecute.js"
 import { reportToCoverage } from "./coverage/reportToCoverage.js"
 import { formatExecuting, formatExecutionResult } from "./executionLogs.js"
 import { createSummaryLog } from "./createSummaryLog.js"
+import { ensureGlobalGc } from "./gc.js"
 
 export const executeConcurrently = async (
   executionSteps,
@@ -28,16 +30,19 @@ export const executeConcurrently = async (
 
     projectDirectoryUrl,
     compileServer,
-
     babelPluginMap,
 
-    defaultMsAllocatedPerExecution = 30000,
-    cooldownBetweenExecutions = 0,
-    maxExecutionsInParallel = 1,
-    stopAfterExecute,
+    logSummary,
+    logMemoryHeapUsage,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
 
+    maxExecutionsInParallel,
+    defaultMsAllocatedPerExecution,
+    stopAfterExecute,
+    cooldownBetweenExecutions,
+    gcBetweenExecutions,
+
     coverage,
     coverageConfig,
     coverageIncludeMissing,
@@ -48,8 +53,6 @@ export const executeConcurrently = async (
 
     beforeExecutionCallback = () => {},
     afterExecutionCallback = () => {},
-
-    logSummary,
   },
 ) => {
   if (completedExecutionLogMerging && !process.stdout.isTTY) {
@@ -62,12 +65,15 @@ export const executeConcurrently = async (
   const executionSpinner = executionLogsEnabled && process.stdout.isTTY
 
   const startMs = Date.now()
-
   const report = {}
   const executionCount = executionSteps.length
 
   let transformReturnValue = (value) => value
 
+  if (gcBetweenExecutions) {
+    ensureGlobalGc()
+  }
+
   const coverageTempDirectoryUrl = resolveUrl(
     coverageTempDirectoryRelativeUrl,
     projectDirectoryUrl,
@@ -185,6 +191,9 @@ export const executeConcurrently = async (
             timedoutCount,
             erroredCount,
             completedCount,
+            ...(logMemoryHeapUsage
+              ? { memoryHeap: memoryUsage().heapUsed }
+              : {}),
           }),
         })
       }
@@ -249,6 +258,10 @@ export const executeConcurrently = async (
         completedCount++
       }
 
+      if (gcBetweenExecutions) {
+        global.gc()
+      }
+
       if (executionLogsEnabled) {
         let log = formatExecutionResult(afterExecutionInfo, {
           completedExecutionLogAbbreviation,
@@ -257,6 +270,7 @@ export const executeConcurrently = async (
           timedoutCount,
           erroredCount,
           completedCount,
+          ...(logMemoryHeapUsage ? { memoryHeap: memoryUsage().heapUsed } : {}),
         })
         log = `${log}
 

package/src/internal/executing/executePlan.js

@@ -24,13 +24,16 @@ export const executePlan = async (
     importResolutionMethod,
     importDefaultExtension,
 
+    logSummary,
+    logMemoryHeapUsage,
+    completedExecutionLogMerging,
+    completedExecutionLogAbbreviation,
+
     defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    gcBetweenExecutions,
     stopAfterExecute,
     cooldownBetweenExecutions,
-    completedExecutionLogMerging,
-    completedExecutionLogAbbreviation,
-    logSummary,
 
     coverage,
     coverageConfig,
@@ -169,13 +172,16 @@ export const executePlan = async (
 
       babelPluginMap: compileServer.babelPluginMap,
 
+      logSummary,
+      logMemoryHeapUsage,
+      completedExecutionLogMerging,
+      completedExecutionLogAbbreviation,
+
       defaultMsAllocatedPerExecution,
       maxExecutionsInParallel,
       stopAfterExecute,
+      gcBetweenExecutions,
       cooldownBetweenExecutions,
-      completedExecutionLogMerging,
-      completedExecutionLogAbbreviation,
-      logSummary,
 
       coverage,
       coverageConfig,

package/src/internal/executing/executionLogs.js

@@ -2,11 +2,18 @@ import { ANSI, UNICODE } from "@jsenv/log"
 
 import { msAsDuration } from "../logs/msAsDuration.js"
 import { EXECUTION_COLORS } from "./execution_colors.js"
-import { createSummaryDetails } from "./createSummaryLog.js"
+import { createIntermediateSummary } from "./createSummaryLog.js"
 
 export const formatExecuting = (
   { executionIndex },
-  { executionCount, abortedCount, timedoutCount, erroredCount, completedCount },
+  {
+    executionCount,
+    abortedCount,
+    timedoutCount,
+    erroredCount,
+    completedCount,
+    memoryHeap,
+  },
 ) => {
   const executionNumber = executionIndex + 1
   const description = ANSI.color(
@@ -16,12 +23,13 @@ export const formatExecuting = (
   const summary =
     executionIndex === 0
       ? ""
-      : `(${createSummaryDetails({
+      : `(${createIntermediateSummary({
           executionCount: executionIndex,
           abortedCount,
           timedoutCount,
           erroredCount,
           completedCount,
+          memoryHeap,
         })})`
 
   return formatExecution({
@@ -45,6 +53,7 @@ export const formatExecutionResult = (
     timedoutCount,
     erroredCount,
     completedCount,
+    memoryHeap,
   },
 ) => {
   const executionNumber = executionIndex + 1
@@ -57,12 +66,13 @@ export const formatExecutionResult = (
     allocatedMs,
   })
 
-  const summary = `(${createSummaryDetails({
+  const summary = `(${createIntermediateSummary({
     executionCount: executionNumber,
     abortedCount,
     timedoutCount,
     erroredCount,
     completedCount,
+    memoryHeap,
   })})`
 
   if (completedExecutionLogAbbreviation && status === "completed") {

package/src/internal/executing/gc.js

@@ -0,0 +1,9 @@
+import v8 from "node:v8"
+import { runInNewContext } from "node:vm"
+
+export const ensureGlobalGc = () => {
+  if (!global.gc) {
+    v8.setFlagsFromString("--expose_gc")
+    global.gc = runInNewContext("gc")
+  }
+}

package/src/internal/logs/byte.js

@@ -0,0 +1,10 @@
+import { createRequire } from "module"
+
+const require = createRequire(import.meta.url)
+
+// https://github.com/visionmedia/bytes.js/
+const bytes = require("bytes")
+
+export const formatByte = (metricValue) => {
+  return bytes(metricValue, { decimalPlaces: 2, unitSeparator: " " })
+}