@jsenv/core 24.6.5 → 25.0.0-alpha.3

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
 }

package/src/internal/runtime/s.js

@@ -497,6 +497,8 @@
 
   var importMapPromise = Promise.resolve();
   var importMap = { imports: {}, scopes: {}, depcache: {}, integrity: {} };
+  systemJSPrototype.importMap = importMap;
+  systemJSPrototype.baseUrl = baseUrl;
 
   // Scripts are processed immediately, on the first System.import, and on DOMReady.
   // Import map scripts are processed only once (by being marked) and in order for each phase.
@@ -552,6 +554,7 @@
           return fetchPromise;
         }).then(function (text) {
           extendImportMap(importMap, text, script.src || baseUrl);
+          return importMap
         });
       }
     });
@@ -566,6 +569,7 @@
     }
     resolveAndComposeImportMap(newMap, newMapUrl, importMap);
   }
+  System.extendImportMap = extendImportMap
 
   /*
    * Script instantiation loading
@@ -719,23 +723,33 @@
    * Supports loading System.register in workers
    */
 
-  if (hasSelf && typeof importScripts === 'function')
+  if (hasSelf && typeof importScripts === 'function') {
     systemJSPrototype.instantiate = function (url) {
       var loader = this;
-      return Promise.resolve().then(function () {
-        importScripts(url);
+      return self.fetch(url, {
+        credentials: 'same-origin',
+      }).then(function (response) {
+        if (!response.ok) {
+          throw Error(errMsg(7,  [response.status, response.statusText, url].join(', ') ));
+        }
+        return response.text()
+      }).then(function (source) {
+        if (source.indexOf('//# sourceURL=') < 0) source += '\n//# sourceURL=' + url;
+        (0, eval)(source);
         return loader.getRegister(url);
-      });
+      })
     };
+  }
 
 }());
 
 (function(){
   var envGlobal = typeof self !== 'undefined' ? self : global;
   var System = envGlobal.System;
-  var register = System.register;
-  var registerRegistry = Object.create(null)
 
+  var registerRegistry = Object.create(null)
+  var register = System.register;
+  System.registerRegistry = registerRegistry;
   System.register = function (name, deps, declare) {
     if (typeof name !== 'string') return register.apply(this, arguments);
     var define = [deps, declare];
@@ -765,4 +779,85 @@
     var result = registerRegistry[url] || register;
     return result;
   };
+}());
+
+(function () {
+  // worker or service worker
+  if (typeof WorkerGlobalScope === 'function' && self instanceof WorkerGlobalScope) {
+    var importMapFromParentPromise = new Promise((resolve) => {
+      var importmapMessageCallback = function (e) {
+        if (e.data === "__importmap_init__") {
+          self.removeEventListener("message", importmapMessageCallback)
+          e.ports[0].onmessage = (message) => {
+            resolve(message.data)
+          }
+          e.ports[0].postMessage('__importmap_request__')         
+        }
+      };
+      self.addEventListener("message", importmapMessageCallback)
+    })
+    // var prepareImport = System.prepareImport
+    System.prepareImport = function () {
+      return importMapFromParentPromise.then(function (importmap) {
+        System.extendImportMap(System.importMap, JSON.stringify(importmap), System.baseUrl)
+      })
+    }
+
+    // auto import first register
+    var messageEvents = []
+    var messageCallback = (event) => {
+      messageEvents.push(event)
+    }
+    self.addEventListener('message', messageCallback)
+    var register = System.register;
+    System.register = function(deps, declare) {
+      System.register = register;
+      System.registerRegistry[self.location.href] = [deps, declare];
+      System.import(self.location.href).then(() => {
+        self.removeEventListener('message', messageCallback)
+        messageEvents.forEach((messageEvent) => {
+          self.dispatchEvent(messageEvent)
+        })
+        messageEvents = null
+      })
+    }
+  }
+  else if (typeof window === 'object') {
+    var WorkerConstructor = window.Worker;
+    if (typeof WorkerConstructor === 'function') {
+      window.Worker = function (url, options) {
+        var worker = new WorkerConstructor(url, options);
+        var importmapChannel = new MessageChannel();
+        importmapChannel.port1.onmessage = function (message) {
+          System.prepareImport().then(function (importmap) {
+            message.target.postMessage(importmap);
+          });
+        }
+        worker.postMessage('__importmap_init__', [importmapChannel.port2]);
+        return worker
+      }
+    }
+
+    var serviceWorker = navigator.serviceWorker;
+    if (serviceWorker) {
+      var register =  serviceWorker.register;
+      serviceWorker.register = function(url, options) {
+        var registrationPromise = register.call(this, url, options);
+        registrationPromise.then(function(registration) {
+          var installing = registration.installing;
+          var waiting = registration.waiting;
+          var active = registration.active;
+          var worker = installing || waiting || active;
+          var importmapChannel = new MessageChannel();
+          importmapChannel.port1.onmessage = function (message) {
+            System.prepareImport().then(function (importmap) {
+              message.target.postMessage(importmap)
+            });
+          }
+          worker.postMessage('__importmap_init__', [importmapChannel.port2]);
+        })
+        return registrationPromise
+      }
+    }
+  }
 }());

package/src/internal/unevalException.js

@@ -1,7 +1,7 @@
 import { uneval } from "@jsenv/uneval"
 
 export const unevalException = (value) => {
-  if (value.hasOwnProperty("toString")) {
+  if (value && value.hasOwnProperty("toString")) {
     delete value.toString
   }
   return uneval(value, { ignoreSymbols: true })

package/src/jsenvServiceWorkerFinalizer.js

@@ -1,23 +1,17 @@
 import { resolveUrl, urlToRelativeUrl } from "@jsenv/filesystem"
 
-import { generateContentHash } from "./internal/building/url-versioning.js"
+import { generateContentHash } from "./internal/building/url_versioning.js"
 
 export const jsenvServiceWorkerFinalizer = (
   code,
-  {
-    serviceWorkerBuildRelativeUrl,
-    buildManifest,
-    rollupBuild,
-    lineBreakNormalization,
-  },
+  { serviceWorkerBuildRelativeUrl, buildFileContents, lineBreakNormalization },
 ) => {
   const generatedUrlsConfig = {}
-  Object.keys(buildManifest).forEach((projectRelativeUrl) => {
-    if (projectRelativeUrl.endsWith(".map")) {
+  Object.keys(buildFileContents).forEach((buildRelativeUrl) => {
+    if (buildRelativeUrl.endsWith(".map")) {
       return
     }
 
-    const buildRelativeUrl = buildManifest[projectRelativeUrl]
     const buildUrl = resolveUrl(buildRelativeUrl, "file://")
     const serviceWorkerBuildUrl = resolveUrl(
       serviceWorkerBuildRelativeUrl,
@@ -32,7 +26,7 @@ export const jsenvServiceWorkerFinalizer = (
       return
     }
     const versioned = fileNameContainsHash(buildRelativeUrl)
-    const rollupFile = rollupBuild[buildRelativeUrl]
+    const buildFileContent = buildFileContents[buildRelativeUrl]
 
     generatedUrlsConfig[urlRelativeToServiceWorker] = {
       versioned,
@@ -42,19 +36,20 @@ export const jsenvServiceWorkerFinalizer = (
             // when url is not versioned we compute a "version" for that url anyway
             // so that service worker source still changes and navigator
             // detect there is a change
-            version: generateContentHash(
-              rollupFile.type === "chunk" ? rollupFile.code : rollupFile.source,
-              { lineBreakNormalization },
-            ),
+            version: generateContentHash(buildFileContent, {
+              lineBreakNormalization,
+            }),
           }),
     }
   })
+  // TODO: ideally should use magic string to prepend code
+  // but it means composing 2 source maps, something not already available in jsenv codebase
 
   return `
-self.generatedUrlsConfig = ${JSON.stringify(generatedUrlsConfig, null, "  ")}
+self.generatedUrlsConfig = ${JSON.stringify(generatedUrlsConfig, null, "  ")};
 ${code}
 `
 }
 
 const fileNameContainsHash = (fileName) =>
-  /-[a-z0-9]{8,}(\..*?)?$/.test(fileName)
+  /_[a-z0-9]{8,}(\..*?)?$/.test(fileName)