@jsenv/core 24.6.3 → 25.0.0-alpha.1

package/src/internal/compiling/startCompileServer.js

@@ -82,9 +82,9 @@ export const startCompileServer = async ({
   projectFileCacheStrategy = "mtime",
 
   // js compile options
-  transformTopLevelAwait = true,
   moduleOutFormat,
   importMetaFormat,
+  topLevelAwait,
   env = {},
   processEnvNodeEnv = process.env.NODE_ENV,
   replaceProcessEnvNodeEnv = true,
@@ -95,10 +95,13 @@ export const startCompileServer = async ({
   babelPluginMap,
   babelConfigFileUrl,
   customCompilers = {},
-
-  // remaining options
+  workers = [],
+  serviceWorkers = [],
+  importMapInWebWorkers = false,
+  prependSystemJs,
   runtimeSupport,
 
+  // remaining options
   livereloadWatchConfig = {
     "./**": true,
     "./**/.*/": false, // any folder starting with a dot is ignored (includes .git for instance)
@@ -138,9 +141,14 @@ export const startCompileServer = async ({
     jsenvDirectoryUrl,
     projectDirectoryUrl,
   )
-
   const logger = createLogger({ logLevel })
 
+  const workerUrls = workers.map((worker) =>
+    resolveUrl(worker, projectDirectoryUrl),
+  )
+  const serviceWorkerUrls = serviceWorkers.map((serviceWorker) =>
+    resolveUrl(serviceWorker, projectDirectoryUrl),
+  )
   const browser = isBrowserPartOfSupportedRuntimes(runtimeSupport)
   const babelPluginMapFromFile = await loadBabelPluginMapFromFile({
     projectDirectoryUrl,
@@ -177,7 +185,19 @@ export const startCompileServer = async ({
   const { babelSyntaxPluginMap, babelPluginMapWithoutSyntax } =
     extractSyntaxBabelPluginMap(babelPluginMap)
   const compileServerGroupMap = generateGroupMap({
-    babelPluginMap: babelPluginMapWithoutSyntax,
+    featureNames: [
+      ...(browser
+        ? [
+            "module",
+            "importmap",
+            "import_assertion_type_json",
+            "import_assertion_type_css",
+          ]
+        : []),
+      ...(browser && workerUrls.length > 0 ? ["worker_type_module"] : []),
+      ...(browser && importMapInWebWorkers ? ["worker_importmap"] : []),
+      ...Object.keys(babelPluginMapWithoutSyntax),
+    ],
     runtimeSupport,
   })
 
@@ -188,7 +208,7 @@ export const startCompileServer = async ({
     // It happens for module written in ESM but also using process.env.NODE_ENV
     // for example "react-redux"
     // This babel plugin won't force compilation because it's added after "generateGroupMap"
-    // however it will be used even if not part of "pluginRequiredNameArray"
+    // however it will be used even if not part of "missingFeatureNames"
     // as visible in "babelPluginMapFromCompileId"
     // This is a quick workaround to get things working because:
     // - If none of your code needs to be compiled but one of your dependency
@@ -310,10 +330,14 @@ export const startCompileServer = async ({
       importDefaultExtension,
 
       runtimeSupport,
-      transformTopLevelAwait,
+      topLevelAwait,
       groupMap: compileServerGroupMap,
       babelPluginMap,
       customCompilers,
+      workerUrls,
+      serviceWorkerUrls,
+      importMapInWebWorkers,
+      prependSystemJs,
       moduleOutFormat,
       importMetaFormat,
       jsenvEventSourceClientInjection,

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

@@ -14,7 +14,7 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
       canAvoidCompilation,
       featuresReport,
       customCompilerPatterns,
-      pluginRequiredNameArray,
+      missingFeatureNames,
       inlineImportMapIntoHTML,
       outDirectoryRelativeUrl,
       compileId,
@@ -38,7 +38,7 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
                 missingOnly: true,
                 featuresReport,
                 customCompilerPatterns,
-                pluginRequiredNameArray,
+                missingFeatureNames,
                 inlineImportMapIntoHTML,
               },
             )}`,
@@ -54,7 +54,7 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
               {
                 featuresReport,
                 customCompilerPatterns,
-                pluginRequiredNameArray,
+                missingFeatureNames,
                 inlineImportMapIntoHTML,
               },
             )}`,
@@ -70,7 +70,7 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
               {
                 featuresReport,
                 customCompilerPatterns,
-                pluginRequiredNameArray,
+                missingFeatureNames,
                 inlineImportMapIntoHTML,
               },
             )}`,
@@ -128,7 +128,7 @@ const getBrowserSupportMessage = ({
   missingOnly,
   featuresReport,
   customCompilerPatterns,
-  pluginRequiredNameArray,
+  missingFeatureNames,
   inlineImportMapIntoHTML,
 }) => {
   const parts = []
@@ -161,14 +161,14 @@ const getBrowserSupportMessage = ({
     parts.push(`top level await is not supported`)
   }
 
-  const pluginRequiredCount = pluginRequiredNameArray.length
-  if (pluginRequiredCount === 0) {
+  const missingFeatureCount = missingFeatureNames.length
+  if (missingFeatureCount === 0) {
     if (!missingOnly) {
-      parts.push(`all plugins are natively supported`)
+      parts.push(`all features are natively supported`)
     }
   } else {
     parts.push(
-      `${pluginRequiredCount} plugins are mandatory: ${pluginRequiredNameArray}`,
+      `${missingFeatureCount} features are missing: ${missingFeatureNames}`,
     )
   }
 

package/src/internal/executing/executePlan.js

@@ -51,6 +51,9 @@ export const executePlan = async (
     compileServerCanWriteOnFilesystem,
     babelPluginMap,
     babelConfigFileUrl,
+    workers,
+    serviceWorkers,
+    importMapInWebWorkers,
     customCompilers,
   } = {},
 ) => {
@@ -123,6 +126,9 @@ export const executePlan = async (
       keepProcessAlive: true, // to be sure it stays alive
       babelPluginMap,
       babelConfigFileUrl,
+      workers,
+      serviceWorkers,
+      importMapInWebWorkers,
       customCompilers,
       runtimeSupport,
     })

package/src/internal/generateGroupMap/{featuresCompatMap.js → features_compatibility.js}

@@ -1,4 +1,4 @@
-// https://github.com/babel/babel/blob/master/packages/babel-compat-data/data/native-modules.json#L1
+import { jsenvBabelPluginCompatMap } from "./babel_plugins_compatibility.js"
 
 export const featuresCompatMap = {
   module: {
@@ -26,4 +26,12 @@ export const featuresCompatMap = {
     chrome: "93",
     edge: "93",
   },
+  worker_type_module: {
+    chrome: "80",
+    edge: "80",
+    opera: "67",
+    android: "80",
+  },
+  worker_importmap: {},
+  ...jsenvBabelPluginCompatMap,
 }

package/src/internal/generateGroupMap/generateGroupMap.js

@@ -17,7 +17,7 @@
 
 {
   "best": {
-    "pluginRequiredNameArray" : [
+    "missingFeatureNames" : [
       "transform-block-scoping",
     ],
     "minRuntimeVersions": {
@@ -33,40 +33,20 @@ Take chars below to update legends
 */
 
 import { COMPILE_ID_OTHERWISE, COMPILE_ID_BEST } from "../CONSTANTS.js"
-import { jsenvBabelPluginCompatMap } from "./jsenvBabelPluginCompatMap.js"
-import { jsenvPluginCompatMap } from "./jsenvPluginCompatMap.js"
 import { createRuntimeCompat } from "./runtime_compat.js"
 
-export const generateGroupMap = ({
-  babelPluginMap,
-  runtimeSupport,
-  babelPluginCompatMap = jsenvBabelPluginCompatMap,
-  // jsenv plugin are for later, for now, nothing is using them
-  jsenvPluginMap = {},
-}) => {
-  if (typeof babelPluginMap !== "object") {
-    throw new TypeError(
-      `babelPluginMap must be an object, got ${babelPluginMap}`,
-    )
-  }
-  if (typeof jsenvPluginMap !== "object") {
-    throw new TypeError(
-      `jsenvPluginMap must be an object, got ${jsenvPluginMap}`,
-    )
+export const generateGroupMap = ({ featureNames, runtimeSupport }) => {
+  if (!Array.isArray(featureNames)) {
+    throw new TypeError(`featureNames must be an array, got ${featureNames}`)
   }
   if (typeof runtimeSupport !== "object") {
     throw new TypeError(
       `runtimeSupport must be an object, got ${runtimeSupport}`,
     )
   }
-
   const runtimeNames = Object.keys(runtimeSupport)
-
   const groupWithoutFeature = {
-    pluginRequiredNameArray: [
-      ...Object.keys(babelPluginMap),
-      ...Object.keys(jsenvPluginMap),
-    ],
+    missingFeatureNames: featureNames,
     minRuntimeVersions: {},
   }
   if (runtimeNames.length === 0) {
@@ -74,19 +54,10 @@ export const generateGroupMap = ({
       [COMPILE_ID_OTHERWISE]: groupWithoutFeature,
     }
   }
-
   const runtimeCompat = createRuntimeCompat({
     runtimeSupport,
-    pluginMap: {
-      ...babelPluginMap,
-      ...jsenvPluginMap,
-    },
-    pluginCompatMap: {
-      ...babelPluginCompatMap,
-      ...jsenvPluginCompatMap,
-    },
+    featureNames,
   })
-
   return {
     [COMPILE_ID_BEST]: runtimeCompat,
     [COMPILE_ID_OTHERWISE]: groupWithoutFeature,

package/src/internal/generateGroupMap/one_runtime_compat.js

@@ -3,18 +3,16 @@ import { findHighestVersion } from "../semantic_versioning/index.js"
 export const createOneRuntimeCompat = ({
   runtimeName,
   runtimeVersion,
-
-  pluginMap,
-  pluginCompatMap,
+  featureNames,
+  featuresCompatMap,
 }) => {
-  const pluginRequiredNameArray = []
+  const missingFeatureNames = []
   // will be the first runtime version compatible with all features not listed in
-  // pluginRequiredNameArray
+  // missingFeatureNames
   let minRuntimeVersion
-
-  Object.keys(pluginMap).forEach((pluginName) => {
-    const pluginCompat = pluginCompatMap[pluginName] || {}
-    const runtimeVersionCompatible = pluginCompat[runtimeName] || "Infinity"
+  featureNames.forEach((featureName) => {
+    const featureCompat = featuresCompatMap[featureName] || {}
+    const runtimeVersionCompatible = featureCompat[runtimeName] || "Infinity"
 
     const highestVersion = findHighestVersion(
       runtimeVersion,
@@ -22,7 +20,7 @@ export const createOneRuntimeCompat = ({
     )
     const compatible = highestVersion === runtimeVersion
     if (!compatible) {
-      pluginRequiredNameArray.push(pluginName)
+      missingFeatureNames.push(featureName)
     }
 
     if (compatible && runtimeVersionCompatible !== "Infinity") {
@@ -33,9 +31,8 @@ export const createOneRuntimeCompat = ({
       )
     }
   })
-
   return {
-    pluginRequiredNameArray,
+    missingFeatureNames,
     minRuntimeVersion: minRuntimeVersion || runtimeVersion,
   }
 }

package/src/internal/generateGroupMap/runtime_compat.js

@@ -1,39 +1,34 @@
+import { featuresCompatMap } from "./features_compatibility.js"
 import { createOneRuntimeCompat } from "./one_runtime_compat.js"
 
-export const createRuntimeCompat = ({
-  runtimeSupport,
-  pluginMap,
-  pluginCompatMap,
-}) => {
+export const createRuntimeCompat = ({ runtimeSupport, featureNames }) => {
   const minRuntimeVersions = {}
-  const pluginRequiredNameArray = []
+  const missingFeatureNames = []
   const runtimeNames = Object.keys(runtimeSupport)
   if (runtimeNames.length === 0) {
     // when runtimes are unknown, everything is required
-    Object.keys(pluginMap).forEach((pluginName) => {
-      pluginRequiredNameArray.push(pluginName)
-    })
+    missingFeatureNames.push(...featureNames)
   } else {
     runtimeNames.forEach((runtimeName) => {
       const runtimeVersion = runtimeSupport[runtimeName]
       const oneRuntimeCompat = createOneRuntimeCompat({
         runtimeName,
         runtimeVersion,
-        pluginMap,
-        pluginCompatMap,
+        featureNames,
+        featuresCompatMap,
       })
 
       minRuntimeVersions[runtimeName] = oneRuntimeCompat.minRuntimeVersion
-      oneRuntimeCompat.pluginRequiredNameArray.forEach((babelPluginName) => {
-        if (!pluginRequiredNameArray.includes(babelPluginName)) {
-          pluginRequiredNameArray.push(babelPluginName)
+      oneRuntimeCompat.missingFeatureNames.forEach((missingFeatureName) => {
+        if (!missingFeatureNames.includes(missingFeatureName)) {
+          missingFeatureNames.push(missingFeatureName)
         }
       })
     })
   }
 
   return {
-    pluginRequiredNameArray,
+    missingFeatureNames,
     minRuntimeVersions,
   }
 }

package/src/internal/generateGroupMap/runtime_compat_composition.js

@@ -31,7 +31,7 @@ const sortObjectKeys = (object) => {
 
 // export const composeRuntimeCompat = (...runtimeCompats) => {
 //   return runtimeCompats.reduce(runtimeCompatComposer, {
-//     pluginRequiredNameArray: [],
+//     missingFeatureNames: [],
 //     runtimeCompatMap: {},
 //   })
 // }
@@ -60,7 +60,7 @@ const sortObjectKeys = (object) => {
 // }
 
 // const runtimeCompatComposer = compositionMappingToStrictReducer({
-//   pluginRequiredNameArray: (
+//   missingFeatureNames: (
 //     babelPluginNamesPrevious,
 //     babelPluginNamesCurrent,
 //   ) => {

package/src/internal/generateGroupMap/shake_babel_plugin_map.js

@@ -0,0 +1,21 @@
+export const shakeBabelPluginMap = ({
+  babelPluginMap,
+  missingFeatureNames,
+}) => {
+  const babelPluginMapForGroup = {}
+  missingFeatureNames.forEach((featureName) => {
+    const babelPlugin = babelPluginMap[featureName]
+    if (babelPlugin) {
+      babelPluginMapForGroup[featureName] = babelPlugin
+    }
+  })
+  Object.keys(babelPluginMap).forEach((key) => {
+    if (key.startsWith("syntax-")) {
+      babelPluginMapForGroup[key] = babelPluginMap[key]
+    }
+    if (key === "transform-replace-expressions") {
+      babelPluginMapForGroup[key] = babelPluginMap[key]
+    }
+  })
+  return babelPluginMapForGroup
+}

package/src/internal/import-resolution/importmap_default.js

@@ -0,0 +1,52 @@
+/**
+ * allows the following:
+ *
+ * import "@jsenv/core/helpers/regenerator-runtime/regenerator-runtime.js"
+ * -> searches a file inside @jsenv/core/*
+ *
+ */
+
+import { urlToRelativeUrl, urlIsInsideOf, resolveUrl } from "@jsenv/filesystem"
+
+import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
+
+export const getDefaultImportmap = (
+  url,
+  { projectDirectoryUrl, compileDirectoryUrl },
+) => {
+  const jsenvCoreDirectoryRelativeUrl = urlToRelativeUrl(
+    jsenvCoreDirectoryUrl,
+    projectDirectoryUrl,
+  )
+
+  let jsenvCoreUrl
+  if (compileDirectoryUrl && urlIsInsideOf(url, compileDirectoryUrl)) {
+    jsenvCoreUrl = resolveUrl(
+      jsenvCoreDirectoryRelativeUrl,
+      compileDirectoryUrl,
+    )
+  } else {
+    jsenvCoreUrl = jsenvCoreDirectoryUrl
+  }
+
+  const importmap = {
+    imports: {
+      "@jsenv/core/": makeRelativeMapping(jsenvCoreUrl, url),
+    },
+  }
+  return importmap
+}
+
+// this function just here to ensure relative urls starts with './'
+// so that importmap do not consider them as bare specifiers
+const makeRelativeMapping = (url, baseUrl) => {
+  const relativeUrl = urlToRelativeUrl(url, baseUrl)
+
+  if (urlIsInsideOf(url, baseUrl)) {
+    if (relativeUrl.startsWith("../")) return relativeUrl
+    if (relativeUrl.startsWith("./")) return relativeUrl
+    return `./${relativeUrl}`
+  }
+
+  return relativeUrl
+}

package/src/internal/node_feature_detection/node_feature_detection.js

@@ -34,7 +34,7 @@ export const scanNodeRuntimeFeatures = async ({
     featuresReport,
     failFastOnFeatureDetection: true,
   })
-  const pluginRequiredNameArray = pluginRequiredNamesFromGroupInfo(groupInfo, {
+  const missingFeatureNames = adjustMissingFeatureNames(groupInfo, {
     featuresReport,
     coverageHandledFromOutside,
   })
@@ -43,14 +43,14 @@ export const scanNodeRuntimeFeatures = async ({
     // node native resolution will not auto add extension
     !importDefaultExtension &&
     customCompilerPatterns.length === 0 &&
-    pluginRequiredNameArray.length === 0 &&
+    missingFeatureNames.length === 0 &&
     featuresReport.dynamicImport &&
     featuresReport.topLevelAwait
 
   return {
     canAvoidCompilation,
     featuresReport,
-    pluginRequiredNameArray,
+    missingFeatureNames,
     compileId,
     importDefaultExtension,
     node,
@@ -84,28 +84,34 @@ const importJson = async (url) => {
   return object
 }
 
-const pluginRequiredNamesFromGroupInfo = (
+const adjustMissingFeatureNames = (
   groupInfo,
   { coverageHandledFromOutside },
 ) => {
-  const { pluginRequiredNameArray } = groupInfo
-  const requiredPluginNames = pluginRequiredNameArray.slice()
-  const markPluginAsSupported = (name) => {
-    const index = requiredPluginNames.indexOf(name)
+  const { missingFeatureNames } = groupInfo
+  const missingFeatureNamesCopy = missingFeatureNames.slice()
+  const markAsSupported = (name) => {
+    const index = missingFeatureNamesCopy.indexOf(name)
     if (index > -1) {
-      requiredPluginNames.splice(index, 1)
+      missingFeatureNamesCopy.splice(index, 1)
     }
   }
-
   if (coverageHandledFromOutside) {
-    markPluginAsSupported("transform-instrument")
+    markAsSupported("transform-instrument")
   }
-  // CSS import assertions and constructable stylesheet are not supported by Node.js
-  // but we assume they are not used for code executed in Node.js
-  // Without this check code executed on Node.js would always be compiled
-  // because import assertions and constructable stylesheet are enabled by default
-  markPluginAsSupported("transform-import-assertions")
-  markPluginAsSupported("new-stylesheet-as-jsenv-import")
-
-  return requiredPluginNames
+  // Jsenv enable some features because they are standard and we can expect code to use them.
+  // At the time of writing this, these features are not available in latest Node.js.
+  // Some feature are also browser specific.
+  // To avoid compiling code for Node.js these feaure are marked as supported.
+  // It means code written to be execute in Node.js should not use these features
+  // because jsenv ignore them (it won't try to "polyfill" them)
+  markAsSupported("module")
+  markAsSupported("importmap")
+  markAsSupported("transform-import-assertions")
+  markAsSupported("import_assertion_type_json")
+  markAsSupported("import_assertion_type_css")
+  markAsSupported("new-stylesheet-as-jsenv-import")
+  markAsSupported("worker_type_module")
+  markAsSupported("worker_importmap")
+  return missingFeatureNamesCopy
 }