@jsenv/core 28.0.2 → 28.1.2

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

@@ -1,315 +0,0 @@
-import { unevalException } from "./uneval_exception.js"
-import { displayErrorInDocument } from "./error_overlay.js"
-import { displayErrorNotification } from "./error_in_notification.js"
-
-const { __html_supervisor__ } = window
-
-const supervisedScripts = []
-
-export const installHtmlSupervisor = ({
-  rootDirectoryUrl,
-  logs,
-  measurePerf,
-  errorOverlay,
-  errorBaseUrl,
-  openInEditor,
-}) => {
-  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 },
-  ) => {
-    const error = executionResult.error
-    if (error && error.code === "NETWORK_FAILURE") {
-      if (currentScript) {
-        const currentScriptErrorEvent = new Event("error")
-        currentScript.dispatchEvent(currentScriptErrorEvent)
-      }
-    } 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)
-    }
-    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
-    },
-    { reload = false } = {},
-  ) => {
-    if (logs) {
-      console.group(`[jsenv] loading ${type} ${src}`)
-    }
-    onExecutionStart(src)
-    let completed
-    let result
-    let error
-    const urlObject = new URL(src, window.location)
-    if (reload) {
-      urlObject.searchParams.set("hmr", Date.now())
-    }
-    __html_supervisor__.currentExecution = {
-      type: type === "module" ? "dynamic_import" : "script_injection",
-      url: urlObject.href,
-    }
-    try {
-      result = await execute(urlObject.href)
-      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()
-      }
-      __html_supervisor__.currentExecution = null
-      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()
-    }
-    __html_supervisor__.currentExecution = null
-  }
-
-  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 (!supervisedScripts.includes(scriptToExecute)) {
-      supervisedScripts.push(scriptToExecute)
-      scriptToExecute.reload = () => {
-        return performExecution(scriptToExecute, { reload: true })
-      }
-    }
-
-    if (scriptToExecute.async) {
-      performExecution(scriptToExecute)
-      return
-    }
-    const useDeferQueue =
-      scriptToExecute.defer || scriptToExecute.type === "module"
-    if (useDeferQueue) {
-      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)
-  })
-
-  if (errorOverlay) {
-    const onErrorReportedByBrowser = (error, { url, line, column }) => {
-      displayErrorInDocument(error, {
-        rootDirectoryUrl,
-        errorBaseUrl,
-        openInEditor,
-        url,
-        line,
-        column,
-      })
-    }
-    window.addEventListener("error", (errorEvent) => {
-      if (!errorEvent.isTrusted) {
-        // ignore custom error event (not sent by browser)
-        return
-      }
-      const { error, filename, lineno, colno } = errorEvent
-      onErrorReportedByBrowser(error, {
-        url: filename,
-        line: lineno,
-        column: colno,
-      })
-    })
-  }
-}
-
-__html_supervisor__.reloadSupervisedScript = ({ type, src }) => {
-  const supervisedScript = supervisedScripts.find(
-    (supervisedScriptCandidate) => {
-      if (type && supervisedScriptCandidate.type !== type) {
-        return false
-      }
-      if (supervisedScriptCandidate.src !== src) {
-        return false
-      }
-      return true
-    },
-  )
-  if (supervisedScript) {
-    supervisedScript.reload()
-  }
-}
-
-export const superviseScriptTypeModule = ({ src, isInline }) => {
-  __html_supervisor__.addScriptToExecute({
-    src,
-    type: "module",
-    isInline,
-    execute: (url) => import(url),
-  })
-}
-
-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

@@ -1,89 +0,0 @@
-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 }) => {
-    const { currentScript } = document
-    window.__html_supervisor__.addScriptToExecute({
-      src,
-      type: "js_classic",
-      isInline,
-      currentScript,
-      execute: (url) => {
-        return new Promise((resolve, reject) => {
-          const script = document.createElement("script")
-          if (crossorigin) {
-            script.crossorigin = crossorigin
-          }
-          if (integrity) {
-            script.integrity = integrity
-          }
-          script.src = url
-          let lastWindowErrorUrl
-          let lastWindowError
-          const windowErrorCallback = (e) => {
-            lastWindowErrorUrl = e.filename
-            lastWindowError = e.error
-          }
-          const cleanup = () => {
-            // the execution of the script itself can remove script from the page
-            if (script.parentNode) {
-              script.parentNode.removeChild(script)
-            }
-            window.removeEventListener("error", windowErrorCallback)
-          }
-          window.addEventListener("error", windowErrorCallback)
-          script.addEventListener("error", () => {
-            cleanup()
-            reject(src)
-          })
-          script.addEventListener("load", () => {
-            cleanup()
-            if (lastWindowErrorUrl === url) {
-              reject(lastWindowError)
-            } else {
-              resolve()
-            }
-          })
-          if (currentScript) {
-            currentScript.parentNode.insertBefore(
-              script,
-              currentScript.nextSibling,
-            )
-          } else {
-            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")
-  },
-}

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

@@ -1,17 +0,0 @@
-const { performance } = window
-
-export const measureAsyncFnPerf = performance
-  ? async (fn, name) => {
-      const perfMarkStartName = `${name}_start`
-
-      performance.mark(perfMarkStartName)
-      try {
-        const value = await fn()
-        return value
-      } finally {
-        performance.measure(name, perfMarkStartName)
-      }
-    }
-  : async (fn) => {
-      return fn()
-    }

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

@@ -1,8 +0,0 @@
-import { uneval } from "@jsenv/uneval"
-
-export const unevalException = (value) => {
-  if (value && value.hasOwnProperty("toString")) {
-    delete value.toString
-  }
-  return uneval(value, { ignoreSymbols: true })
-}