@jsenv/core 27.0.0-alpha.83 → 27.0.0-alpha.86

package/src/helpers/worker_reload.js

@@ -34,12 +34,13 @@ export const createReloadableWorker = (workerFileUrl, options = {}) => {
     worker.once("error", (error) => {
       console.error(error)
     })
-    worker.once("exit", () => {
-      worker = null
-    })
     await new Promise((resolve) => {
       worker.once("online", resolve)
     })
+    worker.once("exit", () => {
+      worker = null
+    })
+    return worker
   }
 
   const reload = async () => {

package/src/omega/compat/runtime_compat.js

@@ -1,4 +1,5 @@
-import { findHighestVersion } from "@jsenv/utils/semantic_versioning/highest_version.js"
+import { findHighestVersion } from "@jsenv/utils/src/semantic_versioning/highest_version.js"
+
 import { featureCompats } from "./features_compats.js"
 
 export const RUNTIME_COMPAT = {

package/src/omega/kitchen.js

@@ -8,7 +8,8 @@ import {
 } from "@jsenv/urls"
 import { writeFileSync, ensureWindowsDriveLetter } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/log"
-import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
+
 import { createPluginController } from "../plugins/plugin_controller.js"
 import { urlSpecifierEncoding } from "./url_specifier_encoding.js"
 import { createUrlInfoTransformer } from "./url_graph/url_info_transformations.js"
@@ -711,6 +712,8 @@ const memoizeCook = (cook) => {
 const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
   if (reference.shouldHandle) {
     urlInfo.shouldHandle = true
+  } else {
+    urlInfo.shouldHandle = false
   }
   urlInfo.originalUrl = urlInfo.originalUrl || reference.url
 

package/src/omega/server/user_agent.js

@@ -1,4 +1,5 @@
-import { memoizeByFirstArgument } from "@jsenv/utils/memoize/memoize_by_first_argument.js"
+import { memoizeByFirstArgument } from "@jsenv/utils/src/memoize/memoize_by_first_argument.js"
+
 import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
 
 export const parseUserAgentHeader = memoizeByFirstArgument((userAgent) => {

package/src/omega/url_graph/sort_by_dependencies.js

@@ -0,0 +1,27 @@
+export const sortByDependencies = (nodes) => {
+  const visited = []
+  const sorted = []
+  const circular = []
+  const visit = (url) => {
+    const isSorted = sorted.includes(url)
+    if (isSorted) {
+      return
+    }
+    const isVisited = visited.includes(url)
+    if (isVisited) {
+      circular.push(url)
+      sorted.push(url)
+    } else {
+      visited.push(url)
+      nodes[url].dependencies.forEach((dependencyUrl) => {
+        visit(dependencyUrl, url)
+      })
+      sorted.push(url)
+    }
+  }
+  Object.keys(nodes).forEach((url) => {
+    visit(url)
+  })
+  sorted.circular = circular
+  return sorted
+}

package/src/omega/url_graph/url_info_transformations.js

@@ -1,12 +1,12 @@
+import { pathToFileURL } from "node:url"
 import { bufferToEtag } from "@jsenv/filesystem"
-import { urlToRelativeUrl } from "@jsenv/urls"
-
-import { composeTwoSourcemaps } from "@jsenv/utils/sourcemap/sourcemap_composition_v3.js"
+import { urlToRelativeUrl, isFileSystemPath } from "@jsenv/urls"
 import {
+  composeTwoSourcemaps,
   SOURCEMAP,
-  sourcemapToBase64Url,
-  generateSourcemapUrl,
-} from "@jsenv/utils/sourcemap/sourcemap_utils.js"
+  generateSourcemapFileUrl,
+  generateSourcemapDataUrl,
+} from "@jsenv/sourcemap"
 
 export const createUrlInfoTransformer = ({
   logger,
@@ -23,18 +23,25 @@ export const createUrlInfoTransformer = ({
     sourcemaps === "programmatic"
 
   const normalizeSourcemap = (urlInfo, sourcemap) => {
+    let { sources } = sourcemap
+    if (sources) {
+      sources = sources.map((source) => {
+        if (source && isFileSystemPath(source)) {
+          return String(pathToFileURL(source))
+        }
+        return source
+      })
+    }
     const wantSourcesContent =
       // for inline content (<script> insdide html)
       // chrome won't be able to fetch the file as it does not exists
       // so sourcemap must contain sources
       sourcemapsSourcesContent ||
       urlInfo.isInline ||
-      (sourcemap.sources &&
-        sourcemap.sources.some(
-          (source) => !source || !source.startsWith("file:"),
-        ))
-    if (sourcemap.sources && sourcemap.sources.length > 1) {
-      sourcemap.sources = sourcemap.sources.map(
+      (sources &&
+        sources.some((source) => !source || !source.startsWith("file:")))
+    if (sources && sources.length > 1) {
+      sourcemap.sources = sources.map(
         (source) => new URL(source, urlInfo.originalUrl).href,
       )
       if (!wantSourcesContent) {
@@ -65,7 +72,9 @@ export const createUrlInfoTransformer = ({
     // when jsenv is done cooking the file
     //   during build it's urlInfo.url to be inside the build
     //   but otherwise it's generatedUrl to be inside .jsenv/ directory
-    urlInfo.sourcemapGeneratedUrl = generateSourcemapUrl(urlInfo.generatedUrl)
+    urlInfo.sourcemapGeneratedUrl = generateSourcemapFileUrl(
+      urlInfo.generatedUrl,
+    )
     const [sourcemapReference, sourcemapUrlInfo] = injectSourcemapPlaceholder({
       urlInfo,
       specifier: urlInfo.sourcemapGeneratedUrl,
@@ -154,7 +163,8 @@ export const createUrlInfoTransformer = ({
       }
       sourcemapUrlInfo.content = JSON.stringify(sourcemap, null, "  ")
       if (sourcemaps === "inline") {
-        sourcemapReference.generatedSpecifier = sourcemapToBase64Url(sourcemap)
+        sourcemapReference.generatedSpecifier =
+          generateSourcemapDataUrl(sourcemap)
       }
       if (sourcemaps === "file" || sourcemaps === "inline") {
         urlInfo.content = SOURCEMAP.writeComment({

package/src/plugins/autoreload/dev_sse/client/reload.js

@@ -1,4 +1,7 @@
-import { htmlAttributeSrcSet } from "@jsenv/utils/html_ast/html_attribute_src_set.js"
+import {
+  parseSrcSet,
+  stringifySrcSet,
+} from "@jsenv/ast/src/html/html_src_set.js"
 
 import { injectQuery, compareTwoUrlPaths } from "./url_helpers.js"
 
@@ -57,7 +60,7 @@ export const reloadDOMNodesUsingUrl = (urlToReload) => {
     visitNodeAttributeAsUrl(img, "src")
     const srcset = img.srcset
     if (srcset) {
-      const srcCandidates = htmlAttributeSrcSet.parse(srcset)
+      const srcCandidates = parseSrcSet(srcset)
       srcCandidates.forEach((srcCandidate) => {
         const url = new URL(srcCandidate.specifier, `${window.location.href}`)
         if (shouldReloadUrl(url)) {
@@ -65,7 +68,7 @@ export const reloadDOMNodesUsingUrl = (urlToReload) => {
         }
       })
       mutations.push(() => {
-        img.srcset = htmlAttributeSrcSet.stringify(srcCandidates)
+        img.srcset = stringifySrcSet(srcCandidates)
       })
     }
   })

package/src/plugins/autoreload/dev_sse/jsenv_plugin_dev_sse_client.js

@@ -1,9 +1,9 @@
 import {
   parseHtmlString,
   stringifyHtmlAst,
-  injectScriptAsEarlyAsPossible,
+  injectScriptNodeAsEarlyAsPossible,
   createHtmlNode,
-} from "@jsenv/utils/html_ast/html_ast.js"
+} from "@jsenv/ast"
 
 export const jsenvPluginDevSSEClient = () => {
   const eventSourceClientFileUrl = new URL(
@@ -22,7 +22,7 @@ export const jsenvPluginDevSSEClient = () => {
           expectedType: "js_module",
           specifier: eventSourceClientFileUrl,
         })
-        injectScriptAsEarlyAsPossible(
+        injectScriptNodeAsEarlyAsPossible(
           htmlAst,
           createHtmlNode({
             "tagName": "script",

package/src/plugins/bundling/css/bundle_css.js

@@ -6,10 +6,10 @@
  *   It can be quite challenging, see "bundle_sourcemap.js"
  */
 
-import { applyPostCss } from "@jsenv/utils/css_ast/apply_post_css.js"
-import { postCssPluginUrlVisitor } from "@jsenv/utils/css_ast/postcss_plugin_url_visitor.js"
-import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
-import { sortByDependencies } from "@jsenv/utils/graph/sort_by_dependencies.js"
+import { createMagicSource } from "@jsenv/sourcemap"
+import { applyPostCss, postCssPluginUrlVisitor } from "@jsenv/ast"
+
+import { sortByDependencies } from "@jsenv/core/src/omega/url_graph/sort_by_dependencies.js"
 
 // Do not use until https://github.com/parcel-bundler/parcel-css/issues/181
 export const bundleCss = async ({ cssUrlInfos, context }) => {

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

@@ -4,8 +4,8 @@ import { URL_META } from "@jsenv/url-meta"
 import { isFileSystemPath } from "@jsenv/urls"
 import { createDetailedMessage } from "@jsenv/log"
 import { babelHelperNameFromUrl } from "@jsenv/babel-plugins"
-import { applyRollupPlugins } from "@jsenv/utils/js_ast/apply_rollup_plugins.js"
-import { sourcemapConverter } from "@jsenv/utils/sourcemap/sourcemap_converter.js"
+import { sourcemapConverter } from "@jsenv/sourcemap"
+
 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

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

package/src/plugins/file_urls/jsenv_plugin_file_urls.js

@@ -6,17 +6,16 @@ import {
   urlToFilename,
   ensurePathnameTrailingSlash,
 } from "@jsenv/urls"
-
 import {
   applyFileSystemMagicResolution,
   getExtensionsToTry,
 } from "@jsenv/node-esm-resolution"
-import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+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 [
@@ -61,7 +60,7 @@ export const jsenvPluginFileUrls = ({
         if (foundADirectory && directoryReferenceAllowed) {
           reference.data.foundADirectory = true
           const directoryFacadeUrl = urlObject.href
-          const directoryUrlRaw = preservesSymlink
+          const directoryUrlRaw = preserveSymlinks
             ? directoryFacadeUrl
             : resolveSymlink(directoryFacadeUrl)
           const directoryUrl = `${directoryUrlRaw}${search}${hash}`
@@ -82,7 +81,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/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
+    },
   }
 }