@jsenv/core 27.3.2 → 27.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "27.3.2",
+  "version": "27.4.0",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -43,7 +43,6 @@
     "eslint": "npx eslint . --ext=.js,.mjs,.cjs,.html",
     "dev": "node --conditions=development ./scripts/dev/dev.mjs",
     "test": "node --conditions=development ./scripts/test/test.mjs",
-    "test:coverage": "cross-env NODE_V8_COVERAGE=.coverage/node npm run test -- --coverage",
     "test:workspace": "npm run test --workspaces --if-present -- --workspace",
     "build": "node --conditions=development ./scripts/build/build.mjs",
     "workspace:versions": "node ./scripts/publish/workspace_versions.mjs",
@@ -68,16 +67,16 @@
     "@jsenv/abort": "4.2.3",
     "@jsenv/ast": "1.1.2",
     "@jsenv/babel-plugins": "1.0.6",
-    "@jsenv/filesystem": "4.1.0",
+    "@jsenv/filesystem": "4.1.1",
     "@jsenv/importmap": "1.2.1",
     "@jsenv/integrity": "0.0.1",
     "@jsenv/log": "3.1.0",
     "@jsenv/node-esm-resolution": "0.1.0",
     "@jsenv/server": "12.8.0",
-    "@jsenv/sourcemap": "1.0.1",
+    "@jsenv/sourcemap": "1.0.2",
     "@jsenv/uneval": "1.6.0",
     "@jsenv/url-meta": "7.0.0",
-    "@jsenv/urls": "1.2.6",
+    "@jsenv/urls": "1.2.7",
     "@jsenv/utils": "2.0.1",
     "acorn-import-assertions": "1.8.0",
     "cuid": "2.1.8",
@@ -86,6 +85,7 @@
     "istanbul-lib-instrument": "5.2.0",
     "istanbul-lib-report": "3.0.0",
     "istanbul-reports": "3.1.4",
+    "launch-editor": "2.4.0",
     "pidtree": "0.6.0",
     "rollup": "2.76.0",
     "string-width": "5.1.2",
@@ -103,7 +103,6 @@
     "@jsenv/https-local": "2.1.0",
     "@jsenv/package-workspace": "0.4.1",
     "@jsenv/performance-impact": "3.0.1",
-    "cross-env": "7.0.3",
     "eslint": "8.19.0",
     "eslint-plugin-html": "6.2.0",
     "eslint-plugin-import": "2.26.0",

package/src/build/build.js

@@ -228,7 +228,9 @@ build ${entryPointKeys.length} entry points`)
         startLoading: (cookEntryFile) => {
           Object.keys(entryPoints).forEach((key) => {
             const [, entryUrlInfo] = cookEntryFile({
-              trace: `"${key}" in entryPoints parameter`,
+              trace: {
+                message: `"${key}" in entryPoints parameter`,
+              },
               type: "entry_point",
               specifier: key,
             })
@@ -722,7 +724,7 @@ build ${entryPointKeys.length} entry points`)
         startLoading: (cookEntryFile) => {
           entryUrls.forEach((entryUrl) => {
             const [, postBuildEntryUrlInfo] = cookEntryFile({
-              trace: `entryPoint`,
+              trace: { message: `entryPoint` },
               type: "entry_point",
               specifier: entryUrl,
             })
@@ -738,7 +740,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 +975,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,
@@ -104,10 +106,12 @@ nodeWorkerThread.run = async ({
   const stop = memoize(async () => {
     // read all stdout before terminating
     // (no need for stderr because it's sync)
-    while (workerThread.stdout.read() !== null) {}
-    await new Promise((resolve) => {
-      setTimeout(resolve)
-    })
+    if (collectConsole) {
+      while (workerThread.stdout.read() !== null) {}
+      await new Promise((resolve) => {
+        setTimeout(resolve, 50)
+      })
+    }
     await workerThread.terminate()
   })
 
@@ -148,6 +152,7 @@ nodeWorkerThread.run = async ({
           coverageEnabled,
           coverageConfig,
           coverageMethodForNodeJs,
+          coverageFileUrl,
           exitAfterAction: true,
         },
       },