@jsenv/core 27.0.0-alpha.54 → 27.0.0-alpha.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "27.0.0-alpha.54",
+  "version": "27.0.0-alpha.57",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {

package/src/build/build.js

@@ -224,16 +224,6 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
     })
   })
   const addToBundlerIfAny = (rawUrlInfo) => {
-    if (
-      // entry point must be given to the bundler (rollup)
-      // so that the bundler know it's an entry point, even if it has no dependency
-      // this way the bundler can share code properly and avoid inlining an entry point
-      // if it's used by an other entry point
-      !rawUrlInfo.data.isEntryPoint &&
-      rawUrlInfo.dependencies.size === 0
-    ) {
-      return
-    }
     const bundler = bundlers[rawUrlInfo.type]
     if (bundler) {
       bundler.urlInfos.push(rawUrlInfo)
@@ -740,12 +730,12 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
       buildInlineContents[buildRelativeUrl] = urlInfo.content
     } else {
       buildFileContents[buildRelativeUrl] = urlInfo.content
+      const buildRelativeUrlWithoutVersioning = urlToRelativeUrl(
+        urlInfo.url,
+        buildDirectoryUrl,
+      )
+      buildManifest[buildRelativeUrlWithoutVersioning] = buildRelativeUrl
     }
-    const buildRelativeUrlWithoutVersioning = urlToRelativeUrl(
-      urlInfo.url,
-      buildDirectoryUrl,
-    )
-    buildManifest[buildRelativeUrlWithoutVersioning] = buildRelativeUrl
   })
   if (writeOnFileSystem) {
     if (buildDirectoryClean) {

package/src/build/start_build_server.js

@@ -68,6 +68,7 @@ export const startBuildServer = async ({
   buildDirectoryUrl = assertAndNormalizeDirectoryUrl(buildDirectoryUrl)
 
   const reloadableProcess = await initReloadableProcess({
+    signal,
     handleSIGINT,
     ...(buildServerAutoreload
       ? {

package/src/omega/kitchen.js

@@ -192,10 +192,7 @@ export const createKitchen = ({
           Object.keys(returnValue).forEach((key) => {
             referenceUrlObject.searchParams.set(key, returnValue[key])
           })
-          reference.generatedUrl = referenceUrlObject.href.replace(
-            /[=](?=&|$)/g,
-            "",
-          )
+          reference.generatedUrl = normalizeUrl(referenceUrlObject.href)
         },
       )
       const returnValue = pluginController.callHooksUntil(
@@ -654,8 +651,6 @@ export const createKitchen = ({
   const prepareEntryPoint = (params) => {
     const entryReference = createReference(params)
     const entryUrlInfo = resolveReference(entryReference)
-    // I should likely delete urlInfo.sourcemap
-    // otherwise it is reused when page is reloaded
     return [entryReference, entryUrlInfo]
   }
 

package/src/omega/server/file_service.js

@@ -20,6 +20,11 @@ export const createFileService = ({
     urlGraph,
     scenario,
   }
+  const augmentResponseContext = {
+    rootDirectoryUrl,
+    urlGraph,
+    scenario,
+  }
 
   const getResponse = async (request) => {
     // serve file inside ".jsenv" directory
@@ -58,9 +63,19 @@ export const createFileService = ({
       reference.parentUrl,
     )
     try {
-      // urlInfo objects are reused, they must be "reset" before cooking then again
-      if (!urlInfo.isInline && !urlInfo.type === "sourcemap") {
-        urlGraph.resetUrlInfo(urlInfo)
+      // urlInfo objects are reused, they must be "reset" before cooking them again
+      if (
+        urlInfo.contentEtag &&
+        !urlInfo.isInline &&
+        urlInfo.type !== "sourcemap"
+      ) {
+        urlInfo.sourcemap = null
+        urlInfo.sourcemapReference = null
+        urlInfo.content = null
+        urlInfo.originalContent = null
+        urlInfo.type = null
+        urlInfo.subtype = null
+        urlInfo.timing = {}
       }
       const { runtimeName, runtimeVersion } = parseUserAgentHeader(
         request.headers["user-agent"],
@@ -92,7 +107,7 @@ export const createFileService = ({
       kitchen.pluginController.callHooks(
         "augmentResponse",
         { reference, urlInfo },
-        {},
+        augmentResponseContext,
         (returnValue) => {
           response = composeTwoResponses(response, returnValue)
         },

package/src/omega/url_graph.js

@@ -15,16 +15,6 @@ export const createUrlGraph = ({
       }
     }
   }
-  const resetUrlInfo = (urlInfo) => {
-    urlInfo.sourcemap = null
-    urlInfo.sourcemapReference = null
-    urlInfo.content = null
-    urlInfo.originalContent = null
-    urlInfo.type = null
-    urlInfo.subtype = null
-    urlInfo.data = {}
-    urlInfo.timing = {}
-  }
 
   const reuseOrCreateUrlInfo = (url) => {
     const existingUrlInfo = urlInfos[url]
@@ -160,7 +150,6 @@ export const createUrlGraph = ({
     reuseOrCreateUrlInfo,
     getUrlInfo,
     deleteUrlInfo,
-    resetUrlInfo,
     inferReference,
     findDependent,
     updateReferences,

package/src/plugins/bundling/js_module/bundle_js_module.js

@@ -1,6 +1,7 @@
 import {
   isFileSystemPath,
   normalizeStructuredMetaMap,
+  urlIsInsideOf,
   urlToMeta,
 } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/logger"
@@ -8,6 +9,12 @@ 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"
+import { babelHelperNameFromUrl } from "@jsenv/babel-plugins"
+
+const jsenvBabelPluginDirectoryUrl = new URL(
+  "../../transpilation/babel/",
+  import.meta.url,
+).href
 
 export const bundleJsModule = async ({
   jsModuleUrlInfos,
@@ -216,6 +223,23 @@ const rollupPluginJsenv = ({
           const name = nameFromUrlInfo || `${chunkInfo.name}.js`
           return insideJs ? `js/${name}` : `${name}`
         },
+        manualChunks: (id) => {
+          const fileUrl = fileUrlConverter.asFileUrl(id)
+          if (
+            fileUrl.endsWith(
+              "babel-plugin-transform-async-to-promises/helpers.mjs",
+            )
+          ) {
+            return "babel_helpers"
+          }
+          if (babelHelperNameFromUrl(fileUrl)) {
+            return "babel_helpers"
+          }
+          if (urlIsInsideOf(fileUrl, jsenvBabelPluginDirectoryUrl)) {
+            return "babel_helpers"
+          }
+          return null
+        },
         // https://rollupjs.org/guide/en/#outputpaths
         // paths: (id) => {
         //   return id

package/src/plugins/cache_control/jsenv_plugin_cache_control.js

@@ -0,0 +1,34 @@
+export const jsenvPluginCacheControl = () => {
+  return {
+    name: "jsenv:cache_control",
+    appliesDuring: {
+      dev: true,
+      test: true,
+    },
+    augmentResponse: ({ reference }, context) => {
+      if (context.scenario === "dev") {
+        // During dev, all files are put into browser cache for 1 hour because:
+        // 1: Browser cache is a temporary directory created by playwright
+        // 2: We assume source files won't be modified while tests are running
+        return {
+          headers: {
+            "cache-control": `private,max-age=3600,immutable`,
+          },
+        }
+      }
+      if (
+        reference.searchParams.has("v") &&
+        !reference.searchParams.has("hmr")
+      ) {
+        return {
+          headers: {
+            "cache-control": `private,max-age=${SECONDS_IN_30_DAYS},immutable`,
+          },
+        }
+      }
+      return null
+    },
+  }
+}
+
+const SECONDS_IN_30_DAYS = 60 * 60 * 24 * 30

package/src/plugins/plugins.js

@@ -17,6 +17,7 @@ import { jsenvPluginBundling } from "./bundling/jsenv_plugin_bundling.js"
 import { jsenvPluginMinification } from "./minification/jsenv_plugin_minification.js"
 import { jsenvPluginImportMetaHot } from "./import_meta_hot/jsenv_plugin_import_meta_hot.js"
 import { jsenvPluginAutoreload } from "./autoreload/jsenv_plugin_autoreload.js"
+import { jsenvPluginCacheControl } from "./cache_control/jsenv_plugin_cache_control.js"
 
 export const getCorePlugins = ({
   rootDirectoryUrl,
@@ -68,7 +69,6 @@ export const getCorePlugins = ({
     jsenvPluginInjectGlobals(injectedGlobals),
     jsenvPluginCommonJsGlobals(),
     jsenvPluginImportMetaScenarios(),
-    // jsenvPluginWorkers(),
 
     jsenvPluginBundling(bundling),
     jsenvPluginMinification(minification),
@@ -87,5 +87,6 @@ export const getCorePlugins = ({
           }),
         ]
       : []),
+    jsenvPluginCacheControl(),
   ]
 }

package/src/plugins/transpilation/as_js_classic/client/s.js

@@ -785,22 +785,88 @@
 (function () {
   // worker or service worker
   if (typeof WorkerGlobalScope === 'function' && self instanceof WorkerGlobalScope) {
-    // auto import first register
-    var messageEvents = []
-    var messageCallback = (event) => {
-      messageEvents.push(event)
+    /*
+     * SystemJs loads X files before executing the worker/service worker main file
+     * It mean events dispatched during this phase could be missed
+     * A warning like the one below is displayed in chrome devtools:
+     * "Event handler of 'install' event must be added on the initial evaluation of worker script"
+     * To fix that code below listen for these events early and redispatch them later
+     * once the worker file is executed (the listeners are installed)
+    */
+    var firstRegisterCallbacks = []
+    var isServiceWorker = typeof self.skipWaiting === 'function'
+    if (isServiceWorker) {
+      // for service worker there is more events to listen
+      // and, to get rid of the warning, we override self.addEventListener
+      var eventsToCatch = ['message', 'install', 'activate', 'fetch']
+      var eventCallbackProxies = {}
+      var firstRegisterPromise = new Promise((resolve) => {
+        firstRegisterCallbacks.push(resolve)
+      })
+      eventsToCatch.forEach(function(eventName) {
+        var eventsToDispatch = []
+        var eventCallback = function (event) {
+          const eventCallbackProxy = eventCallbackProxies[event.type]
+          if (eventCallbackProxy) {
+            eventCallbackProxy(event)
+          }
+          else {
+            eventsToDispatch.push(event)
+            event.waitUntil(firstRegisterPromise)
+          }
+        }
+        self.addEventListener(eventName, eventCallback)
+        firstRegisterCallbacks.push(function() {
+          if (eventsToDispatch.length) {
+            const eventCallbackProxy = eventCallbackProxies[eventsToDispatch[0].type]
+            if (eventCallbackProxy) {
+              eventsToDispatch.forEach(function (event) {
+                eventCallbackProxy(event)
+              })
+            }
+            eventsToDispatch.length = 0
+          }
+        })
+      })
+     
+      var addEventListener = self.addEventListener
+      self.addEventListener = function (eventName, callback, options) {
+        if (eventsToCatch.indexOf(eventName) > -1) {
+          eventCallbackProxies[eventName] = callback
+          return
+        }
+        return addEventListener.call(self, eventName, callback, options)
+      }
+    }
+    else {
+      var eventsToCatch = ['message']
+      eventsToCatch.forEach(function (eventName) {
+        var eventQueue = []
+        var eventCallback = (event) => {
+          eventQueue.push(event)
+        }
+        self.addEventListener(eventName, eventCallback)
+        firstRegisterCallbacks.push(function() {
+          self.removeEventListener(eventName, eventCallback)
+          eventQueue.forEach(function (event) {
+            self.dispatchEvent(event)
+          })
+          eventQueue.length = 0
+        })
+      })
     }
-    self.addEventListener('message', messageCallback)
+
+
+    // auto import first register
     var register = System.register;
     System.register = function(deps, declare) {
       System.register = register;
       System.registerRegistry[self.location.href] = [deps, declare];
       return System.import(self.location.href).then((result) => {
-        self.removeEventListener('message', messageCallback)
-        messageEvents.forEach((messageEvent) => {
-          self.dispatchEvent(messageEvent)
+        firstRegisterCallbacks.forEach(firstRegisterCallback => {
+          firstRegisterCallback()
         })
-        messageEvents = null
+        firstRegisterCallbacks.length = 0
         return result
       })
     }

package/src/plugins/transpilation/babel/helpers/babel_plugin_structure.js

@@ -1,7 +1,12 @@
 import { getBabelHelperFileUrl, requireBabelPlugin } from "@jsenv/babel-plugins"
 import { babelPluginCompatMap } from "./babel_plugins_compatibility.js"
 
-export const getBaseBabelPluginStructure = ({ url, isSupported }) => {
+export const getBaseBabelPluginStructure = ({
+  url,
+  isSupported,
+  // isJsModule,
+  // getImportSpecifier,
+}) => {
   const isBabelPluginNeeded = (babelPluginName) => {
     return !isSupported(babelPluginCompatMap[babelPluginName])
   }
@@ -35,6 +40,12 @@ export const getBaseBabelPluginStructure = ({ url, isSupported }) => {
       requireBabelPlugin("babel-plugin-transform-async-to-promises"),
       {
         topLevelAwait: "ignore", // will be handled by "jsenv:top_level_await" plugin
+        externalHelpers: false,
+        // enable once https://github.com/rpetrich/babel-plugin-transform-async-to-promises/pull/83
+        // externalHelpers: isJsModule,
+        // externalHelpersPath: isJsModule ? getImportSpecifier(
+        //     "babel-plugin-transform-async-to-promises/helpers.mjs",
+        //   ) : null
       },
     ]
   }

package/src/plugins/transpilation/babel/jsenv_plugin_babel.js

@@ -33,27 +33,29 @@ export const jsenvPluginBabel = ({ getCustomBabelPlugins } = {}) => {
       )
     }
 
-    const { referenceUtils } = context
     const isSupported = (feature) =>
       RUNTIME_COMPAT.isSupported(clientRuntimeCompat, feature)
+    const getImportSpecifier = (clientFileUrl) => {
+      const [reference] = context.referenceUtils.inject({
+        type: "js_import_export",
+        expectedType: "js_module",
+        specifier: clientFileUrl,
+      })
+      return JSON.parse(reference.generatedSpecifier)
+    }
+
     const babelPluginStructure = getBaseBabelPluginStructure({
       url: urlInfo.url,
       isSupported,
       isWorkerContext,
+      isJsModule,
+      getImportSpecifier,
     })
     if (getCustomBabelPlugins) {
       Object.assign(babelPluginStructure, getCustomBabelPlugins(context))
     }
 
     if (isJsModule) {
-      const getImportSpecifier = (clientFileUrl) => {
-        const [reference] = referenceUtils.inject({
-          type: "js_import_export",
-          expectedType: "js_module",
-          specifier: clientFileUrl,
-        })
-        return JSON.parse(reference.generatedSpecifier)
-      }
       if (!isSupported("global_this")) {
         babelPluginStructure["global-this-as-jsenv-import"] = [
           babelPluginGlobalThisAsJsenvImport,

package/src/plugins/transpilation/jsenv_plugin_top_level_await.js

@@ -24,6 +24,16 @@ export const jsenvPluginTopLevelAwait = () => {
                 // Maybe we could pass target: "es6" when we support arrow function
                 // https://github.com/rpetrich/babel-plugin-transform-async-to-promises/blob/92755ff8c943c97596523e586b5fa515c2e99326/async-to-promises.ts#L55
                 topLevelAwait: "simple",
+                // enable once https://github.com/rpetrich/babel-plugin-transform-async-to-promises/pull/83
+                // externalHelpers: true,
+                // externalHelpersPath: JSON.parse(
+                //   context.referenceUtils.inject({
+                //     type: "js_import_export",
+                //     expectedType: "js_module",
+                //     specifier:
+                //       "babel-plugin-transform-async-to-promises/helpers.mjs",
+                //   })[0],
+                // ),
               },
             ],
           ],

package/src/plugins/url_version/jsenv_plugin_url_version.js

@@ -1,7 +1,7 @@
-export const jsenvPluginUrlVersion = ({ longTermCache = true } = {}) => {
+export const jsenvPluginUrlVersion = () => {
   return {
     name: "jsenv:url_version",
-    appliesDuring: "*", // maybe only during dev?
+    appliesDuring: "*",
     redirectUrl: (reference) => {
       // "v" search param goal is to enable long-term cache
       // for server response headers
@@ -24,24 +24,5 @@ export const jsenvPluginUrlVersion = ({ longTermCache = true } = {}) => {
         v: reference.data.version,
       }
     },
-    augmentResponse: ({ reference }) => {
-      if (!longTermCache) {
-        return null
-      }
-      if (!reference.searchParams.has("v")) {
-        return null
-      }
-      if (reference.searchParams.has("hmr")) {
-        return null
-      }
-      // When url is versioned put it in browser cache for 30 days
-      return {
-        headers: {
-          "cache-control": `private,max-age=${SECONDS_IN_30_DAYS},immutable`,
-        },
-      }
-    },
   }
 }
-
-const SECONDS_IN_30_DAYS = 60 * 60 * 24 * 30