@jsenv/core 27.0.0-alpha.9 → 27.0.0-alpha.92

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

@@ -1,168 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,233 +0,0 @@
-/*
- * 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})`
-}

package/src/omega/core_plugins/import_assertions/helpers/babel_plugin_metadata_import_assertions.js

@@ -1,98 +0,0 @@
-export const babelPluginMetadataImportAssertions = () => {
-  return {
-    name: "metadata-import-assertions",
-    visitor: {
-      Program: (programPath, state) => {
-        const importAssertions = collectProgramImportAssertions(programPath)
-        state.file.metadata.importAssertions = importAssertions
-      },
-    },
-  }
-}
-
-/*
- * Jsenv wont touch code where "specifier" or "type" is dynamic (see code below)
- * ```js
- * const file ="./style.css"
- * const type = "css"
- * import(file, { assert: { type }})
- * ```
- * Jsenv could throw an error because we know browser will fail to execute the code
- * because import assertions are not supported.
- * But for now (as it is simpler to do so) we let the browser throw the error
- */
-const collectProgramImportAssertions = (programPath) => {
-  const importAssertions = []
-  programPath.traverse({
-    CallExpression: (path) => {
-      if (path.node.callee.type !== "Import") {
-        // Some other function call, not import();
-        return
-      }
-      if (path.node.arguments[0].type !== "StringLiteral") {
-        // Non-string argument, probably a variable or expression, e.g.
-        // import(moduleId)
-        // import('./' + moduleName)
-        return
-      }
-      const args = path.node.arguments
-      const secondArg = args[1]
-      if (!secondArg) {
-        return
-      }
-      const { properties } = secondArg
-      const assertProperty = properties.find((property) => {
-        return property.key.name === "assert"
-      })
-      if (!assertProperty) {
-        return
-      }
-      const assertProperties = assertProperty.value.properties
-      const typePropertyNode = assertProperties.find((property) => {
-        return property.key.name === "type"
-      })
-      if (!typePropertyNode) {
-        return
-      }
-      const typePropertyValue = typePropertyNode.value
-      if (typePropertyValue.type !== "StringLiteral") {
-        return
-      }
-      const type = typePropertyValue.value
-      importAssertions.push({
-        path,
-        assert: {
-          type,
-        },
-      })
-    },
-
-    ImportDeclaration: (path) => {
-      const { assertions } = path.node
-      if (!assertions) {
-        return
-      }
-      if (assertions.length === 0) {
-        return
-      }
-      const typeAssertion = assertions.find(
-        (assertion) => assertion.key.name === "type",
-      )
-      if (!typeAssertion) {
-        return
-      }
-      const typeNode = typeAssertion.value
-      if (typeNode.type !== "StringLiteral") {
-        return
-      }
-      const type = typeNode.value
-      importAssertions.push({
-        path,
-        assert: {
-          type,
-        },
-      })
-    },
-  })
-  return importAssertions
-}

package/src/omega/core_plugins/import_assertions/helpers/json_module.js

@@ -1,12 +0,0 @@
-export const convertJsonTextToJavascriptModule = ({ content }) => {
-  // here we could do the following
-  // return export default jsonText
-  // This would return valid js, that would be minified later
-  // however we will prefer using JSON.parse because it's faster
-  // for js engine to parse JSON than JS
-
-  return {
-    contentType: "application/javascript",
-    content: `export default JSON.parse(${JSON.stringify(content.trim())})`,
-  }
-}

package/src/omega/core_plugins/import_assertions/helpers/text_module.js

@@ -1,6 +0,0 @@
-export const convertTextToJavascriptModule = ({ content }) => {
-  return {
-    contentType: "application/javascript",
-    content: `export default ${JSON.stringify(content)}`,
-  }
-}