@jsenv/core 27.0.3 → 27.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "27.0.3",
+  "version": "27.2.1",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -43,9 +43,9 @@
     "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": "npm run test -- --coverage",
+    "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:test": "npm run test --workspaces --if-present -- --workspace",
     "workspace:versions": "node ./scripts/publish/workspace_versions.mjs",
     "workspace:publish": "node ./scripts/publish/workspace_publish.mjs",
     "performances": "node --expose-gc ./scripts/performance/generate_performance_report.mjs --log --once",
@@ -65,20 +65,20 @@
     "@babel/plugin-transform-modules-umd": "7.18.6",
     "@c88/v8-coverage": "0.1.1",
     "@financial-times/polyfill-useragent-normaliser": "2.0.1",
-    "@jsenv/ast": "1.1.1",
     "@jsenv/abort": "4.2.3",
+    "@jsenv/ast": "1.1.1",
+    "@jsenv/babel-plugins": "1.0.5",
     "@jsenv/filesystem": "4.1.0",
     "@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.7.4",
+    "@jsenv/server": "12.7.5",
+    "@jsenv/sourcemap": "1.0.1",
     "@jsenv/uneval": "1.6.0",
     "@jsenv/url-meta": "7.0.0",
     "@jsenv/urls": "1.2.6",
     "@jsenv/utils": "2.0.1",
-    "@jsenv/babel-plugins": "1.0.5",
-    "@jsenv/log": "3.0.2",
-    "@jsenv/sourcemap": "1.0.1",
     "acorn-import-assertions": "1.8.0",
     "cuid": "2.1.8",
     "html-minifier": "4.0.0",
@@ -103,6 +103,7 @@
     "@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

@@ -287,7 +287,7 @@ build ${entryPointKeys.length} entry points`)
       }
     }
     GRAPH.forEach(rawGraph, (rawUrlInfo) => {
-      if (rawUrlInfo.data.isEntryPoint) {
+      if (rawUrlInfo.isEntryPoint) {
         addToBundlerIfAny(rawUrlInfo)
         if (rawUrlInfo.type === "html") {
           rawUrlInfo.dependencies.forEach((dependencyUrl) => {
@@ -370,6 +370,7 @@ build ${entryPointKeys.length} entry points`)
           const bundleUrlInfo = {
             type,
             subtype: rawUrlInfo ? rawUrlInfo.subtype : undefined,
+            isEntryPoint: rawUrlInfo ? rawUrlInfo.isEntryPoint : undefined,
             filename: rawUrlInfo ? rawUrlInfo.filename : undefined,
             originalUrl: rawUrlInfo ? rawUrlInfo.originalUrl : undefined,
             originalContent: rawUrlInfo
@@ -516,11 +517,10 @@ build ${entryPointKeys.length} entry points`)
               // Here we just want to reserve an url for that file
               const buildUrl = buildUrlsGenerator.generate(rawUrl, {
                 urlInfo: {
-                  data: {
-                    ...reference.data,
-                    isWebWorkerEntryPoint:
-                      isWebWorkerEntryPointReference(reference),
-                  },
+                  data: reference.data,
+                  isEntryPoint:
+                    reference.isEntryPoint ||
+                    isWebWorkerEntryPointReference(reference),
                   type: reference.expectedType,
                   subtype: reference.expectedSubtype,
                   filename: reference.filename,
@@ -801,7 +801,7 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
       // - versioning update inline content
       // - file converted for import assertion of js_classic conversion
       if (
-        !urlInfo.data.isEntryPoint &&
+        !urlInfo.isEntryPoint &&
         urlInfo.type !== "sourcemap" &&
         urlInfo.dependents.size === 0
       ) {
@@ -998,7 +998,7 @@ const applyUrlVersioning = async ({
       if (!urlInfo.shouldHandle) {
         return
       }
-      if (!urlInfo.data.isEntryPoint && urlInfo.dependents.size === 0) {
+      if (!urlInfo.isEntryPoint && urlInfo.dependents.size === 0) {
         return
       }
 
@@ -1255,14 +1255,11 @@ const assertEntryPoints = ({ entryPoints }) => {
 }
 
 const canUseVersionedUrl = (urlInfo) => {
-  if (urlInfo.data.isEntryPoint) {
+  if (urlInfo.isEntryPoint) {
     return false
   }
   if (urlInfo.type === "webmanifest") {
     return false
   }
-  if (urlInfo.subtype === "service_worker") {
-    return !urlInfo.data.isWebWorkerEntryPoint
-  }
   return true
 }

package/src/build/build_urls_generator.js

@@ -91,7 +91,7 @@ const determineDirectoryPath = ({
     })
     return parentDirectoryPath
   }
-  if (urlInfo.data.isEntryPoint || urlInfo.data.isWebWorkerEntryPoint) {
+  if (urlInfo.isEntryPoint) {
     return ""
   }
   if (urlInfo.type === "importmap") {

package/src/build/inject_global_version_mappings.js

@@ -8,6 +8,7 @@ import {
   stringifyHtmlAst,
 } from "@jsenv/ast"
 
+import { isWebWorkerUrlInfo } from "@jsenv/core/src/omega/web_workers.js"
 import { GRAPH } from "./graph_utils.js"
 
 export const injectGlobalVersionMapping = async ({
@@ -17,7 +18,7 @@ export const injectGlobalVersionMapping = async ({
 }) => {
   await Promise.all(
     GRAPH.map(finalGraph, async (urlInfo) => {
-      if (urlInfo.data.isEntryPoint || urlInfo.data.isWebWorkerEntryPoint) {
+      if (urlInfo.isEntryPoint) {
         await injectVersionMappings({
           urlInfo,
           kitchen: finalGraphKitchen,
@@ -43,7 +44,7 @@ const jsInjector = (urlInfo, { versionMappings }) => {
   const magicSource = createMagicSource(urlInfo.content)
   magicSource.prepend(
     generateClientCodeForVersionMappings(versionMappings, {
-      globalName: urlInfo.data.isWebWorkerEntryPoint ? "self" : "window",
+      globalName: isWebWorkerUrlInfo(urlInfo) ? "self" : "window",
     }),
   )
   return magicSource.toContentAndSourcemap()

package/src/build/inject_service_worker_urls.js

@@ -12,8 +12,7 @@ export const injectServiceWorkerUrls = async ({
     finalGraph,
     (finalUrlInfo) => {
       return (
-        finalUrlInfo.subtype === "service_worker" &&
-        finalUrlInfo.data.isWebWorkerEntryPoint
+        finalUrlInfo.subtype === "service_worker" && finalUrlInfo.isEntryPoint
       )
     },
   )

package/src/execute/run.js

@@ -1,7 +1,6 @@
 import cuid from "cuid"
 import { Abort, raceCallbacks } from "@jsenv/abort"
-import { resolveUrl } from "@jsenv/urls"
-import { writeFile } from "@jsenv/filesystem"
+import { writeFileSync } from "@jsenv/filesystem"
 
 export const run = async ({
   signal = new AbortController().signal,
@@ -10,17 +9,18 @@ export const run = async ({
   keepRunning = false,
   mirrorConsole = false,
   collectConsole = false,
-  collectCoverage = false,
+  coverageEnabled = false,
   coverageTempDirectoryUrl,
   collectPerformance = false,
 
   runtime,
   runtimeParams,
 }) => {
+  let result = {}
+  const callbacks = []
+
   const onConsoleRef = { current: () => {} }
   const stopSignal = { notify: () => {} }
-
-  let resultTransformer = (result) => result
   const runtimeLabel = `${runtime.name}/${runtime.version}`
 
   const runOperation = Abort.startOperation()
@@ -33,22 +33,24 @@ export const run = async ({
     allocatedMs !== Infinity
   ) {
     const timeoutAbortSource = runOperation.timeout(allocatedMs)
-    resultTransformer = composeTransformer(resultTransformer, (result) => {
+    callbacks.push(() => {
       if (
         result.status === "errored" &&
         Abort.isAbortError(result.error) &&
         timeoutAbortSource.signal.aborted
       ) {
-        return createTimedoutResult()
+        result = {
+          status: "timedout",
+        }
       }
-      return result
     })
   }
-  resultTransformer = composeTransformer(resultTransformer, (result) => {
+  callbacks.push(() => {
     if (result.status === "errored" && Abort.isAbortError(result.error)) {
-      return createAbortedResult()
+      result = {
+        status: "aborted",
+      }
     }
-    return result
   })
   const consoleCalls = []
   onConsoleRef.current = ({ type, text }) => {
@@ -64,45 +66,14 @@ export const run = async ({
     }
   }
   if (collectConsole) {
-    resultTransformer = composeTransformer(resultTransformer, (result) => {
+    callbacks.push(() => {
       result.consoleCalls = consoleCalls
-      return result
-    })
-  }
-  if (collectCoverage) {
-    resultTransformer = composeTransformer(
-      resultTransformer,
-      async (result) => {
-        // 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 { coverage } = result
-        if (coverage) {
-          const coverageFileUrl = resolveUrl(
-            `./${runtime.name}/${cuid()}`,
-            coverageTempDirectoryUrl,
-          )
-          await writeFile(coverageFileUrl, JSON.stringify(coverage, null, "  "))
-          result.coverageFileUrl = coverageFileUrl
-          delete result.coverage
-        }
-        return result
-      },
-    )
-  } else {
-    resultTransformer = composeTransformer(resultTransformer, (result) => {
-      // as collectCoverage is disabled
-      // executionResult.coverage is undefined or {}
-      // we delete it just to have a cleaner object
-      delete result.coverage
-      return result
     })
   }
 
   const startMs = Date.now()
-  resultTransformer = composeTransformer(resultTransformer, (result) => {
+  callbacks.push(() => {
     result.duration = Date.now() - startMs
-    return result
   })
 
   try {
@@ -119,7 +90,7 @@ export const run = async ({
           },
           runned: async (cb) => {
             try {
-              const result = await runtime.run({
+              const runResult = await runtime.run({
                 signal: runOperation.signal,
                 logger,
                 ...runtimeParams,
@@ -128,7 +99,7 @@ export const run = async ({
                 stopSignal,
                 onConsole: (log) => onConsoleRef.current(log),
               })
-              cb(result)
+              cb(runResult)
             } catch (e) {
               cb({
                 status: "errored",
@@ -144,35 +115,46 @@ export const run = async ({
     if (winner.name === "aborted") {
       runOperation.throwIfAborted()
     }
-    let result = winner.data
-    result = await resultTransformer(result)
+
+    const { status, namespace, error, performance, coverage } = winner.data
+    result.status = status
+    if (status === "errored") {
+      result.error = error
+    } else {
+      result.namespace = namespace
+    }
+    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) {
-    let result = {
+    result = {
       status: "errored",
       error: e,
     }
-    result = await resultTransformer(result)
+    callbacks.forEach((callback) => {
+      callback()
+    })
     return result
   } finally {
     await runOperation.end()
   }
 }
-
-const composeTransformer = (previousTransformer, transformer) => {
-  return async (value) => {
-    const transformedValue = await previousTransformer(value)
-    return transformer(transformedValue)
-  }
-}
-
-const createAbortedResult = () => {
-  return {
-    status: "aborted",
-  }
-}
-const createTimedoutResult = () => {
-  return {
-    status: "timedout",
-  }
-}

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

@@ -2,7 +2,7 @@ import { createRuntimeFromPlaywright } from "./from_playwright.js"
 
 export const chromium = createRuntimeFromPlaywright({
   browserName: "chromium",
-  browserVersion: "97.0.4666.0",
+  browserVersion: "104.0.5112.20", // to update, check https://github.com/microsoft/playwright/releases
   coveragePlaywrightAPIAvailable: true,
 })
 export const chromiumIsolatedTab = chromium.isolatedTab

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

@@ -2,6 +2,6 @@ import { createRuntimeFromPlaywright } from "./from_playwright.js"
 
 export const firefox = createRuntimeFromPlaywright({
   browserName: "firefox",
-  browserVersion: "93.0",
+  browserVersion: "100.0.2", // to update, check https://github.com/microsoft/playwright/releases
 })
 export const firefoxIsolatedTab = firefox.isolatedTab

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

@@ -11,7 +11,7 @@ import { moveUrl } from "@jsenv/urls"
 import { memoize } from "@jsenv/utils/src/memoize/memoize.js"
 import { escapeRegexpSpecialChars } from "@jsenv/utils/src/string/escape_regexp_special_chars.js"
 
-import { filterV8Coverage } from "@jsenv/core/src/test/coverage/v8_coverage_from_directory.js"
+import { filterV8Coverage } from "@jsenv/core/src/test/coverage/v8_coverage.js"
 import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/core/src/test/coverage/istanbul_coverage_composition.js"
 
 export const createRuntimeFromPlaywright = ({
@@ -23,6 +23,7 @@ export const createRuntimeFromPlaywright = ({
   isolatedTab = false,
 }) => {
   const runtime = {
+    type: "browser",
     name: browserName,
     version: browserVersion,
     needsServer: true,
@@ -37,9 +38,9 @@ export const createRuntimeFromPlaywright = ({
 
     // measurePerformance,
     collectPerformance,
-    collectCoverage = false,
-    coverageForceIstanbul,
-    urlShouldBeCovered,
+    coverageEnabled = false,
+    coverageConfig,
+    coverageMethodForBrowsers,
 
     stopAfterAllSignal,
     stopSignal,
@@ -108,8 +109,11 @@ export const createRuntimeFromPlaywright = ({
     }
 
     let resultTransformer = (result) => result
-    if (collectCoverage) {
-      if (coveragePlaywrightAPIAvailable && !coverageForceIstanbul) {
+    if (coverageEnabled) {
+      if (
+        coveragePlaywrightAPIAvailable &&
+        coverageMethodForBrowsers === "playwright_api"
+      ) {
         await page.coverage.startJSCoverage({
           // reportAnonymousScripts: true,
         })
@@ -133,10 +137,11 @@ export const createRuntimeFromPlaywright = ({
                 }
               },
             )
-            const coverage = filterV8Coverage(
+            const coverage = await filterV8Coverage(
               { result: v8CoveragesWithFsUrls },
               {
-                urlShouldBeCovered,
+                rootDirectoryUrl,
+                coverageConfig,
               },
             )
             return {

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

@@ -2,7 +2,7 @@ import { createRuntimeFromPlaywright } from "./from_playwright.js"
 
 export const webkit = createRuntimeFromPlaywright({
   browserName: "webkit",
-  browserVersion: "15.4",
+  browserVersion: "15.4", // to update, check https://github.com/microsoft/playwright/releases
   ignoreErrorHook: (error) => {
     // we catch error during execution but safari throw unhandled rejection
     // in a non-deterministic way.

package/src/execute/runtimes/node/{controllable_file.mjs → controllable_child_process.mjs}

@@ -1,48 +1,23 @@
-import v8 from "node:v8"
 import { uneval } from "@jsenv/uneval"
-import { startObservingPerformances } from "./node_execution_performance.js"
+
+import { executeUsingDynamicImport } from "./execute_using_dynamic_import.js"
 
 const ACTIONS_AVAILABLE = {
-  "execute-using-dynamic-import": async ({ fileUrl, collectPerformance }) => {
-    const getNamespace = async () => {
-      const namespace = await import(fileUrl)
-      const namespaceResolved = {}
-      await Promise.all([
-        ...Object.keys(namespace).map(async (key) => {
-          const value = await namespace[key]
-          namespaceResolved[key] = value
-        }),
-      ])
-      return namespaceResolved
-    }
-    if (collectPerformance) {
-      const getPerformance = startObservingPerformances()
-      const namespace = await getNamespace()
-      const performance = await getPerformance()
-      return {
-        namespace,
-        performance,
-      }
-    }
-    const namespace = await getNamespace()
-    return {
-      namespace,
-    }
-  },
+  "execute-using-dynamic-import": executeUsingDynamicImport,
   "execute-using-require": async ({ fileUrl }) => {
-    const { createRequire } = await import("module")
-    const { fileURLToPath } = await import("url")
+    const { createRequire } = await import("node:module")
+    const { fileURLToPath } = await import("node:url")
     const filePath = fileURLToPath(fileUrl)
     const require = createRequire(fileUrl)
     // eslint-disable-next-line import/no-dynamic-require
     const namespace = require(filePath)
     const namespaceResolved = {}
-    await Promise.all([
-      ...Object.keys(namespace).map(async (key) => {
+    await Promise.all(
+      Object.keys(namespace).map(async (key) => {
         const value = await namespace[key]
         namespaceResolved[key] = value
       }),
-    ])
+    )
     return namespaceResolved
   },
 }
@@ -94,18 +69,17 @@ const sendToParent = (type, data) => {
   // It means node process may stay alive longer than expected
   // the time to send the data to the parent.
   process.send({
+    jsenv: true,
     type,
     data,
   })
 }
 
-const onceProcessMessage = (type, callback) => {
-  const listener = (event) => {
-    if (event.type === type) {
-      // commenting line below keep this process alive
-      removeListener()
-      // eslint-disable-next-line no-eval
-      callback(eval(`(${event.data})`))
+const onceParentMessage = (type, callback) => {
+  const listener = (message) => {
+    if (message && message.jsenv && message.type === type) {
+      removeListener() // commenting this line keep this process alive
+      callback(message.data)
     }
   }
   const removeListener = () => {
@@ -115,7 +89,7 @@ const onceProcessMessage = (type, callback) => {
   return removeListener
 }
 
-const removeActionRequestListener = onceProcessMessage(
+const removeActionRequestListener = onceParentMessage(
   ACTION_REQUEST_EVENT_NAME,
   async ({ actionType, actionParams }) => {
     const action = ACTIONS_AVAILABLE[actionType]
@@ -133,13 +107,6 @@ const removeActionRequestListener = onceProcessMessage(
       value = e
     }
 
-    if (process.env.NODE_V8_COVERAGE) {
-      v8.takeCoverage()
-      // if (actionParams.stopCoverageAfterExecution) {
-      //   v8.stopCoverage()
-      // }
-    }
-
     // setTimeout(() => {}, 100)
 
     if (failed) {
@@ -151,7 +118,6 @@ const removeActionRequestListener = onceProcessMessage(
     // removeActionRequestListener()
     if (actionParams.exitAfterAction) {
       removeActionRequestListener()
-
       // for some reason this fixes v8 coverage directory sometimes empty on Ubuntu
       // process.exit()
     }
@@ -164,4 +130,6 @@ const removeActionRequestListener = onceProcessMessage(
 // process.once("SIGTERM", removeActionRequestListener)
 // process.once("SIGINT", removeActionRequestListener)
 
-setTimeout(() => sendToParent("ready"))
+setTimeout(() => {
+  sendToParent("ready")
+})

package/src/execute/runtimes/node/controllable_worker_thread.mjs

@@ -0,0 +1,103 @@
+import { parentPort } from "node:worker_threads"
+import { uneval } from "@jsenv/uneval"
+
+import { executeUsingDynamicImport } from "./execute_using_dynamic_import.js"
+
+const ACTIONS_AVAILABLE = {
+  "execute-using-dynamic-import": executeUsingDynamicImport,
+}
+const ACTION_REQUEST_EVENT_NAME = "action"
+const ACTION_RESPONSE_EVENT_NAME = "action-result"
+const ACTION_RESPONSE_STATUS_FAILED = "action-failed"
+const ACTION_RESPONSE_STATUS_COMPLETED = "action-completed"
+
+const sendActionFailed = (error) => {
+  if (error.hasOwnProperty("toString")) {
+    delete error.toString
+  }
+  sendToParent(
+    ACTION_RESPONSE_EVENT_NAME,
+    // process.send algorithm does not send non enumerable values
+    // so use @jsenv/uneval
+    uneval(
+      {
+        status: ACTION_RESPONSE_STATUS_FAILED,
+        value: error,
+      },
+      { ignoreSymbols: true },
+    ),
+  )
+}
+
+const sendActionCompleted = (value) => {
+  sendToParent(
+    ACTION_RESPONSE_EVENT_NAME,
+    // here we use JSON.stringify because we should not
+    // have non enumerable value (unlike there is on Error objects)
+    // otherwise uneval is quite slow to turn a giant object
+    // into a string (and value can be giant when using coverage)
+    JSON.stringify({
+      status: ACTION_RESPONSE_STATUS_COMPLETED,
+      value,
+    }),
+  )
+}
+
+const sendToParent = (type, data) => {
+  // this can keep process alive longer than expected
+  // when source is a long string.
+  // It means node process may stay alive longer than expected
+  // the time to send the data to the parent.
+  parentPort.postMessage({
+    jsenv: true,
+    type,
+    data,
+  })
+}
+
+const onceParentMessage = (type, callback) => {
+  const listener = (message) => {
+    if (message && message.jsenv && message.type === type) {
+      removeListener() // commenting this line keep this worker alive
+      callback(message.data)
+    }
+  }
+  const removeListener = () => {
+    parentPort.removeListener("message", listener)
+  }
+  parentPort.on("message", listener)
+  return removeListener
+}
+
+const removeActionRequestListener = onceParentMessage(
+  ACTION_REQUEST_EVENT_NAME,
+  async ({ actionType, actionParams }) => {
+    const action = ACTIONS_AVAILABLE[actionType]
+    if (!action) {
+      sendActionFailed(new Error(`unknown action ${actionType}`))
+      return
+    }
+
+    let value
+    let failed = false
+    try {
+      value = await action(actionParams)
+    } catch (e) {
+      failed = true
+      value = e
+    }
+
+    if (failed) {
+      sendActionFailed(value)
+    } else {
+      sendActionCompleted(value)
+    }
+    if (actionParams.exitAfterAction) {
+      removeActionRequestListener()
+    }
+  },
+)
+
+setTimeout(() => {
+  sendToParent("ready")
+})