@jsenv/core 27.3.3 → 27.5.0

package/src/helpers/event_source/sse_service.js

@@ -1,53 +0,0 @@
-import { createSSERoom } from "@jsenv/server"
-import { createCallbackListNotifiedOnce } from "@jsenv/abort"
-
-export const createSSEService = ({ serverEventCallbackList }) => {
-  const destroyCallbackList = createCallbackListNotifiedOnce()
-
-  const cache = []
-  const sseRoomLimit = 100
-  const getOrCreateSSERoom = (request) => {
-    const htmlFileRelativeUrl = request.ressource.slice(1)
-    const cacheEntry = cache.find(
-      (cacheEntryCandidate) =>
-        cacheEntryCandidate.htmlFileRelativeUrl === htmlFileRelativeUrl,
-    )
-    if (cacheEntry) {
-      return cacheEntry.sseRoom
-    }
-    const sseRoom = createSSERoom({
-      retryDuration: 2000,
-      historyLength: 100,
-      welcomeEventEnabled: true,
-      effect: () => {
-        return serverEventCallbackList.add((event) => {
-          sseRoom.sendEvent(event)
-        })
-      },
-    })
-    const removeSSECleanupCallback = destroyCallbackList.add(() => {
-      removeSSECleanupCallback()
-      sseRoom.close()
-    })
-    cache.push({
-      htmlFileRelativeUrl,
-      sseRoom,
-      cleanup: () => {
-        removeSSECleanupCallback()
-        sseRoom.close()
-      },
-    })
-    if (cache.length >= sseRoomLimit) {
-      const firstCacheEntry = cache.shift()
-      firstCacheEntry.cleanup()
-    }
-    return sseRoom
-  }
-
-  return {
-    getOrCreateSSERoom,
-    destroy: () => {
-      destroyCallbackList.notify()
-    },
-  }
-}

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,
-  {
-    reload: ({ data }) => {
-      const reloadMessage = JSON.parse(data)
-      addReloadMessage(reloadMessage)
-    },
-  },
-  {
-    retryMaxAttempt: Infinity,
-    retryAllocatedMs: 20 * 1000,
-  },
-)
-
-const { status, connect, disconnect } = eventsourceConnection
-connect()
-window.__jsenv_event_source_client__ = {
-  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,203 +0,0 @@
-import { urlToRelativeUrl } from "@jsenv/urls"
-import { createCallbackList } from "@jsenv/abort"
-
-import { createSSEService } from "@jsenv/core/src/helpers/event_source/sse_service.js"
-
-export const jsenvPluginDevSSEServer = ({
-  rootDirectoryUrl,
-  urlGraph,
-  clientFileChangeCallbackList,
-  clientFilesPruneCallbackList,
-}) => {
-  const serverEventCallbackList = createCallbackList()
-  const sseService = createSSEService({ serverEventCallbackList })
-
-  const notifyDeclined = ({ cause, reason, declinedBy }) => {
-    serverEventCallbackList.notify({
-      type: "reload",
-      data: JSON.stringify({
-        cause,
-        type: "full",
-        typeReason: reason,
-        declinedBy,
-      }),
-    })
-  }
-  const notifyAccepted = ({ cause, reason, instructions }) => {
-    serverEventCallbackList.notify({
-      type: "reload",
-      data: JSON.stringify({
-        cause,
-        type: "hot",
-        typeReason: reason,
-        hotInstructions: instructions,
-      }),
-    })
-  }
-  const propagateUpdate = (firstUrlInfo) => {
-    const iterate = (urlInfo, trace) => {
-      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 (trace.includes(dependentUrl)) {
-          return {
-            declined: true,
-            reason: "circular dependency",
-            declinedBy: urlToRelativeUrl(dependentUrl, rootDirectoryUrl),
-          }
-        }
-        const dependentPropagationResult = iterate(dependentUrlInfo, [
-          ...trace,
-          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 trace = []
-    return iterate(firstUrlInfo, trace)
-  }
-  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,
-    })
-  })
-
-  return {
-    name: "jsenv:sse_server",
-    appliesDuring: { dev: true },
-    serve: (request) => {
-      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,
-        }
-      }
-      const { accept } = request.headers
-      if (accept && accept.includes("text/event-stream")) {
-        const room = sseService.getOrCreateSSERoom(request)
-        return room.join(request)
-      }
-      return null
-    },
-    destroy: () => {
-      sseService.destroy()
-    },
-  }
-}

package/src/plugins/html_supervisor/client/error_in_document.js

@@ -1,198 +0,0 @@
-export const displayErrorInDocument = (error) => {
-  const title = "An error occured"
-  let theme =
-    error && error.cause && error.cause.code === "PARSE_ERROR"
-      ? "light"
-      : "dark"
-  let message = errorToHTML(error)
-  const css = `
-    .jsenv-console {
-      background: rgba(0, 0, 0, 0.95);
-      position: absolute;
-      top: 0;
-      left: 0;
-      width: 100%;
-      height: 100%;
-      display: flex;
-      flex-direction: column;
-      align-items: center;
-      z-index: 1000;
-      box-sizing: border-box;
-      padding: 1em;
-    }
-
-    .jsenv-console h1 {
-      color: red;
-      display: flex;
-      align-items: center;
-    }
-
-    #button-close-jsenv-console {
-      margin-left: 10px;
-    }
-
-    .jsenv-console pre {
-      overflow: auto;
-      max-width: 70em;
-      /* avoid scrollbar to hide the text behind it */
-      padding: 20px;
-    }
-
-    .jsenv-console pre[data-theme="dark"] {
-      background: #111;
-      border: 1px solid #333;
-      color: #eee;
-    }
-
-    .jsenv-console pre[data-theme="light"] {
-      background: #1E1E1E;
-      border: 1px solid white;
-      color: #EEEEEE;
-    }
-
-    .jsenv-console pre a {
-      color: inherit;
-    }
-    `
-  const html = `
-      <style type="text/css">${css}></style>
-      <div class="jsenv-console">
-        <h1>${title} <button id="button-close-jsenv-console">X</button></h1>
-        <pre data-theme="${theme}">${message}</pre>
-      </div>
-      `
-  const removeJsenvConsole = appendHMTLInside(html, document.body)
-
-  document.querySelector("#button-close-jsenv-console").onclick = () => {
-    removeJsenvConsole()
-  }
-}
-
-const escapeHtml = (string) => {
-  return string
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-    .replace(/'/g, "&#039;")
-}
-
-const errorToHTML = (error) => {
-  let html
-
-  if (error && error instanceof Error) {
-    if (error.cause && error.cause.code === "PARSE_ERROR") {
-      html = error.messageHTML || escapeHtml(error.message)
-    }
-    // stackTrace formatted by V8
-    else if (Error.captureStackTrace) {
-      html = escapeHtml(error.stack)
-    } else {
-      // other stack trace such as firefox do not contain error.message
-      html = escapeHtml(`${error.message}
-  ${error.stack}`)
-    }
-  } else if (typeof error === "string") {
-    html = error
-  } else if (error === undefined) {
-    html = "undefined"
-  } else {
-    html = JSON.stringify(error)
-  }
-
-  const htmlWithCorrectLineBreaks = html.replace(/\n/g, "\n")
-  const htmlWithLinks = stringToStringWithLink(htmlWithCorrectLineBreaks, {
-    transform: (url) => {
-      return { href: url, text: url }
-    },
-  })
-  return htmlWithLinks
-}
-
-// `Error: yo
-// at Object.execute (http://127.0.0.1:57300/build/src/__test__/file-throw.js:9:13)
-// at doExec (http://127.0.0.1:3000/src/__test__/file-throw.js:452:38)
-// at postOrderExec (http://127.0.0.1:3000/src/__test__/file-throw.js:448:16)
-// at http://127.0.0.1:3000/src/__test__/file-throw.js:399:18`.replace(/(?:https?|ftp|file):\/\/(.*+)$/gm, (...args) => {
-//   debugger
-// })
-const stringToStringWithLink = (
-  source,
-  {
-    transform = (url) => {
-      return {
-        href: url,
-        text: url,
-      }
-    },
-  } = {},
-) => {
-  return source.replace(/(?:https?|ftp|file):\/\/\S+/gm, (match) => {
-    let linkHTML = ""
-
-    const lastChar = match[match.length - 1]
-
-    // hotfix because our url regex sucks a bit
-    const endsWithSeparationChar = lastChar === ")" || lastChar === ":"
-    if (endsWithSeparationChar) {
-      match = match.slice(0, -1)
-    }
-
-    const lineAndColumnPattern = /:([0-9]+):([0-9]+)$/
-    const lineAndColumMatch = match.match(lineAndColumnPattern)
-    if (lineAndColumMatch) {
-      const lineAndColumnString = lineAndColumMatch[0]
-      const lineNumber = lineAndColumMatch[1]
-      const columnNumber = lineAndColumMatch[2]
-      const url = match.slice(0, -lineAndColumnString.length)
-      const { href, text } = transform(url)
-      linkHTML = link({ href, text: `${text}:${lineNumber}:${columnNumber}` })
-    } else {
-      const linePattern = /:([0-9]+)$/
-      const lineMatch = match.match(linePattern)
-      if (lineMatch) {
-        const lineString = lineMatch[0]
-        const lineNumber = lineMatch[1]
-        const url = match.slice(0, -lineString.length)
-        const { href, text } = transform(url)
-        linkHTML = link({
-          href,
-          text: `${text}:${lineNumber}`,
-        })
-      } else {
-        const url = match
-        const { href, text } = transform(url)
-        linkHTML = link({ href, text })
-      }
-    }
-
-    if (endsWithSeparationChar) {
-      return `${linkHTML}${lastChar}`
-    }
-    return linkHTML
-  })
-}
-
-const link = ({ href, text = href }) => `<a href="${href}">${text}</a>`
-
-const appendHMTLInside = (html, parentNode) => {
-  const temoraryParent = document.createElement("div")
-  temoraryParent.innerHTML = html
-  return transferChildren(temoraryParent, parentNode)
-}
-
-const transferChildren = (fromNode, toNode) => {
-  const childNodes = [].slice.call(fromNode.childNodes, 0)
-  let i = 0
-  while (i < childNodes.length) {
-    toNode.appendChild(childNodes[i])
-    i++
-  }
-  return () => {
-    let c = 0
-    while (c < childNodes.length) {
-      fromNode.appendChild(childNodes[c])
-      c++
-    }
-  }
-}