@jsenv/core 27.0.0-alpha.56 → 27.0.0-alpha.59

package/src/build/start_build_server.js

@@ -26,17 +26,15 @@ import {
   registerDirectoryLifecycle,
 } from "@jsenv/filesystem"
 import { createLogger } from "@jsenv/logger"
-import { Abort } from "@jsenv/abort"
 
 import { initReloadableProcess } from "@jsenv/utils/process_reload/process_reload.js"
 import { createTaskLog } from "@jsenv/utils/logs/task_log.js"
-import { executeCommand } from "@jsenv/utils/command/command.js"
 
 export const startBuildServer = async ({
   signal = new AbortController().signal,
   handleSIGINT = true,
   logLevel,
-  buildCommandLogLevel = "warn",
+  serverLogLevel = "warn",
   protocol = "http",
   http2,
   certificate,
@@ -53,14 +51,7 @@ export const startBuildServer = async ({
   },
   buildServerMainFile,
   buildServerAutoreload = false,
-  clientFiles = {
-    "./**": true,
-    "./**/.*/": false, // any folder starting with a dot is ignored (includes .git,.jsenv for instance)
-    "./dist/": false,
-    "./**/node_modules/": false,
-  },
   cooldownBetweenFileEvents,
-  buildCommand,
   mainBuildFileUrl = "/index.html",
 }) => {
   const logger = createLogger({ logLevel })
@@ -123,32 +114,6 @@ export const startBuildServer = async ({
   }
   signal = reloadableProcess.signal
 
-  let buildPromise
-  let buildAbortController
-  const runBuild = async () => {
-    buildAbortController = new AbortController()
-    const buildOperation = Abort.startOperation()
-    buildOperation.addAbortSignal(signal)
-    buildOperation.addAbortSignal(buildAbortController.signal)
-    const buildTask = createTaskLog(logger, `execute build command`)
-    buildPromise = executeCommand(buildCommand, {
-      cwd: rootDirectoryUrl,
-      logLevel: buildCommandLogLevel,
-      signal: buildOperation.signal,
-    })
-    try {
-      await buildPromise
-      buildTask.done()
-    } catch (e) {
-      if (e.code === "ABORT_ERR") {
-        buildTask.fail(`execute build command aborted`)
-      } else {
-        buildTask.fail()
-        throw e
-      }
-    }
-  }
-
   const startServerTask = createTaskLog(logger, "start build server")
   const server = await startServer({
     signal,
@@ -156,7 +121,7 @@ export const startBuildServer = async ({
     stopOnSIGINT: false,
     stopOnInternalError: false,
     keepProcessAlive: true,
-    logLevel,
+    logLevel: serverLogLevel,
     startLog: false,
 
     protocol,
@@ -183,8 +148,7 @@ export const startBuildServer = async ({
       }),
     },
     sendErrorDetails: true,
-    requestToResponse: async (request) => {
-      await buildPromise
+    requestToResponse: (request) => {
       const urlIsVersioned = new URL(
         request.ressource,
         request.origin,
@@ -217,37 +181,9 @@ export const startBuildServer = async ({
   })
   logger.info(``)
 
-  runBuild()
-  const clientFileChangeCallback = ({ relativeUrl, event }) => {
-    const url = new URL(relativeUrl, rootDirectoryUrl).href
-    buildAbortController.abort()
-    // setTimeout is to ensure the abortController.abort() above
-    // is properly taken into account so that logs about abort comes first
-    // then logs about re-running the build happens
-    setTimeout(() => {
-      logger.info(`${url.slice(rootDirectoryUrl.length)} ${event} -> rebuild`)
-      runBuild()
-    })
-  }
-  const stopWatchingClientFiles = registerDirectoryLifecycle(rootDirectoryUrl, {
-    watchPatterns: clientFiles,
-    cooldownBetweenFileEvents,
-    keepProcessAlive: false,
-    recursive: true,
-    added: ({ relativeUrl }) => {
-      clientFileChangeCallback({ relativeUrl, event: "added" })
-    },
-    updated: ({ relativeUrl }) => {
-      clientFileChangeCallback({ relativeUrl, event: "modified" })
-    },
-    removed: ({ relativeUrl }) => {
-      clientFileChangeCallback({ relativeUrl, event: "removed" })
-    },
-  })
   return {
     origin: server.origin,
     stop: () => {
-      stopWatchingClientFiles()
       server.stop()
     },
   }

package/src/omega/url_graph/url_graph_load.js

@@ -1,6 +1,7 @@
 import { ensureEmptyDirectory } from "@jsenv/filesystem"
 
 export const loadUrlGraph = async ({
+  operation,
   urlGraph,
   kitchen,
   startLoading,
@@ -69,6 +70,7 @@ export const loadUrlGraph = async ({
   )
 
   const waitAll = async () => {
+    operation.throwIfAborted()
     if (promises.length === 0) {
       return
     }

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
       })
     }