@jsenv/core 27.4.0 → 27.5.0

package/src/plugins/autoreload/dev_sse/client/event_source_client.js

@@ -1,193 +0,0 @@
-import { createEventSourceConnection } from "@jsenv/core/src/helpers/event_source/event_source.js"
-import { urlHotMetas } from "../../../import_meta_hot/client/import_meta_hot.js"
-import {
-  isAutoreloadEnabled,
-  setAutoreloadPreference,
-} from "./autoreload_preference.js"
-import { compareTwoUrlPaths } from "./url_helpers.js"
-import {
-  reloadHtmlPage,
-  reloadDOMNodesUsingUrl,
-  reloadJsImport,
-} from "./reload.js"
-
-const reloadMessages = []
-const reloadMessagesSignal = { onchange: () => {} }
-let pendingCallbacks = []
-let running = false
-const addToHotQueue = async (callback) => {
-  pendingCallbacks.push(callback)
-  dequeue()
-}
-const dequeue = async () => {
-  if (running) {
-    return
-  }
-  const callbacks = pendingCallbacks.slice()
-  pendingCallbacks = []
-  running = true
-  try {
-    await callbacks.reduce(async (previous, callback) => {
-      await previous
-      await callback()
-    }, Promise.resolve())
-  } finally {
-    running = false
-    if (pendingCallbacks.length) {
-      dequeue()
-    }
-  }
-}
-
-const applyReloadMessageEffects = async () => {
-  const someEffectIsFullReload = reloadMessages.some(
-    (reloadMessage) => reloadMessage.type === "full",
-  )
-  if (someEffectIsFullReload) {
-    reloadHtmlPage()
-    return
-  }
-
-  const onApplied = (reloadMessage) => {
-    const index = reloadMessages.indexOf(reloadMessage)
-    reloadMessages.splice(index, 1)
-    reloadMessagesSignal.onchange()
-  }
-  const setReloadMessagePromise = (reloadMessage, promise) => {
-    reloadMessage.status = "pending"
-    promise.then(
-      () => {
-        onApplied(reloadMessage)
-      },
-      (e) => {
-        // TODO: reuse error display from html supervisor
-        console.error(e)
-        console.error(
-          `[hmr] Failed to reload after ${reloadMessage.reason}.
-This could be due to syntax errors or importing non-existent modules (see errors above)`,
-        )
-        reloadMessage.status = "failed"
-        reloadMessagesSignal.onchange()
-      },
-    )
-  }
-  reloadMessages.forEach((reloadMessage) => {
-    if (reloadMessage.type === "hot") {
-      const promise = addToHotQueue(() => {
-        return applyHotReload(reloadMessage)
-      })
-      setReloadMessagePromise(reloadMessage, promise)
-    } else {
-      setReloadMessagePromise(reloadMessage, Promise.resolve())
-    }
-  })
-  reloadMessagesSignal.onchange() // reload status is "pending"
-}
-
-const applyHotReload = async ({ hotInstructions }) => {
-  await hotInstructions.reduce(
-    async (previous, { type, boundary, acceptedBy }) => {
-      await previous
-
-      const urlToFetch = new URL(boundary, `${window.location.origin}/`).href
-      const urlHotMeta = urlHotMetas[urlToFetch]
-      // TODO: we should return when there is no url hot meta because
-      // it means code was not executed (code splitting with dynamic import)
-      // if (!urlHotMeta) {return }
-
-      if (type === "prune") {
-        console.groupCollapsed(
-          `[jsenv] prune: ${boundary} (inside ${acceptedBy})`,
-        )
-      } else if (acceptedBy === boundary) {
-        console.groupCollapsed(`[jsenv] hot reloading: ${boundary}`)
-      } else {
-        console.groupCollapsed(
-          `[jsenv] hot reloading: ${acceptedBy} inside ${boundary}`,
-        )
-      }
-      if (urlHotMeta && urlHotMeta.disposeCallback) {
-        console.log(`call dispose callback`)
-        await urlHotMeta.disposeCallback()
-      }
-      if (type === "prune") {
-        delete urlHotMetas[urlToFetch]
-        console.log(`cleanup pruned url`)
-        console.groupEnd()
-        return null
-      }
-      if (type === "js_module") {
-        console.log(`importing js module`)
-        const namespace = await reloadJsImport(urlToFetch)
-        if (urlHotMeta && urlHotMeta.acceptCallback) {
-          await urlHotMeta.acceptCallback(namespace)
-        }
-        console.log(`js module import done`)
-        console.groupEnd()
-        return namespace
-      }
-      if (type === "html") {
-        if (!compareTwoUrlPaths(urlToFetch, window.location.href)) {
-          // we are not in that HTML page
-          return null
-        }
-        console.log(`reloading url`)
-        const urlToReload = new URL(acceptedBy, `${window.location.origin}/`)
-          .href
-        reloadDOMNodesUsingUrl(urlToReload)
-        console.log(`url reloaded`)
-        console.groupEnd()
-        return null
-      }
-      console.warn(`unknown update type: "${type}"`)
-      return null
-    },
-    Promise.resolve(),
-  )
-}
-
-const addReloadMessage = (reloadMessage) => {
-  reloadMessages.push(reloadMessage)
-  if (isAutoreloadEnabled()) {
-    applyReloadMessageEffects()
-  } else {
-    reloadMessagesSignal.onchange()
-  }
-}
-
-const eventsourceConnection = createEventSourceConnection(
-  document.location.href,
-  {
-    retryMaxAttempt: Infinity,
-    retryAllocatedMs: 20 * 1000,
-  },
-)
-const { status, connect, addEventCallbacks, disconnect } = eventsourceConnection
-eventsourceConnection.addEventCallbacks({
-  reload: ({ data }) => {
-    const reloadMessage = JSON.parse(data)
-    addReloadMessage(reloadMessage)
-  },
-})
-connect()
-window.__jsenv_event_source_client__ = {
-  addEventCallbacks,
-  status,
-  connect,
-  disconnect,
-  isAutoreloadEnabled,
-  setAutoreloadPreference,
-  urlHotMetas,
-  reloadMessages,
-  reloadMessagesSignal,
-  applyReloadMessageEffects,
-  addReloadMessage,
-}
-
-// const findHotMetaUrl = (originalFileRelativeUrl) => {
-//   return Object.keys(urlHotMetas).find((compileUrl) => {
-//     return (
-//       parseCompiledUrl(compileUrl).fileRelativeUrl === originalFileRelativeUrl
-//     )
-//   })
-// }

package/src/plugins/autoreload/dev_sse/jsenv_plugin_dev_sse_server.js

@@ -1,192 +0,0 @@
-import { urlToRelativeUrl } from "@jsenv/urls"
-
-export const jsenvPluginDevSSEServer = ({
-  clientFileChangeCallbackList,
-  clientFilesPruneCallbackList,
-}) => {
-  return {
-    name: "jsenv:sse_server",
-    appliesDuring: { dev: true },
-    registerServerEvents: (
-      { sendServerEvent },
-      { rootDirectoryUrl, urlGraph },
-    ) => {
-      const notifyDeclined = ({ cause, reason, declinedBy }) => {
-        sendServerEvent({
-          type: "reload",
-          data: {
-            cause,
-            type: "full",
-            typeReason: reason,
-            declinedBy,
-          },
-        })
-      }
-      const notifyAccepted = ({ cause, reason, instructions }) => {
-        sendServerEvent({
-          type: "reload",
-          data: {
-            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: urlToRelativeUrl(urlInfo.url, rootDirectoryUrl),
-                  acceptedBy: urlToRelativeUrl(urlInfo.url, rootDirectoryUrl),
-                },
-              ],
-            }
-          }
-          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: urlToRelativeUrl(dependentUrl, rootDirectoryUrl),
-                acceptedBy: urlToRelativeUrl(urlInfo.url, rootDirectoryUrl),
-              })
-              continue
-            }
-            if (seen.includes(dependentUrl)) {
-              return {
-                declined: true,
-                reason: "circular dependency",
-                declinedBy: urlToRelativeUrl(dependentUrl, rootDirectoryUrl),
-              }
-            }
-            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 = urlToRelativeUrl(url, rootDirectoryUrl)
-        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) =>
-            urlToRelativeUrl(prunedUrlInfo.url, rootDirectoryUrl),
-        )}`
-        // 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: urlToRelativeUrl(prunedUrlInfo.url, rootDirectoryUrl),
-            })
-            return
-          }
-          instructions.push({
-            type: "prune",
-            boundary: urlToRelativeUrl(prunedUrlInfo.url, rootDirectoryUrl),
-            acceptedBy: urlToRelativeUrl(firstUrlInfo.url, rootDirectoryUrl),
-          })
-        }
-        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
-    },
-  }
-}