@jsenv/core 25.3.0 → 25.4.3

package/src/internal/browser_runtime/createBrowserRuntime.js

@@ -3,7 +3,7 @@
 import { normalizeImportMap } from "@jsenv/importmap/src/normalizeImportMap.js"
 
 // do not use memoize from @jsenv/filesystem to avoid pulling @jsenv/filesystem code into the browser build
-import { fetchUrl } from "../browser_utils/fetch-browser.js"
+import { fetchUrl } from "../browser_utils/fetch_browser.js"
 import { createImportResolverForImportmap } from "../import-resolution/import-resolver-importmap.js"
 import { memoize } from "../memoize.js"
 import { measureAsyncFnPerf } from "../perf_browser.js"
@@ -15,7 +15,7 @@ const memoizedCreateBrowserSystem = memoize(createBrowserSystem)
 
 export const createBrowserRuntime = async ({
   compileServerOrigin,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
   compileId,
 }) => {
   const fetchSource = (url, { contentTypeExpected }) => {
@@ -33,10 +33,11 @@ export const createBrowserRuntime = async ({
     return json
   }
 
-  const outDirectoryUrl = `${compileServerOrigin}/${outDirectoryRelativeUrl}`
-  const envUrl = String(new URL("env.json", outDirectoryUrl))
-  const { importDefaultExtension } = await fetchJson(envUrl)
-  const compileDirectoryRelativeUrl = `${outDirectoryRelativeUrl}${compileId}/`
+  const compileServerMetaUrl = String(
+    new URL("__jsenv_compile_profile__", `${compileServerOrigin}/`),
+  )
+  const { importDefaultExtension } = await fetchJson(compileServerMetaUrl)
+  const compileDirectoryRelativeUrl = `${jsenvDirectoryRelativeUrl}${compileId}/`
   // if there is an importmap in the document we use it instead of fetching.
   // systemjs style with systemjs-importmap
   const importmapScript = document.querySelector(

package/src/internal/browser_utils/fetchAndEvalUsingFetch.js

@@ -2,7 +2,7 @@
 
 import { createDetailedMessage } from "@jsenv/logger"
 
-import { fetchUrl } from "./fetch-browser.js"
+import { fetchUrl } from "./fetch_browser.js"
 
 export const fetchAndEvalUsingFetch = async (url) => {
   const response = await fetchUrl(url)

package/src/internal/browser_utils/fetchJson.js

@@ -1,4 +1,4 @@
-import { fetchUrl } from "./fetch-browser.js"
+import { fetchUrl } from "./fetch_browser.js"
 
 export const fetchJson = async (url, options = {}) => {
   const response = await fetchUrl(url, options)

package/src/internal/browser_utils/{fetch-browser.js → fetch_browser.js}

@@ -1,5 +1,3 @@
-/* eslint-env browser */
-
 import { fetchUsingXHR } from "./fetchUsingXHR.js"
 
 const fetchNative = async (url, { mode = "cors", ...options } = {}) => {

package/src/internal/building/buildUsingRollup.js

@@ -9,82 +9,60 @@ import {
 import { createDetailedMessage } from "@jsenv/logger"
 
 import { humanizeUrl } from "@jsenv/core/src/internal/building/url_trace.js"
-import {
-  isNodePartOfSupportedRuntimes,
-  isBrowserPartOfSupportedRuntimes,
-} from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
-import { createRuntimeCompat } from "@jsenv/core/src/internal/generateGroupMap/runtime_compat.js"
+
 import { createRollupPlugins } from "./rollup_plugin_jsenv.js"
 
 export const buildUsingRollup = async ({
   buildOperation,
   logger,
 
-  projectDirectoryUrl,
   entryPoints,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  jsenvDirectoryRelativeUrl,
+  projectDirectoryUrl,
   buildDirectoryUrl,
   buildDirectoryClean,
-  assetManifestFile = false,
+  assetManifestFile,
   assetManifestFileRelativeUrl,
-  sourcemapExcludeSources,
-  writeOnFileSystem,
-
-  format,
-  systemJsUrl,
-  globalName,
-  globals,
-  babelPluginMap,
-  runtimeSupport,
 
   urlMappings,
   importResolutionMethod,
   importMapFileRelativeUrl,
   importDefaultExtension,
   externalImportSpecifiers,
-  importPaths,
   preservedUrls,
+  importPaths,
+
+  format,
+  systemJsUrl,
+  globalName,
+  globals,
   workers,
   serviceWorkers,
   serviceWorkerFinalizer,
   classicWorkers,
   classicServiceWorkers,
 
+  node,
+  browser,
+  compileServer,
+  compileProfile,
+  compileId,
+
   urlVersioning,
   lineBreakNormalization,
-  jsConcatenation,
-  cssConcatenation,
   useImportMapToMaximizeCacheReuse,
   preserveEntrySignatures,
   treeshake,
+  jsConcatenation,
+  cssConcatenation,
 
   minify,
+  minifyHtmlOptions,
   minifyJsOptions,
   minifyCssOptions,
-  minifyHtmlOptions,
-}) => {
-  const node = isNodePartOfSupportedRuntimes(runtimeSupport)
-  const browser = isBrowserPartOfSupportedRuntimes(runtimeSupport)
-
-  const runtimeCompatMap = createRuntimeCompat({
-    runtimeSupport,
-    featureNames: ["import_assertion_type_json", "import_assertion_type_css"],
-  })
-  const importAssertionsSupport = {
-    json:
-      format === "esmodule" &&
-      !runtimeCompatMap.missingFeatureNames.includes(
-        "import_assertion_type_json",
-      ),
-    css:
-      format === "esmodule" &&
-      !runtimeCompatMap.missingFeatureNames.includes(
-        "import_assertion_type_json",
-      ),
-  }
 
+  writeOnFileSystem,
+  sourcemapExcludeSources,
+}) => {
   const {
     rollupPlugins,
     getLastErrorMessage,
@@ -97,18 +75,10 @@ export const buildUsingRollup = async ({
 
     projectDirectoryUrl,
     entryPoints,
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-    jsenvDirectoryRelativeUrl,
     buildDirectoryUrl,
 
     format,
     systemJsUrl,
-    babelPluginMap,
-    node,
-    browser,
-    importAssertionsSupport,
-
     urlMappings,
     importResolutionMethod,
     importMapFileRelativeUrl,
@@ -122,6 +92,12 @@ export const buildUsingRollup = async ({
     classicWorkers,
     classicServiceWorkers,
 
+    node,
+    browser,
+    compileServer,
+    compileProfile,
+    compileId,
+
     urlVersioning,
     lineBreakNormalization,
     jsConcatenation,
@@ -140,7 +116,7 @@ export const buildUsingRollup = async ({
       logger,
 
       rollupPlugins,
-      babelPluginMap,
+      compileProfile,
       format,
       globals,
       globalName,
@@ -246,7 +222,7 @@ const useRollup = async ({
   buildOperation,
   logger,
   rollupPlugins,
-  babelPluginMap,
+  compileProfile,
   format,
   globals,
   globalName,
@@ -319,10 +295,18 @@ const useRollup = async ({
     // experimentalTopLevelAwait: true,
     // https://rollupjs.org/guide/en/#outputgeneratedcode
     generatedCode: {
-      arrowFunctions: !babelPluginMap["transform-arrow-functions"],
-      constBindings: !babelPluginMap["transform-block-scoping"],
-      objectShorthand: !babelPluginMap["transform-shorthand-properties"],
-      reservedNamesAsProps: !babelPluginMap["transform-reserved-words"],
+      arrowFunctions:
+        compileProfile &&
+        !compileProfile.missingFeatures["transform-arrow-functions"],
+      constBindings:
+        compileProfile &&
+        !compileProfile.missingFeatures["transform-block-scoping"],
+      objectShorthand:
+        compileProfile &&
+        !compileProfile.missingFeatures["transform-shorthand-properties"],
+      reservedNamesAsProps:
+        compileProfile &&
+        !compileProfile.missingFeatures["transform-reserved-words"],
     },
     // https://rollupjs.org/guide/en#output-dir
     dir: urlToFileSystemPath(buildDirectoryUrl),

package/src/internal/building/rollup_plugin_jsenv.js

@@ -32,6 +32,7 @@ import { createImportResolverForImportmap } from "@jsenv/core/src/internal/impor
 import { getDefaultImportmap } from "@jsenv/core/src/internal/import-resolution/importmap_default.js"
 import { createJsenvRemoteDirectory } from "@jsenv/core/src/internal/jsenv_remote_directory.js"
 import { setUrlSearchParamsDescriptor } from "@jsenv/core/src/internal/url_utils.js"
+import { shakeBabelPluginMap } from "@jsenv/core/src/internal/compiling/jsenv_directory/compile_profile.js"
 
 import {
   formatBuildStartLog,
@@ -56,9 +57,6 @@ export const createRollupPlugins = async ({
 
   projectDirectoryUrl,
   entryPoints,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  jsenvDirectoryRelativeUrl,
   buildDirectoryUrl,
 
   urlMappings,
@@ -73,12 +71,13 @@ export const createRollupPlugins = async ({
   serviceWorkerFinalizer,
   classicWorkers,
   classicServiceWorkers,
-
   format,
   systemJsUrl,
-  babelPluginMap,
+
   node,
-  importAssertionsSupport,
+  compileServer,
+  compileProfile,
+  compileId,
 
   urlVersioning,
   lineBreakNormalization,
@@ -91,6 +90,29 @@ export const createRollupPlugins = async ({
   minifyCssOptions,
   minifyHtmlOptions,
 }) => {
+  const compileServerOrigin = compileServer.origin
+  // For now the compilation is forced during build because this plugin
+  // was coded assuming build always requires to be compiled.
+  // Ideally jsenv should also be able to build a project using source files
+  // and in that case compileProfile and compileId are null
+  // the babel plugin map is useless (we can just fetch the source file directly)
+  const jsenvDirectoryRelativeUrl = compileServer.jsenvDirectoryRelativeUrl
+  const compileDirectoryRelativeUrl = `${jsenvDirectoryRelativeUrl}${compileId}/`
+  const babelPluginMap = shakeBabelPluginMap({
+    babelPluginMap: compileServer.babelPluginMap,
+    compileProfile,
+  })
+  const importAssertionsSupport = {
+    json:
+      format === "esmodule" &&
+      compileProfile &&
+      !compileProfile.missingFeatures["import_assertion_type_json"],
+    css:
+      format === "esmodule" &&
+      compileProfile &&
+      !compileProfile.missingFeatures["import_assertion_type_css"],
+  }
+
   const jsenvRemoteDirectory = createJsenvRemoteDirectory({
     projectDirectoryUrl,
     jsenvDirectoryRelativeUrl,
@@ -433,7 +455,6 @@ export const createRollupPlugins = async ({
               asCompiledServerUrl(importMapInfoFromHtml.htmlUrl),
             )
             importMapUrl = applyUrlMappings(importMapUrl)
-
             if (!urlIsInsideOf(importMapUrl, compileDirectoryServerUrl)) {
               logger.warn(
                 formatImportmapOutsideCompileDirectory({
@@ -442,7 +463,6 @@ export const createRollupPlugins = async ({
                 }),
               )
             }
-
             fetchImportMap = () => {
               return fetchImportMapFromUrl(
                 importMapUrl,

package/src/internal/compiling/babel_parse_error.js

@@ -0,0 +1,9 @@
+export const createParseError = ({ message, cause, ...data }) => {
+  const parseError = new Error(message, { cause })
+  parseError.code = "PARSE_ERROR"
+  parseError.data = {
+    message,
+    ...data,
+  }
+  return parseError
+}

package/src/internal/{babel_plugin_transform_import_meta.js → compiling/babel_plugin_transform_import_meta.js}

@@ -4,56 +4,75 @@
 
 import { require } from "@jsenv/core/src/internal/require.js"
 
-export const babelPluginTransformImportMeta = (api, pluginOptions) => {
+import { createParseError } from "./babel_parse_error.js"
+
+export const babelPluginTransformImportMeta = (api, { importMetaFormat }) => {
   const {
     addNamespace,
     addDefault,
     addNamed,
   } = require("@babel/helper-module-imports")
-  const { parseExpression } = require("@babel/parser")
-
-  const { replaceImportMeta } = pluginOptions
-
   let babelState
   const jsValueToAst = (jsValue) => {
-    const valueAst = parseExpression(jsValue, babelState.opts)
+    const { parseExpression } = require("@babel/parser")
+    const valueAst = parseExpression(jsValue, babelState.parserOpts)
     return valueAst
   }
+  const visitImportMetaProperty = ({
+    importMetaPropertyName,
+    replaceWithImport,
+    replaceWithValue,
+  }) => {
+    if (importMetaFormat === "esmodule") {
+      // keep native version
+      return
+    }
+    if (importMetaFormat === "systemjs") {
+      // systemjs will handle it
+      return
+    }
+    if (importMetaFormat === "commonjs") {
+      if (importMetaPropertyName === "url") {
+        replaceWithImport({
+          from: `@jsenv/core/helpers/import-meta/import-meta-url-commonjs.js`,
+        })
+        return
+      }
+      if (importMetaPropertyName === "resolve") {
+        throw createParseError({
+          message: `import.meta.resolve() not supported with commonjs format`,
+        })
+      }
+      replaceWithValue(undefined)
+      return
+    }
+    if (importMetaFormat === "global") {
+      if (importMetaPropertyName === "url") {
+        replaceWithImport({
+          from: `@jsenv/core/helpers/import-meta/import-meta-url-global.js`,
+        })
+        return
+      }
+      if (importMetaPropertyName === "resolve") {
+        throw createParseError({
+          message: `import.meta.resolve() not supported with global format`,
+        })
+      }
+      replaceWithValue(undefined)
+      return
+    }
+  }
 
   return {
+    name: "transform-import-meta",
+
     pre: (state) => {
       babelState = state
     },
 
-    //  visitor: {
-    //     Program(programPath) {
-    //       const paths = []
-    //       programPath.traverse({
-    //         MetaProperty(metaPropertyPath) {
-    //           const metaPropertyNode = metaPropertyPath.node
-    //           if (!metaPropertyNode.meta) {
-    //             return
-    //           }
-    //           if (metaPropertyNode.meta.name !== "import") {
-    //             return
-    //           }
-    //           if (metaPropertyNode.property.name !== "meta") {
-    //             return
-    //           }
-    //           paths.push(metaPropertyPath)
-    //         },
-    //       })
-
-    //       const importAst = addNamespace(programPath, importMetaSpecifier)
-    //       paths.forEach((path) => {
-    //         path.replaceWith(importAst)
-    //       })
-    //     },
-
     visitor: {
       Program(programPath) {
         const metaPropertyPathMap = {}
-
         programPath.traverse({
           MemberExpression(path) {
             const { node } = path
@@ -61,12 +80,10 @@ export const babelPluginTransformImportMeta = (api, pluginOptions) => {
             if (object.type !== "MetaProperty") {
               return
             }
-
             const { property: objectProperty } = object
             if (objectProperty.name !== "meta") {
               return
             }
-
             const { property } = node
             const { name } = property
             if (name in metaPropertyPathMap) {
@@ -76,9 +93,9 @@ export const babelPluginTransformImportMeta = (api, pluginOptions) => {
             }
           },
         })
-
         Object.keys(metaPropertyPathMap).forEach((importMetaPropertyName) => {
-          replaceImportMeta(importMetaPropertyName, {
+          visitImportMetaProperty({
+            importMetaPropertyName,
             replaceWithImport: ({ namespace, name, from, nameHint }) => {
               let importAst
               if (namespace) {

package/src/internal/compiling/compileFile.js

@@ -7,8 +7,8 @@ import {
 } from "@jsenv/filesystem"
 import { convertFileSystemErrorToResponseProperties } from "@jsenv/server/src/internal/convertFileSystemErrorToResponseProperties.js"
 
-import { getOrGenerateCompiledFile } from "./compile-directory/getOrGenerateCompiledFile.js"
-import { updateMeta } from "./compile-directory/updateMeta.js"
+import { getOrGenerateCompiledFile } from "./jsenv_directory/getOrGenerateCompiledFile.js"
+import { updateMeta } from "./jsenv_directory/updateMeta.js"
 
 export const compileFile = async ({
   logger,

package/src/internal/compiling/compileHtml.js

@@ -313,7 +313,7 @@ export const collectHtmlDependenciesFromAst = (htmlAst) => {
     const srcsetAttribute = getHtmlNodeAttributeByName(htmlNode, "srcset")
     if (srcsetAttribute) {
       const srcsetParts = parseSrcset(srcsetAttribute.value)
-      srcsetParts.forEeach(({ specifier }) => {
+      srcsetParts.forEach(({ specifier }) => {
         dependencies.push({
           htmlNode,
           attribute: srcsetAttribute,

package/src/internal/compiling/createCompiledFileService.js

@@ -4,19 +4,14 @@ import {
   resolveDirectoryUrl,
   normalizeStructuredMetaMap,
   urlToMeta,
+  urlToRelativeUrl,
 } from "@jsenv/filesystem"
 
-import { createRuntimeCompat } from "@jsenv/core/src/internal/generateGroupMap/runtime_compat.js"
-import { shakeBabelPluginMap } from "@jsenv/core/src/internal/generateGroupMap/shake_babel_plugin_map.js"
+import { REDIRECTOR_BUILD_URL } from "@jsenv/core/dist/build_manifest.js"
 import { serverUrlToCompileInfo } from "@jsenv/core/src/internal/url_conversion.js"
-
 import { setUrlExtension } from "../url_utils.js"
-import {
-  COMPILE_ID_BUILD_GLOBAL,
-  COMPILE_ID_BUILD_GLOBAL_FILES,
-  COMPILE_ID_BUILD_COMMONJS,
-  COMPILE_ID_BUILD_COMMONJS_FILES,
-} from "../CONSTANTS.js"
+
+import { shakeBabelPluginMap } from "./jsenv_directory/compile_profile.js"
 import { compileFile } from "./compileFile.js"
 import { compileHtml } from "./jsenvCompilerForHtml.js"
 import { compileImportmap } from "./jsenvCompilerForImportmap.js"
@@ -39,20 +34,15 @@ export const createCompiledFileService = ({
 
   projectDirectoryUrl,
   jsenvDirectoryRelativeUrl,
-  outDirectoryRelativeUrl,
+  jsenvDirectory,
   jsenvRemoteDirectory,
 
-  runtimeSupport,
   babelPluginMap,
-  moduleOutFormat,
-  importMetaFormat,
   topLevelAwait,
   prependSystemJs,
-  groupMap,
   customCompilers,
   workerUrls,
   serviceWorkerUrls,
-  importMapInWebWorkers,
 
   jsenvEventSourceClientInjection,
   jsenvToolbarInjection,
@@ -62,17 +52,6 @@ export const createCompiledFileService = ({
   sourcemapMethod,
   sourcemapExcludeSources,
 }) => {
-  const compileIdModuleFormats = {}
-  Object.keys(groupMap).forEach((groupName) => {
-    compileIdModuleFormats[groupName] = canAvoidSystemJs({
-      runtimeSupport: groupMap[groupName].minRuntimeVersions,
-      workerUrls,
-      importMapInWebWorkers,
-    })
-      ? "esmodule"
-      : "systemjs"
-  })
-
   Object.keys(customCompilers).forEach((key) => {
     const value = customCompilers[key]
     if (typeof value !== "function") {
@@ -88,27 +67,26 @@ export const createCompiledFileService = ({
     },
     projectDirectoryUrl,
   )
-
   const importmapInfos = {}
-
+  const redirectorRelativeUrlForProject = urlToRelativeUrl(
+    REDIRECTOR_BUILD_URL,
+    projectDirectoryUrl,
+  )
   return async (request, { pushResponse, redirectRequest }) => {
     const { origin, ressource } = request
     const requestUrl = `${origin}${ressource}`
-
     const requestCompileInfo = serverUrlToCompileInfo(requestUrl, {
-      outDirectoryRelativeUrl,
       compileServerOrigin: origin,
+      jsenvDirectoryRelativeUrl,
     })
-
     // not inside compile directory -> nothing to compile
     if (!requestCompileInfo.insideCompileDirectory) {
       return null
     }
-
     const { compileId, afterCompileId } = requestCompileInfo
     // serve files inside /.jsenv/* directly without compilation
     // this is just to allow some files to be written inside outDirectory and read directly
-    // if asked by the client (such __compile_server_meta__.json)
+    // if asked by the client
     if (!compileId) {
       return fetchFileSystem(
         new URL(request.ressource.slice(1), projectDirectoryUrl),
@@ -118,29 +96,27 @@ export const createCompiledFileService = ({
         },
       )
     }
-
-    const allowedCompileIds = [
-      ...Object.keys(groupMap),
-      COMPILE_ID_BUILD_GLOBAL,
-      COMPILE_ID_BUILD_GLOBAL_FILES,
-      COMPILE_ID_BUILD_COMMONJS,
-      COMPILE_ID_BUILD_COMMONJS_FILES,
-    ]
-    if (!allowedCompileIds.includes(compileId)) {
+    const compileDirectory = jsenvDirectory.compileDirectories[compileId]
+    if (!compileDirectory) {
       return {
-        status: 400,
-        statusText: `compileId must be one of ${allowedCompileIds}, received ${compileId}`,
+        status: 307,
+        headers: {
+          location: `${
+            request.origin
+          }/${redirectorRelativeUrlForProject}?redirect=${encodeURIComponent(
+            afterCompileId,
+          )}`,
+        },
       }
     }
-
     // nothing after compileId, we don't know what to compile (not supposed to happen)
     if (afterCompileId === "") {
       return null
     }
-
+    const { compileProfile } = compileDirectory
     const originalFileRelativeUrl = afterCompileId
     const originalFileUrl = `${projectDirectoryUrl}${originalFileRelativeUrl}`
-    const compileDirectoryRelativeUrl = `${outDirectoryRelativeUrl}${compileId}/`
+    const compileDirectoryRelativeUrl = `${jsenvDirectoryRelativeUrl}${compileId}/`
     const compileDirectoryUrl = resolveDirectoryUrl(
       compileDirectoryRelativeUrl,
       projectDirectoryUrl,
@@ -181,24 +157,18 @@ export const createCompiledFileService = ({
           jsenvRemoteDirectory,
           compileServerOrigin: request.origin,
           jsenvDirectoryRelativeUrl,
-          outDirectoryRelativeUrl,
           url: originalFileUrl,
           compiledUrl: compiledFileUrl,
           request,
 
+          compileProfile,
           compileId,
           babelPluginMap: shakeBabelPluginMap({
             babelPluginMap,
-            missingFeatureNames: groupMap[compileId].missingFeatureNames,
+            compileProfile,
           }),
-          runtimeSupport,
           workerUrls,
           serviceWorkerUrls,
-          moduleOutFormat:
-            moduleOutFormat === undefined
-              ? compileIdModuleFormats[compileId]
-              : moduleOutFormat,
-          importMetaFormat,
           topLevelAwait,
           prependSystemJs,
 
@@ -217,25 +187,6 @@ export const createCompiledFileService = ({
   }
 }
 
-const canAvoidSystemJs = ({
-  runtimeSupport,
-  workerUrls,
-  importMapInWebWorkers,
-}) => {
-  const runtimeCompatMap = createRuntimeCompat({
-    featureNames: [
-      "module",
-      "importmap",
-      "import_assertion_type_json",
-      "import_assertion_type_css",
-      ...(workerUrls.length > 0 ? ["worker_type_module"] : []),
-      ...(importMapInWebWorkers ? ["worker_importmap"] : []),
-    ],
-    runtimeSupport,
-  })
-  return runtimeCompatMap.missingFeatureNames.length === 0
-}
-
 const getCompiler = ({ originalFileUrl, compileMeta }) => {
   // we remove eventual query param from the url
   // Without this a pattern like "**/*.js" would not match "file.js?t=1"