@jsenv/core 27.0.0-alpha.11 → 27.0.0-alpha.14

package/src/{build/plugins/bundle_js_module/jsenv_plugin_bundle_js_module.js → plugins/bundling/js_module/bundle_js_module.js}

@@ -1,43 +1,32 @@
-import { isFileSystemPath, urlToRelativeUrl } from "@jsenv/filesystem"
+import { isFileSystemPath } from "@jsenv/filesystem"
+import { createDetailedMessage } from "@jsenv/logger"
 
 import { applyRollupPlugins } from "@jsenv/utils/js_ast/apply_rollup_plugins.js"
 import { sourcemapConverter } from "@jsenv/utils/sourcemap/sourcemap_converter.js"
 import { fileUrlConverter } from "@jsenv/core/src/omega/file_url_converter.js"
 
-export const jsenvPluginBundleJsModule = () => {
-  return {
-    name: "jsenv:bundle_js_module",
-    appliesDuring: {
-      build: true,
-    },
-    bundle: {
-      js_module: async (
-        jsModuleUrlInfos,
-        {
-          signal,
-          logger,
-          rootDirectoryUrl,
-          buildDirectoryUrl,
-          urlGraph,
-          runtimeSupport,
-          sourcemaps,
-        },
-      ) => {
-        const { jsModuleBundleUrlInfos } = await buildWithRollup({
-          signal,
-          logger,
-          rootDirectoryUrl,
-          buildDirectoryUrl,
-          urlGraph,
-          jsModuleUrlInfos,
+export const bundleJsModule = async ({ jsModuleUrlInfos, context }) => {
+  const {
+    signal,
+    logger,
+    rootDirectoryUrl,
+    buildDirectoryUrl,
+    urlGraph,
+    runtimeCompat,
+    sourcemaps,
+  } = context
+  const { jsModuleBundleUrlInfos } = await buildWithRollup({
+    signal,
+    logger,
+    rootDirectoryUrl,
+    buildDirectoryUrl,
+    urlGraph,
+    jsModuleUrlInfos,
 
-          runtimeSupport,
-          sourcemaps,
-        })
-        return jsModuleBundleUrlInfos
-      },
-    },
-  }
+    runtimeCompat,
+    sourcemaps,
+  })
+  return jsModuleBundleUrlInfos
 }
 
 export const buildWithRollup = async ({
@@ -48,36 +37,46 @@ export const buildWithRollup = async ({
   urlGraph,
   jsModuleUrlInfos,
 
-  runtimeSupport,
+  runtimeCompat,
   sourcemaps,
 }) => {
   const resultRef = { current: null }
-  await applyRollupPlugins({
-    rollupPlugins: [
-      rollupPluginJsenv({
-        signal,
-        logger,
-        rootDirectoryUrl,
-        buildDirectoryUrl,
-        urlGraph,
-        jsModuleUrlInfos,
+  try {
+    await applyRollupPlugins({
+      rollupPlugins: [
+        rollupPluginJsenv({
+          signal,
+          logger,
+          rootDirectoryUrl,
+          buildDirectoryUrl,
+          urlGraph,
+          jsModuleUrlInfos,
 
-        runtimeSupport,
-        sourcemaps,
-        resultRef,
-      }),
-    ],
-    inputOptions: {
-      input: [],
-      onwarn: (warning) => {
-        if (warning.code === "CIRCULAR_DEPENDENCY") {
-          return
-        }
-        logger.warn(String(warning))
+          runtimeCompat,
+          sourcemaps,
+          resultRef,
+        }),
+      ],
+      inputOptions: {
+        input: [],
+        onwarn: (warning) => {
+          if (warning.code === "CIRCULAR_DEPENDENCY") {
+            return
+          }
+          logger.warn(String(warning))
+        },
       },
-    },
-  })
-  return resultRef.current
+    })
+    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 = ({
@@ -119,6 +118,7 @@ const rollupPluginJsenv = ({
           implicitlyLoadedAfterOneOf: previousNonEntryPointModuleId
             ? [previousNonEntryPointModuleId]
             : null,
+          preserveSignature: "allow-extension",
         })
         previousNonEntryPointModuleId = id
       })
@@ -135,8 +135,12 @@ const rollupPluginJsenv = ({
             // buildRelativeUrl: rollupFileInfo.fileName,
             data: {
               generatedBy: "rollup",
+              usesImport:
+                rollupFileInfo.imports.length > 0 ||
+                rollupFileInfo.dynamicImports.length > 0,
+              usesExport: rollupFileInfo.exports.length > 0,
             },
-            contentType: "application/javascript",
+            contentType: "text/javascript",
             content: rollupFileInfo.code,
             sourcemap: rollupFileInfo.map,
           }
@@ -144,7 +148,7 @@ const rollupPluginJsenv = ({
           if (rollupFileInfo.facadeModuleId) {
             url = fileUrlConverter.asFileUrl(rollupFileInfo.facadeModuleId)
           } else {
-            url = new URL(rollupFileInfo.fileName, rootDirectoryUrl).href
+            url = new URL(rollupFileInfo.fileName, buildDirectoryUrl).href
           }
           jsModuleBundleUrlInfos[url] = jsModuleBundleUrlInfo
         }
@@ -167,19 +171,12 @@ const rollupPluginJsenv = ({
           return `[name].js`
         },
         chunkFileNames: (chunkInfo) => {
-          // preserves relative path parts:
-          // the goal is to maintain the original relative path (relative to the root directory)
-          // so that later in the build process, when resolving these urls, we are able to
-          // re-resolve the specifier againt the original parent url and find the original url
-          if (chunkInfo.facadeModuleId) {
-            const fileUrl = fileUrlConverter.asFileUrl(chunkInfo.facadeModuleId)
-            const relativePath = urlToRelativeUrl(fileUrl, rootDirectoryUrl)
-            return relativePath
-          }
-          // chunk generated dynamically by rollup to share code.
-          // we prefix with "__rollup__/" to avoid potential conflict of filename
-          // between this one and a file with the same name existing in the root directory
-          return `__rollup__/${chunkInfo.name}.js`
+          const insideJs = willBeInsideJsDirectory({
+            chunkInfo,
+            fileUrlConverter,
+            jsModuleUrlInfos,
+          })
+          return insideJs ? `js/${chunkInfo.name}.js` : `${chunkInfo.name}.js`
         },
         // https://rollupjs.org/guide/en/#outputpaths
         // paths: (id) => {
@@ -197,7 +194,7 @@ const rollupPluginJsenv = ({
         urlImporters[url] = importer
       }
       if (!url.startsWith("file:")) {
-        return { url, external: true }
+        return { id: url, external: true }
       }
       const filePath = fileUrlConverter.asFilePath(url)
       return filePath
@@ -225,3 +222,31 @@ const rollupPluginJsenv = ({
     },
   }
 }
+
+const willBeInsideJsDirectory = ({
+  chunkInfo,
+  fileUrlConverter,
+  jsModuleUrlInfos,
+}) => {
+  // if the chunk is generated dynamically by rollup
+  // for an entry point jsenv will put that file inside js/ directory
+  // if it's generated dynamically for a file already in js/ directory
+  // both will be inside the js/ directory
+  if (!chunkInfo.facadeModuleId) {
+    // generated by rollup
+    return true
+  }
+  const url = fileUrlConverter.asFileUrl(chunkInfo.facadeModuleId)
+  const jsModuleUrlInfo = jsModuleUrlInfos.find(
+    (jsModuleUrlInfo) => jsModuleUrlInfo.url === url,
+  )
+  if (!jsModuleUrlInfo) {
+    // generated by rollup
+    return true
+  }
+  if (!jsModuleUrlInfo.data.isEntryPoint) {
+    // not an entry point, jsenv will put it inside js/ directory
+    return true
+  }
+  return false
+}

package/src/plugins/bundling/jsenv_plugin_bundling.js

@@ -0,0 +1,51 @@
+import { bundleCss } from "./css/bundle_css.js"
+import { bundleJsClassicWorkers } from "./js_classic_workers/bundle_js_classic_workers.js"
+import { bundleJsModule } from "./js_module/bundle_js_module.js"
+
+export const jsenvPluginBundling = (bundling) => {
+  if (typeof bundling === "boolean") {
+    bundling = {
+      css: bundling,
+      js_classic_workers: bundling,
+      js_module: bundling,
+    }
+  } else if (typeof bundling !== "object") {
+    throw new Error(`bundling must be a boolean or an object, got ${bundling}`)
+  }
+  Object.keys(bundling).forEach((key) => {
+    if (bundling[key] === true) bundling[key] = {}
+  })
+
+  return {
+    name: "jsenv:bundling",
+    appliesDuring: {
+      build: true,
+    },
+    bundle: {
+      css: bundling.css
+        ? (cssUrlInfos, context) =>
+            bundleCss({
+              cssUrlInfos,
+              context,
+              options: bundling.css,
+            })
+        : undefined,
+      js_classic: bundling.js_classic
+        ? (jsClassicUrlInfos, context) =>
+            bundleJsClassicWorkers({
+              jsClassicUrlInfos,
+              context,
+              options: bundling.js_classic_workers,
+            })
+        : undefined,
+      js_module: bundling.js_module
+        ? (jsModuleUrlInfos, context) =>
+            bundleJsModule({
+              jsModuleUrlInfos,
+              context,
+              options: bundling.js_module,
+            })
+        : undefined,
+    },
+  }
+}

package/src/{omega/core_plugins → plugins}/commonjs_globals/jsenv_plugin_commonjs_globals.js

@@ -11,50 +11,57 @@ import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
 
 export const jsenvPluginCommonJsGlobals = () => {
+  const transformCommonJsGlobals = async (urlInfo, { scenario }) => {
+    const isJsModule = urlInfo.type === "js_module"
+
+    const replaceMap = {
+      "process.env.NODE_ENV": `("${
+        scenario === "dev" || scenario === "test" ? "dev" : "prod"
+      }")`,
+      "global": "globalThis",
+      "__filename": isJsModule
+        ? `import.meta.url.slice('file:///'.length)`
+        : `document.currentScript.src`,
+      "__dirname": isJsModule
+        ? `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`
+        : `new URL('./', document.currentScript.src).href`,
+    }
+    const { metadata } = await applyBabelPlugins({
+      babelPlugins: [
+        [
+          babelPluginMetadataExpressionPaths,
+          {
+            replaceMap,
+            allowConflictingReplacements: true,
+          },
+        ],
+      ],
+      urlInfo,
+    })
+    const { expressionPaths } = metadata
+    const keys = Object.keys(expressionPaths)
+    if (keys.length === 0) {
+      return null
+    }
+    const magicSource = createMagicSource(urlInfo.content)
+    keys.forEach((key) => {
+      expressionPaths[key].forEach((path) => {
+        magicSource.replace({
+          start: path.node.start,
+          end: path.node.end,
+          replacement: replaceMap[key],
+        })
+      })
+    })
+    return magicSource.toContentAndSourcemap()
+  }
+
   return {
     name: "jsenv:commonjs_globals",
     appliesDuring: "*",
-    transform: {
-      js_module: async ({ url, generatedUrl, content }, { scenario }) => {
-        const replaceMap = {
-          "process.env.NODE_ENV": `("${
-            scenario === "dev" || scenario === "test" ? "dev" : "prod"
-          }")`,
-          "global": "globalThis",
-          "__filename": `import.meta.url.slice('file:///'.length)`,
-          "__dirname": `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`,
-        }
-        const { metadata } = await applyBabelPlugins({
-          babelPlugins: [
-            [
-              babelPluginMetadataExpressionPaths,
-              {
-                replaceMap,
-                allowConflictingReplacements: true,
-              },
-            ],
-          ],
-          url,
-          generatedUrl,
-          content,
-        })
-        const { expressionPaths } = metadata
-        const keys = Object.keys(expressionPaths)
-        if (keys.length === 0) {
-          return null
-        }
-        const magicSource = createMagicSource(content)
-        keys.forEach((key) => {
-          expressionPaths[key].forEach((path) => {
-            magicSource.replace({
-              start: path.node.start,
-              end: path.node.end,
-              replacement: replaceMap[key],
-            })
-          })
-        })
-        return magicSource.toContentAndSourcemap()
-      },
+    transformUrlContent: {
+      js_classic: transformCommonJsGlobals,
+      js_module: transformCommonJsGlobals,
     },
   }
 }

package/src/plugins/file_urls/jsenv_plugin_file_urls.js

@@ -0,0 +1,66 @@
+import { readFileSync } from "node:fs"
+import { urlIsInsideOf, urlToRelativeUrl } from "@jsenv/filesystem"
+
+import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+
+export const jsenvPluginFileUrls = () => {
+  return [jsenvPluginResolveAbsoluteFileUrls(), jsenvPluginFetchFileUrls()]
+}
+
+const jsenvPluginResolveAbsoluteFileUrls = () => {
+  return {
+    name: "jsenv:resolve_absolute_file_urls",
+    appliesDuring: {
+      // during dev and test it's a browser running the code
+      // so absolute file urls needs to be relativized
+      dev: true,
+      test: true,
+      // during build it's fine to use file:// urls
+      build: false,
+    },
+    resolveUrl: (reference) => {
+      if (!reference.specifier.startsWith("/@fs/")) {
+        return null
+      }
+      const fsRootRelativeUrl = reference.specifier.slice("/@fs/".length)
+      return `file:///${fsRootRelativeUrl}`
+    },
+    formatUrl: (reference, context) => {
+      if (!reference.generatedUrl.startsWith("file:")) {
+        return null
+      }
+      if (urlIsInsideOf(reference.generatedUrl, context.rootDirectoryUrl)) {
+        return `/${urlToRelativeUrl(
+          reference.generatedUrl,
+          context.rootDirectoryUrl,
+        )}`
+      }
+      return `/@fs/${reference.generatedUrl.slice("file:///".length)}`
+    },
+  }
+}
+
+const jsenvPluginFetchFileUrls = () => {
+  return {
+    name: "jsenv:fetch_file_urls",
+    appliesDuring: "*",
+    fetchUrlContent: (urlInfo) => {
+      if (!urlInfo.url.startsWith("file:")) {
+        return null
+      }
+      const urlObject = new URL(urlInfo.url)
+      const fileBuffer = readFileSync(urlObject)
+      const contentType = CONTENT_TYPE.fromUrlExtension(urlInfo.url)
+      if (CONTENT_TYPE.isTextual(contentType)) {
+        return {
+          contentType,
+          content: String(fileBuffer),
+        }
+      }
+      return {
+        contentType,
+        content: fileBuffer,
+      }
+    },
+  }
+}

package/src/{omega/core_plugins → plugins}/filesystem_magic/jsenv_plugin_filesystem_magic.js

@@ -13,12 +13,12 @@ export const jsenvPluginFileSystemMagic = ({
   return {
     name: "jsenv:filesystem_magic",
     appliesDuring: "*",
-    normalize: ({ parentUrl, url }) => {
+    normalizeUrl: (reference) => {
       // http, https, data, about, etc
-      if (!url.startsWith("file:")) {
+      if (!reference.url.startsWith("file:")) {
         return null
       }
-      const urlObject = new URL(url)
+      const urlObject = new URL(reference.url)
       const { search, hash } = urlObject
       urlObject.search = ""
       urlObject.hash = ""
@@ -26,7 +26,10 @@ export const jsenvPluginFileSystemMagic = ({
         urlObject.href,
         {
           magicDirectoryIndex,
-          magicExtensions: getExtensionsToTry(magicExtensions, parentUrl),
+          magicExtensions: getExtensionsToTry(
+            magicExtensions,
+            reference.parentUrl,
+          ),
         },
       )
       if (!filesystemResolution.found) {

package/src/{omega/core_plugins → plugins}/html_supervisor/client/html_supervisor_installer.js

@@ -89,7 +89,6 @@ export const installHtmlSupervisor = ({ logs, measurePerf }) => {
         onExecutionSettled(src, executionResult)
         if (logs) {
           console.log(`${type} load ended`)
-
           console.groupEnd()
         }
       },
@@ -120,7 +119,9 @@ export const installHtmlSupervisor = ({ logs, measurePerf }) => {
             console.error(error)
           }
         }
-        console.groupEnd()
+        if (logs) {
+          console.groupEnd()
+        }
       },
     )
   }

package/src/{omega/core_plugins → plugins}/html_supervisor/jsenv_plugin_html_supervisor.js

@@ -2,27 +2,21 @@
  * 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,
+  removeHtmlNodeText,
+  setHtmlNodeGeneratedText,
 } from "@jsenv/utils/html_ast/html_ast.js"
 import { generateInlineContentUrl } from "@jsenv/utils/urls/inline_content_url_generator.js"
 
@@ -45,7 +39,7 @@ export const jsenvPluginHtmlSupervisor = ({
       dev: true,
       test: true,
     },
-    transform: {
+    transformUrlContent: {
       html: ({ url, content }, { referenceUtils }) => {
         const htmlAst = parseHtmlString(content)
         const scriptsToSupervise = []
@@ -64,27 +58,22 @@ export const jsenvPluginHtmlSupervisor = ({
             lineEnd,
             columnEnd,
           })
-          if (scriptCategory === "classic") {
-            inlineScriptUrl = injectQueryParams(inlineScriptUrl, {
-              js_classic: "",
-            })
-          }
           const [inlineScriptReference] = referenceUtils.foundInline({
             type: "script_src",
+            expectedType: { classic: "js_classic", module: "js_module" }[
+              scriptCategory
+            ],
             line: line - 1,
             column,
-            isOriginal,
+            isOriginalPosition: isOriginal,
             specifier: inlineScriptUrl,
-            contentType: "application/javascript",
+            contentType: "text/javascript",
             content: textNode.value,
           })
-          assignHtmlNodeAttributes(node, {
-            "src": inlineScriptReference.generatedSpecifier,
-            "src-generated-from-inline-content": "",
-          })
           removeHtmlNodeText(node)
           scriptsToSupervise.push({
             node,
+            isInline: true,
             type: scriptCategory,
             src: inlineScriptReference.generatedSpecifier,
           })
@@ -105,6 +94,7 @@ export const jsenvPluginHtmlSupervisor = ({
           const crossorigin = crossoriginAttribute
             ? crossoriginAttribute.value
             : undefined
+          removeHtmlNodeAttributeByName(node, "src")
           scriptsToSupervise.push({
             node,
             type: scriptCategory,
@@ -151,6 +141,7 @@ export const jsenvPluginHtmlSupervisor = ({
         }
         const [htmlSupervisorInstallerFileReference] = referenceUtils.inject({
           type: "js_import_export",
+          expectedType: "js_module",
           specifier: htmlSupervisorInstallerFileUrl,
         })
         injectScriptAsEarlyAsPossible(
@@ -159,25 +150,24 @@ export const jsenvPluginHtmlSupervisor = ({
             "tagName": "script",
             "type": "module",
             "textContent": `
-import { installHtmlSupervisor } from ${
-              htmlSupervisorInstallerFileReference.generatedSpecifier
-            }
-installHtmlSupervisor(${JSON.stringify(
-              {
-                logs,
-                measurePerf,
-              },
-              null,
-              "  ",
-            )})`,
+      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: "",
-          }),
+          expectedType: "js_classic",
+          specifier: htmlSupervisorSetupFileUrl,
         })
         injectScriptAsEarlyAsPossible(
           htmlAst,
@@ -188,14 +178,9 @@ installHtmlSupervisor(${JSON.stringify(
           }),
         )
         scriptsToSupervise.forEach(
-          ({ node, type, src, integrity, crossorigin }) => {
-            removeHtmlNodeAttributeByName(node, "src")
-            assignHtmlNodeAttributes(node, {
-              "content-src": src,
-            })
-            setHtmlNodeText(
-              node,
-              generateCodeToSuperviseScript({
+          ({ node, isInline, type, src, integrity, crossorigin }) => {
+            setHtmlNodeGeneratedText(node, {
+              generatedText: generateCodeToSuperviseScript({
                 type,
                 src,
                 integrity,
@@ -203,7 +188,10 @@ installHtmlSupervisor(${JSON.stringify(
                 htmlSupervisorInstallerSpecifier:
                   htmlSupervisorInstallerFileReference.generatedSpecifier,
               }),
-            )
+              generatedBy: "jsenv:html_supervisor",
+              generatedFromSrc: src,
+              generatedFromInlineContent: isInline,
+            })
           },
         )
         const htmlModified = stringifyHtmlAst(htmlAst)
@@ -226,8 +214,12 @@ const generateCodeToSuperviseScript = ({
 }) => {
   const paramsAsJson = JSON.stringify({ src, integrity, crossorigin })
   if (type === "module") {
-    return `import { superviseScriptTypeModule } from ${htmlSupervisorInstallerSpecifier}
-superviseScriptTypeModule(${paramsAsJson})`
+    return `
+      import { superviseScriptTypeModule } from ${htmlSupervisorInstallerSpecifier}
+      superviseScriptTypeModule(${paramsAsJson})
+`
   }
-  return `window.__html_supervisor__.superviseScript(${paramsAsJson})`
+  return `
+      window.__html_supervisor__.superviseScript(${paramsAsJson})
+`
 }