@jsenv/core 27.0.2 → 27.2.0

package/src/omega/kitchen.js

@@ -86,6 +86,7 @@ export const createKitchen = ({
     baseUrl,
     isOriginalPosition,
     shouldHandle,
+    isEntryPoint = false,
     isInline = false,
     injected = false,
     isRessourceHint = false,
@@ -122,6 +123,7 @@ export const createKitchen = ({
       baseUrl,
       isOriginalPosition,
       shouldHandle,
+      isEntryPoint,
       isInline,
       injected,
       isRessourceHint,
@@ -138,6 +140,7 @@ export const createKitchen = ({
     reference.next = newReference
     newReference.prev = reference
     newReference.original = reference.original || reference
+    //  newReference.isEntryPoint = reference.isEntryPoint
   }
   const resolveReference = (reference) => {
     try {
@@ -166,12 +169,16 @@ export const createKitchen = ({
         },
       )
 
-      const urlInfo = urlGraph.reuseOrCreateUrlInfo(reference.url)
-      applyReferenceEffectsOnUrlInfo(reference, urlInfo, kitchenContext)
-
       const referenceUrlObject = new URL(reference.url)
       reference.searchParams = referenceUrlObject.searchParams
       reference.generatedUrl = reference.url
+      if (reference.searchParams.has("entry_point")) {
+        reference.isEntryPoint = true
+      }
+
+      const urlInfo = urlGraph.reuseOrCreateUrlInfo(reference.url)
+      applyReferenceEffectsOnUrlInfo(reference, urlInfo, kitchenContext)
+
       // This hook must touch reference.generatedUrl, NOT reference.url
       // And this is because this hook inject query params used to:
       // - bypass browser cache (?v)
@@ -286,6 +293,7 @@ export const createKitchen = ({
         status = 200,
         headers = {},
         body,
+        isEntryPoint,
       } = fetchUrlContentReturnValue
       if (status !== 200) {
         throw new Error(`unexpected status, ${status}`)
@@ -319,6 +327,9 @@ export const createKitchen = ({
       if (data) {
         Object.assign(urlInfo.data, data)
       }
+      if (typeof isEntryPoint === "boolean") {
+        urlInfo.isEntryPoint = isEntryPoint
+      }
       if (filename) {
         urlInfo.filename = filename
       }
@@ -620,6 +631,7 @@ export const createKitchen = ({
 
   const prepareEntryPoint = (params) => {
     const entryReference = createReference(params)
+    entryReference.isEntryPoint = true
     const entryUrlInfo = resolveReference(entryReference)
     return [entryReference, entryUrlInfo]
   }
@@ -718,6 +730,10 @@ const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
   }
   urlInfo.originalUrl = urlInfo.originalUrl || reference.url
 
+  if (reference.isEntryPoint || isWebWorkerEntryPointReference(reference)) {
+    urlInfo.isEntryPoint = true
+  }
+
   Object.assign(urlInfo.data, reference.data)
   Object.assign(urlInfo.timing, reference.timing)
   if (reference.injected) {
@@ -746,9 +762,6 @@ const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
         : reference.content
     urlInfo.content = reference.content
   }
-  if (isWebWorkerEntryPointReference(reference)) {
-    urlInfo.data.isWebWorkerEntryPoint = true
-  }
 }
 
 const adjustUrlSite = (urlInfo, { urlGraph, url, line, column }) => {

package/src/omega/server/file_service.js

@@ -50,10 +50,10 @@ export const createFileService = ({
       reference = urlGraph.inferReference(request.ressource, parentUrl)
     }
     if (!reference) {
-      const entryPoint = kitchen.prepareEntryPoint({
+      const entryPoint = kitchen.injectReference({
         trace: parentUrl || rootDirectoryUrl,
         parentUrl: parentUrl || rootDirectoryUrl,
-        type: "entry_point",
+        type: "http_request",
         specifier: request.ressource,
       })
       reference = entryPoint[0]

package/src/omega/url_graph/url_graph_load.js

@@ -56,7 +56,6 @@ export const loadUrlGraph = async ({
         type,
         specifier,
       })
-      entryUrlInfo.data.isEntryPoint = true
       cook(entryUrlInfo, { reference: entryReference })
       return [entryReference, entryUrlInfo]
     },

package/src/omega/url_graph/url_info_transformations.js

@@ -117,7 +117,8 @@ export const createUrlInfoTransformer = ({
     if (!transformations) {
       return
     }
-    const { type, contentType, content, sourcemap } = transformations
+    const { type, contentType, content, sourcemap, sourcemapIsWrong } =
+      transformations
     if (type) {
       urlInfo.type = type
     }
@@ -138,6 +139,16 @@ export const createUrlInfoTransformer = ({
         finalSourcemap,
       )
       urlInfo.sourcemap = finalSourcemapNormalized
+      // A plugin is allowed to modify url content
+      // without returning a sourcemap
+      // This is the case for preact and react plugins.
+      // They are currently generating wrong source mappings
+      // when used.
+      // Generating the correct sourcemap in this situation
+      // is a nightmare no-one could solve in years so
+      // jsenv won't emit a warning and use the following strategy:
+      // "no sourcemap is better than wrong sourcemap"
+      urlInfo.sourcemapIsWrong = sourcemapIsWrong
     }
   }
 
@@ -162,19 +173,21 @@ export const createUrlInfoTransformer = ({
         })
       }
       sourcemapUrlInfo.content = JSON.stringify(sourcemap, null, "  ")
-      if (sourcemaps === "inline") {
-        sourcemapReference.generatedSpecifier =
-          generateSourcemapDataUrl(sourcemap)
-      }
-      if (sourcemaps === "file" || sourcemaps === "inline") {
-        urlInfo.content = SOURCEMAP.writeComment({
-          contentType: urlInfo.contentType,
-          content: urlInfo.content,
-          specifier:
-            sourcemaps === "file" && sourcemapsRelativeSources
-              ? urlToRelativeUrl(sourcemapReference.url, urlInfo.url)
-              : sourcemapReference.generatedSpecifier,
-        })
+      if (!urlInfo.sourcemapIsWrong) {
+        if (sourcemaps === "inline") {
+          sourcemapReference.generatedSpecifier =
+            generateSourcemapDataUrl(sourcemap)
+        }
+        if (sourcemaps === "file" || sourcemaps === "inline") {
+          urlInfo.content = SOURCEMAP.writeComment({
+            contentType: urlInfo.contentType,
+            content: urlInfo.content,
+            specifier:
+              sourcemaps === "file" && sourcemapsRelativeSources
+                ? urlToRelativeUrl(sourcemapReference.url, urlInfo.url)
+                : sourcemapReference.generatedSpecifier,
+          })
+        }
       }
     } else if (urlInfo.sourcemapReference) {
       // in the end we don't use the sourcemap placeholder

package/src/omega/url_graph.js

@@ -207,6 +207,7 @@ const createUrlInfo = (url) => {
     originalUrl: undefined,
     generatedUrl: null,
     filename: "",
+    isEntryPoint: false,
     isInline: false,
     inlineUrlSite: null,
     shouldHandle: undefined,
@@ -215,6 +216,7 @@ const createUrlInfo = (url) => {
 
     sourcemap: null,
     sourcemapReference: null,
+    sourcemapIsWrong: false,
     timing: {},
     headers: {},
   }

package/src/plugins/bundling/js_module/bundle_js_module.js

@@ -94,7 +94,7 @@ const rollupPluginJsenv = ({
       let previousNonEntryPointModuleId
       jsModuleUrlInfos.forEach((jsModuleUrlInfo) => {
         const id = jsModuleUrlInfo.url
-        if (jsModuleUrlInfo.data.isEntryPoint) {
+        if (jsModuleUrlInfo.isEntryPoint) {
           emitChunk({
             id,
           })
@@ -355,10 +355,7 @@ const willBeInsideJsDirectory = ({
     // generated by rollup
     return true
   }
-  if (
-    !jsModuleUrlInfo.data.isEntryPoint &&
-    !jsModuleUrlInfo.data.isWebWorkerEntryPoint
-  ) {
+  if (!jsModuleUrlInfo.isEntryPoint) {
     // not an entry point, jsenv will put it inside js/ directory
     return true
   }

package/src/plugins/transpilation/as_js_classic/jsenv_plugin_as_js_classic.js

@@ -101,24 +101,24 @@ const jsenvPluginAsJsClassicConversion = ({
       if (!originalUrlInfo) {
         return null
       }
-      const isJsEntryPoint =
-        // in general html files are entry points
-        // but during build js can be sepcified as an entry point
-        // (meaning there is no html file where we can inject systemjs)
-        // in that case we need to inject systemjs in the js file
-        originalUrlInfo.data.isEntryPoint ||
-        // In thoose case we need to inject systemjs the worker js file
-        originalUrlInfo.data.isWebWorkerEntryPoint
-      // if it's an entry point without dependency (it does not use import)
-      // then we can use UMD, otherwise we have to use systemjs
-      // because it is imported by systemjs
       const jsClassicFormat =
-        isJsEntryPoint && !originalUrlInfo.data.usesImport ? "umd" : "system"
+        // in general html file are entry points, but js can be entry point when:
+        // - passed in entryPoints to build
+        // - is used by web worker
+        // - the reference contains ?entry_point
+        // When js is entry point there can be no HTML to inject systemjs
+        // and systemjs must be injected into the js file
+        originalUrlInfo.isEntryPoint &&
+        // if it's an entry point without dependency (it does not use import)
+        // then we can use UMD, otherwise we have to use systemjs
+        // because it is imported by systemjs
+        !originalUrlInfo.data.usesImport
+          ? "umd"
+          : "system"
       const { content, sourcemap } = await convertJsModuleToJsClassic({
         systemJsInjection,
         systemJsClientFileUrl,
         urlInfo: originalUrlInfo,
-        isJsEntryPoint,
         jsClassicFormat,
       })
       urlInfo.data.jsClassicFormat = jsClassicFormat
@@ -160,7 +160,6 @@ const convertJsModuleToJsClassic = async ({
   systemJsInjection,
   systemJsClientFileUrl,
   urlInfo,
-  isJsEntryPoint,
   jsClassicFormat,
 }) => {
   const { code, map } = await applyBabelPlugins({
@@ -193,7 +192,11 @@ const convertJsModuleToJsClassic = async ({
   })
   let sourcemap = urlInfo.sourcemap
   sourcemap = await composeTwoSourcemaps(sourcemap, map)
-  if (systemJsInjection && jsClassicFormat === "system" && isJsEntryPoint) {
+  if (
+    systemJsInjection &&
+    jsClassicFormat === "system" &&
+    urlInfo.isEntryPoint
+  ) {
     const magicSource = createMagicSource(code)
     const systemjsCode = readFileSync(systemJsClientFileUrl, { as: "string" })
     magicSource.prepend(`${systemjsCode}\n\n`)

package/src/plugins/url_resolution/jsenv_plugin_url_resolution.js

@@ -9,7 +9,8 @@ export const jsenvPluginUrlResolution = () => {
     name: "jsenv:url_resolution",
     appliesDuring: "*",
     resolveUrl: {
-      "entry_point": urlResolver,
+      "http_request": urlResolver, // during dev
+      "entry_point": urlResolver, // during build
       "link_href": urlResolver,
       "script_src": urlResolver,
       "a_href": urlResolver,

package/src/test/coverage/report_to_coverage.js

@@ -1,10 +1,8 @@
-import { readFile } from "@jsenv/filesystem"
+import { readFileSync } from "node:fs"
 import { Abort } from "@jsenv/abort"
 
-import {
-  visitNodeV8Directory,
-  filterV8Coverage,
-} from "./v8_coverage_from_directory.js"
+import { filterV8Coverage } from "./v8_coverage.js"
+import { readNodeV8CoverageDirectory } from "./v8_coverage_node_directory.js"
 import { composeTwoV8Coverages } from "./v8_coverage_composition.js"
 import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
 import { v8CoverageToIstanbul } from "./v8_coverage_to_istanbul.js"
@@ -20,8 +18,7 @@ export const reportToCoverage = async (
     rootDirectoryUrl,
     coverageConfig,
     coverageIncludeMissing,
-    urlShouldBeCovered,
-    coverageForceIstanbul,
+    coverageMethodForNodeJs,
     coverageV8ConflictWarning,
   },
 ) => {
@@ -49,24 +46,24 @@ export const reportToCoverage = async (
       // that were suppose to be coverage but were not.
       if (
         executionResult.status === "completed" &&
-        executionResult.runtimeName !== "node" &&
-        !process.env.NODE_V8_COVERAGE
+        executionResult.type === "node" &&
+        coverageMethodForNodeJs !== "NODE_V8_COVERAGE"
       ) {
         logger.warn(
-          `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
+          `No "coverageFileUrl" from execution named "${executionName}" of ${file}`,
         )
       }
     },
   })
 
-  if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
-    await visitNodeV8Directory({
+  if (coverageMethodForNodeJs === "NODE_V8_COVERAGE") {
+    await readNodeV8CoverageDirectory({
       logger,
       signal,
-      NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
-      onV8Coverage: (nodeV8Coverage) => {
-        const nodeV8CoverageLight = filterV8Coverage(nodeV8Coverage, {
-          urlShouldBeCovered,
+      onV8Coverage: async (nodeV8Coverage) => {
+        const nodeV8CoverageLight = await filterV8Coverage(nodeV8Coverage, {
+          rootDirectoryUrl,
+          coverageConfig,
         })
         v8Coverage = v8Coverage
           ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
@@ -164,9 +161,9 @@ const getCoverageFromReport = async ({ signal, report, onMissing }) => {
             return
           }
 
-          const executionCoverage = await readFile(coverageFileUrl, {
-            as: "json",
-          })
+          const executionCoverage = JSON.parse(
+            String(readFileSync(new URL(coverageFileUrl))),
+          )
           if (isV8Coverage(executionCoverage)) {
             v8Coverage = v8Coverage
               ? composeTwoV8Coverages(v8Coverage, executionCoverage)

package/src/test/coverage/v8_coverage.js

@@ -0,0 +1,26 @@
+import { URL_META } from "@jsenv/url-meta"
+
+export const filterV8Coverage = async (
+  v8Coverage,
+  { rootDirectoryUrl, coverageConfig },
+) => {
+  const associations = URL_META.resolveAssociations(
+    { cover: coverageConfig },
+    rootDirectoryUrl,
+  )
+  const urlShouldBeCovered = (url) => {
+    const { cover } = URL_META.applyAssociations({
+      url: new URL(url, rootDirectoryUrl).href,
+      associations,
+    })
+    return cover
+  }
+
+  const v8CoverageFiltered = {
+    ...v8Coverage,
+    result: v8Coverage.result.filter((fileReport) =>
+      urlShouldBeCovered(fileReport.url),
+    ),
+  }
+  return v8CoverageFiltered
+}

package/src/test/coverage/{v8_coverage_from_directory.js → v8_coverage_node_directory.js}

@@ -1,27 +1,30 @@
-import {
-  assertAndNormalizeDirectoryUrl,
-  readDirectory,
-  readFile,
-} from "@jsenv/filesystem"
-import { resolveUrl } from "@jsenv/urls"
+import { readFileSync, readdirSync } from "node:fs"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/log"
 import { Abort } from "@jsenv/abort"
 
-export const visitNodeV8Directory = async ({
+export const readNodeV8CoverageDirectory = async ({
   logger,
   signal,
-  NODE_V8_COVERAGE,
   onV8Coverage,
   maxMsWaitingForNodeToWriteCoverageFile = 2000,
 }) => {
+  const NODE_V8_COVERAGE = process.env.NODE_V8_COVERAGE
   const operation = Abort.startOperation()
   operation.addAbortSignal(signal)
 
+  let timeSpentTrying = 0
   const tryReadDirectory = async () => {
-    const dirContent = await readDirectory(NODE_V8_COVERAGE)
+    const dirContent = readdirSync(NODE_V8_COVERAGE)
     if (dirContent.length > 0) {
       return dirContent
     }
+    if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
+      await new Promise((resolve) => setTimeout(resolve, 200))
+      timeSpentTrying += 200
+      logger.debug("retry to read coverage directory")
+      return tryReadDirectory()
+    }
     logger.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`)
     return dirContent
   }
@@ -32,17 +35,19 @@ export const visitNodeV8Directory = async ({
 
     const coverageDirectoryUrl =
       assertAndNormalizeDirectoryUrl(NODE_V8_COVERAGE)
+
     await dirContent.reduce(async (previous, dirEntry) => {
       operation.throwIfAborted()
       await previous
 
-      const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
-      const tryReadJsonFile = async (timeSpentTrying = 0) => {
-        const fileContent = await readFile(dirEntryUrl, { as: "string" })
+      const dirEntryUrl = new URL(dirEntry, coverageDirectoryUrl)
+      const tryReadJsonFile = async () => {
+        const fileContent = String(readFileSync(dirEntryUrl))
         if (fileContent === "") {
-          if (timeSpentTrying < 400) {
+          if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
             await new Promise((resolve) => setTimeout(resolve, 200))
-            return tryReadJsonFile(timeSpentTrying + 200)
+            timeSpentTrying += 200
+            return tryReadJsonFile()
           }
           console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`)
           return null
@@ -54,7 +59,8 @@ export const visitNodeV8Directory = async ({
         } catch (e) {
           if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
             await new Promise((resolve) => setTimeout(resolve, 200))
-            return tryReadJsonFile(timeSpentTrying + 200)
+            timeSpentTrying += 200
+            return tryReadJsonFile()
           }
           console.warn(
             createDetailedMessage(`Error while reading coverage file`, {
@@ -68,20 +74,10 @@ export const visitNodeV8Directory = async ({
 
       const fileContent = await tryReadJsonFile()
       if (fileContent) {
-        onV8Coverage(fileContent)
+        await onV8Coverage(fileContent)
       }
     }, Promise.resolve())
   } finally {
     await operation.end()
   }
 }
-
-export const filterV8Coverage = (v8Coverage, { urlShouldBeCovered }) => {
-  const v8CoverageFiltered = {
-    ...v8Coverage,
-    result: v8Coverage.result.filter((fileReport) =>
-      urlShouldBeCovered(fileReport.url),
-    ),
-  }
-  return v8CoverageFiltered
-}