@jsenv/core 27.0.0-alpha.8 → 27.0.0-alpha.82

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/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)}`,
-  }
-}

package/src/omega/core_plugins/import_assertions/jsenv_plugin_import_assertions.js

@@ -1,211 +0,0 @@
-import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
-import { ContentType } from "@jsenv/utils/src/content_type.js"
-import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
-import { injectQueryParamsIntoSpecifier } from "@jsenv/utils/urls/url_utils.js"
-import { JS_QUOTES } from "@jsenv/utils/string/js_quotes.js"
-
-import { babelPluginMetadataImportAssertions } from "./helpers/babel_plugin_metadata_import_assertions.js"
-import { convertJsonTextToJavascriptModule } from "./helpers/json_module.js"
-import { convertTextToJavascriptModule } from "./helpers/text_module.js"
-
-export const jsenvPluginImportAssertions = () => {
-  const importAssertions = [
-    {
-      name: "jsenv:import_assertions",
-      appliesDuring: "*",
-      transform: {
-        js_module: async (
-          { url, generatedUrl, content },
-          { scenario, isSupportedOnRuntime, referenceUtils },
-        ) => {
-          const importTypesToHandle = getImportTypesToHandle({
-            scenario,
-            isSupportedOnRuntime,
-          })
-          if (importTypesToHandle.length === 0) {
-            return null
-          }
-          const { metadata } = await applyBabelPlugins({
-            babelPlugins: [babelPluginMetadataImportAssertions],
-            url,
-            generatedUrl,
-            content,
-          })
-          const { importAssertions } = metadata
-          const magicSource = createMagicSource(content)
-          importAssertions.forEach((importAssertion) => {
-            const assertType = importAssertion.assert.type
-            if (!importTypesToHandle.includes(assertType)) {
-              return
-            }
-            const { path } = importAssertion
-            const { node } = path
-            const importType = `${assertType}_module`
-            if (node.type === "CallExpression") {
-              const importSpecifierPath = path.get("arguments")[0]
-              const specifier = importSpecifierPath.node.value
-              const newSpecifier = injectQueryParamsIntoSpecifier(specifier, {
-                [importType]: "",
-              })
-              const [newReference, newUrlInfo] = referenceUtils.updateSpecifier(
-                JSON.stringify(specifier),
-                newSpecifier,
-              )
-              newUrlInfo.data.importType = importType
-              magicSource.replace({
-                start: importSpecifierPath.node.start,
-                end: importSpecifierPath.node.end,
-                replacement: newReference.generatedSpecifier,
-              })
-              const secondArgPath = path.get("arguments")[1]
-              magicSource.remove({
-                start: secondArgPath.node.start,
-                end: secondArgPath.node.end,
-              })
-              return
-            }
-            const importSpecifierPath = path.get("source")
-            const specifier = importSpecifierPath.node.value
-            const newSpecifier = injectQueryParamsIntoSpecifier(specifier, {
-              [importType]: "",
-            })
-            const [newReference, newUrlInfo] = referenceUtils.updateSpecifier(
-              JSON.stringify(specifier),
-              newSpecifier,
-            )
-            newUrlInfo.data.importType = importType
-            magicSource.replace({
-              start: importSpecifierPath.node.start,
-              end: importSpecifierPath.node.end,
-              replacement: newReference.generatedSpecifier,
-            })
-            const assertionsPath = path.get("assertions")[0]
-            magicSource.remove({
-              start: assertionsPath.node.start,
-              end: assertionsPath.node.end,
-            })
-          })
-          return magicSource.toContentAndSourcemap()
-        },
-      },
-    },
-  ]
-
-  const importTypeJson = {
-    name: "jsenv:import_type_json",
-    appliesDuring: "*",
-    finalize: ({ url, contentType, content }) => {
-      if (!new URL(url).searchParams.has("json_module")) {
-        return null
-      }
-      if (contentType !== "application/json") {
-        throw new Error(
-          `Unexpected content type on ${url}, should be "application/json" but got ${contentType}`,
-        )
-      }
-      return convertJsonTextToJavascriptModule({
-        content,
-      })
-    },
-  }
-
-  // not standard but I expect this to happen one day?
-  const importTypeText = {
-    name: "jsenv:import_type_text",
-    appliesDuring: "*",
-    finalize: ({ url, contentType, content }) => {
-      if (!new URL(url).searchParams.has("text_module")) {
-        return null
-      }
-      if (ContentType.isTextual(contentType)) {
-        throw new Error(
-          `Unexpected content type on ${url}, should be "text/*" but got ${contentType}`,
-        )
-      }
-      return convertTextToJavascriptModule({
-        content,
-      })
-    },
-  }
-
-  return [
-    importAssertions,
-    importTypeJson,
-    jsenvPluginImportTypeCss(),
-    importTypeText,
-  ]
-}
-
-const jsenvPluginImportTypeCss = () => {
-  const inlineContentClientFileUrl = new URL(
-    "../inline/client/inline_content.js",
-    import.meta.url,
-  ).href
-
-  return {
-    name: "jsenv:import_type_css",
-    appliesDuring: "*",
-    // load the original css url
-    load: ({ data }, { urlGraph, load }) => {
-      if (data.importType !== "css_module") {
-        return null
-      }
-      return load({
-        reference: data.originalReference,
-        urlInfo: urlGraph.getUrlInfo(data.originalReference.url),
-      })
-    },
-    transform: ({ url, data, contentType, content }, { referenceUtils }) => {
-      if (data.importType !== "css_module") {
-        return null
-      }
-      if (contentType !== "text/css") {
-        throw new Error(
-          `Unexpected content type on ${url}, should be "text/css" but got ${contentType}`,
-        )
-      }
-      const [reference] = referenceUtils.inject({
-        type: "js_import_export",
-        specifier: inlineContentClientFileUrl,
-      })
-      const cssText = JS_QUOTES.escapeSpecialChars(content, {
-        // If template string is choosen and runtime do not support template literals
-        // it's ok because "jsenv:new_inline_content" plugin executes after this one
-        // and convert template strings into raw strings
-        canUseTemplateString: true,
-      })
-      return {
-        type: "js_module",
-        contentType: "application/javascript",
-        content: `import { InlineContent } from ${reference.generatedSpecifier}
-
-const css = new InlineContent(${cssText}, { type: "text/css" })
-const stylesheet = new CSSStyleSheet()
-stylesheet.replaceSync(css.text)
-export default stylesheet`,
-      }
-    },
-  }
-}
-
-const getImportTypesToHandle = ({ scenario, isSupportedOnRuntime }) => {
-  // during build always replace import assertions with the js:
-  // - means rollup can bundle more js file together
-  // - means url versioning can work for css inlined in js
-  // - avoid rollup to see import assertions
-  //   We would have to tell rollup to ignore import with assertion
-  if (scenario === "build") {
-    return ["json", "css", "text"]
-  }
-  const importTypes = []
-  if (!isSupportedOnRuntime("import_type_json")) {
-    importTypes.push("json")
-  }
-  if (!isSupportedOnRuntime("import_type_css")) {
-    importTypes.push("css")
-  }
-  if (!isSupportedOnRuntime("import_type_text")) {
-    importTypes.push("text")
-  }
-  return importTypes
-}

package/src/omega/core_plugins/inline/jsenv_plugin_inline.js

@@ -1,13 +0,0 @@
-import { jsenvPluginJsAndCssInsideHtml } from "./jsenv_plugin_js_and_css_inside_html.js"
-import { jsenvPluginNewInlineContent } from "./jsenv_plugin_new_inline_content.js"
-import { jsenvPluginDataUrls } from "./jsenv_plugin_data_urls.js"
-import { jsenvPluginInlineQueryParam } from "./jsenv_plugin_inline_query_param.js"
-
-export const jsenvPluginInline = ({ allowEscapeForVersioning } = {}) => {
-  return [
-    jsenvPluginJsAndCssInsideHtml(),
-    jsenvPluginNewInlineContent({ allowEscapeForVersioning }),
-    jsenvPluginDataUrls(),
-    jsenvPluginInlineQueryParam(),
-  ]
-}

package/src/omega/core_plugins/inline/jsenv_plugin_js_and_css_inside_html.js

@@ -1,142 +0,0 @@
-import {
-  parseHtmlString,
-  stringifyHtmlAst,
-  visitHtmlAst,
-  getHtmlNodeTextNode,
-  htmlNodePosition,
-  parseScriptNode,
-  setHtmlNodeText,
-  getHtmlNodeAttributeByName,
-} from "@jsenv/utils/html_ast/html_ast.js"
-import { injectQueryParams } from "@jsenv/utils/urls/url_utils.js"
-import { generateInlineContentUrl } from "@jsenv/utils/urls/inline_content_url_generator.js"
-
-export const jsenvPluginJsAndCssInsideHtml = () => {
-  return {
-    name: "jsenv:js_and_css_inside_html",
-    appliesDuring: "*",
-    transform: {
-      html: async ({ url, content }, { cook, referenceUtils }) => {
-        const htmlAst = parseHtmlString(content)
-        const actions = []
-        const handleInlineStyle = (node) => {
-          if (node.nodeName !== "style") {
-            return
-          }
-          const textNode = getHtmlNodeTextNode(node)
-          if (!textNode) {
-            return
-          }
-          actions.push(async () => {
-            const { line, column, lineEnd, columnEnd, isOriginal } =
-              htmlNodePosition.readNodePosition(node, {
-                preferOriginal: true,
-              })
-            const inlineStyleUrl = generateInlineContentUrl({
-              url,
-              extension: ".css",
-              line,
-              column,
-              lineEnd,
-              columnEnd,
-            })
-            const [inlineStyleReference, inlineStyleUrlInfo] =
-              referenceUtils.foundInline({
-                type: "link_href",
-                // we remove 1 to the line because imagine the following html:
-                // <style>body { color: red; }</style>
-                // -> content starts same line as <style>
-                line: line - 1,
-                column,
-                isOriginal,
-                specifier: inlineStyleUrl,
-                contentType: "text/css",
-                content: textNode.value,
-              })
-            await cook({
-              reference: inlineStyleReference,
-              urlInfo: inlineStyleUrlInfo,
-            })
-            setHtmlNodeText(node, inlineStyleUrlInfo.content)
-          })
-        }
-        const handleInlineScript = (node) => {
-          if (node.nodeName !== "script") {
-            return
-          }
-          const textNode = getHtmlNodeTextNode(node)
-          if (!textNode) {
-            return
-          }
-          const contentSrc = getHtmlNodeAttributeByName(node, "content-src")
-          if (contentSrc) {
-            // it's inline but there is a corresponding "src" somewhere
-            // - for instance the importmap was inlined by importmap plugin
-            //   in that case the content is already cooked and can be kept as it is
-            // - any other logic that would turn a remote script into some content
-            //   but don't want to cook the content
-            return
-          }
-          actions.push(async () => {
-            const scriptCategory = parseScriptNode(node)
-            const { line, column, lineEnd, columnEnd, isOriginal } =
-              htmlNodePosition.readNodePosition(node, {
-                preferOriginal: true,
-              })
-            let inlineScriptUrl = generateInlineContentUrl({
-              url,
-              extension: scriptCategory === "importmap" ? ".importmap" : ".js",
-              line,
-              column,
-              lineEnd,
-              columnEnd,
-            })
-            if (scriptCategory === "classic") {
-              inlineScriptUrl = injectQueryParams(inlineScriptUrl, {
-                js_classic: "",
-              })
-            }
-            const [inlineScriptReference, inlineScriptUrlInfo] =
-              referenceUtils.foundInline({
-                node,
-                type: "script_src",
-                // we remove 1 to the line because imagine the following html:
-                // <script>console.log('ok')</script>
-                // -> content starts same line as <script>
-                line: line - 1,
-                column,
-                isOriginal,
-                specifier: inlineScriptUrl,
-                contentType:
-                  scriptCategory === "importmap"
-                    ? "application/importmap+json"
-                    : "application/javascript",
-                content: textNode.value,
-              })
-            await cook({
-              reference: inlineScriptReference,
-              urlInfo: inlineScriptUrlInfo,
-            })
-            setHtmlNodeText(node, inlineScriptUrlInfo.content)
-          })
-        }
-        visitHtmlAst(htmlAst, (node) => {
-          handleInlineStyle(node)
-          handleInlineScript(node)
-        })
-        if (actions.length === 0) {
-          return null
-        }
-        await Promise.all(
-          actions.map(async (action) => {
-            await action()
-          }),
-        )
-        const htmlModified = stringifyHtmlAst(htmlAst)
-        return {
-          content: htmlModified,
-        }
-      },
-    },
-  }
-}