@jsenv/core 27.3.4 → 27.5.1

package/src/plugins/autoreload/{dev_sse/client → client}/reload.js

@@ -13,8 +13,8 @@ export const reloadHtmlPage = () => {
 // - no need to check [hot-accept]and [hot-decline] attributes for instance
 // This is because if something should full reload, we receive "full_reload"
 // from server and this function is not called
-export const reloadDOMNodesUsingUrl = (urlToReload) => {
-  const mutations = []
+export const getDOMNodesUsingUrl = (urlToReload) => {
+  const nodes = []
   const shouldReloadUrl = (urlCandidate) => {
     return compareTwoUrlPaths(urlCandidate, urlToReload)
   }
@@ -29,8 +29,11 @@ export const reloadDOMNodesUsingUrl = (urlToReload) => {
     if (!shouldReloadUrl(attribute)) {
       return
     }
-    mutations.push(() => {
-      node[attributeName] = injectQuery(attribute, { hmr: Date.now() })
+    nodes.push({
+      node,
+      reload: () => {
+        node[attributeName] = injectQuery(attribute, { hmr: Date.now() })
+      },
     })
   }
   Array.from(document.querySelectorAll(`link[rel="stylesheet"]`)).forEach(
@@ -41,8 +44,23 @@ export const reloadDOMNodesUsingUrl = (urlToReload) => {
   Array.from(document.querySelectorAll(`link[rel="icon"]`)).forEach((link) => {
     visitNodeAttributeAsUrl(link, "href")
   })
-  Array.from(document.querySelector("script")).forEach((script) => {
+  Array.from(document.querySelectorAll("script")).forEach((script) => {
     visitNodeAttributeAsUrl(script, "src")
+    const generatedFromSrc = script.getAttribute("generated-from-src")
+    if (generatedFromSrc) {
+      const generatedFromUrl = new URL(generatedFromSrc, window.location.origin)
+        .href
+      if (shouldReloadUrl(generatedFromUrl)) {
+        nodes.push({
+          node: script,
+          reload: () =>
+            window.__html_supervisor__.reloadSupervisedScript({
+              type: script.type,
+              src: generatedFromSrc,
+            }),
+        })
+      }
+    }
   })
   // There is no real need to update a.href because the ressource will be fetched when clicked.
   // But in a scenario where the ressource was already visited and is in browser cache, adding
@@ -67,8 +85,11 @@ export const reloadDOMNodesUsingUrl = (urlToReload) => {
           srcCandidate.specifier = injectQuery(url, { hmr: Date.now() })
         }
       })
-      mutations.push(() => {
-        img.srcset = stringifySrcSet(srcCandidates)
+      nodes.push({
+        node: img,
+        reload: () => {
+          img.srcset = stringifySrcSet(srcCandidates)
+        },
       })
     }
   })
@@ -83,9 +104,7 @@ export const reloadDOMNodesUsingUrl = (urlToReload) => {
   Array.from(document.querySelectorAll("use")).forEach((use) => {
     visitNodeAttributeAsUrl(use, "href")
   })
-  mutations.forEach((mutation) => {
-    mutation()
-  })
+  return nodes
 }
 
 export const reloadJsImport = async (url) => {

package/src/plugins/autoreload/jsenv_plugin_autoreload.js

@@ -1,10 +1,8 @@
 import { jsenvPluginHmr } from "./jsenv_plugin_hmr.js"
-import { jsenvPluginDevSSEClient } from "./dev_sse/jsenv_plugin_dev_sse_client.js"
-import { jsenvPluginDevSSEServer } from "./dev_sse/jsenv_plugin_dev_sse_server.js"
+import { jsenvPluginAutoreloadClient } from "./jsenv_plugin_autoreload_client.js"
+import { jsenvPluginAutoreloadServer } from "./jsenv_plugin_autoreload_server.js"
 
 export const jsenvPluginAutoreload = ({
-  rootDirectoryUrl,
-  urlGraph,
   scenario,
   clientFileChangeCallbackList,
   clientFilesPruneCallbackList,
@@ -14,10 +12,8 @@ export const jsenvPluginAutoreload = ({
   }
   return [
     jsenvPluginHmr(),
-    jsenvPluginDevSSEClient(),
-    jsenvPluginDevSSEServer({
-      rootDirectoryUrl,
-      urlGraph,
+    jsenvPluginAutoreloadClient(),
+    jsenvPluginAutoreloadServer({
       clientFileChangeCallbackList,
       clientFilesPruneCallbackList,
     }),

package/src/plugins/autoreload/{dev_sse/jsenv_plugin_dev_sse_client.js → jsenv_plugin_autoreload_client.js}

@@ -5,30 +5,30 @@ import {
   createHtmlNode,
 } from "@jsenv/ast"
 
-export const jsenvPluginDevSSEClient = () => {
-  const eventSourceClientFileUrl = new URL(
-    "./client/event_source_client.js",
+export const jsenvPluginAutoreloadClient = () => {
+  const autoreloadClientFileUrl = new URL(
+    "./client/autoreload.js",
     import.meta.url,
   ).href
 
   return {
-    name: "jsenv:dev_sse_client",
+    name: "jsenv:autoreload_client",
     appliesDuring: { dev: true },
     transformUrlContent: {
       html: (htmlUrlInfo, context) => {
         const htmlAst = parseHtmlString(htmlUrlInfo.content)
-        const [eventSourceClientReference] = context.referenceUtils.inject({
+        const [autoreloadClientReference] = context.referenceUtils.inject({
           type: "script_src",
           expectedType: "js_module",
-          specifier: eventSourceClientFileUrl,
+          specifier: autoreloadClientFileUrl,
         })
         injectScriptNodeAsEarlyAsPossible(
           htmlAst,
           createHtmlNode({
             "tagName": "script",
             "type": "module",
-            "src": eventSourceClientReference.generatedSpecifier,
-            "injected-by": "jsenv:dev_sse_client",
+            "src": autoreloadClientReference.generatedSpecifier,
+            "injected-by": "jsenv:autoreload_client",
           }),
         )
         const htmlModified = stringifyHtmlAst(htmlAst)

package/src/plugins/autoreload/jsenv_plugin_autoreload_server.js

@@ -0,0 +1,196 @@
+import { urlIsInsideOf, urlToRelativeUrl } from "@jsenv/urls"
+
+export const jsenvPluginAutoreloadServer = ({
+  clientFileChangeCallbackList,
+  clientFilesPruneCallbackList,
+}) => {
+  return {
+    name: "jsenv:autoreload_server",
+    appliesDuring: { dev: true },
+    serverEvents: {
+      reload: ({ sendServerEvent, rootDirectoryUrl, urlGraph }) => {
+        const formatUrlForClient = (url) => {
+          if (urlIsInsideOf(url, rootDirectoryUrl)) {
+            return urlToRelativeUrl(url, rootDirectoryUrl)
+          }
+          if (url.startsWith("file:")) {
+            return `/@fs/${url.slice("file:///".length)}`
+          }
+          return url
+        }
+
+        const notifyDeclined = ({ cause, reason, declinedBy }) => {
+          sendServerEvent({
+            cause,
+            type: "full",
+            typeReason: reason,
+            declinedBy,
+          })
+        }
+        const notifyAccepted = ({ cause, reason, instructions }) => {
+          sendServerEvent({
+            cause,
+            type: "hot",
+            typeReason: reason,
+            hotInstructions: instructions,
+          })
+        }
+        const propagateUpdate = (firstUrlInfo) => {
+          const iterate = (urlInfo, seen) => {
+            if (urlInfo.data.hotAcceptSelf) {
+              return {
+                accepted: true,
+                reason:
+                  urlInfo === firstUrlInfo
+                    ? `file accepts hot reload`
+                    : `a dependent file accepts hot reload`,
+                instructions: [
+                  {
+                    type: urlInfo.type,
+                    boundary: formatUrlForClient(urlInfo.url),
+                    acceptedBy: formatUrlForClient(urlInfo.url),
+                  },
+                ],
+              }
+            }
+            const { dependents } = urlInfo
+            const instructions = []
+            for (const dependentUrl of dependents) {
+              const dependentUrlInfo = urlGraph.getUrlInfo(dependentUrl)
+              if (dependentUrlInfo.data.hotDecline) {
+                return {
+                  declined: true,
+                  reason: `a dependent file declines hot reload`,
+                  declinedBy: dependentUrl,
+                }
+              }
+              const { hotAcceptDependencies = [] } = dependentUrlInfo.data
+              if (hotAcceptDependencies.includes(urlInfo.url)) {
+                instructions.push({
+                  type: dependentUrlInfo.type,
+                  boundary: formatUrlForClient(dependentUrl),
+                  acceptedBy: formatUrlForClient(urlInfo.url),
+                })
+                continue
+              }
+              if (seen.includes(dependentUrl)) {
+                return {
+                  declined: true,
+                  reason: "circular dependency",
+                  declinedBy: formatUrlForClient(dependentUrl),
+                }
+              }
+              const dependentPropagationResult = iterate(dependentUrlInfo, [
+                ...seen,
+                dependentUrl,
+              ])
+              if (dependentPropagationResult.accepted) {
+                instructions.push(...dependentPropagationResult.instructions)
+                continue
+              }
+              if (
+                // declined explicitely by an other file, it must decline the whole update
+                dependentPropagationResult.declinedBy
+              ) {
+                return dependentPropagationResult
+              }
+              // declined by absence of boundary, we can keep searching
+              continue
+            }
+            if (instructions.length === 0) {
+              return {
+                declined: true,
+                reason: `there is no file accepting hot reload while propagating update`,
+              }
+            }
+            return {
+              accepted: true,
+              reason: `${instructions.length} dependent file(s) accepts hot reload`,
+              instructions,
+            }
+          }
+          const seen = []
+          return iterate(firstUrlInfo, seen)
+        }
+        clientFileChangeCallbackList.push(({ url, event }) => {
+          const urlInfo = urlGraph.getUrlInfo(url)
+          // file not part of dependency graph
+          if (!urlInfo) {
+            return
+          }
+          const relativeUrl = formatUrlForClient(url)
+          const hotUpdate = propagateUpdate(urlInfo)
+          if (hotUpdate.declined) {
+            notifyDeclined({
+              cause: `${relativeUrl} ${event}`,
+              reason: hotUpdate.reason,
+              declinedBy: hotUpdate.declinedBy,
+            })
+          } else {
+            notifyAccepted({
+              cause: `${relativeUrl} ${event}`,
+              reason: hotUpdate.reason,
+              instructions: hotUpdate.instructions,
+            })
+          }
+        })
+        clientFilesPruneCallbackList.push(
+          ({ prunedUrlInfos, firstUrlInfo }) => {
+            const mainHotUpdate = propagateUpdate(firstUrlInfo)
+            const cause = `following files are no longer referenced: ${prunedUrlInfos.map(
+              (prunedUrlInfo) => formatUrlForClient(prunedUrlInfo.url),
+            )}`
+            // now check if we can hot update the main ressource
+            // then if we can hot update all dependencies
+            if (mainHotUpdate.declined) {
+              notifyDeclined({
+                cause,
+                reason: mainHotUpdate.reason,
+                declinedBy: mainHotUpdate.declinedBy,
+              })
+              return
+            }
+            // main can hot update
+            let i = 0
+            const instructions = []
+            while (i < prunedUrlInfos.length) {
+              const prunedUrlInfo = prunedUrlInfos[i++]
+              if (prunedUrlInfo.data.hotDecline) {
+                notifyDeclined({
+                  cause,
+                  reason: `a pruned file declines hot reload`,
+                  declinedBy: formatUrlForClient(prunedUrlInfo.url),
+                })
+                return
+              }
+              instructions.push({
+                type: "prune",
+                boundary: formatUrlForClient(prunedUrlInfo.url),
+                acceptedBy: formatUrlForClient(firstUrlInfo.url),
+              })
+            }
+            notifyAccepted({
+              cause,
+              reason: mainHotUpdate.reason,
+              instructions,
+            })
+          },
+        )
+      },
+    },
+    serve: (request, { rootDirectoryUrl, urlGraph }) => {
+      if (request.ressource === "/__graph__") {
+        const graphJson = JSON.stringify(urlGraph.toJSON(rootDirectoryUrl))
+        return {
+          status: 200,
+          headers: {
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(graphJson),
+          },
+          body: graphJson,
+        }
+      }
+      return null
+    },
+  }
+}

package/src/{dev/plugins → plugins}/explorer/jsenv_plugin_explorer.js

@@ -9,9 +9,7 @@ export const jsenvPluginExplorer = ({ groups }) => {
 
   return {
     name: "jsenv:explorer",
-    appliesDuring: {
-      dev: true,
-    },
+    appliesDuring: "dev",
     serve: async (request, { rootDirectoryUrl }) => {
       if (request.ressource !== "/") {
         return null