@jsenv/core 25.4.5 → 25.6.1

package/src/internal/building/build_stats.js

@@ -19,8 +19,9 @@ export const createBuildStats = ({
     projectFileSizes: projectFileSizeInfo.fileSizes,
     projectTotalFileSize: projectFileSizeInfo.totalSize,
     buildFileSizes: buildFileSizeInfo.fileSizes,
-    buildTotalFileSize: buildFileSizeInfo.totalSize,
+    buildFileTotalSize: buildFileSizeInfo.totalSize,
     buildSourcemapFileSizes: sourcemapFileSizeInfo.fileSizes,
+    buildSourcemapFileTotalSize: sourcemapFileSizeInfo.totalSize,
     buildDuration,
   }
 }

package/src/internal/building/es_to_system.js

@@ -0,0 +1,34 @@
+export const esToSystem = async ({ code, url, map }) => {
+  const { rollup } = await import("rollup")
+  const rollupBuild = await rollup({
+    input: url,
+    plugins: [
+      {
+        name: "es-to-system",
+        resolveId: (id) => {
+          if (id === url) {
+            return id
+          }
+          return { external: true }
+        },
+        load: (id) => {
+          if (id === url) {
+            return code
+          }
+          return null
+        },
+      },
+    ],
+  })
+  const { output } = await rollupBuild.generate({
+    format: "system",
+    sourcemap: true,
+  })
+  const firstChunk = output[0]
+  code = firstChunk.code
+  map = firstChunk.map
+  return {
+    code,
+    map,
+  }
+}

package/src/internal/building/import_references.js

@@ -4,7 +4,6 @@ export const visitImportReferences = async ({
   onReferenceWithImportAssertion,
 }) => {
   const { asyncWalk } = await import("estree-walker")
-
   await asyncWalk(ast, {
     enter: async (node, parent) => {
       if (isNewUrlImportMetaUrl(node)) {

package/src/internal/building/rollup_plugin_jsenv.js

@@ -1,4 +1,4 @@
-import { extname } from "node:path"
+import path from "node:path"
 import MagicString from "magic-string"
 import { composeTwoImportMaps, normalizeImportMap } from "@jsenv/importmap"
 import { isSpecifierForNodeCoreModule } from "@jsenv/importmap/src/isSpecifierForNodeCoreModule.js"
@@ -15,9 +15,11 @@ import {
   urlToBasename,
   urlToFilename,
   readFile,
+  urlToFileSystemPath,
 } from "@jsenv/filesystem"
 import { UNICODE } from "@jsenv/log"
 
+import { require } from "@jsenv/core/src/internal/require.js"
 import { convertJsonTextToJavascriptModule } from "@jsenv/core/src/internal/building/json_module.js"
 import { convertCssTextToJavascriptModule } from "@jsenv/core/src/internal/building/css_module.js"
 import { transformJs } from "@jsenv/core/src/internal/compiling/js-compilation-service/transformJs.js"
@@ -49,6 +51,7 @@ import {
 } from "./ressource_builder.js"
 import { createBuildUrlGenerator } from "./build_url_generator.js"
 import { visitImportReferences } from "./import_references.js"
+import { esToSystem } from "./es_to_system.js"
 import { createBuildStats } from "./build_stats.js"
 
 export const createRollupPlugins = async ({
@@ -66,13 +69,12 @@ export const createRollupPlugins = async ({
   externalImportSpecifiers,
   importPaths,
   preservedUrls,
-  workers,
-  serviceWorkers,
   serviceWorkerFinalizer,
-  classicWorkers,
-  classicServiceWorkers,
+
   format,
   systemJsUrl,
+  globals,
+  preservedDynamicImports,
 
   node,
   compileServer,
@@ -127,12 +129,15 @@ export const createRollupPlugins = async ({
   let buildStats = {}
   const buildStartMs = Date.now()
 
+  const serviceWorkerUrls = []
+  const classicServiceWorkerUrls = []
+
   let lastErrorMessage
   const storeLatestJsenvPluginError = (error) => {
     lastErrorMessage = error.message
   }
 
-  const extension = extname(entryPoints[Object.keys(entryPoints)[0]])
+  const extension = path.extname(entryPoints[Object.keys(entryPoints)[0]])
   const outputExtension = extension === ".html" ? ".js" : extension
 
   const entryPointUrls = {}
@@ -140,19 +145,6 @@ export const createRollupPlugins = async ({
     const url = resolveUrl(key, projectDirectoryUrl)
     entryPointUrls[url] = entryPoints[key]
   })
-  const workerUrls = workers.map((worker) =>
-    resolveUrl(worker, projectDirectoryUrl),
-  )
-  const serviceWorkerUrls = serviceWorkers.map((serviceWorker) =>
-    resolveUrl(serviceWorker, projectDirectoryUrl),
-  )
-  const classicWorkerUrls = classicWorkers.map((classicWorker) =>
-    resolveUrl(classicWorker, projectDirectoryUrl),
-  )
-  const classicServiceWorkerUrls = classicServiceWorkers.map(
-    (classicServiceWorker) =>
-      resolveUrl(classicServiceWorker, projectDirectoryUrl),
-  )
 
   let ressourceBuilder
   let importResolver
@@ -311,6 +303,123 @@ export const createRollupPlugins = async ({
       },
     })
   }
+  if (format === "global") {
+    const globalsForRollup = {}
+    Object.keys(globals).forEach((key) => {
+      if (key.startsWith("./")) {
+        const keyAsUrl = resolveUrl(key, projectDirectoryUrl)
+        const keyAsPath = urlToFileSystemPath(keyAsUrl)
+        globalsForRollup[keyAsPath] = globals[key]
+      } else {
+        globalsForRollup[key] = globals[key]
+      }
+    })
+    const ESIIFE = require("es-iife")
+    const globalNameFromChunkInfo = (chunkInfo) => {
+      const originalUrl = asOriginalUrl(chunkInfo.facadeModuleId)
+      const originalPath = urlToFileSystemPath(originalUrl)
+      const nameFromGlobals = globalsForRollup[originalPath]
+      return nameFromGlobals || path.parse(chunkInfo.fileName).name
+    }
+    const structuredMetaMap = normalizeStructuredMetaMap(
+      { preserved: preservedDynamicImports },
+      projectDirectoryUrl,
+    )
+    const isPreservedDynamicImport = (url) => {
+      const meta = urlToMeta({ url, structuredMetaMap })
+      return Boolean(meta.preserved)
+    }
+    rollupPlugins.push({
+      async transform(code, id) {
+        const serverUrl = asServerUrl(id)
+        const originalUrl = asOriginalUrl(id)
+        if (isPreservedDynamicImport(originalUrl)) {
+          return null
+        }
+        const jsRessource = ressourceBuilder.findRessource((ressource) => {
+          return ressource.url === serverUrl
+        })
+        if (!jsRessource || !jsRessource.isEntryPoint) {
+          return null
+        }
+        let map = null
+        const ast = this.parse(code, {
+          // used to know node line and column
+          locations: true,
+        })
+        let useDynamicImport = false
+        const { walk } = await import("estree-walker")
+        walk(ast, {
+          enter: (node) => {
+            if (node.type === "ImportExpression") {
+              useDynamicImport = true
+            }
+          },
+        })
+        if (!useDynamicImport) {
+          return null
+        }
+        const magicString = new MagicString(code)
+        magicString.prepend(`import "@jsenv/core/src/internal/runtime/s.js";`)
+        code = magicString.toString()
+        map = magicString.generateMap({ hires: true })
+        return { code, map }
+      },
+
+      outputOptions: (outputOptions) => {
+        outputOptions.globals = globalsForRollup
+        outputOptions.format = "esm"
+      },
+      resolveImportMeta: (property, { chunkId }) => {
+        if (property === "url") {
+          return `(document.currentScript && document.currentScript.src || new URL("${chunkId}", document.baseURI).href);`
+        }
+        return undefined
+      },
+      renderDynamicImport: ({ moduleId }) => {
+        const originalUrl = asOriginalUrl(moduleId)
+        if (isPreservedDynamicImport(originalUrl)) {
+          return null
+        }
+        return {
+          left: "System.import(",
+          right: ")",
+        }
+      },
+      async renderChunk(code, chunkInfo) {
+        const serverUrl = asServerUrl(chunkInfo.facadeModuleId)
+        const jsRessource = ressourceBuilder.findRessource(
+          (ressource) => ressource.url === serverUrl,
+        )
+        if (jsRessource.isEntryPoint) {
+          const name = globalNameFromChunkInfo(chunkInfo)
+          const out = ESIIFE.transform({
+            code,
+            parse: this.parse,
+            name,
+            sourcemap: true,
+            resolveGlobal: (specifier) => {
+              const url = resolveUrl(specifier, chunkInfo.facadeModuleId)
+              const globalName = urlToBasename(url)
+              return globalName
+            },
+            strict: true,
+          })
+          code = out.code
+          const map = out.map
+          return {
+            code,
+            map,
+          }
+        }
+        return esToSystem({
+          code,
+          url: serverUrl,
+          map: chunkInfo.map,
+        })
+      },
+    })
+  }
   if (minify) {
     const methodHooks = {
       minifyJs: async (...args) => {
@@ -322,7 +431,6 @@ export const createRollupPlugins = async ({
         return minifyHtml(...args)
       },
     }
-
     minifyJs = async ({ url, code, map, ...rest }) => {
       const result = await methodHooks.minifyJs({
         url,
@@ -336,11 +444,9 @@ export const createRollupPlugins = async ({
         map: result.map,
       }
     }
-
     minifyHtml = async (html) => {
       return methodHooks.minifyHtml(html, minifyHtmlOptions)
     }
-
     rollupPlugins.push({
       name: "jsenv_minifier",
       async renderChunk(code, chunk) {
@@ -354,7 +460,6 @@ export const createRollupPlugins = async ({
           module: format === "esmodule",
           ...(format === "global" ? { toplevel: false } : { toplevel: true }),
         })
-
         code = result.code
         map = result.map
         return {
@@ -685,19 +790,21 @@ export const createRollupPlugins = async ({
               const compiledFileUrl = asCompiledServerUrl(fileUrl)
               resolutionResult.url = compiledFileUrl
             }
-
-            if (workerUrls.includes(ressourceOriginalUrl)) {
+            const { searchParams } = new URL(ressourceUrl)
+            if (searchParams.has("module")) {
+              resolutionResult.isJsModule = true
+            } else if (searchParams.has("worker")) {
               resolutionResult.isWorker = true
               resolutionResult.isJsModule = true
-            } else if (serviceWorkerUrls.includes(ressourceOriginalUrl)) {
+            } else if (searchParams.has("service_worker")) {
               resolutionResult.isServiceWorker = true
               resolutionResult.isJsModule = true
-            } else if (classicWorkerUrls.includes(ressourceOriginalUrl)) {
+              serviceWorkerUrls.push(ressourceOriginalUrl)
+            } else if (searchParams.has("worker_type_classic")) {
               resolutionResult.isWorker = true
-            } else if (
-              classicServiceWorkerUrls.includes(ressourceOriginalUrl)
-            ) {
+            } else if (searchParams.has("service_worker_type_classic")) {
               resolutionResult.isServiceWorker = true
+              classicServiceWorkerUrls.push(ressourceOriginalUrl)
             }
             return resolutionResult
           },
@@ -927,6 +1034,9 @@ export const createRollupPlugins = async ({
           return ressource.rollupReferenceId === referenceId
         })
         ressource.buildRelativeUrlWithoutHash = fileName
+        if (ressource.isJsModule) {
+          return fileName
+        }
         const buildRelativeUrl = ressource.buildRelativeUrl
         return buildRelativeUrl
       }
@@ -1047,22 +1157,16 @@ export const createRollupPlugins = async ({
         onReferenceWithImportMetaUrlPattern: async ({ importNode }) => {
           const specifier = importNode.arguments[0].value
           const { line, column } = importNode.loc.start
-
           const { id } = normalizeRollupResolveReturnValue(
             await this.resolve(specifier, url),
           )
           const ressourceUrl = asServerUrl(id)
-          const originalUrl = asOriginalUrl(ressourceUrl)
-          const isJsModule = Boolean(
-            workerUrls[originalUrl] || serviceWorkerUrls[originalUrl],
-          )
           const reference = ressourceBuilder.createReferenceFoundInJsModule({
             referenceLabel: "URL + import.meta.url",
             jsUrl: url,
             jsLine: line,
             jsColumn: column,
             ressourceSpecifier: ressourceUrl,
-            isJsModule,
           })
           if (!reference) {
             return
@@ -1363,7 +1467,6 @@ export const createRollupPlugins = async ({
         }
         return sourceUrl
       }
-
       return outputOptions
     },
 
@@ -1373,9 +1476,12 @@ export const createRollupPlugins = async ({
         // happens for inline module scripts for instance
         return null
       }
-
       const url = asOriginalUrl(facadeModuleId)
-      if (workerUrls.includes(url) || serviceWorkerUrls.includes(url)) {
+      const { searchParams } = new URL(url)
+      if (
+        format === "systemjs" &&
+        (searchParams.has("worker") || searchParams.has("service_worker"))
+      ) {
         const magicString = new MagicString(code)
         const systemjsCode = await readFile(
           new URL("../runtime/s.js", import.meta.url),
@@ -1388,7 +1494,6 @@ export const createRollupPlugins = async ({
           map,
         }
       }
-
       return null
     },
 
@@ -1609,9 +1714,9 @@ export const createRollupPlugins = async ({
       buildMappings = sortObjectByPathnames(buildMappings)
       await visitServiceWorkers({
         projectDirectoryUrl,
+        serviceWorkerFinalizer,
         serviceWorkerUrls,
         classicServiceWorkerUrls,
-        serviceWorkerFinalizer,
         buildMappings,
         ressourceMappings,
         buildFileContents,
@@ -1831,7 +1936,6 @@ const visitServiceWorkers = async ({
     ...serviceWorkerUrls,
     ...classicServiceWorkerUrls,
   ]
-
   await Promise.all(
     allServiceWorkerUrls.map(async (serviceWorkerUrl) => {
       const serviceWorkerRelativeUrl = urlToRelativeUrl(
@@ -1845,7 +1949,6 @@ const visitServiceWorkers = async ({
           `"${serviceWorkerRelativeUrl}" service worker file missing in the build`,
         )
       }
-
       if (serviceWorkerFinalizer) {
         let code = buildFileContents[serviceWorkerBuildRelativeUrl]
         code = await serviceWorkerFinalizer(code, {

package/src/internal/compiling/createCompiledFileService.js

@@ -41,8 +41,6 @@ export const createCompiledFileService = ({
   topLevelAwait,
   prependSystemJs,
   customCompilers,
-  workerUrls,
-  serviceWorkerUrls,
 
   jsenvEventSourceClientInjection,
   jsenvToolbarInjection,
@@ -167,8 +165,6 @@ export const createCompiledFileService = ({
             babelPluginMap,
             compileProfile,
           }),
-          workerUrls,
-          serviceWorkerUrls,
           topLevelAwait,
           prependSystemJs,
 

package/src/internal/compiling/jsenvCompilerForJavaScript.js

@@ -11,8 +11,6 @@ export const compileJavascript = async ({
 
   compileProfile,
   babelPluginMap,
-  workerUrls,
-  serviceWorkerUrls,
   topLevelAwait,
   prependSystemJs,
 
@@ -22,8 +20,9 @@ export const compileJavascript = async ({
   sourcemapMethod,
 }) => {
   if (prependSystemJs === undefined) {
+    const { searchParams } = new URL(url)
     prependSystemJs =
-      workerUrls.includes(url) || serviceWorkerUrls.includes(url)
+      searchParams.has("worker") || searchParams.has("service_worker")
   }
   const transformResult = await transformJs({
     projectDirectoryUrl,

package/src/internal/compiling/jsenv_directory/compile_context.js

@@ -7,15 +7,10 @@ import {
 } from "@jsenv/core/dist/build_manifest.js"
 import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
 
-import {
-  sameValuesInTwoArrays,
-  sameValueInTwoObjects,
-} from "./comparison_utils.js"
+import { sameValueInTwoObjects } from "./comparison_utils.js"
 
 const COMPARERS = {
   preservedUrls: sameValueInTwoObjects,
-  workers: sameValuesInTwoArrays,
-  serviceWorkers: sameValuesInTwoArrays,
   replaceProcessEnvNodeEnv: (a, b) => a === b,
   inlineImportMapIntoHTML: (a, b) => a === b,
 
@@ -36,15 +31,11 @@ export const compareCompileContexts = (
 
 export const createCompileContext = async ({
   preservedUrls,
-  workers,
-  serviceWorkers,
   replaceProcessEnvNodeEnv,
   inlineImportMapIntoHTML,
 }) => {
   return {
     preservedUrls,
-    workers,
-    serviceWorkers,
     replaceProcessEnvNodeEnv,
     inlineImportMapIntoHTML,
 

package/src/internal/compiling/jsenv_directory/compile_profile.js

@@ -18,7 +18,6 @@ export const createCompileProfile = ({
   preservedUrls,
   customCompilers,
   babelPluginMapWithoutSyntax,
-  workerUrls,
   importMapInWebWorkers,
   moduleOutFormat,
   sourcemapMethod,
@@ -65,7 +64,7 @@ export const createCompileProfile = ({
       import_assertion_type_css: true,
     })
   }
-  if (env.browser && workerUrls.length > 0) {
+  if (env.browser) {
     features["worker_type_module"] = true
   }
   if (env.browser && importMapInWebWorkers) {

package/src/internal/compiling/jsenv_directory/jsenv_directory.js

@@ -84,7 +84,7 @@ export const setupJsenvDirectory = async ({
       const { runtimes } = compileDirectory
       if (!runtimes.includes(runtime)) {
         runtimes.push(runtime)
-        await writeMetaFile()
+        writeMetaFile()
       }
       return existingCompileId
     }

package/src/internal/compiling/startCompileServer.js

@@ -9,7 +9,6 @@ import {
   readRequestBody,
 } from "@jsenv/server"
 import {
-  resolveUrl,
   urlToRelativeUrl,
   resolveDirectoryUrl,
   urlIsInsideOf,
@@ -79,8 +78,6 @@ export const startCompileServer = async ({
   babelConfigFileUrl,
   customCompilers = {},
   preservedUrls,
-  workers = [],
-  serviceWorkers = [],
   importMapInWebWorkers = false,
   prependSystemJs,
 
@@ -127,12 +124,6 @@ export const startCompileServer = async ({
      */
     ...preservedUrls,
   }
-  const workerUrls = workers.map((worker) =>
-    resolveUrl(worker, projectDirectoryUrl),
-  )
-  const serviceWorkerUrls = serviceWorkers.map((serviceWorker) =>
-    resolveUrl(serviceWorker, projectDirectoryUrl),
-  )
   const babelPluginMapFromFile = await loadBabelPluginMapFromFile({
     projectDirectoryUrl,
     babelConfigFileUrl,
@@ -209,8 +200,6 @@ export const startCompileServer = async ({
   })
   const compileContext = await createCompileContext({
     preservedUrls,
-    workers,
-    serviceWorkers,
     replaceProcessEnvNodeEnv,
     inlineImportMapIntoHTML,
   })
@@ -252,7 +241,6 @@ export const startCompileServer = async ({
       customCompilers,
       babelPluginMapWithoutSyntax,
       preservedUrls,
-      workerUrls,
       importMapInWebWorkers,
       moduleOutFormat,
       sourcemapMethod,
@@ -343,8 +331,6 @@ export const startCompileServer = async ({
       topLevelAwait,
       babelPluginMap,
       customCompilers,
-      workerUrls,
-      serviceWorkerUrls,
       prependSystemJs,
       jsenvEventSourceClientInjection,
       jsenvToolbarInjection,

package/src/internal/dev_server/toolbar/compilation/compilation.css

@@ -17,6 +17,7 @@
 
 .browser_support_text[data-warning],
 .files_compilation_text[data-warning] {
-  background: orange;
-  color: black;
+  color: #cb5909;
+  margin-bottom: 5px;
+  display: block;
 }

package/src/internal/dev_server/toolbar/compilation/toolbar.compilation.js

@@ -1,4 +1,5 @@
 import { scanBrowserRuntimeFeatures } from "../../../features/browser_feature_detection/browser_feature_detection.js"
+import { setLinkHrefForParentWindow } from "../util/iframe_to_parent_href.js"
 import { removeForceHideElement } from "../util/dom.js"
 import { enableVariant } from "../variant/variant.js"
 import {
@@ -101,25 +102,24 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
           ".files_compilation_text",
         ).innerHTML = `Files shown are compiled for ${runtimeReport.name}@${runtimeReport.version}`
       }
-      filesCompilationRootNode.querySelector("a.link_to_source_files").onclick =
-        () => {
-          window.parent.location.href = `/${compileGroup.fileRelativeUrl}`
-        }
-      filesCompilationRootNode.querySelector(
-        "a.link_to_compiled_files",
-      ).onclick = () => {
-        window.parent.location.href = `/${jsenvDirectoryRelativeUrl}${expectedCompiledId}/${compileGroup.fileRelativeUrl}`
-      }
-      filesCompilationRootNode.querySelector(
-        "a.link_to_compilation_forced_files",
-      ).onclick = () => {
-        window.parent.location.href = `/${jsenvDirectoryRelativeUrl}force/${compileGroup.fileRelativeUrl}`
-      }
-      filesCompilationRootNode.querySelector(
-        "a.link_to_appropriate_files",
-      ).onclick = () => {
-        window.parent.location.href = `/${jsenvDirectoryRelativeUrl}${expectedCompiledId}/${compileGroup.fileRelativeUrl}`
-      }
+      setLinkHrefForParentWindow(
+        filesCompilationRootNode.querySelector("a.link_to_source_files"),
+        `/${compileGroup.fileRelativeUrl}`,
+      )
+      setLinkHrefForParentWindow(
+        filesCompilationRootNode.querySelector("a.link_to_compiled_files"),
+        `/${jsenvDirectoryRelativeUrl}${expectedCompiledId}/${compileGroup.fileRelativeUrl}`,
+      )
+      setLinkHrefForParentWindow(
+        filesCompilationRootNode.querySelector(
+          "a.link_to_compilation_forced_files",
+        ),
+        `/${jsenvDirectoryRelativeUrl}force/${compileGroup.fileRelativeUrl}`,
+      )
+      setLinkHrefForParentWindow(
+        filesCompilationRootNode.querySelector("a.link_to_appropriate_files"),
+        `/${jsenvDirectoryRelativeUrl}${expectedCompiledId}/${compileGroup.fileRelativeUrl}`,
+      )
 
       if (hasWarning) {
         enableWarningStyle()