@jsenv/core 28.1.1 → 28.2.0

package/src/plugins/inline/jsenv_plugin_html_inline_content.js

@@ -19,6 +19,7 @@ export const jsenvPluginHtmlInlineContent = ({ analyzeConvertedScripts }) => {
     transformUrlContent: {
       html: async (urlInfo, context) => {
         const htmlAst = parseHtmlString(urlInfo.content)
+        const mutations = []
         const actions = []
         visitHtmlNodes(htmlAst, {
           style: (styleNode) => {
@@ -26,37 +27,42 @@ export const jsenvPluginHtmlInlineContent = ({ analyzeConvertedScripts }) => {
             if (!styleNodeText) {
               return
             }
-            actions.push(async () => {
-              const { line, column, lineEnd, columnEnd, isOriginal } =
-                getHtmlNodePosition(styleNode, {
-                  preferOriginal: true,
-                })
-              const inlineStyleUrl = generateInlineContentUrl({
-                url: urlInfo.url,
-                extension: ".css",
-                line,
-                column,
-                lineEnd,
-                columnEnd,
+            const { line, column, lineEnd, columnEnd, isOriginal } =
+              getHtmlNodePosition(styleNode, {
+                preferOriginal: true,
+              })
+            const inlineStyleUrl = generateInlineContentUrl({
+              url: urlInfo.url,
+              extension: ".css",
+              line,
+              column,
+              lineEnd,
+              columnEnd,
+            })
+            const debug =
+              getHtmlNodeAttribute(styleNode, "jsenv-debug") !== undefined
+            const [inlineStyleReference, inlineStyleUrlInfo] =
+              context.referenceUtils.foundInline({
+                node: styleNode,
+                type: "link_href",
+                expectedType: "css",
+                isOriginalPosition: isOriginal,
+                // we remove 1 to the line because imagine the following html:
+                // <style>body { color: red; }</style>
+                // -> content starts same line as <style>
+                specifierLine: line - 1,
+                specifierColumn: column,
+                specifier: inlineStyleUrl,
+                contentType: "text/css",
+                content: styleNodeText,
+                debug,
               })
-              const [inlineStyleReference, inlineStyleUrlInfo] =
-                context.referenceUtils.foundInline({
-                  node: styleNode,
-                  type: "link_href",
-                  expectedType: "css",
-                  isOriginalPosition: isOriginal,
-                  // we remove 1 to the line because imagine the following html:
-                  // <style>body { color: red; }</style>
-                  // -> content starts same line as <style>
-                  specifierLine: line - 1,
-                  specifierColumn: column,
-                  specifier: inlineStyleUrl,
-                  contentType: "text/css",
-                  content: styleNodeText,
-                })
+            actions.push(async () => {
               await context.cook(inlineStyleUrlInfo, {
                 reference: inlineStyleReference,
               })
+            })
+            mutations.push(() => {
               setHtmlNodeText(styleNode, inlineStyleUrlInfo.content)
               setHtmlNodeAttributes(styleNode, {
                 "jsenv-plugin-owner": "jsenv:html_inline_content",
@@ -85,40 +91,44 @@ export const jsenvPluginHtmlInlineContent = ({ analyzeConvertedScripts }) => {
             if (jsenvPluginOwner === "jsenv:supervisor") {
               return
             }
-            actions.push(async () => {
-              const { type, contentType, extension } =
-                analyzeScriptNode(scriptNode)
-              const { line, column, lineEnd, columnEnd, isOriginal } =
-                getHtmlNodePosition(scriptNode, {
-                  preferOriginal: true,
-                })
-              let inlineScriptUrl = generateInlineContentUrl({
-                url: urlInfo.url,
-                extension:
-                  extension || CONTENT_TYPE.asFileExtension(contentType),
-                line,
-                column,
-                lineEnd,
-                columnEnd,
+            const { type, contentType, extension } =
+              analyzeScriptNode(scriptNode)
+            const { line, column, lineEnd, columnEnd, isOriginal } =
+              getHtmlNodePosition(scriptNode, {
+                preferOriginal: true,
               })
-              const [inlineScriptReference, inlineScriptUrlInfo] =
-                context.referenceUtils.foundInline({
-                  node: scriptNode,
-                  type: "script_src",
-                  expectedType: type,
-                  // we remove 1 to the line because imagine the following html:
-                  // <script>console.log('ok')</script>
-                  // -> content starts same line as <script>
-                  specifierLine: line - 1,
-                  specifierColumn: column,
-                  isOriginalPosition: isOriginal,
-                  specifier: inlineScriptUrl,
-                  contentType,
-                  content: scriptNodeText,
-                })
+            let inlineScriptUrl = generateInlineContentUrl({
+              url: urlInfo.url,
+              extension: extension || CONTENT_TYPE.asFileExtension(contentType),
+              line,
+              column,
+              lineEnd,
+              columnEnd,
+            })
+            const debug =
+              getHtmlNodeAttribute(scriptNode, "jsenv-debug") !== undefined
+            const [inlineScriptReference, inlineScriptUrlInfo] =
+              context.referenceUtils.foundInline({
+                node: scriptNode,
+                type: "script_src",
+                expectedType: type,
+                // we remove 1 to the line because imagine the following html:
+                // <script>console.log('ok')</script>
+                // -> content starts same line as <script>
+                specifierLine: line - 1,
+                specifierColumn: column,
+                isOriginalPosition: isOriginal,
+                specifier: inlineScriptUrl,
+                contentType,
+                content: scriptNodeText,
+                debug,
+              })
+            actions.push(async () => {
               await context.cook(inlineScriptUrlInfo, {
                 reference: inlineScriptReference,
               })
+            })
+            mutations.push(() => {
               setHtmlNodeText(scriptNode, inlineScriptUrlInfo.content)
               setHtmlNodeAttributes(scriptNode, {
                 "jsenv-plugin-owner": "jsenv:html_inline_content",
@@ -130,14 +140,15 @@ export const jsenvPluginHtmlInlineContent = ({ analyzeConvertedScripts }) => {
             })
           },
         })
-        if (actions.length === 0) {
+        if (actions.length > 0) {
+          await Promise.all(actions.map((action) => action()))
+        }
+        if (mutations.length === 0) {
           return null
         }
-        await Promise.all(actions.map((action) => action()))
+        mutations.forEach((mutation) => mutation())
         const htmlModified = stringifyHtmlAst(htmlAst)
-        return {
-          content: htmlModified,
-        }
+        return htmlModified
       },
     },
   }

package/src/plugins/node_esm_resolution/jsenv_plugin_node_esm_resolution.js

@@ -7,8 +7,8 @@
  *   it should likely be an other plugin happening after the others
  */
 
-import { registerFileLifecycle } from "@jsenv/filesystem"
-
+import { readFileSync } from "node:fs"
+import { bufferToEtag } from "@jsenv/filesystem"
 import {
   applyNodeEsmResolution,
   defaultLookupPackageScope,
@@ -16,13 +16,34 @@ import {
   readCustomConditionsFromProcessArgs,
 } from "@jsenv/node-esm-resolution"
 
-export const jsenvPluginNodeEsmResolution = ({
-  packageConditions,
-  filesInvalidatingCache = ["package.json", "package-lock.json"],
-}) => {
-  const unregisters = []
-  let lookupPackageScope // defined in "init"
-  let readPackageJson // defined in "init"
+export const jsenvPluginNodeEsmResolution = ({ packageConditions }) => {
+  const addRelationshipWithPackageJson = ({
+    context,
+    packageJsonUrl,
+    field,
+    hasVersioningEffect = false,
+  }) => {
+    const referenceFound = context.referenceUtils.find(
+      (ref) => ref.type === "package_json" && ref.subtype === field,
+    )
+    if (referenceFound) {
+      return
+    }
+    const [, packageJsonUrlInfo] = context.referenceUtils.inject({
+      type: "package_json",
+      subtype: field,
+      specifier: packageJsonUrl,
+      isImplicit: true,
+      hasVersioningEffect,
+    })
+    if (packageJsonUrlInfo.type === undefined) {
+      const packageJsonContentAsBuffer = readFileSync(new URL(packageJsonUrl))
+      packageJsonUrlInfo.type = "json"
+      packageJsonUrlInfo.content = String(packageJsonContentAsBuffer)
+      packageJsonUrlInfo.originalContentEtag = packageJsonUrlInfo.contentEtag =
+        bufferToEtag(packageJsonContentAsBuffer)
+    }
+  }
 
   return {
     name: "jsenv:node_esm_resolution",
@@ -37,91 +58,41 @@ export const jsenvPluginNodeEsmResolution = ({
         nodeRuntimeEnabled ? "node" : "browser",
         "import",
       ]
-
-      const packageScopesCache = new Map()
-      lookupPackageScope = (url) => {
-        const fromCache = packageScopesCache.get(url)
-        if (fromCache) {
-          return fromCache
-        }
-        const packageScope = defaultLookupPackageScope(url)
-        packageScopesCache.set(url, packageScope)
-        return packageScope
-      }
-      const packageJsonsCache = new Map()
-      readPackageJson = (url) => {
-        const fromCache = packageJsonsCache.get(url)
-        if (fromCache) {
-          return fromCache
-        }
-        const packageJson = defaultReadPackageJson(url)
-        packageJsonsCache.set(url, packageJson)
-        return packageJson
-      }
-
-      if (context.scenarios.dev) {
-        const onFileChange = () => {
-          packageScopesCache.clear()
-          packageJsonsCache.clear()
-          context.urlGraph.urlInfoMap.forEach((urlInfo) => {
-            if (urlInfo.dependsOnPackageJson) {
-              context.urlGraph.considerModified(urlInfo)
-            }
-          })
-        }
-        filesInvalidatingCache.forEach((file) => {
-          const unregister = registerFileLifecycle(
-            new URL(file, context.rootDirectoryUrl),
-            {
-              added: () => {
-                onFileChange()
-              },
-              updated: () => {
-                onFileChange()
-              },
-              removed: () => {
-                onFileChange()
-              },
-              keepProcessAlive: false,
-            },
-          )
-          unregisters.push(unregister)
-        })
-      }
     },
     resolveUrl: {
-      js_import_export: (reference) => {
+      js_import_export: (reference, context) => {
         const { parentUrl, specifier } = reference
-        const { type, url } = applyNodeEsmResolution({
+        const { url, type, packageUrl } = applyNodeEsmResolution({
           conditions: packageConditions,
           parentUrl,
           specifier,
-          lookupPackageScope,
-          readPackageJson,
         })
-        // this reference depend on package.json and node_modules
-        // to be resolved. Each file using this specifier
-        // must be invalidated when package.json or package_lock.json
-        // changes
-        const dependsOnPackageJson =
-          type !== "relative_specifier" &&
-          type !== "absolute_specifier" &&
-          type !== "node_builtin_specifier"
-        reference.dependsOnPackageJson = dependsOnPackageJson
+        if (context.scenarios.dev) {
+          const dependsOnPackageJson =
+            type !== "relative_specifier" &&
+            type !== "absolute_specifier" &&
+            type !== "node_builtin_specifier"
+          if (dependsOnPackageJson) {
+            // this reference depends on package.json and node_modules
+            // to be resolved. Each file using this specifier
+            // must be invalidated when corresponding package.json changes
+            addRelationshipWithPackageJson({
+              reference,
+              context,
+              packageJsonUrl: `${packageUrl}package.json`,
+              field: type.startsWith("field:")
+                ? `#${type.slice("field:".length)}`
+                : "",
+            })
+          }
+        }
         return url
       },
     },
-    fetchUrlContent: (urlInfo) => {
-      if (urlInfo.url.startsWith("file:///@ignore/")) {
-        return {
-          content: "export default {}",
-          contentType: "text/javascript",
-          type: "js_module",
-        }
-      }
-      return null
-    },
     transformUrlSearchParams: (reference, context) => {
+      if (reference.type === "package_json") {
+        return null
+      }
       if (context.scenarios.build) {
         return null
       }
@@ -137,24 +108,41 @@ export const jsenvPluginNodeEsmResolution = ({
       if (reference.searchParams.has("v")) {
         return null
       }
-      const packageUrl = lookupPackageScope(reference.url)
-      if (!packageUrl) {
+      const packageDirectoryUrl = defaultLookupPackageScope(reference.url)
+      if (!packageDirectoryUrl) {
         return null
       }
-      if (packageUrl === context.rootDirectoryUrl) {
+      if (packageDirectoryUrl === context.rootDirectoryUrl) {
         return null
       }
-      const packageVersion = readPackageJson(packageUrl).version
+      // there is a dependency between this file and the package.json version field
+      const packageVersion = defaultReadPackageJson(packageDirectoryUrl).version
       if (!packageVersion) {
         // example where it happens: https://github.com/babel/babel/blob/2ce56e832c2dd7a7ed92c89028ba929f874c2f5c/packages/babel-runtime/helpers/esm/package.json#L2
         return null
       }
+      if (reference.type === "js_import_export") {
+        addRelationshipWithPackageJson({
+          reference,
+          context,
+          packageJsonUrl: `${packageDirectoryUrl}package.json`,
+          field: "version",
+          hasVersioningEffect: true,
+        })
+      }
       return {
         v: packageVersion,
       }
     },
-    destroy: () => {
-      unregisters.forEach((unregister) => unregister())
+    fetchUrlContent: (urlInfo) => {
+      if (urlInfo.url.startsWith("file:///@ignore/")) {
+        return {
+          content: "export default {}",
+          contentType: "text/javascript",
+          type: "js_module",
+        }
+      }
+      return null
     },
   }
 }

package/src/plugins/plugin_controller.js

@@ -1,4 +1,4 @@
-import { timeStart } from "@jsenv/server"
+import { performance } from "node:perf_hooks"
 
 const HOOK_NAMES = [
   "init",
@@ -60,6 +60,7 @@ export const createPluginController = ({ plugins, scenarios }) => {
     pushPlugin(plugin)
   })
 
+  let lastPluginUsed = null
   let currentPlugin = null
   let currentHookName = null
   const callHook = (hook, info, context) => {
@@ -67,21 +68,21 @@ export const createPluginController = ({ plugins, scenarios }) => {
     if (!hookFn) {
       return null
     }
-    currentPlugin = hook.plugin
-    currentHookName = hook.name
-    let timeEnd
+    let startTimestamp
     if (info.timing) {
-      timeEnd = timeStart(
-        `${currentHookName}-${currentPlugin.name.replace("jsenv:", "")}`,
-      )
+      startTimestamp = performance.now()
     }
+    lastPluginUsed = hook.plugin
+    currentPlugin = hook.plugin
+    currentHookName = hook.name
     let valueReturned = hookFn(info, context)
+    currentPlugin = null
+    currentHookName = null
     if (info.timing) {
-      Object.assign(info.timing, timeEnd())
+      info.timing[`${hook.name}-${hook.plugin.name.replace("jsenv:", "")}`] =
+        performance.now() - startTimestamp
     }
     valueReturned = assertAndNormalizeReturnValue(hook.name, valueReturned)
-    currentPlugin = null
-    currentHookName = null
     return valueReturned
   }
   const callAsyncHook = async (hook, info, context) => {
@@ -89,21 +90,22 @@ export const createPluginController = ({ plugins, scenarios }) => {
     if (!hookFn) {
       return null
     }
-    currentPlugin = hook.plugin
-    currentHookName = hook.name
-    let timeEnd
+
+    let startTimestamp
     if (info.timing) {
-      timeEnd = timeStart(
-        `${currentHookName}-${currentPlugin.name.replace("jsenv:", "")}`,
-      )
+      startTimestamp = performance.now()
     }
+    lastPluginUsed = hook.plugin
+    currentPlugin = hook.plugin
+    currentHookName = hook.name
     let valueReturned = await hookFn(info, context)
+    currentPlugin = null
+    currentHookName = null
     if (info.timing) {
-      Object.assign(info.timing, timeEnd())
+      info.timing[`${hook.name}-${hook.plugin.name.replace("jsenv:", "")}`] =
+        performance.now() - startTimestamp
     }
     valueReturned = assertAndNormalizeReturnValue(hook.name, valueReturned)
-    currentPlugin = null
-    currentHookName = null
     return valueReturned
   }
 
@@ -113,7 +115,7 @@ export const createPluginController = ({ plugins, scenarios }) => {
       for (const hook of hooks) {
         const returnValue = callHook(hook, info, context)
         if (returnValue && callback) {
-          callback(returnValue)
+          callback(returnValue, hook.plugin)
         }
       }
     }
@@ -125,7 +127,7 @@ export const createPluginController = ({ plugins, scenarios }) => {
         await previous
         const returnValue = await callAsyncHook(hook, info, context)
         if (returnValue && callback) {
-          await callback(returnValue)
+          await callback(returnValue, hook.plugin)
         }
       }, Promise.resolve())
     }
@@ -182,6 +184,7 @@ export const createPluginController = ({ plugins, scenarios }) => {
     callAsyncHooks,
     callAsyncHooksUntil,
 
+    getLastPluginUsed: () => lastPluginUsed,
     getCurrentPlugin: () => currentPlugin,
     getCurrentHookName: () => currentHookName,
   }
@@ -200,7 +203,8 @@ const flattenAndFilterPlugins = (plugins, { scenarios }) => {
       }
       const { appliesDuring } = pluginEntry
       if (appliesDuring === undefined) {
-        console.warn(`"appliesDuring" is undefined on ${pluginEntry.name}`)
+        // console.debug(`"appliesDuring" is undefined on ${pluginEntry.name}`)
+        flatPlugins.push(pluginEntry)
         return
       }
       if (appliesDuring === "*") {

package/src/plugins/server_events/jsenv_plugin_server_events_client_injection.js

@@ -25,6 +25,7 @@ export const jsenvPluginServerEventsClientInjection = () => {
         const [serverEventsClientFileReference] = context.referenceUtils.inject(
           {
             type: "script_src",
+            subtype: "js_module",
             expectedType: "js_module",
             specifier: serverEventsClientFileUrl,
           },

package/src/plugins/supervisor/client/script_type_module_supervisor.js

@@ -9,16 +9,12 @@ export const superviseScriptTypeModule = async ({ src, async }) => {
   const execute = isWebkitOrSafari
     ? createExecuteWithDynamicImport({ src })
     : createExecuteWithScript({ currentScript, src })
-  if (!async) {
-    await window.__supervisor__.getPreviousExecutionDonePromise()
-  }
-  const execution = window.__supervisor__.createExecution({
+  return window.__supervisor__.addExecution({
     src,
     async,
     type: "js_module",
     execute,
   })
-  return execution.start()
 }
 
 const createExecuteWithScript = ({ currentScript, src }) => {
@@ -64,10 +60,10 @@ const createExecuteWithScript = ({ currentScript, src }) => {
         needsReport: true,
       }
     }
-    // do not resolve right away, wait for top level execution
     try {
-      const namespace = await import(urlObject.href)
-      return namespace
+      return {
+        executionPromise: import(urlObject.href),
+      }
     } catch (e) {
       e.reportedBy = "dynamic_import"
       throw e
@@ -83,7 +79,9 @@ const createExecuteWithDynamicImport = ({ src }) => {
     }
     try {
       const namespace = await import(urlObject.href)
-      return namespace
+      return {
+        executionPromise: Promise.resolve(namespace),
+      }
     } catch (e) {
       e.reportedBy = "dynamic_import"
       // dynamic import would hide the error to the browser