@jsenv/core 27.0.0-alpha.7 → 27.0.0-alpha.72

package/src/plugins/file_urls/jsenv_plugin_file_urls.js

@@ -0,0 +1,198 @@
+import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs"
+import { pathToFileURL } from "node:url"
+import {
+  urlIsInsideOf,
+  urlToRelativeUrl,
+  urlToExtension,
+  urlToFilename,
+  ensurePathnameTrailingSlash,
+} from "@jsenv/urls"
+
+import { applyFileSystemMagicResolution } from "@jsenv/node-esm-resolution"
+import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+
+export const jsenvPluginFileUrls = ({
+  magicExtensions = ["inherit", ".js"],
+  magicDirectoryIndex = true,
+  preservesSymlink = true,
+  directoryReferenceAllowed = false,
+}) => {
+  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())
+  }
+
+  return [
+    {
+      name: "jsenv:file_url_resolution",
+      appliesDuring: "*",
+      redirectUrl: (reference) => {
+        // http, https, data, about, ...
+        if (!reference.url.startsWith("file:")) {
+          return null
+        }
+        if (reference.isInline) {
+          return null
+        }
+        const urlObject = new URL(reference.url)
+        let stat
+        try {
+          stat = statSync(urlObject)
+        } catch (e) {
+          if (e.code === "ENOENT") {
+            stat = null
+          } else {
+            throw e
+          }
+        }
+        const { search, hash } = urlObject
+        let { pathname } = urlObject
+        const pathnameUsesTrailingSlash = pathname.endsWith("/")
+        urlObject.search = ""
+        urlObject.hash = ""
+        const foundADirectory = stat && stat.isDirectory()
+        const foundSomething = stat && !foundADirectory
+        // force trailing slash on directories
+        if (foundADirectory && !pathnameUsesTrailingSlash) {
+          urlObject.pathname = `${pathname}/`
+        }
+        // otherwise remove trailing slash if any
+        if (foundSomething && pathnameUsesTrailingSlash) {
+          // a warning here? (because it's strange to reference a file with a trailing slash)
+          urlObject.pathname = pathname.slice(0, -1)
+        }
+        if (foundADirectory && directoryReferenceAllowed) {
+          reference.data.foundADirectory = true
+          const directoryFacadeUrl = urlObject.href
+          const directoryUrlRaw = preservesSymlink
+            ? directoryFacadeUrl
+            : resolveSymlink(directoryFacadeUrl)
+          const directoryUrl = `${directoryUrlRaw}${search}${hash}`
+          return directoryUrl
+        }
+        const url = urlObject.href
+        const filesystemResolution = applyFileSystemMagicResolution(url, {
+          fileStat: stat,
+          magicDirectoryIndex,
+          magicExtensions: getExtensionsToTry(
+            magicExtensions,
+            reference.parentUrl,
+          ),
+        })
+        if (!filesystemResolution.found) {
+          reference.data.foundADirectory = foundADirectory
+          return null
+        }
+        reference.data.foundADirectory = filesystemResolution.isDirectory
+        const fileFacadeUrl = filesystemResolution.url
+        const fileUrlRaw = preservesSymlink
+          ? fileFacadeUrl
+          : resolveSymlink(fileFacadeUrl)
+        const fileUrl = `${fileUrlRaw}${search}${hash}`
+        return fileUrl
+      },
+    },
+    {
+      name: "jsenv:filesystem_resolution",
+      appliesDuring: "*",
+      resolveUrl: {
+        filesystem: (reference, context) => {
+          const { parentUrl } = reference
+          const parentUrlInfo = context.urlGraph.getUrlInfo(parentUrl)
+          const baseUrl =
+            parentUrlInfo && parentUrlInfo.type === "directory"
+              ? ensurePathnameTrailingSlash(parentUrl)
+              : parentUrl
+          return new URL(reference.specifier, baseUrl).href
+        },
+      },
+    },
+    {
+      name: "jsenv:@fs_resolution",
+      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,
+      },
+      resolveUrl: (reference) => {
+        if (reference.specifier.startsWith("/@fs/")) {
+          const fsRootRelativeUrl = reference.specifier.slice("/@fs/".length)
+          return `file:///${fsRootRelativeUrl}`
+        }
+        return null
+      },
+      formatUrl: (reference, context) => {
+        if (!reference.generatedUrl.startsWith("file:")) {
+          return null
+        }
+        if (urlIsInsideOf(reference.generatedUrl, context.rootDirectoryUrl)) {
+          return `/${urlToRelativeUrl(
+            reference.generatedUrl,
+            context.rootDirectoryUrl,
+          )}`
+        }
+        return `/@fs/${reference.generatedUrl.slice("file:///".length)}`
+      },
+    },
+    {
+      name: "jsenv:file_url_fetching",
+      appliesDuring: "*",
+      fetchUrlContent: (urlInfo, context) => {
+        if (!urlInfo.url.startsWith("file:")) {
+          return null
+        }
+        const urlObject = new URL(urlInfo.url)
+        if (context.reference.data.foundADirectory) {
+          if (directoryReferenceAllowed) {
+            const directoryEntries = readdirSync(urlObject)
+            let filename
+            if (context.reference.type === "filesystem") {
+              const parentUrlInfo = context.urlGraph.getUrlInfo(
+                context.reference.parentUrl,
+              )
+              filename = `${parentUrlInfo.filename}${context.reference.specifier}/`
+            } else {
+              filename = `${urlToFilename(urlInfo.url)}/`
+            }
+            return {
+              type: "directory",
+              contentType: "application/json",
+              content: JSON.stringify(directoryEntries, null, "  "),
+              filename,
+            }
+          }
+          const error = new Error("found a directory on filesystem")
+          error.code = "DIRECTORY_REFERENCE_NOT_ALLOWED"
+          throw error
+        }
+        const fileBuffer = readFileSync(urlObject)
+        const contentType = CONTENT_TYPE.fromUrlExtension(urlInfo.url)
+        if (CONTENT_TYPE.isTextual(contentType)) {
+          return {
+            contentType,
+            content: String(fileBuffer),
+          }
+        }
+        return {
+          contentType,
+          content: fileBuffer,
+        }
+      },
+    },
+  ]
+}
+
+const resolveSymlink = (fileUrl) => {
+  return pathToFileURL(realpathSync(new URL(fileUrl))).href
+}

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

@@ -0,0 +1,254 @@
+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()
+    }
+  }
+
+  const performExecution = async ({
+    src,
+    type,
+    currentScript,
+    execute,
+    // https://developer.mozilla.org/en-US/docs/web/html/element/script
+  }) => {
+    if (logs) {
+      console.group(`[jsenv] loading ${type} ${src}`)
+    }
+    onExecutionStart(src)
+    let completed
+    let result
+    let error
+    try {
+      result = await execute()
+      completed = true
+    } catch (e) {
+      completed = false
+      error = e
+    }
+    if (completed) {
+      const executionResult = {
+        status: "completed",
+        namespace: result,
+        coverage: window.__coverage__,
+      }
+      onExecutionSettled(src, executionResult)
+      if (logs) {
+        console.log(`${type} load ended`)
+        console.groupEnd()
+      }
+      return
+    }
+    const executionResult = {
+      status: "errored",
+      coverage: window.__coverage__,
+    }
+    let errorExposureInConsole = true
+    if (error.name === "SyntaxError") {
+      // errorExposureInConsole = false
+    }
+    if (errorTransformer) {
+      try {
+        error = await errorTransformer(error)
+      } 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)
+      }
+    }
+    if (logs) {
+      console.groupEnd()
+    }
+  }
+
+  const classicExecutionQueue = createExecutionQueue(performExecution)
+  const deferedExecutionQueue = createExecutionQueue(performExecution)
+  deferedExecutionQueue.waitFor(
+    new Promise((resolve) => {
+      if (
+        document.readyState === "interactive" ||
+        document.readyState === "complete"
+      ) {
+        resolve()
+      } else {
+        document.addEventListener("readystatechange", () => {
+          if (document.readyState === "interactive") {
+            resolve()
+          }
+        })
+      }
+    }),
+  )
+  __html_supervisor__.addScriptToExecute = async (scriptToExecute) => {
+    if (scriptToExecute.async) {
+      performExecution(scriptToExecute)
+      return
+    }
+    const useDeferQueue =
+      scriptToExecute.defer || scriptToExecute.type === "js_module"
+    if (useDeferQueue) {
+      // defer must wait for classic script to be done
+      const classicExecutionPromise = classicExecutionQueue.getPromise()
+      if (classicExecutionPromise) {
+        deferedExecutionQueue.waitFor(classicExecutionPromise)
+      }
+      deferedExecutionQueue.executeAsap(scriptToExecute)
+    } else {
+      classicExecutionQueue.executeAsap(scriptToExecute)
+    }
+  }
+
+  __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,
+    }
+  }
+
+  const { scriptsToExecute } = __html_supervisor__
+  const copy = scriptsToExecute.slice()
+  scriptsToExecute.length = 0
+  copy.forEach((scriptToExecute) => {
+    __html_supervisor__.addScriptToExecute(scriptToExecute)
+  })
+}
+
+export const superviseScriptTypeModule = ({ src, isInline }) => {
+  __html_supervisor__.addScriptToExecute({
+    src,
+    type: "js_module",
+    isInline,
+    execute: () => import(new URL(src, document.location.href).href),
+  })
+}
+
+const createExecutionQueue = (execute) => {
+  const scripts = []
+
+  let promiseToWait = null
+  const waitFor = async (promise) => {
+    promiseToWait = promise
+    promiseToWait.then(
+      () => {
+        promiseToWait = null
+        dequeue()
+      },
+      () => {
+        promiseToWait = null
+        dequeue()
+      },
+    )
+  }
+
+  const executeAsap = async (script) => {
+    if (promiseToWait) {
+      scripts.push(script)
+      return
+    }
+    waitFor(execute(script))
+  }
+
+  const dequeue = () => {
+    const scriptWaiting = scripts.shift()
+    if (scriptWaiting) {
+      __html_supervisor__.addScriptToExecute(scriptWaiting)
+    }
+  }
+
+  return {
+    waitFor,
+    executeAsap,
+    getPromise: () => promiseToWait,
+  }
+}

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

@@ -0,0 +1,79 @@
+window.__html_supervisor__ = {
+  // "html_supervisor_installer.js" will implement
+  // - "addScriptToExecute"
+  // - "superviseScriptTypeModule"
+  // - "collectScriptResults"
+  // and take all executions in "scriptsToExecute" and implement their supervision
+  scriptsToExecute: [],
+  addScriptToExecute: (scriptToExecute) => {
+    window.__html_supervisor__.scriptsToExecute.push(scriptToExecute)
+  },
+  superviseScript: ({ src, isInline, crossorigin, integrity }) => {
+    window.__html_supervisor__.addScriptToExecute({
+      src,
+      type: "js_classic",
+      isInline,
+      currentScript: document.currentScript,
+      execute: () => {
+        return 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)
+        })
+      },
+    })
+  },
+  superviseScriptTypeModule: () => {
+    throw new Error("htmlSupervisor not installed")
+  },
+  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()
+    })
+  },
+  collectScriptResults: () => {
+    throw new Error("htmlSupervisor not installed")
+  },
+}