@jsenv/core 27.0.0-alpha.84 → 27.0.0-alpha.87

package/src/plugins/bundling/js_module/bundle_js_module.js

@@ -5,7 +5,7 @@ import { isFileSystemPath } from "@jsenv/urls"
 import { createDetailedMessage } from "@jsenv/log"
 import { babelHelperNameFromUrl } from "@jsenv/babel-plugins"
 import { sourcemapConverter } from "@jsenv/sourcemap"
-import { applyRollupPlugins } from "@jsenv/utils/src/js_ast/apply_rollup_plugins.js"
+
 import { fileUrlConverter } from "@jsenv/core/src/omega/file_url_converter.js"
 
 const globalThisClientFileUrl = new URL(
@@ -53,71 +53,6 @@ export const bundleJsModule = async ({
   return jsModuleBundleUrlInfos
 }
 
-export const buildWithRollup = async ({
-  signal,
-  logger,
-  rootDirectoryUrl,
-  buildDirectoryUrl,
-  urlGraph,
-  jsModuleUrlInfos,
-
-  runtimeCompat,
-  sourcemaps,
-
-  include,
-  babelHelpersChunk,
-}) => {
-  const resultRef = { current: null }
-  try {
-    await applyRollupPlugins({
-      rollupPlugins: [
-        rollupPluginJsenv({
-          signal,
-          logger,
-          rootDirectoryUrl,
-          buildDirectoryUrl,
-          urlGraph,
-          jsModuleUrlInfos,
-
-          runtimeCompat,
-          sourcemaps,
-          include,
-          babelHelpersChunk,
-          resultRef,
-        }),
-      ],
-      inputOptions: {
-        input: [],
-        onwarn: (warning) => {
-          if (warning.code === "CIRCULAR_DEPENDENCY") {
-            return
-          }
-          if (
-            warning.code === "THIS_IS_UNDEFINED" &&
-            pathToFileURL(warning.id).href === globalThisClientFileUrl
-          ) {
-            return
-          }
-          if (warning.code === "EVAL") {
-            // ideally we should disable only for jsenv files
-            return
-          }
-          logger.warn(String(warning))
-        },
-      },
-    })
-    return resultRef.current
-  } catch (e) {
-    if (e.code === "MISSING_EXPORT") {
-      const detailedMessage = createDetailedMessage(e.message, {
-        frame: e.frame,
-      })
-      throw new Error(detailedMessage, { cause: e })
-    }
-    throw e
-  }
-}
-
 const rollupPluginJsenv = ({
   // logger,
   rootDirectoryUrl,
@@ -311,6 +246,90 @@ const rollupPluginJsenv = ({
   }
 }
 
+const buildWithRollup = async ({
+  signal,
+  logger,
+  rootDirectoryUrl,
+  buildDirectoryUrl,
+  urlGraph,
+  jsModuleUrlInfos,
+
+  runtimeCompat,
+  sourcemaps,
+
+  include,
+  babelHelpersChunk,
+}) => {
+  const resultRef = { current: null }
+  try {
+    await applyRollupPlugins({
+      rollupPlugins: [
+        rollupPluginJsenv({
+          signal,
+          logger,
+          rootDirectoryUrl,
+          buildDirectoryUrl,
+          urlGraph,
+          jsModuleUrlInfos,
+
+          runtimeCompat,
+          sourcemaps,
+          include,
+          babelHelpersChunk,
+          resultRef,
+        }),
+      ],
+      inputOptions: {
+        input: [],
+        onwarn: (warning) => {
+          if (warning.code === "CIRCULAR_DEPENDENCY") {
+            return
+          }
+          if (
+            warning.code === "THIS_IS_UNDEFINED" &&
+            pathToFileURL(warning.id).href === globalThisClientFileUrl
+          ) {
+            return
+          }
+          if (warning.code === "EVAL") {
+            // ideally we should disable only for jsenv files
+            return
+          }
+          logger.warn(String(warning))
+        },
+      },
+    })
+    return resultRef.current
+  } catch (e) {
+    if (e.code === "MISSING_EXPORT") {
+      const detailedMessage = createDetailedMessage(e.message, {
+        frame: e.frame,
+      })
+      throw new Error(detailedMessage, { cause: e })
+    }
+    throw e
+  }
+}
+
+const applyRollupPlugins = async ({
+  rollupPlugins,
+  inputOptions = {},
+  outputOptions = {},
+}) => {
+  const { rollup } = await import("rollup")
+  const { importAssertions } = await import("acorn-import-assertions")
+  const rollupReturnValue = await rollup({
+    ...inputOptions,
+    plugins: rollupPlugins,
+    acornInjectPlugins: [
+      importAssertions,
+      ...(inputOptions.acornInjectPlugins || []),
+    ],
+  })
+  const rollupOutputArray = await rollupReturnValue.generate(outputOptions)
+  return rollupOutputArray
+}
+
 const willBeInsideJsDirectory = ({
   chunkInfo,
   fileUrlConverter,

package/src/plugins/commonjs_globals/jsenv_plugin_commonjs_globals.js

@@ -8,7 +8,7 @@
  */
 
 import { createMagicSource } from "@jsenv/sourcemap"
-import { applyBabelPlugins } from "@jsenv/utils/src/js_ast/apply_babel_plugins.js"
+import { applyBabelPlugins } from "@jsenv/ast"
 
 export const jsenvPluginCommonJsGlobals = () => {
   const transformCommonJsGlobals = async (urlInfo, { scenario }) => {

package/src/plugins/file_urls/jsenv_plugin_file_urls.js

@@ -15,7 +15,7 @@ import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
 export const jsenvPluginFileUrls = ({
   magicExtensions = ["inherit", ".js"],
   magicDirectoryIndex = true,
-  preservesSymlink = true,
+  preserveSymlinks = false,
   directoryReferenceAllowed = false,
 }) => {
   return [
@@ -58,9 +58,17 @@ export const jsenvPluginFileUrls = ({
           urlObject.pathname = pathname.slice(0, -1)
         }
         if (foundADirectory && directoryReferenceAllowed) {
+          if (
+            // ignore new URL second arg
+            reference.subtype === "new_url_second_arg" ||
+            // ignore root file url
+            reference.url === "file:///"
+          ) {
+            reference.shouldHandle = false
+          }
           reference.data.foundADirectory = true
           const directoryFacadeUrl = urlObject.href
-          const directoryUrlRaw = preservesSymlink
+          const directoryUrlRaw = preserveSymlinks
             ? directoryFacadeUrl
             : resolveSymlink(directoryFacadeUrl)
           const directoryUrl = `${directoryUrlRaw}${search}${hash}`
@@ -81,7 +89,7 @@ export const jsenvPluginFileUrls = ({
         }
         reference.data.foundADirectory = filesystemResolution.isDirectory
         const fileFacadeUrl = filesystemResolution.url
-        const fileUrlRaw = preservesSymlink
+        const fileUrlRaw = preserveSymlinks
           ? fileFacadeUrl
           : resolveSymlink(fileFacadeUrl)
         const fileUrl = `${fileUrlRaw}${search}${hash}`

package/src/plugins/html_supervisor/jsenv_plugin_html_supervisor.js

@@ -7,17 +7,17 @@
 import {
   parseHtmlString,
   stringifyHtmlAst,
-  visitHtmlAst,
-  getHtmlNodeAttributeByName,
-  removeHtmlNodeAttributeByName,
-  parseScriptNode,
-  injectScriptAsEarlyAsPossible,
+  visitHtmlNodes,
+  getHtmlNodeAttribute,
+  setHtmlNodeAttributes,
+  analyzeScriptNode,
+  injectScriptNodeAsEarlyAsPossible,
   createHtmlNode,
-  htmlNodePosition,
-  getHtmlNodeTextNode,
+  getHtmlNodePosition,
+  getHtmlNodeText,
   removeHtmlNodeText,
-  setHtmlNodeGeneratedText,
-} from "@jsenv/utils/src/html_ast/html_ast.js"
+  setHtmlNodeText,
+} from "@jsenv/ast"
 import { generateInlineContentUrl } from "@jsenv/urls"
 
 export const jsenvPluginHtmlSupervisor = ({
@@ -45,10 +45,10 @@ export const jsenvPluginHtmlSupervisor = ({
         const htmlAst = parseHtmlString(content)
         const scriptsToSupervise = []
 
-        const handleInlineScript = (node, textNode) => {
-          const scriptCategory = parseScriptNode(node)
+        const handleInlineScript = (node, htmlNodeText) => {
+          const scriptCategory = analyzeScriptNode(node)
           const { line, column, lineEnd, columnEnd, isOriginal } =
-            htmlNodePosition.readNodePosition(node, {
+            getHtmlNodePosition(node, {
               preferOriginal: true,
             })
           let inlineScriptUrl = generateInlineContentUrl({
@@ -69,7 +69,7 @@ export const jsenvPluginHtmlSupervisor = ({
             specifierColumn: column,
             specifier: inlineScriptUrl,
             contentType: "text/javascript",
-            content: textNode.value,
+            content: htmlNodeText,
           })
           removeHtmlNodeText(node)
           scriptsToSupervise.push({
@@ -79,76 +79,61 @@ export const jsenvPluginHtmlSupervisor = ({
             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
-          const deferAttribute = getHtmlNodeAttributeByName(node, "crossorigin")
-          const defer = deferAttribute ? deferAttribute.value : undefined
-          const asyncAttribute = getHtmlNodeAttributeByName(node, "crossorigin")
-          const async = asyncAttribute ? asyncAttribute.value : undefined
-          removeHtmlNodeAttributeByName(node, "src")
+        const handleScriptWithSrc = (node, src) => {
+          const scriptCategory = analyzeScriptNode(node)
+          const integrity = getHtmlNodeAttribute(node, "integrity")
+          const crossorigin =
+            getHtmlNodeAttribute(node, "crossorigin") !== undefined
+          const defer = getHtmlNodeAttribute(node, "defer") !== undefined
+          const async = getHtmlNodeAttribute(node, "async") !== undefined
+          setHtmlNodeAttributes(node, {
+            src: undefined,
+          })
           scriptsToSupervise.push({
             node,
             type: scriptCategory,
-            src: srcAttribute.value,
+            src,
             defer,
             async,
             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
-          }
+        visitHtmlNodes(htmlAst, {
+          script: (node) => {
+            const scriptCategory = analyzeScriptNode(node)
+            if (scriptCategory !== "classic" && scriptCategory !== "module") {
+              return
+            }
+            const injectedBy = getHtmlNodeAttribute(node, "injected-by")
+            if (injectedBy !== undefined) {
+              return
+            }
+            const noHtmlSupervisor = getHtmlNodeAttribute(
+              node,
+              "no-html-supervisor",
+            )
+            if (noHtmlSupervisor !== undefined) {
+              return
+            }
+            const htmlNodeText = getHtmlNodeText(node)
+            if (htmlNodeText) {
+              handleInlineScript(node, htmlNodeText)
+              return
+            }
+            const src = getHtmlNodeAttribute(node, "src")
+            if (src) {
+              handleScriptWithSrc(node, src)
+              return
+            }
+          },
         })
         const [htmlSupervisorInstallerFileReference] = referenceUtils.inject({
           type: "js_import_export",
           expectedType: "js_module",
           specifier: htmlSupervisorInstallerFileUrl,
         })
-        injectScriptAsEarlyAsPossible(
+        injectScriptNodeAsEarlyAsPossible(
           htmlAst,
           createHtmlNode({
             "tagName": "script",
@@ -173,7 +158,7 @@ export const jsenvPluginHtmlSupervisor = ({
           expectedType: "js_classic",
           specifier: htmlSupervisorSetupFileUrl,
         })
-        injectScriptAsEarlyAsPossible(
+        injectScriptNodeAsEarlyAsPossible(
           htmlAst,
           createHtmlNode({
             "tagName": "script",
@@ -192,8 +177,9 @@ export const jsenvPluginHtmlSupervisor = ({
             integrity,
             crossorigin,
           }) => {
-            setHtmlNodeGeneratedText(node, {
-              generatedText: generateCodeToSuperviseScript({
+            setHtmlNodeText(
+              node,
+              generateCodeToSuperviseScript({
                 type,
                 src,
                 isInline,
@@ -204,9 +190,11 @@ export const jsenvPluginHtmlSupervisor = ({
                 htmlSupervisorInstallerSpecifier:
                   htmlSupervisorInstallerFileReference.generatedSpecifier,
               }),
-              generatedBy: "jsenv:html_supervisor",
-              generatedFromSrc: src,
-              generatedFromInlineContent: isInline,
+            )
+            setHtmlNodeAttributes(node, {
+              "generated-by": "jsenv:html_supervisor",
+              ...(src ? { "generated-from-src": src } : {}),
+              ...(isInline ? { "generated-from-inline-content": "" } : {}),
             })
           },
         )

package/src/plugins/http_urls/jsenv_plugin_http_urls.js

@@ -2,11 +2,15 @@ export const jsenvPluginHttpUrls = () => {
   return {
     name: "jsenv:http_urls",
     appliesDuring: "*",
-    // fetchUrlContent: (urlInfo) => {
-    //   if (urlInfo.url.startsWith("http") || urlInfo.url.startsWith("https")) {
-    //     return { shouldHandle: false }
-    //   }
-    //   return null
-    // },
+    redirectUrl: (reference) => {
+      if (
+        reference.url.startsWith("http:") ||
+        reference.url.startsWith("https:")
+      ) {
+        reference.shouldHandle = false
+      }
+      // TODO: according to some pattern matching jsenv could be allowed
+      // to fetch and transform http urls
+    },
   }
 }

package/src/plugins/import_meta_hot/html_hot_dependencies.js

@@ -1,8 +1,4 @@
-import {
-  getHtmlNodeAttributeByName,
-  parseLinkNode,
-} from "@jsenv/utils/src/html_ast/html_ast.js"
-import { htmlAttributeSrcSet } from "@jsenv/utils/src/html_ast/html_attribute_src_set.js"
+import { getHtmlNodeAttribute, analyzeLinkNode, parseSrcSet } from "@jsenv/ast"
 
 // Some "smart" default applied to decide what should hot reload / fullreload:
 // By default:
@@ -28,8 +24,7 @@ export const collectHotDataFromHtmlAst = (htmlAst) => {
   }
 
   const visitUrlSpecifierAttribute = ({ node, attributeName, hotAccepted }) => {
-    const attribute = getHtmlNodeAttributeByName(node, attributeName)
-    const value = attribute ? attribute.value : undefined
+    const value = getHtmlNodeAttribute(node, attributeName)
     if (value) {
       onSpecifier({
         specifier: value,
@@ -70,10 +65,9 @@ export const collectHotDataFromHtmlAst = (htmlAst) => {
       })
     }
     if (nodeNamesWithSrcset.includes(node.nodeName)) {
-      const srcsetAttribute = getHtmlNodeAttributeByName(node, "srcset")
-      const srcset = srcsetAttribute ? srcsetAttribute.value : undefined
+      const srcset = getHtmlNodeAttribute(node, "srcset")
       if (srcset) {
-        const srcCandidates = htmlAttributeSrcSet.parse(srcset)
+        const srcCandidates = parseSrcSet(srcset)
         srcCandidates.forEach((srcCandidate) => {
           onSpecifier({
             node,
@@ -112,12 +106,12 @@ const nodeNamesWithSrcset = ["img", "source"]
 
 const getNodeContext = (node) => {
   const context = {}
-  const hotAcceptAttribute = getHtmlNodeAttributeByName(node, "hot-accept")
-  if (hotAcceptAttribute) {
+  const hotAccept = getHtmlNodeAttribute(node, "hot-accept")
+  if (hotAccept !== undefined) {
     context.hotAccepted = true
   }
-  const hotDeclineAttribute = getHtmlNodeAttributeByName(node, "hot-decline")
-  if (hotDeclineAttribute) {
+  const hotDecline = getHtmlNodeAttribute(node, "hot-decline")
+  if (hotDecline !== undefined) {
     context.hotAccepted = false
   }
   return context
@@ -125,7 +119,7 @@ const getNodeContext = (node) => {
 
 const htmlNodeCanHotReload = (node) => {
   if (node.nodeName === "link") {
-    const { isStylesheet, isRessourceHint, rel } = parseLinkNode(node)
+    const { isStylesheet, isRessourceHint, rel } = analyzeLinkNode(node)
     if (isStylesheet) {
       // stylesheets can be hot replaced by default
       return true

package/src/plugins/import_meta_hot/jsenv_plugin_import_meta_hot.js

@@ -1,6 +1,5 @@
 import { createMagicSource } from "@jsenv/sourcemap"
-import { parseHtmlString } from "@jsenv/utils/src/html_ast/html_ast.js"
-import { applyBabelPlugins } from "@jsenv/utils/src/js_ast/apply_babel_plugins.js"
+import { parseHtmlString, applyBabelPlugins } from "@jsenv/ast"
 
 import { collectHotDataFromHtmlAst } from "./html_hot_dependencies.js"
 import { babelPluginMetadataImportMetaHot } from "./babel_plugin_metadata_import_meta_hot.js"

package/src/plugins/import_meta_scenarios/jsenv_plugin_import_meta_scenarios.js

@@ -10,7 +10,7 @@
  */
 
 import { createMagicSource } from "@jsenv/sourcemap"
-import { applyBabelPlugins } from "@jsenv/utils/src/js_ast/apply_babel_plugins.js"
+import { applyBabelPlugins } from "@jsenv/ast"
 
 export const jsenvPluginImportMetaScenarios = () => {
   return {

package/src/plugins/importmap/jsenv_plugin_importmap.js

@@ -26,14 +26,14 @@ import { generateInlineContentUrl } from "@jsenv/urls"
 import {
   parseHtmlString,
   stringifyHtmlAst,
-  findNode,
-  getHtmlNodeAttributeByName,
-  htmlNodePosition,
-  removeHtmlNodeAttributeByName,
-  setHtmlNodeGeneratedText,
-  getHtmlNodeTextNode,
+  findHtmlNode,
+  getHtmlNodeAttribute,
+  setHtmlNodeAttributes,
+  getHtmlNodePosition,
+  getHtmlNodeText,
+  setHtmlNodeText,
   removeHtmlNode,
-} from "@jsenv/utils/src/html_ast/html_ast.js"
+} from "@jsenv/ast"
 
 export const jsenvPluginImportmap = () => {
   let finalImportmap = null
@@ -92,12 +92,12 @@ export const jsenvPluginImportmap = () => {
     transformUrlContent: {
       html: async (htmlUrlInfo, context) => {
         const htmlAst = parseHtmlString(htmlUrlInfo.content)
-        const importmap = findNode(htmlAst, (node) => {
+        const importmap = findHtmlNode(htmlAst, (node) => {
           if (node.nodeName !== "script") {
             return false
           }
-          const typeAttribute = getHtmlNodeAttributeByName(node, "type")
-          if (!typeAttribute || typeAttribute.value !== "importmap") {
+          const type = getHtmlNodeAttribute(node, "type")
+          if (type === undefined || type !== "importmap") {
             return false
           }
           return true
@@ -108,7 +108,7 @@ export const jsenvPluginImportmap = () => {
         }
         const handleInlineImportmap = async (importmap, textNode) => {
           const { line, column, lineEnd, columnEnd, isOriginal } =
-            htmlNodePosition.readNodePosition(importmap, {
+            getHtmlNodePosition(importmap, {
               preferOriginal: true,
             })
           const inlineImportmapUrl = generateInlineContentUrl({
@@ -132,9 +132,9 @@ export const jsenvPluginImportmap = () => {
           await context.cook(inlineImportmapUrlInfo, {
             reference: inlineImportmapReference,
           })
-          setHtmlNodeGeneratedText(importmap, {
-            generatedText: inlineImportmapUrlInfo.content,
-            generatedBy: "jsenv:importmap",
+          setHtmlNodeText(importmap, inlineImportmapUrlInfo.content)
+          setHtmlNodeAttributes(importmap, {
+            "generated-by": "jsenv:importmap",
           })
           onHtmlImportmapParsed(
             JSON.parse(inlineImportmapUrlInfo.content),
@@ -159,15 +159,15 @@ export const jsenvPluginImportmap = () => {
             JSON.parse(importmapUrlInfo.content),
             htmlUrlInfo.url,
           )
-          removeHtmlNodeAttributeByName(importmap, "src")
-          setHtmlNodeGeneratedText(importmap, {
-            generatedText: importmapUrlInfo.content,
-            generatedBy: "jsenv:importmap",
-            generatedFromSrc: src,
+          setHtmlNodeText(importmap, importmapUrlInfo.content)
+          setHtmlNodeAttributes(importmap, {
+            "src": undefined,
+            "generated-by": "jsenv:importmap",
+            "generated-from-src": src,
           })
 
           const { line, column, lineEnd, columnEnd, isOriginal } =
-            htmlNodePosition.readNodePosition(importmap, {
+            getHtmlNodePosition(importmap, {
               preferOriginal: true,
             })
           const inlineImportmapUrl = generateInlineContentUrl({
@@ -188,14 +188,13 @@ export const jsenvPluginImportmap = () => {
           })
         }
 
-        const srcAttribute = getHtmlNodeAttributeByName(importmap, "src")
-        const src = srcAttribute ? srcAttribute.value : undefined
+        const src = getHtmlNodeAttribute(importmap, "src")
         if (src) {
           await handleImportmapWithSrc(importmap, src)
         } else {
-          const textNode = getHtmlNodeTextNode(importmap)
-          if (textNode) {
-            await handleInlineImportmap(importmap, textNode)
+          const htmlNodeText = getHtmlNodeText(importmap)
+          if (htmlNodeText) {
+            await handleInlineImportmap(importmap, htmlNodeText)
           }
         }
         // once this plugin knows the importmap, it will use it

package/src/plugins/inject_globals/inject_globals.js

@@ -1,10 +1,10 @@
 import { createMagicSource } from "@jsenv/sourcemap"
 import {
   parseHtmlString,
-  injectScriptAsEarlyAsPossible,
+  injectScriptNodeAsEarlyAsPossible,
   createHtmlNode,
   stringifyHtmlAst,
-} from "@jsenv/utils/src/html_ast/html_ast.js"
+} from "@jsenv/ast"
 
 export const injectGlobals = (urlInfo, globals) => {
   if (urlInfo.type === "html") {
@@ -27,7 +27,7 @@ const globalInjectorOnHtml = async (urlInfo, globals) => {
     globals,
     isWebWorker: false,
   })
-  injectScriptAsEarlyAsPossible(
+  injectScriptNodeAsEarlyAsPossible(
     htmlAst,
     createHtmlNode({
       "tagName": "script",