@jsenv/core 27.0.0-alpha.3 → 27.0.0-alpha.30

package/src/{omega/core_plugins → plugins}/inline/jsenv_plugin_data_urls.js

@@ -1,42 +1,46 @@
 import { DataUrl } from "@jsenv/utils/urls/data_url.js"
-import { ContentType } from "@jsenv/utils/src/content_type.js"
+import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
 
 export const jsenvPluginDataUrls = () => {
   return {
     name: "jsenv:data_urls",
     appliesDuring: "*",
-    resolve: ({ specifier }) => {
-      if (!specifier.startsWith("data:")) {
+    resolveUrl: (reference) => {
+      if (!reference.specifier.startsWith("data:")) {
         return null
       }
-      return specifier
+      return reference.specifier
     },
-    load: ({ url, data }) => {
-      if (!url.startsWith("data:")) {
+    fetchUrlContent: (urlInfo) => {
+      if (!urlInfo.url.startsWith("data:")) {
         return null
       }
-      const { contentType, base64Flag, data: urlData } = DataUrl.parse(url)
-      data.base64Flag = base64Flag
+      const {
+        contentType,
+        base64Flag,
+        data: urlData,
+      } = DataUrl.parse(urlInfo.url)
+      urlInfo.data.base64Flag = base64Flag
       return {
         contentType,
         content: contentFromUrlData({ contentType, base64Flag, urlData }),
       }
     },
-    formatReferencedUrl: (reference, { urlGraph, cook }) => {
-      if (!reference.url.startsWith("data:")) {
+    formatUrl: (reference, context) => {
+      if (!reference.generatedUrl.startsWith("data:")) {
         return null
       }
       if (reference.type === "sourcemap_comment") {
         return null
       }
       return (async () => {
-        const urlInfo = urlGraph.getUrlInfo(reference.url)
-        await cook({
+        const urlInfo = context.urlGraph.getUrlInfo(reference.url)
+        await context.cook({
           reference,
           urlInfo,
         })
         if (urlInfo.originalContent === urlInfo.content) {
-          return reference.url
+          return reference.generatedUrl
         }
         const specifier = DataUrl.stringify({
           contentType: urlInfo.contentType,
@@ -52,7 +56,7 @@ export const jsenvPluginDataUrls = () => {
 }
 
 const contentFromUrlData = ({ contentType, base64Flag, urlData }) => {
-  if (ContentType.isTextual(contentType)) {
+  if (CONTENT_TYPE.isTextual(contentType)) {
     if (base64Flag) {
       return base64ToString(urlData)
     }

package/src/{omega/core_plugins/inline/jsenv_plugin_js_and_css_inside_html.js → plugins/inline/jsenv_plugin_html_inline_content.js}

@@ -5,19 +5,19 @@ import {
   getHtmlNodeTextNode,
   htmlNodePosition,
   parseScriptNode,
-  setHtmlNodeText,
+  setHtmlNodeGeneratedText,
   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"
+import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
 
-export const jsenvPluginJsAndCssInsideHtml = () => {
+export const jsenvPluginHtmlInlineContent = ({ analyzeConvertedScripts }) => {
   return {
-    name: "jsenv:js_and_css_inside_html",
+    name: "jsenv:html_inline_content",
     appliesDuring: "*",
-    transform: {
-      html: async ({ url, content }, { cook, referenceUtils }) => {
-        const htmlAst = parseHtmlString(content)
+    transformUrlContent: {
+      html: async (urlInfo, context) => {
+        const htmlAst = parseHtmlString(urlInfo.content)
         const actions = []
         const handleInlineStyle = (node) => {
           if (node.nodeName !== "style") {
@@ -33,7 +33,7 @@ export const jsenvPluginJsAndCssInsideHtml = () => {
                 preferOriginal: true,
               })
             const inlineStyleUrl = generateInlineContentUrl({
-              url,
+              url: urlInfo.url,
               extension: ".css",
               line,
               column,
@@ -41,23 +41,27 @@ export const jsenvPluginJsAndCssInsideHtml = () => {
               columnEnd,
             })
             const [inlineStyleReference, inlineStyleUrlInfo] =
-              referenceUtils.foundInline({
+              context.referenceUtils.foundInline({
                 type: "link_href",
+                expectedType: "css",
                 // 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,
+                isOriginalPosition: isOriginal,
                 specifier: inlineStyleUrl,
                 contentType: "text/css",
                 content: textNode.value,
               })
-            await cook({
+            await context.cook({
               reference: inlineStyleReference,
               urlInfo: inlineStyleUrlInfo,
             })
-            setHtmlNodeText(node, inlineStyleUrlInfo.content)
+            setHtmlNodeGeneratedText(node, {
+              generatedText: inlineStyleUrlInfo.content,
+              generatedBy: "jsenv:html_inline_content",
+            })
           })
         }
         const handleInlineScript = (node) => {
@@ -68,14 +72,19 @@ export const jsenvPluginJsAndCssInsideHtml = () => {
           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
+          // If the inline script was already handled by an other plugin, ignore it
+          // - we want to preserve inline scripts generated by html supervisor during dev
+          // - we want to avoid cooking twice a script during build
+          const generatedBy = getHtmlNodeAttributeByName(node, "generated-by")
+          if (generatedBy) {
+            if (generatedBy.value === "jsenv:script_type_module_as_classic") {
+              if (!analyzeConvertedScripts) {
+                return
+              }
+            }
+            if (generatedBy.value === "jsenv:html_supervisor") {
+              return
+            }
           }
           actions.push(async () => {
             const scriptCategory = parseScriptNode(node)
@@ -83,41 +92,57 @@ export const jsenvPluginJsAndCssInsideHtml = () => {
               htmlNodePosition.readNodePosition(node, {
                 preferOriginal: true,
               })
+            // from MDN about [type] attribute:
+            // "Any other value: The embedded content is treated as a data block
+            // which won't be processed by the browser. Developers must use a valid MIME type
+            // that is not a JavaScript MIME type to denote data blocks.
+            // The src attribute will be ignored."
+            // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
+            const isJs =
+              scriptCategory === "classic" || scriptCategory === "module"
+            const isImportmap = scriptCategory === "importmap"
+            const contentType = isJs
+              ? "text/javascript"
+              : isImportmap
+              ? "application/importmap+json"
+              : scriptCategory
+
             let inlineScriptUrl = generateInlineContentUrl({
-              url,
-              extension: scriptCategory === "importmap" ? ".importmap" : ".js",
+              url: urlInfo.url,
+              extension: CONTENT_TYPE.asFileExtension(contentType),
               line,
               column,
               lineEnd,
               columnEnd,
             })
-            if (scriptCategory === "classic") {
-              inlineScriptUrl = injectQueryParams(inlineScriptUrl, {
-                js_classic: "",
-              })
-            }
             const [inlineScriptReference, inlineScriptUrlInfo] =
-              referenceUtils.foundInline({
+              context.referenceUtils.foundInline({
                 node,
                 type: "script_src",
+                expectedType: {
+                  classic: "js_classic",
+                  module: "js_module",
+                  importmap: "importmap",
+                }[scriptCategory],
                 // 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,
+                isOriginalPosition: isOriginal,
                 specifier: inlineScriptUrl,
-                contentType:
-                  scriptCategory === "importmap"
-                    ? "application/importmap+json"
-                    : "application/javascript",
+                contentType,
                 content: textNode.value,
               })
-            await cook({
+
+            await context.cook({
               reference: inlineScriptReference,
               urlInfo: inlineScriptUrlInfo,
             })
-            setHtmlNodeText(node, inlineScriptUrlInfo.content)
+            setHtmlNodeGeneratedText(node, {
+              generatedText: inlineScriptUrlInfo.content,
+              generatedBy: "jsenv:html_inline_content",
+            })
           })
         }
         visitHtmlAst(htmlAst, (node) => {
@@ -127,11 +152,7 @@ export const jsenvPluginJsAndCssInsideHtml = () => {
         if (actions.length === 0) {
           return null
         }
-        await Promise.all(
-          actions.map(async (action) => {
-            await action()
-          }),
-        )
+        await Promise.all(actions.map((action) => action()))
         const htmlModified = stringifyHtmlAst(htmlAst)
         return {
           content: htmlModified,

package/src/plugins/inline/jsenv_plugin_inline.js

@@ -0,0 +1,36 @@
+import { jsenvPluginHtmlInlineContent } from "./jsenv_plugin_html_inline_content.js"
+import { jsenvPluginJsInlineContent } from "./jsenv_plugin_js_inline_content.js"
+import { jsenvPluginDataUrls } from "./jsenv_plugin_data_urls.js"
+import { jsenvPluginInlineQueryParam } from "./jsenv_plugin_inline_query_param.js"
+
+export const jsenvPluginInline = ({
+  fetchInlineUrls = true,
+  analyzeConvertedScripts = false,
+  allowEscapeForVersioning = false,
+} = {}) => {
+  return [
+    ...(fetchInlineUrls ? [jsenvPluginInlineUrls()] : []),
+    jsenvPluginHtmlInlineContent({ analyzeConvertedScripts }),
+    jsenvPluginJsInlineContent({ allowEscapeForVersioning }),
+    jsenvPluginDataUrls(),
+    jsenvPluginInlineQueryParam(),
+  ]
+}
+
+const jsenvPluginInlineUrls = () => {
+  return {
+    name: "jsenv:inline_urls",
+    appliesDuring: "*",
+    fetchUrlContent: (urlInfo) => {
+      if (!urlInfo.isInline) {
+        return null
+      }
+      return {
+        contentType: urlInfo.contentType,
+        // we want to fetch the original content otherwise we might re-cook
+        // content already cooked
+        content: urlInfo.originalContent,
+      }
+    },
+  }
+}

package/src/{omega/core_plugins → plugins}/inline/jsenv_plugin_inline_query_param.js

@@ -4,7 +4,7 @@ export const jsenvPluginInlineQueryParam = () => {
   return {
     name: "jsenv:inline_query_param",
     appliesDuring: "*",
-    formatReferencedUrl: {
+    formatUrl: {
       // <link> and <script> can be inlined in the html
       // this should be done during dev and postbuild but not build
       // so that the bundled file gets inlined and not the entry point
@@ -15,17 +15,17 @@ export const jsenvPluginInlineQueryParam = () => {
       // but maybe we should rather use ?object_url
       // or people could do this:
       // import workerText from './worker.js?text'
-      // const blob = new Blob(workerText, { type: 'application/javascript' })
+      // const blob = new Blob(workerText, { type: 'text/javascript' })
       // window.URL.createObjectURL(blob)
       // in any case the recommended way is to use an url
       // to benefit from shared worker and reuse worker between tabs
-      "*": (reference, { urlGraph, cook }) => {
-        if (!new URL(reference.url).searchParams.has("inline")) {
+      "*": (reference, context) => {
+        if (!reference.searchParams.has("inline")) {
           return null
         }
         return (async () => {
-          const urlInfo = urlGraph.getUrlInfo(reference.url)
-          await cook({
+          const urlInfo = context.urlGraph.getUrlInfo(reference.url)
+          await context.cook({
             reference,
             urlInfo,
           })

package/src/plugins/inline/jsenv_plugin_js_inline_content.js

@@ -0,0 +1,263 @@
+import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
+import { JS_QUOTES } from "@jsenv/utils/string/js_quotes.js"
+import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
+import { getTypePropertyNode } from "@jsenv/utils/js_ast/js_ast.js"
+import { generateInlineContentUrl } from "@jsenv/utils/urls/inline_content_url_generator.js"
+
+export const jsenvPluginJsInlineContent = ({ allowEscapeForVersioning }) => {
+  const parseAndTransformInlineContentCalls = async (urlInfo, context) => {
+    const { metadata } = await applyBabelPlugins({
+      babelPlugins: [babelPluginMetadataInlineContentCalls],
+      urlInfo,
+    })
+    const { inlineContentCalls } = metadata
+    if (inlineContentCalls.length === 0) {
+      return null
+    }
+    const magicSource = createMagicSource(urlInfo.content)
+    await inlineContentCalls.reduce(async (previous, inlineContentCall) => {
+      await previous
+      const inlineUrl = generateInlineContentUrl({
+        url: urlInfo.url,
+        extension: CONTENT_TYPE.asFileExtension(inlineContentCall.contentType),
+        line: inlineContentCall.line,
+        column: inlineContentCall.column,
+        lineEnd: inlineContentCall.lineEnd,
+        columnEnd: inlineContentCall.columnEnd,
+      })
+      let { quote } = inlineContentCall
+      if (
+        quote === "`" &&
+        !context.isSupportedOnCurrentClients("template_literals")
+      ) {
+        // if quote is "`" and template literals are not supported
+        // we'll use a regular string (single or double quote)
+        // when rendering the string
+        quote = JS_QUOTES.pickBest(inlineContentCall.content)
+      }
+      const [inlineReference, inlineUrlInfo] =
+        context.referenceUtils.foundInline({
+          type: "js_inline_content",
+          subtype: inlineContentCall.type, // "new_blob_first_arg", "new_inline_content_first_arg", "json_parse_first_arg"
+          isOriginalPosition: urlInfo.content === urlInfo.originalContent,
+          line: inlineContentCall.line,
+          column: inlineContentCall.column,
+          specifier: inlineUrl,
+          contentType: inlineContentCall.contentType,
+          content: inlineContentCall.content,
+        })
+      inlineUrlInfo.jsQuote = quote
+      inlineReference.escape = (value) =>
+        JS_QUOTES.escapeSpecialChars(value.slice(1, -1), { quote })
+      await context.cook({
+        reference: inlineReference,
+        urlInfo: inlineUrlInfo,
+      })
+      magicSource.replace({
+        start: inlineContentCall.start,
+        end: inlineContentCall.end,
+        replacement: JS_QUOTES.escapeSpecialChars(inlineUrlInfo.content, {
+          quote,
+          allowEscapeForVersioning,
+        }),
+      })
+    }, Promise.resolve())
+    return magicSource.toContentAndSourcemap()
+  }
+
+  return {
+    name: "jsenv:js_inline_content",
+    appliesDuring: "*",
+    transformUrlContent: {
+      js_classic: parseAndTransformInlineContentCalls,
+      js_module: parseAndTransformInlineContentCalls,
+    },
+  }
+}
+
+const babelPluginMetadataInlineContentCalls = () => {
+  return {
+    name: "metadata-inline-content-calls",
+    visitor: {
+      Program: (programPath, state) => {
+        const inlineContentCalls = []
+        programPath.traverse({
+          NewExpression: (path) => {
+            const inlineContentCall = analyzeNewInlineContentCall(path)
+            if (inlineContentCall) {
+              inlineContentCalls.push(inlineContentCall)
+              return
+            }
+          },
+          CallExpression: (path) => {
+            const jsonParseCall = analyzeJsonParseCall(path)
+            if (jsonParseCall) {
+              inlineContentCalls.push(jsonParseCall)
+              return
+            }
+          },
+        })
+        state.file.metadata.inlineContentCalls = inlineContentCalls
+      },
+    },
+  }
+}
+
+const analyzeNewInlineContentCall = (path) => {
+  const identifier = parseNewIdentifier(path)
+  if (!identifier) {
+    return null
+  }
+  const node = path.node
+  if (node.arguments.length !== 2) {
+    return null
+  }
+  const [firstArg, secondArg] = node.arguments
+  const typePropertyNode = getTypePropertyNode(secondArg)
+  if (!typePropertyNode || typePropertyNode.value.type !== "StringLiteral") {
+    return null
+  }
+  const contentType = typePropertyNode.value.value
+  const type = identifier.type
+  let nodeHoldingInlineContent
+  if (type === "new_inline_content") {
+    nodeHoldingInlineContent = firstArg
+  } else if (type === "new_blob") {
+    if (firstArg.type !== "ArrayExpression") {
+      return null
+    }
+    if (firstArg.elements.length !== 1) {
+      return null
+    }
+    nodeHoldingInlineContent = firstArg.elements[0]
+  }
+  const inlineContentInfo = extractInlineContentInfo(nodeHoldingInlineContent)
+  if (!inlineContentInfo) {
+    return null
+  }
+  return {
+    type:
+      type === "new_inline_content"
+        ? "new_inline_content_first_arg"
+        : "new_blob_first_arg",
+    contentType,
+    ...inlineContentInfo,
+    ...getNodePosition(nodeHoldingInlineContent),
+  }
+}
+
+const extractInlineContentInfo = (node) => {
+  if (node.type === "StringLiteral") {
+    return {
+      nodeType: "StringLiteral",
+      quote: node.extra.raw[0],
+      content: node.value,
+    }
+  }
+  if (node.type === "TemplateLiteral") {
+    const quasis = node.quasis
+    if (quasis.length !== 1) {
+      return null
+    }
+    const templateElementNode = quasis[0]
+    return {
+      nodeType: "TemplateLiteral",
+      quote: "`",
+      content: templateElementNode.value.cooked,
+    }
+  }
+  return null
+}
+
+const parseNewIdentifier = (path) => {
+  const node = path.node
+  if (node.callee.type === "Identifier") {
+    // terser rename import to use a shorter name
+    const name = getOriginalName(path, node.callee.name)
+    if (name === "InlineContent") {
+      return {
+        type: "new_inline_content",
+      }
+    }
+    if (name === "Blob") {
+      return {
+        type: "new_blob",
+      }
+    }
+    return null
+  }
+  if (node.callee.id) {
+    // terser might combine new InlineContent('') declaration and usage
+    if (node.callee.id.type !== "Identifier") {
+      return null
+    }
+    const name = getOriginalName(path, node.callee.id.name)
+    if (name === "InlineContent") {
+      return {
+        type: "new_inline_content",
+      }
+    }
+  }
+  return null
+}
+
+const analyzeJsonParseCall = (path) => {
+  const node = path.node
+  if (!isJSONParseCall(node)) {
+    return null
+  }
+  const inlineContentInfo = extractInlineContentInfo(node.arguments[0])
+  if (!inlineContentInfo) {
+    return null
+  }
+  return {
+    type: "json_parse_first_arg",
+    contentType: "application/json",
+    ...inlineContentInfo,
+    ...getNodePosition(node.arguments[0]),
+  }
+}
+
+const isJSONParseCall = (node) => {
+  const callee = node.callee
+  return (
+    callee.type === "MemberExpression" &&
+    callee.object.type === "Identifier" &&
+    callee.object.name === "JSON" &&
+    callee.property.type === "Identifier" &&
+    callee.property.name === "parse"
+  )
+}
+
+const getNodePosition = (node) => {
+  return {
+    start: node.start,
+    end: node.end,
+    line: node.loc.start.line,
+    column: node.loc.start.column,
+    lineEnd: node.loc.end.line,
+    columnEnd: node.loc.end.column,
+  }
+}
+
+const getOriginalName = (path, name) => {
+  const binding = path.scope.getBinding(name)
+  if (!binding) {
+    return name
+  }
+  if (binding.path.type === "ImportSpecifier") {
+    const importedName = binding.path.node.imported.name
+    if (name === importedName) {
+      return name
+    }
+    return getOriginalName(path, importedName)
+  }
+  if (binding.path.type === "VariableDeclarator") {
+    if (binding.path.node.init.type === "Identifier") {
+      const previousName = binding.path.node.init.name
+      return getOriginalName(path, previousName)
+    }
+  }
+  return name
+}

package/src/plugins/leading_slash/jsenv_plugin_leading_slash.js

@@ -0,0 +1,13 @@
+export const jsenvPluginLeadingSlash = () => {
+  return {
+    name: "jsenv:leading_slash",
+    appliesDuring: "*",
+    resolveUrl: (reference, context) => {
+      if (reference.specifier[0] !== "/") {
+        return null
+      }
+      return new URL(reference.specifier.slice(1), context.rootDirectoryUrl)
+        .href
+    },
+  }
+}

package/src/plugins/minification/css/minify_css.js

@@ -0,0 +1,9 @@
+import { minifyWithParcel } from "@jsenv/utils/css_ast/parcel_css.js"
+
+export const minifyCss = ({ cssUrlInfo, context }) => {
+  const { code, map } = minifyWithParcel(cssUrlInfo, context)
+  return {
+    content: String(code),
+    sourcemap: map,
+  }
+}

package/src/plugins/minification/html/minify_html.js

@@ -0,0 +1,15 @@
+import { createRequire } from "node:module"
+
+const require = createRequire(import.meta.url)
+
+// https://github.com/kangax/html-minifier#options-quick-reference
+export const minifyHtml = ({ htmlUrlInfo, options } = {}) => {
+  const { collapseWhitespace = true, removeComments = true } = options
+
+  const { minify } = require("html-minifier")
+  const htmlMinified = minify(htmlUrlInfo.content, {
+    collapseWhitespace,
+    removeComments,
+  })
+  return htmlMinified
+}

package/src/{build/plugins/minify_js/jsenv_plugin_minify_js.js → plugins/minification/js/minify_js.js}

@@ -1,28 +1,11 @@
 // https://github.com/terser-js/terser#minify-options
 
-export const jsenvPluginMinifyJs = () => {
-  const applyTerser = async (urlInfo) => {
-    return minifyJs({
-      url: urlInfo.url,
-      content: urlInfo.content,
-      sourcemap: urlInfo.sourcemap,
-      isJsModule: urlInfo.type === "js_module",
-    })
-  }
-
-  return {
-    name: "jsenv:minify_js",
-    appliesDuring: {
-      build: true,
-    },
-    optimize: {
-      js_classic: applyTerser,
-      js_module: applyTerser,
-    },
-  }
-}
+export const minifyJs = async ({ jsUrlInfo, options }) => {
+  const url = jsUrlInfo.url
+  const content = jsUrlInfo.content
+  const sourcemap = jsUrlInfo.sourcemap
+  const isJsModule = jsUrlInfo.type === "js_module"
 
-const minifyJs = async ({ url, content, sourcemap, isJsModule }) => {
   const { minify } = await import("terser")
   const terserResult = await minify(
     {
@@ -38,6 +21,7 @@ const minifyJs = async ({ url, content, sourcemap, isJsModule }) => {
       // We need to preserve "new InlineContent()" calls to be able to recognize them
       // after minification in order to version urls inside inline content text
       keep_fnames: /InlineContent/,
+      ...options,
     },
   )
   return {