@jsenv/core 27.3.1 → 27.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "27.3.1",
+  "version": "27.3.4",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {

package/src/build/build.js

@@ -738,7 +738,7 @@ build ${entryPointKeys.length} entry points`)
 
     logger.debug(
       `graph urls pre-versioning:
-${Object.keys(finalGraph.urlInfos).join("\n")}`,
+${Array.from(finalGraph.urlInfoMap.keys()).join("\n")}`,
     )
     if (versioning) {
       await applyUrlVersioning({
@@ -973,7 +973,7 @@ const applyUrlVersioning = async ({
     disabled: infoLogsAreDisabled,
   })
   try {
-    const urlsSorted = sortByDependencies(finalGraph.urlInfos)
+    const urlsSorted = sortByDependencies(finalGraph.toObject())
     urlsSorted.forEach((url) => {
       if (url.startsWith("data:")) {
         return

package/src/build/graph_utils.js

@@ -1,20 +1,19 @@
 export const GRAPH = {
   map: (graph, callback) => {
-    return Object.keys(graph.urlInfos).map((url) => {
-      return callback(graph.urlInfos[url])
+    const array = []
+    graph.urlInfoMap.forEach((urlInfo) => {
+      array.push(callback(urlInfo))
     })
+    return array
   },
 
   forEach: (graph, callback) => {
-    Object.keys(graph.urlInfos).forEach((url) => {
-      callback(graph.urlInfos[url], url)
-    })
+    graph.urlInfoMap.forEach(callback)
   },
 
   filter: (graph, callback) => {
     const urlInfos = []
-    Object.keys(graph.urlInfos).forEach((url) => {
-      const urlInfo = graph.urlInfos[url]
+    graph.urlInfoMap.forEach((urlInfo) => {
       if (callback(urlInfo)) {
         urlInfos.push(urlInfo)
       }
@@ -23,9 +22,13 @@ export const GRAPH = {
   },
 
   find: (graph, callback) => {
-    const urlFound = Object.keys(graph.urlInfos).find((url) => {
-      return callback(graph.urlInfos[url])
-    })
-    return graph.urlInfos[urlFound]
+    let found = null
+    for (const urlInfo of graph.urlInfoMap.values()) {
+      if (callback(urlInfo)) {
+        found = urlInfo
+        break
+      }
+    }
+    return found
   },
 }

package/src/execute/run.js

@@ -1,6 +1,6 @@
 import cuid from "cuid"
 import { Abort, raceCallbacks } from "@jsenv/abort"
-import { writeFileSync } from "@jsenv/filesystem"
+import { ensureParentDirectories } from "@jsenv/filesystem"
 
 export const run = async ({
   signal = new AbortController().signal,
@@ -16,7 +16,7 @@ export const run = async ({
   runtime,
   runtimeParams,
 }) => {
-  let result = {}
+  const result = {}
   const callbacks = []
 
   const onConsoleRef = { current: () => {} }
@@ -39,17 +39,15 @@ export const run = async ({
         Abort.isAbortError(result.error) &&
         timeoutAbortSource.signal.aborted
       ) {
-        result = {
-          status: "timedout",
-        }
+        result.status = "timedout"
+        delete result.error
       }
     })
   }
   callbacks.push(() => {
     if (result.status === "errored" && Abort.isAbortError(result.error)) {
-      result = {
-        status: "aborted",
-      }
+      result.status = "aborted"
+      delete result.error
     }
   })
   const consoleCalls = []
@@ -71,6 +69,24 @@ export const run = async ({
     })
   }
 
+  // we do not keep coverage in memory, it can grow very big
+  // instead we store it on the filesystem
+  // and they can be read later at "coverageFileUrl"
+  let coverageFileUrl
+  if (coverageEnabled) {
+    coverageFileUrl = new URL(
+      `./${runtime.name}/${cuid()}.json`,
+      coverageTempDirectoryUrl,
+    ).href
+    await ensureParentDirectories(coverageFileUrl)
+    if (coverageEnabled) {
+      result.coverageFileUrl = coverageFileUrl
+      // written within the child_process/worker_thread or during runtime.run()
+      // for browsers
+      // (because it takes time to serialize and transfer the coverage object)
+    }
+  }
+
   const startMs = Date.now()
   callbacks.push(() => {
     result.duration = Date.now() - startMs
@@ -94,7 +110,9 @@ export const run = async ({
                 signal: runOperation.signal,
                 logger,
                 ...runtimeParams,
+                collectConsole,
                 collectPerformance,
+                coverageFileUrl,
                 keepRunning,
                 stopSignal,
                 onConsole: (log) => onConsoleRef.current(log),
@@ -116,7 +134,7 @@ export const run = async ({
       runOperation.throwIfAborted()
     }
 
-    const { status, namespace, error, performance, coverage } = winner.data
+    const { status, namespace, error, performance } = winner.data
     result.status = status
     if (status === "errored") {
       result.error = error
@@ -126,30 +144,13 @@ export const run = async ({
     if (collectPerformance) {
       result.performance = performance
     }
-    if (coverageEnabled) {
-      if (coverage) {
-        // we do not keep coverage in memory, it can grow very big
-        // instead we store it on the filesystem
-        // and they can be read later at "coverageFileUrl"
-        const coverageFileUrl = new URL(
-          `./${runtime.name}/${cuid()}.json`,
-          coverageTempDirectoryUrl,
-        )
-        writeFileSync(coverageFileUrl, JSON.stringify(coverage, null, "  "))
-        result.coverageFileUrl = coverageFileUrl.href
-      } else {
-        // will eventually log a warning in report_to_coverage.js
-      }
-    }
     callbacks.forEach((callback) => {
       callback()
     })
     return result
   } catch (e) {
-    result = {
-      status: "errored",
-      error: e,
-    }
+    result.status = "errored"
+    result.error = e
     callbacks.forEach((callback) => {
       callback()
     })

package/src/execute/runtimes/browsers/from_playwright.js

@@ -1,4 +1,5 @@
 import { Script } from "node:vm"
+import { writeFileSync } from "node:fs"
 
 import { createDetailedMessage } from "@jsenv/log"
 import {
@@ -41,6 +42,7 @@ export const createRuntimeFromPlaywright = ({
     coverageEnabled = false,
     coverageConfig,
     coverageMethodForBrowsers,
+    coverageFileUrl,
 
     stopAfterAllSignal,
     stopSignal,
@@ -108,7 +110,8 @@ export const createRuntimeFromPlaywright = ({
       }
     }
 
-    let resultTransformer = (result) => result
+    const result = {}
+    const callbacks = []
     if (coverageEnabled) {
       if (
         coveragePlaywrightAPIAvailable &&
@@ -117,93 +120,86 @@ export const createRuntimeFromPlaywright = ({
         await page.coverage.startJSCoverage({
           // reportAnonymousScripts: true,
         })
-        resultTransformer = composeTransformer(
-          resultTransformer,
-          async (result) => {
-            const v8CoveragesWithWebUrls = await page.coverage.stopJSCoverage()
-            // we convert urls starting with http:// to file:// because we later
-            // convert the url to filesystem path in istanbulCoverageFromV8Coverage function
-            const v8CoveragesWithFsUrls = v8CoveragesWithWebUrls.map(
-              (v8CoveragesWithWebUrl) => {
-                const fsUrl = moveUrl({
-                  url: v8CoveragesWithWebUrl.url,
-                  from: `${server.origin}/`,
-                  to: rootDirectoryUrl,
-                  preferAbsolute: true,
-                })
-                return {
-                  ...v8CoveragesWithWebUrl,
-                  url: fsUrl,
-                }
-              },
-            )
-            const coverage = await filterV8Coverage(
-              { result: v8CoveragesWithFsUrls },
-              {
-                rootDirectoryUrl,
-                coverageConfig,
-              },
-            )
-            return {
-              ...result,
-              coverage,
-            }
-          },
-        )
+        callbacks.push(async () => {
+          const v8CoveragesWithWebUrls = await page.coverage.stopJSCoverage()
+          // we convert urls starting with http:// to file:// because we later
+          // convert the url to filesystem path in istanbulCoverageFromV8Coverage function
+          const v8CoveragesWithFsUrls = v8CoveragesWithWebUrls.map(
+            (v8CoveragesWithWebUrl) => {
+              const fsUrl = moveUrl({
+                url: v8CoveragesWithWebUrl.url,
+                from: `${server.origin}/`,
+                to: rootDirectoryUrl,
+                preferAbsolute: true,
+              })
+              return {
+                ...v8CoveragesWithWebUrl,
+                url: fsUrl,
+              }
+            },
+          )
+          const coverage = await filterV8Coverage(
+            { result: v8CoveragesWithFsUrls },
+            {
+              rootDirectoryUrl,
+              coverageConfig,
+            },
+          )
+          writeFileSync(
+            new URL(coverageFileUrl),
+            JSON.stringify(coverage, null, "  "),
+          )
+        })
       } else {
-        resultTransformer = composeTransformer(
-          resultTransformer,
-          async (result) => {
-            const scriptExecutionResults = result.namespace
-            if (scriptExecutionResults) {
-              result.coverage = generateCoverageForPage(scriptExecutionResults)
-            }
-            return result
-          },
-        )
+        callbacks.push(() => {
+          const scriptExecutionResults = result.namespace
+          if (scriptExecutionResults) {
+            const coverage =
+              generateCoverageForPage(scriptExecutionResults) || {}
+            writeFileSync(
+              new URL(coverageFileUrl),
+              JSON.stringify(coverage, null, "  "),
+            )
+          }
+        })
       }
     } else {
-      resultTransformer = composeTransformer(resultTransformer, (result) => {
+      callbacks.push(() => {
         const scriptExecutionResults = result.namespace
         if (scriptExecutionResults) {
           Object.keys(scriptExecutionResults).forEach((fileRelativeUrl) => {
             delete scriptExecutionResults[fileRelativeUrl].coverage
           })
         }
-        return result
       })
     }
 
     if (collectPerformance) {
-      resultTransformer = composeTransformer(
-        resultTransformer,
-        async (result) => {
-          const performance = await page.evaluate(
-            /* eslint-disable no-undef */
-            /* istanbul ignore next */
-            () => {
-              const { performance } = window
-              if (!performance) {
-                return null
-              }
-              const measures = {}
-              const measurePerfEntries = performance.getEntriesByType("measure")
-              measurePerfEntries.forEach((measurePerfEntry) => {
-                measures[measurePerfEntry.name] = measurePerfEntry.duration
-              })
-              return {
-                timeOrigin: performance.timeOrigin,
-                timing: performance.timing.toJSON(),
-                navigation: performance.navigation.toJSON(),
-                measures,
-              }
-            },
-            /* eslint-enable no-undef */
-          )
-          result.performance = performance
-          return result
-        },
-      )
+      callbacks.push(async () => {
+        const performance = await page.evaluate(
+          /* eslint-disable no-undef */
+          /* istanbul ignore next */
+          () => {
+            const { performance } = window
+            if (!performance) {
+              return null
+            }
+            const measures = {}
+            const measurePerfEntries = performance.getEntriesByType("measure")
+            measurePerfEntries.forEach((measurePerfEntry) => {
+              measures[measurePerfEntry.name] = measurePerfEntry.duration
+            })
+            return {
+              timeOrigin: performance.timeOrigin,
+              timing: performance.timing.toJSON(),
+              navigation: performance.navigation.toJSON(),
+              measures,
+            }
+          },
+          /* eslint-enable no-undef */
+        )
+        result.performance = performance
+      })
     }
 
     const fileClientUrl = new URL(fileRelativeUrl, `${server.origin}/`).href
@@ -290,7 +286,7 @@ export const createRuntimeFromPlaywright = ({
           response: async (cb) => {
             try {
               await page.goto(fileClientUrl, { timeout: 0 })
-              const result = await page.evaluate(
+              const returnValue = await page.evaluate(
                 /* eslint-disable no-undef */
                 /* istanbul ignore next */
                 () => {
@@ -301,9 +297,9 @@ export const createRuntimeFromPlaywright = ({
                 },
                 /* eslint-enable no-undef */
               )
-              const { status, scriptExecutionResults } = result
+              const { status, scriptExecutionResults } = returnValue
               if (status === "errored") {
-                const { exceptionSource } = result
+                const { exceptionSource } = returnValue
                 const error = evalException(exceptionSource, {
                   rootDirectoryUrl,
                   server,
@@ -353,16 +349,25 @@ export const createRuntimeFromPlaywright = ({
       }
       return winner.data
     }
-    let result
 
     try {
-      result = await getResult()
-      result = await resultTransformer(result)
-    } catch (e) {
-      result = {
-        status: "errored",
-        error: e,
+      const { status, error, namespace, performance } = await getResult()
+      result.status = status
+      if (status === "errored") {
+        result.error = error
+      } else {
+        result.namespace = namespace
       }
+      if (collectPerformance) {
+        result.performance = performance
+      }
+      await callbacks.reduce(async (previous, callback) => {
+        await previous
+        await callback()
+      }, Promise.resolve())
+    } catch (e) {
+      result.status = "errored"
+      result.error = e
     }
     if (keepRunning) {
       stopSignal.notify = cleanup
@@ -478,13 +483,6 @@ const isTargetClosedError = (error) => {
   return false
 }
 
-const composeTransformer = (previousTransformer, transformer) => {
-  return async (value) => {
-    const transformedValue = await previousTransformer(value)
-    return transformer(transformedValue)
-  }
-}
-
 const extractTextFromConsoleMessage = (consoleMessage) => {
   return consoleMessage.text()
   // ensure we use a string so that istanbul won't try

package/src/execute/runtimes/node/execute_using_dynamic_import.js

@@ -1,3 +1,5 @@
+import { writeFileSync } from "node:fs"
+
 import { startJsCoverage } from "./profiler_v8_coverage.js"
 import { startObservingPerformances } from "./node_execution_performance.js"
 
@@ -8,8 +10,9 @@ export const executeUsingDynamicImport = async ({
   coverageEnabled,
   coverageConfig,
   coverageMethodForNodeJs,
+  coverageFileUrl,
 }) => {
-  let result = {}
+  const result = {}
   const afterImportCallbacks = []
   if (coverageEnabled && coverageMethodForNodeJs === "Profiler") {
     const { filterV8Coverage } = await import(
@@ -22,7 +25,10 @@ export const executeUsingDynamicImport = async ({
         rootDirectoryUrl,
         coverageConfig,
       })
-      result.coverage = coverageLight
+      writeFileSync(
+        new URL(coverageFileUrl),
+        JSON.stringify(coverageLight, null, "  "),
+      )
     })
   }
   if (collectPerformance) {

package/src/execute/runtimes/node/node_child_process.js

@@ -39,6 +39,7 @@ nodeChildProcess.run = async ({
   coverageEnabled = false,
   coverageConfig,
   coverageMethodForNodeJs,
+  coverageFileUrl,
   collectPerformance,
 
   env,
@@ -199,6 +200,7 @@ nodeChildProcess.run = async ({
           coverageEnabled,
           coverageConfig,
           coverageMethodForNodeJs,
+          coverageFileUrl,
           exitAfterAction: true,
         },
       },

package/src/execute/runtimes/node/node_worker_thread.js

@@ -35,10 +35,12 @@ nodeWorkerThread.run = async ({
   stopSignal,
   onConsole,
 
+  collectConsole = false,
+  collectPerformance,
+  coverageEnabled = false,
   coverageConfig,
   coverageMethodForNodeJs,
-  coverageEnabled = false,
-  collectPerformance,
+  coverageFileUrl,
 
   env,
   debugPort,
@@ -102,6 +104,14 @@ nodeWorkerThread.run = async ({
   })
 
   const stop = memoize(async () => {
+    // read all stdout before terminating
+    // (no need for stderr because it's sync)
+    if (collectConsole) {
+      while (workerThread.stdout.read() !== null) {}
+      await new Promise((resolve) => {
+        setTimeout(resolve, 50)
+      })
+    }
     await workerThread.terminate()
   })
 
@@ -142,6 +152,7 @@ nodeWorkerThread.run = async ({
           coverageEnabled,
           coverageConfig,
           coverageMethodForNodeJs,
+          coverageFileUrl,
           exitAfterAction: true,
         },
       },

package/src/omega/url_graph/url_graph_report.js

@@ -11,7 +11,6 @@ ${createRepartitionMessage(graphReport)}
 }
 
 const createUrlGraphReport = (urlGraph) => {
-  const { urlInfos } = urlGraph
   const countGroups = {
     sourcemaps: 0,
     html: 0,
@@ -30,11 +29,10 @@ const createUrlGraphReport = (urlGraph) => {
     other: 0,
     total: 0,
   }
-  Object.keys(urlInfos).forEach((url) => {
-    if (url.startsWith("data:")) {
+  urlGraph.urlInfoMap.forEach((urlInfo) => {
+    if (urlInfo.url.startsWith("data:")) {
       return
     }
-    const urlInfo = urlInfos[url]
     // ignore:
     // - inline files: they are already taken into account in the file where they appear
     // - ignored files: we don't know their content

package/src/omega/url_graph.js

@@ -5,12 +5,12 @@ export const createUrlGraph = ({
   clientFileChangeCallbackList,
   clientFilesPruneCallbackList,
 } = {}) => {
-  const urlInfos = {}
-  const getUrlInfo = (url) => urlInfos[url]
+  const urlInfoMap = new Map()
+  const getUrlInfo = (url) => urlInfoMap.get(url)
   const deleteUrlInfo = (url) => {
-    const urlInfo = urlInfos[url]
+    const urlInfo = urlInfoMap.get(url)
     if (urlInfo) {
-      delete urlInfos[url]
+      urlInfoMap.delete(url)
       if (urlInfo.sourcemapReference) {
         deleteUrlInfo(urlInfo.sourcemapReference.url)
       }
@@ -18,14 +18,14 @@ export const createUrlGraph = ({
   }
 
   const reuseOrCreateUrlInfo = (url) => {
-    const existingUrlInfo = urlInfos[url]
+    const existingUrlInfo = getUrlInfo(url)
     if (existingUrlInfo) return existingUrlInfo
     const urlInfo = createUrlInfo(url)
-    urlInfos[url] = urlInfo
+    urlInfoMap.set(url, urlInfo)
     return urlInfo
   }
   const inferReference = (specifier, parentUrl) => {
-    const parentUrlInfo = urlInfos[parentUrl]
+    const parentUrlInfo = getUrlInfo(parentUrl)
     if (!parentUrlInfo) {
       return null
     }
@@ -37,13 +37,13 @@ export const createUrlGraph = ({
     return firstReferenceOnThatUrl
   }
   const findDependent = (url, predicate) => {
-    const urlInfo = urlInfos[url]
+    const urlInfo = getUrlInfo(url)
     if (!urlInfo) {
       return null
     }
     const visitDependents = (urlInfo) => {
       for (const dependentUrl of urlInfo.dependents) {
-        const dependent = urlInfos[dependentUrl]
+        const dependent = getUrlInfo(dependentUrl)
         if (predicate(dependent)) {
           return dependent
         }
@@ -90,7 +90,7 @@ export const createUrlGraph = ({
     const removeDependencies = (urlInfo, urlsToPrune) => {
       urlsToPrune.forEach((urlToPrune) => {
         urlInfo.dependencies.delete(urlToPrune)
-        const dependency = urlInfos[urlToPrune]
+        const dependency = getUrlInfo(urlToPrune)
         if (!dependency) {
           return
         }
@@ -122,7 +122,7 @@ export const createUrlGraph = ({
 
   if (clientFileChangeCallbackList) {
     clientFileChangeCallbackList.push(({ url }) => {
-      const urlInfo = urlInfos[url]
+      const urlInfo = getUrlInfo(url)
       if (urlInfo) {
         considerModified(urlInfo, Date.now())
       }
@@ -139,12 +139,18 @@ export const createUrlGraph = ({
       urlInfo.modifiedTimestamp = modifiedTimestamp
       urlInfo.contentEtag = undefined
       urlInfo.dependents.forEach((dependentUrl) => {
-        const dependentUrlInfo = urlInfos[dependentUrl]
+        const dependentUrlInfo = getUrlInfo(dependentUrl)
         const { hotAcceptDependencies = [] } = dependentUrlInfo.data
         if (!hotAcceptDependencies.includes(urlInfo.url)) {
           iterate(dependentUrlInfo)
         }
       })
+      urlInfo.dependencies.forEach((dependencyUrl) => {
+        const dependencyUrlInfo = getUrlInfo(dependencyUrl)
+        if (dependencyUrlInfo.isInline) {
+          iterate(dependencyUrlInfo)
+        }
+      })
     }
     iterate(urlInfo)
   }
@@ -164,7 +170,7 @@ export const createUrlGraph = ({
   }
 
   return {
-    urlInfos,
+    urlInfoMap,
     reuseOrCreateUrlInfo,
     getUrlInfo,
     deleteUrlInfo,
@@ -174,12 +180,19 @@ export const createUrlGraph = ({
     considerModified,
     getRelatedUrlInfos,
 
+    toObject: () => {
+      const data = {}
+      urlInfoMap.forEach((urlInfo) => {
+        data[urlInfo.url] = urlInfo
+      })
+      return data
+    },
     toJSON: (rootDirectoryUrl) => {
       const data = {}
-      Object.keys(urlInfos).forEach((url) => {
-        const dependencyUrls = Array.from(urlInfos[url].dependencies)
+      urlInfoMap.forEach((urlInfo) => {
+        const dependencyUrls = Array.from(urlInfo.dependencies)
         if (dependencyUrls.length) {
-          const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl)
+          const relativeUrl = urlToRelativeUrl(urlInfo.url, rootDirectoryUrl)
           data[relativeUrl] = dependencyUrls.map((dependencyUrl) =>
             urlToRelativeUrl(dependencyUrl, rootDirectoryUrl),
           )