@jsenv/core 27.0.0-alpha.6 → 27.0.0-alpha.60

package/src/dev/start_dev_server.js

@@ -1,21 +1,26 @@
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
+import {
+  assertAndNormalizeDirectoryUrl,
+  registerDirectoryLifecycle,
+} from "@jsenv/filesystem"
 import { createLogger } from "@jsenv/logger"
 
+import { initReloadableProcess } from "@jsenv/utils/process_reload/process_reload.js"
 import { createTaskLog } from "@jsenv/utils/logs/task_log.js"
+import { getCorePlugins } from "@jsenv/core/src/plugins/plugins.js"
 import { createUrlGraph } from "@jsenv/core/src/omega/url_graph.js"
-import { getCorePlugins } from "@jsenv/core/src/omega/core_plugins.js"
 import { createKitchen } from "@jsenv/core/src/omega/kitchen.js"
 import { startOmegaServer } from "@jsenv/core/src/omega/omega_server.js"
 
-import { jsenvPluginAutoreload } from "./plugins/autoreload/jsenv_plugin_autoreload.js"
 import { jsenvPluginExplorer } from "./plugins/explorer/jsenv_plugin_explorer.js"
 import { jsenvPluginToolbar } from "./plugins/toolbar/jsenv_plugin_toolbar.js"
 
 export const startDevServer = async ({
   signal = new AbortController().signal,
-  logLevel,
-  port,
-  protocol,
+  handleSIGINT,
+  logLevel = "info",
+  omegaServerLogLevel = "warn",
+  port = 3456,
+  protocol = "http",
   listenAnyIp,
   // it's better to use http1 by default because it allows to get statusText in devtools
   // which gives valuable information when there is errors
@@ -23,18 +28,29 @@ export const startDevServer = async ({
   certificate,
   privateKey,
   keepProcessAlive = true,
-
   rootDirectoryUrl,
-  plugins = [],
-
-  sourcemaps = "inline",
-  autoreload = true,
-  autoreloadPatterns = {
+  devServerFiles = {
+    "./package.json": true,
+    "./jsenv.config.mjs": true,
+  },
+  devServerMainFile,
+  devServerAutoreload = false,
+  clientFiles = {
     "./**": true,
-    "./**/.*/": false, // any folder starting with a dot is ignored (includes .git for instance)
-    "./dist/": false,
+    "./**/.*/": false, // any folder starting with a dot is ignored (includes .git,.jsenv for instance)
+    "./**/dist/": false,
     "./**/node_modules/": false,
   },
+  cooldownBetweenFileEvents,
+  clientAutoreload = true,
+
+  sourcemaps = "inline",
+  plugins = [],
+  htmlSupervisor = true,
+  injectedGlobals,
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  transpilation,
   explorerGroups = {
     source: {
       "./*.html": true,
@@ -47,37 +63,121 @@ export const startDevServer = async ({
   toolbar = false,
 }) => {
   const logger = createLogger({ logLevel })
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
+  const reloadableProcess = await initReloadableProcess({
+    signal,
+    handleSIGINT,
+    ...(devServerAutoreload
+      ? {
+          enabled: true,
+          logLevel: "warn",
+          fileToRestart: devServerMainFile,
+        }
+      : {
+          enabled: false,
+        }),
+  })
+  if (reloadableProcess.isPrimary) {
+    const devServerFileChangeCallback = ({ relativeUrl, event }) => {
+      const url = new URL(relativeUrl, rootDirectoryUrl).href
+      if (devServerAutoreload) {
+        logger.info(`file ${event} ${url} -> restarting server...`)
+        reloadableProcess.reload()
+      }
+    }
+    const unregisterDevServerFilesWatcher = registerDirectoryLifecycle(
+      rootDirectoryUrl,
+      {
+        watchPatterns: {
+          [devServerMainFile]: true,
+          ...devServerFiles,
+        },
+        cooldownBetweenFileEvents,
+        keepProcessAlive: false,
+        recursive: true,
+        added: ({ relativeUrl }) => {
+          devServerFileChangeCallback({ relativeUrl, event: "added" })
+        },
+        updated: ({ relativeUrl }) => {
+          devServerFileChangeCallback({ relativeUrl, event: "modified" })
+        },
+        removed: ({ relativeUrl }) => {
+          devServerFileChangeCallback({ relativeUrl, event: "removed" })
+        },
+      },
+    )
+    signal.addEventListener("abort", () => {
+      unregisterDevServerFilesWatcher()
+    })
+    return {
+      origin: `${protocol}://127.0.0.1:${port}`,
+      stop: () => {
+        unregisterDevServerFilesWatcher()
+        reloadableProcess.stop()
+      },
+    }
+  }
+
   const startServerTask = createTaskLog(logger, "start server")
 
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
-  const urlGraph = createUrlGraph()
+  const clientFileChangeCallbackList = []
+  const clientFilesPruneCallbackList = []
+  const clientFileChangeCallback = ({ relativeUrl, event }) => {
+    const url = new URL(relativeUrl, rootDirectoryUrl).href
+    clientFileChangeCallbackList.forEach((callback) => {
+      callback({ url, event })
+    })
+  }
+  const stopWatchingClientFiles = registerDirectoryLifecycle(rootDirectoryUrl, {
+    watchPatterns: clientFiles,
+    cooldownBetweenFileEvents,
+    keepProcessAlive: false,
+    recursive: true,
+    added: ({ relativeUrl }) => {
+      clientFileChangeCallback({ event: "added", relativeUrl })
+    },
+    updated: ({ relativeUrl }) => {
+      clientFileChangeCallback({ event: "modified", relativeUrl })
+    },
+    removed: ({ relativeUrl }) => {
+      clientFileChangeCallback({ event: "removed", relativeUrl })
+    },
+  })
+  const urlGraph = createUrlGraph({
+    clientFileChangeCallbackList,
+    clientFilesPruneCallbackList,
+  })
   const kitchen = createKitchen({
     signal,
     logger,
     rootDirectoryUrl,
     urlGraph,
+    scenario: "dev",
+    sourcemaps,
     plugins: [
       ...plugins,
-      ...getCorePlugins(),
-      ...(autoreload
-        ? [
-            jsenvPluginAutoreload({
-              rootDirectoryUrl,
-              urlGraph,
-              autoreloadPatterns,
-            }),
-          ]
-        : []),
+      ...getCorePlugins({
+        rootDirectoryUrl,
+        urlGraph,
+        scenario: "dev",
+
+        htmlSupervisor,
+        injectedGlobals,
+        nodeEsmResolution,
+        fileSystemMagicResolution,
+        transpilation,
+        clientAutoreload,
+        clientFileChangeCallbackList,
+        clientFilesPruneCallbackList,
+      }),
       jsenvPluginExplorer({
         groups: explorerGroups,
       }),
       ...(toolbar ? [jsenvPluginToolbar(toolbar)] : []),
     ],
-    scenario: "dev",
-    sourcemaps,
   })
   const server = await startOmegaServer({
-    logger,
+    logLevel: omegaServerLogLevel,
     keepProcessAlive,
     listenAnyIp,
     port,
@@ -101,5 +201,11 @@ export const startDevServer = async ({
       kitchen.pluginController.callHooks("destroy")
     }
   })
-  return server
+  return {
+    origin: server.origin,
+    stop: () => {
+      stopWatchingClientFiles()
+      server.stop()
+    },
+  }
 }

package/src/execute/execute.js

@@ -3,8 +3,8 @@ import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { createLogger } from "@jsenv/logger"
 
+import { getCorePlugins } from "@jsenv/core/src/plugins/plugins.js"
 import { createUrlGraph } from "@jsenv/core/src/omega/url_graph.js"
-import { getCorePlugins } from "@jsenv/core/src/omega/core_plugins.js"
 import { createKitchen } from "@jsenv/core/src/omega/kitchen.js"
 import { startOmegaServer } from "@jsenv/core/src/omega/omega_server.js"
 
@@ -23,12 +23,18 @@ export const execute = async ({
   collectConsole,
   collectCoverage,
   coverageTempDirectoryUrl,
+  collectPerformance = false,
   runtime,
   runtimeParams,
 
-  plugins = [],
   scenario = "dev",
   sourcemaps = "inline",
+  plugins = [],
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  injectedGlobals,
+  transpilation,
+  htmlSupervisor = true,
 
   port,
   protocol,
@@ -53,6 +59,7 @@ export const execute = async ({
     })
   }
 
+  let resultTransformer = (result) => result
   runtimeParams = {
     rootDirectoryUrl,
     fileRelativeUrl,
@@ -65,14 +72,26 @@ export const execute = async ({
       logger,
       rootDirectoryUrl,
       urlGraph,
-      plugins: [...plugins, ...getCorePlugins()],
       scenario,
       sourcemaps,
+      plugins: [
+        ...plugins,
+        ...getCorePlugins({
+          rootDirectoryUrl,
+          urlGraph,
+          scenario,
+
+          htmlSupervisor,
+          injectedGlobals,
+          nodeEsmResolution,
+          fileSystemMagicResolution,
+          transpilation,
+        }),
+      ],
     })
-    const serverLogger = createLogger({ logLevel: "warn" })
     const server = await startOmegaServer({
       signal: executeOperation.signal,
-      logger: serverLogger,
+      logLevel: "warn",
       rootDirectoryUrl,
       urlGraph,
       kitchen,
@@ -91,9 +110,13 @@ export const execute = async ({
       ...runtimeParams,
       server,
     }
+    resultTransformer = (result) => {
+      result.server = server
+      return result
+    }
   }
 
-  const result = await run({
+  let result = await run({
     signal: executeOperation.signal,
     logger,
     allocatedMs,
@@ -102,9 +125,11 @@ export const execute = async ({
     collectConsole,
     collectCoverage,
     coverageTempDirectoryUrl,
+    collectPerformance,
     runtime,
     runtimeParams,
   })
+  result = resultTransformer(result)
 
   try {
     if (result.status === "errored") {

package/src/execute/run.js

@@ -1,7 +1,6 @@
 import cuid from "cuid"
 import { Abort, raceCallbacks } from "@jsenv/abort"
 import { resolveUrl, writeFile } from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
 
 export const run = async ({
   signal = new AbortController().signal,
@@ -12,15 +11,12 @@ export const run = async ({
   collectConsole = false,
   collectCoverage = false,
   coverageTempDirectoryUrl,
-  // measurePerformance,
-  // collectPerformance = false,
+  collectPerformance = false,
 
   runtime,
   runtimeParams,
 }) => {
-  const onErrorRef = { current: () => {} }
   const onConsoleRef = { current: () => {} }
-  const onStopRef = { current: () => {} }
   const stopSignal = { notify: () => {} }
 
   let resultTransformer = (result) => result
@@ -105,7 +101,7 @@ export const run = async ({
   try {
     logger.debug(`run() ${runtimeLabel}`)
     runOperation.throwIfAborted()
-    const winnerPromise = new Promise((resolve, reject) => {
+    const winnerPromise = new Promise((resolve) => {
       raceCallbacks(
         {
           aborted: (cb) => {
@@ -114,35 +110,23 @@ export const run = async ({
               runOperation.signal.removeEventListener("abort", cb)
             }
           },
-          errored: (cb) => {
-            onErrorRef.current = (error) => {
-              logger.debug(
-                createDetailedMessage(`error during execution`, {
-                  ["error stack"]: error.stack,
-                  ["runtime"]: runtimeLabel,
-                }),
-              )
-              cb(error)
-            }
-          },
-          stopped: (cb) => {
-            onStopRef.current = cb
-          },
           runned: async (cb) => {
             try {
-              await runtime.run({
-                signal,
+              const result = await runtime.run({
+                signal: runOperation.signal,
                 logger,
                 ...runtimeParams,
+                collectPerformance,
                 keepRunning,
                 stopSignal,
-                onStop: (stopInfo) => onStopRef.current(stopInfo),
-                onError: (error) => onErrorRef.current(error),
                 onConsole: (log) => onConsoleRef.current(log),
-                onResult: cb,
               })
+              cb(result)
             } catch (e) {
-              reject(e)
+              cb({
+                status: "errored",
+                error: e,
+              })
             }
           },
         },
@@ -153,31 +137,16 @@ export const run = async ({
     if (winner.name === "aborted") {
       runOperation.throwIfAborted()
     }
-    if (winner.name === "errored") {
-      return await resultTransformer(
-        createErroredExecutionResult({
-          error: winner.data,
-        }),
-      )
-    }
-    if (winner.name === "stopped") {
-      return await resultTransformer(
-        createErroredExecutionResult({
-          error: new Error(`runtime stopped during execution`),
-        }),
-      )
-    }
-    onErrorRef.current = (error) => {
-      throw error
+    let result = winner.data
+    result = await resultTransformer(result)
+    return result
+  } catch (e) {
+    let result = {
+      status: "errored",
+      error: e,
     }
-    const result = winner.data
-    return await resultTransformer(result)
-  } catch (error) {
-    return await resultTransformer(
-      createErroredExecutionResult({
-        error,
-      }),
-    )
+    result = await resultTransformer(result)
+    return result
   } finally {
     await runOperation.end()
   }
@@ -200,9 +169,3 @@ const createTimedoutResult = () => {
     status: "timedout",
   }
 }
-const createErroredExecutionResult = ({ error }) => {
-  return {
-    status: "errored",
-    error,
-  }
-}