@jsenv/core 26.0.1 → 27.0.0-alpha.10

package/src/omega/core_plugins/file_urls/jsenv_plugin_file_urls.js

@@ -0,0 +1,67 @@
+import { readFileSync } from "node:fs"
+import { urlToContentType } from "@jsenv/server"
+import {
+  urlIsInsideOf,
+  urlToRelativeUrl,
+  fileSystemRootUrl,
+} from "@jsenv/filesystem"
+import { ContentType } from "@jsenv/utils/src/content_type.js"
+
+export const jsenvPluginFileUrls = () => {
+  return [jsenvPluginResolveAbsoluteFileUrls(), jsenvPluginLoadFileUrls()]
+}
+
+const jsenvPluginResolveAbsoluteFileUrls = () => {
+  return {
+    name: "jsenv:resolve_absolute_file_urls",
+    appliesDuring: {
+      // during dev and test it's a browser running the code
+      // so absolute file urls needs to be relativized
+      dev: true,
+      test: true,
+      // during build it's fine to use file:// urls
+      build: false,
+    },
+    resolve: ({ specifier }, { rootDirectoryUrl }) => {
+      if (!specifier.startsWith("/@fs/")) {
+        return null
+      }
+      const url = new URL(specifier.slice("/@fs".length), rootDirectoryUrl).href
+      return url
+    },
+    formatReferencedUrl: ({ url }, { rootDirectoryUrl }) => {
+      if (!url.startsWith("file:")) {
+        return null
+      }
+      const specifier = urlIsInsideOf(url, rootDirectoryUrl)
+        ? `/${urlToRelativeUrl(url, rootDirectoryUrl)}`
+        : `/@fs/${url.slice(fileSystemRootUrl.length)}`
+      return specifier
+    },
+  }
+}
+
+const jsenvPluginLoadFileUrls = () => {
+  return {
+    name: "jsenv:load_file_urls",
+    appliesDuring: "*",
+    load: ({ url }) => {
+      if (!url.startsWith("file:")) {
+        return null
+      }
+      const urlObject = new URL(url)
+      const fileBuffer = readFileSync(urlObject)
+      const contentType = urlToContentType(url)
+      if (ContentType.isTextual(contentType)) {
+        return {
+          contentType,
+          content: String(fileBuffer),
+        }
+      }
+      return {
+        contentType,
+        content: fileBuffer,
+      }
+    },
+  }
+}

package/src/omega/core_plugins/filesystem_magic/jsenv_plugin_filesystem_magic.js

@@ -0,0 +1,58 @@
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/plugins/resolve.ts
+
+import { realpathSync } from "node:fs"
+import { pathToFileURL } from "node:url"
+import { urlToExtension } from "@jsenv/filesystem"
+import { applyFileSystemMagicResolution } from "@jsenv/node-esm-resolution"
+
+export const jsenvPluginFileSystemMagic = ({
+  magicExtensions = ["inherit"],
+  magicDirectoryIndex = true,
+  preservesSymlink = true,
+} = {}) => {
+  return {
+    name: "jsenv:filesystem_magic",
+    appliesDuring: "*",
+    normalize: ({ parentUrl, url }) => {
+      // http, https, data, about, etc
+      if (!url.startsWith("file:")) {
+        return null
+      }
+      const urlObject = new URL(url)
+      const { search, hash } = urlObject
+      urlObject.search = ""
+      urlObject.hash = ""
+      const filesystemResolution = applyFileSystemMagicResolution(
+        urlObject.href,
+        {
+          magicDirectoryIndex,
+          magicExtensions: getExtensionsToTry(magicExtensions, parentUrl),
+        },
+      )
+      if (!filesystemResolution.found) {
+        return null
+      }
+      const fileUrlRaw = filesystemResolution.url
+      const fileUrl = `${fileUrlRaw}${search}${hash}`
+      if (preservesSymlink) {
+        return fileUrl
+      }
+      const realPath = realpathSync(urlObject)
+      const realFileUrl = `${pathToFileURL(realPath)}${search}${hash}`
+      return realFileUrl
+    },
+  }
+}
+
+const getExtensionsToTry = (magicExtensions, importer) => {
+  const extensionsSet = new Set()
+  magicExtensions.forEach((magicExtension) => {
+    if (magicExtension === "inherit") {
+      const importerExtension = urlToExtension(importer)
+      extensionsSet.add(importerExtension)
+    } else {
+      extensionsSet.add(magicExtension)
+    }
+  })
+  return Array.from(extensionsSet.values())
+}

package/src/{internal/browser_client → omega/core_plugins/html_supervisor/client}/error_in_document.js

@@ -1,19 +1,10 @@
 export const displayErrorInDocument = (error) => {
   const title = "An error occured"
-  let theme
-  let message
-
-  if (error && error.parsingError) {
-    theme = "light"
-    const { parsingError } = error
-    message = errorToHTML(
-      parsingError.messageHTML || escapeHtml(parsingError.message),
-    )
-  } else {
-    theme = "dark"
-    message = errorToHTML(error)
-  }
-
+  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);
@@ -90,8 +81,11 @@ const errorToHTML = (error) => {
   let html
 
   if (error && error instanceof Error) {
-    //  stackTrace formatted by V8
-    if (Error.captureStackTrace) {
+    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

package/src/omega/core_plugins/html_supervisor/client/html_supervisor_installer.js

@@ -0,0 +1,168 @@
+import { unevalException } from "./uneval_exception.js"
+import { displayErrorInDocument } from "./error_in_document.js"
+import { displayErrorNotification } from "./error_in_notification.js"
+
+const { __html_supervisor__ } = window
+
+export const installHtmlSupervisor = ({ logs, measurePerf }) => {
+  const errorTransformer = null // could implement error stack remapping if needed
+  const scriptExecutionResults = {}
+  let collectCalled = false
+  let pendingExecutionCount = 0
+  let resolveScriptExecutionsPromise
+  const scriptExecutionsPromise = new Promise((resolve) => {
+    resolveScriptExecutionsPromise = resolve
+  })
+  const onExecutionStart = (name) => {
+    scriptExecutionResults[name] = null // ensure execution order is reflected into the object
+    pendingExecutionCount++
+    if (measurePerf) {
+      performance.mark(`execution_start`)
+    }
+  }
+  const onExecutionSettled = (name, executionResult) => {
+    if (measurePerf) {
+      performance.measure(`execution`, `execution_start`)
+    }
+    scriptExecutionResults[name] = executionResult
+    pendingExecutionCount--
+    if (pendingExecutionCount === 0 && collectCalled) {
+      resolveScriptExecutionsPromise()
+    }
+  }
+  const onExecutionError = (
+    executionResult,
+    {
+      currentScript,
+      errorExposureInNotification = false,
+      errorExposureInDocument = true,
+    },
+  ) => {
+    const error = executionResult.error
+    if (error && error.code === "NETWORK_FAILURE") {
+      if (currentScript) {
+        const errorEvent = new Event("error")
+        currentScript.dispatchEvent(errorEvent)
+      }
+    } else if (typeof error === "object") {
+      const globalErrorEvent = new Event("error")
+      globalErrorEvent.filename = error.filename
+      globalErrorEvent.lineno = error.line || error.lineno
+      globalErrorEvent.colno = error.column || error.columnno
+      globalErrorEvent.message = error.message
+      window.dispatchEvent(globalErrorEvent)
+    }
+    if (errorExposureInNotification) {
+      displayErrorNotification(error)
+    }
+    if (errorExposureInDocument) {
+      displayErrorInDocument(error)
+    }
+    executionResult.exceptionSource = unevalException(error)
+    delete executionResult.error
+  }
+  const getNavigationStartTime = () => {
+    try {
+      return window.performance.timing.navigationStart
+    } catch (e) {
+      return Date.now()
+    }
+  }
+
+  __html_supervisor__.addExecution = async ({
+    type,
+    src,
+    currentScript,
+    promise,
+  }) => {
+    if (logs) {
+      console.group(`[jsenv] loading ${type} ${src}`)
+    }
+    onExecutionStart(src)
+    promise.then(
+      (namespace) => {
+        const executionResult = {
+          status: "completed",
+          namespace,
+          coverage: window.__coverage__,
+        }
+        onExecutionSettled(src, executionResult)
+        if (logs) {
+          console.log(`${type} load ended`)
+
+          console.groupEnd()
+        }
+      },
+      async (e) => {
+        let error = e
+        const executionResult = {
+          status: "errored",
+          coverage: window.__coverage__,
+        }
+        let errorExposureInConsole = true
+        if (e.name === "SyntaxError") {
+          // errorExposureInConsole = false
+        }
+        if (errorTransformer) {
+          try {
+            error = await errorTransformer(e)
+          } catch (e) {}
+        }
+        executionResult.error = error
+        onExecutionSettled(src, executionResult)
+        onExecutionError(executionResult, {
+          currentScript,
+        })
+        if (errorExposureInConsole) {
+          if (typeof window.reportError === "function") {
+            window.reportError(error)
+          } else {
+            console.error(error)
+          }
+        }
+        console.groupEnd()
+      },
+    )
+  }
+  __html_supervisor__.collectScriptResults = async () => {
+    collectCalled = true
+    if (pendingExecutionCount === 0) {
+      resolveScriptExecutionsPromise()
+    } else {
+      await scriptExecutionsPromise
+    }
+
+    let status = "completed"
+    let exceptionSource = ""
+    Object.keys(scriptExecutionResults).forEach((key) => {
+      const scriptExecutionResult = scriptExecutionResults[key]
+      if (scriptExecutionResult.status === "errored") {
+        status = "errored"
+        exceptionSource = scriptExecutionResult.exceptionSource
+      }
+    })
+    return {
+      status,
+      ...(status === "errored" ? { exceptionSource } : {}),
+      startTime: getNavigationStartTime(),
+      endTime: Date.now(),
+      scriptExecutionResults,
+    }
+  }
+}
+
+export const superviseScriptTypeModule = ({ src }) => {
+  __html_supervisor__.addExecution({
+    type: "js_module",
+    currentScript: null,
+    improveErrorWithFetch: true,
+    src,
+    promise: import(new URL(src, document.location.href).href),
+  })
+}
+
+const { executions } = __html_supervisor__
+executions.forEach((execution) => {
+  __html_supervisor__.addExecution(execution)
+})
+executions.length = 0

package/src/omega/core_plugins/html_supervisor/client/html_supervisor_setup.js

@@ -0,0 +1,77 @@
+window.__html_supervisor__ = {
+  // "html_supervisor_installer.js" will implement
+  // - "addExecution"
+  // - "collectScriptResults"
+  // - "superviseScriptTypeModule"
+  // and take all executions in "executions" and implement their supervision
+  executions: [],
+  addExecution: (execution) => {
+    window.__html_supervisor__.executions.push(execution)
+  },
+  collectScriptResults: () => {
+    throw new Error("htmlSupervisor not installed")
+  },
+  superviseScriptTypeModule: () => {
+    throw new Error("htmlSupervisor not installed")
+  },
+  superviseScript: ({ src, crossorigin, integrity }) => {
+    window.__html_supervisor__.addExecution({
+      type: "js_classic",
+      improveErrorWithFetch: true,
+      currentScript: document.currentScript,
+      src,
+      promise: new Promise((resolve, reject) => {
+        const script = document.createElement("script")
+        if (crossorigin) {
+          script.crossorigin = crossorigin
+        }
+        if (integrity) {
+          script.integrity = integrity
+        }
+        script.src = src
+        const scriptUrl = new URL(src, window.location).href
+        let lastWindowErrorUrl
+        let lastWindowError
+        const windowErrorCallback = (e) => {
+          lastWindowErrorUrl = e.filename
+          lastWindowError = e.error
+        }
+        const cleanup = () => {
+          document.body.removeChild(script)
+          window.removeEventListener("error", windowErrorCallback)
+        }
+        window.addEventListener("error", windowErrorCallback)
+        script.addEventListener("error", () => {
+          cleanup()
+          reject(src)
+        })
+        script.addEventListener("load", () => {
+          cleanup()
+          if (lastWindowErrorUrl === scriptUrl) {
+            reject(lastWindowError)
+          } else {
+            resolve()
+          }
+        })
+        document.body.appendChild(script)
+      }),
+    })
+  },
+  getScriptExecutionResults: () => {
+    // wait for page to load before collecting script execution results
+    const htmlReadyPromise = new Promise((resolve) => {
+      if (document.readyState === "complete") {
+        resolve()
+        return
+      }
+      const loadCallback = () => {
+        window.removeEventListener("load", loadCallback)
+        resolve()
+      }
+      window.addEventListener("load", loadCallback)
+    })
+    return htmlReadyPromise.then(() => {
+      return window.__html_supervisor__.collectScriptResults()
+    })
+  },
+}

package/src/omega/core_plugins/html_supervisor/jsenv_plugin_html_supervisor.js

@@ -0,0 +1,233 @@
+/*
+ * Things happening here
+ * - html supervisor module injection
+ * - scripts are wrapped to be supervised
+ *
+ * TODO:
+ *  - if ressource is referenced by ressource hint we should do sthing?
+ *   I think so when we inject ?js_classic
+ */
+
+import { injectQueryParams } from "@jsenv/utils/urls/url_utils.js"
+import {
+  parseHtmlString,
+  stringifyHtmlAst,
+  visitHtmlAst,
+  getHtmlNodeAttributeByName,
+  removeHtmlNodeAttributeByName,
+  setHtmlNodeText,
+  assignHtmlNodeAttributes,
+  parseScriptNode,
+  injectScriptAsEarlyAsPossible,
+  createHtmlNode,
+  htmlNodePosition,
+  removeHtmlNodeText,
+  getHtmlNodeTextNode,
+} from "@jsenv/utils/html_ast/html_ast.js"
+import { generateInlineContentUrl } from "@jsenv/utils/urls/inline_content_url_generator.js"
+
+export const jsenvPluginHtmlSupervisor = ({
+  logs = false,
+  measurePerf = false,
+} = {}) => {
+  const htmlSupervisorSetupFileUrl = new URL(
+    "./client/html_supervisor_setup.js",
+    import.meta.url,
+  ).href
+  const htmlSupervisorInstallerFileUrl = new URL(
+    "./client/html_supervisor_installer.js",
+    import.meta.url,
+  ).href
+
+  return {
+    name: "jsenv:html_supervisor",
+    appliesDuring: {
+      dev: true,
+      test: true,
+    },
+    transform: {
+      html: ({ url, content }, { referenceUtils }) => {
+        const htmlAst = parseHtmlString(content)
+        const scriptsToSupervise = []
+
+        const handleInlineScript = (node, textNode) => {
+          const scriptCategory = parseScriptNode(node)
+          const { line, column, lineEnd, columnEnd, isOriginal } =
+            htmlNodePosition.readNodePosition(node, {
+              preferOriginal: true,
+            })
+          let inlineScriptUrl = generateInlineContentUrl({
+            url,
+            extension: ".js",
+            line,
+            column,
+            lineEnd,
+            columnEnd,
+          })
+          if (scriptCategory === "classic") {
+            inlineScriptUrl = injectQueryParams(inlineScriptUrl, {
+              js_classic: "",
+            })
+          }
+          const [inlineScriptReference] = referenceUtils.foundInline({
+            type: "script_src",
+            line: line - 1,
+            column,
+            isOriginal,
+            specifier: inlineScriptUrl,
+            contentType: "application/javascript",
+            content: textNode.value,
+          })
+          assignHtmlNodeAttributes(node, {
+            "src": inlineScriptReference.generatedSpecifier,
+            "src-generated-from-inline-content": "",
+          })
+          removeHtmlNodeText(node)
+          scriptsToSupervise.push({
+            node,
+            type: scriptCategory,
+            src: inlineScriptReference.generatedSpecifier,
+          })
+        }
+        const handleScriptWithSrc = (node, srcAttribute) => {
+          const scriptCategory = parseScriptNode(node)
+          const integrityAttribute = getHtmlNodeAttributeByName(
+            node,
+            "integrity",
+          )
+          const integrity = integrityAttribute
+            ? integrityAttribute.value
+            : undefined
+          const crossoriginAttribute = getHtmlNodeAttributeByName(
+            node,
+            "crossorigin",
+          )
+          const crossorigin = crossoriginAttribute
+            ? crossoriginAttribute.value
+            : undefined
+          scriptsToSupervise.push({
+            node,
+            type: scriptCategory,
+            src: srcAttribute.value,
+            integrity,
+            crossorigin,
+          })
+        }
+        visitHtmlAst(htmlAst, (node) => {
+          if (node.nodeName !== "script") {
+            return
+          }
+          const scriptCategory = parseScriptNode(node)
+          if (scriptCategory !== "classic" && scriptCategory !== "module") {
+            return
+          }
+          const injectedByAttribute = getHtmlNodeAttributeByName(
+            node,
+            "injected-by",
+          )
+          if (injectedByAttribute) {
+            return
+          }
+          const noHtmlSupervisor = getHtmlNodeAttributeByName(
+            node,
+            "no-html-supervisor",
+          )
+          if (noHtmlSupervisor) {
+            return
+          }
+          const textNode = getHtmlNodeTextNode(node)
+          if (textNode) {
+            handleInlineScript(node, textNode)
+            return
+          }
+          const srcAttribute = getHtmlNodeAttributeByName(node, "src")
+          if (srcAttribute) {
+            handleScriptWithSrc(node, srcAttribute)
+            return
+          }
+        })
+        if (scriptsToSupervise.length === 0) {
+          return null
+        }
+        const [htmlSupervisorInstallerFileReference] = referenceUtils.inject({
+          type: "js_import_export",
+          specifier: htmlSupervisorInstallerFileUrl,
+        })
+        injectScriptAsEarlyAsPossible(
+          htmlAst,
+          createHtmlNode({
+            "tagName": "script",
+            "type": "module",
+            "textContent": `
+import { installHtmlSupervisor } from ${
+              htmlSupervisorInstallerFileReference.generatedSpecifier
+            }
+installHtmlSupervisor(${JSON.stringify(
+              {
+                logs,
+                measurePerf,
+              },
+              null,
+              "  ",
+            )})`,
+            "injected-by": "jsenv:html_supervisor",
+          }),
+        )
+        const [htmlSupervisorSetupFileReference] = referenceUtils.inject({
+          type: "script_src",
+          specifier: injectQueryParams(htmlSupervisorSetupFileUrl, {
+            js_classic: "",
+          }),
+        })
+        injectScriptAsEarlyAsPossible(
+          htmlAst,
+          createHtmlNode({
+            "tagName": "script",
+            "src": htmlSupervisorSetupFileReference.generatedSpecifier,
+            "injected-by": "jsenv:html_supervisor",
+          }),
+        )
+        scriptsToSupervise.forEach(
+          ({ node, type, src, integrity, crossorigin }) => {
+            removeHtmlNodeAttributeByName(node, "src")
+            assignHtmlNodeAttributes(node, {
+              "content-src": src,
+            })
+            setHtmlNodeText(
+              node,
+              generateCodeToSuperviseScript({
+                type,
+                src,
+                integrity,
+                crossorigin,
+                htmlSupervisorInstallerSpecifier:
+                  htmlSupervisorInstallerFileReference.generatedSpecifier,
+              }),
+            )
+          },
+        )
+        const htmlModified = stringifyHtmlAst(htmlAst)
+        return {
+          content: htmlModified,
+        }
+      },
+    },
+  }
+}
+
+// Ideally jsenv should take into account eventual
+// "integrity" and "crossorigin" attribute during supervision
+const generateCodeToSuperviseScript = ({
+  type,
+  src,
+  integrity,
+  crossorigin,
+  htmlSupervisorInstallerSpecifier,
+}) => {
+  const paramsAsJson = JSON.stringify({ src, integrity, crossorigin })
+  if (type === "module") {
+    return `import { superviseScriptTypeModule } from ${htmlSupervisorInstallerSpecifier}
+superviseScriptTypeModule(${paramsAsJson})`
+  }
+  return `window.__html_supervisor__.superviseScript(${paramsAsJson})`
+}