@jsenv/core 27.0.0-alpha.3 → 27.0.0-alpha.32

package/src/dev/start_dev_server.js

@@ -1,21 +1,22 @@
 import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { createLogger } from "@jsenv/logger"
 
+import { initProcessAutorestart } from "@jsenv/utils/file_watcher/process_auto_restart.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,
+  handleSIGINT,
   logLevel,
-  port,
-  protocol,
+  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 +24,16 @@ export const startDevServer = async ({
   certificate,
   privateKey,
   keepProcessAlive = true,
-
   rootDirectoryUrl,
-  plugins = [],
 
   sourcemaps = "inline",
+  plugins = [],
+  htmlSupervisor = true,
+  injectedGlobals,
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  transpilation,
   autoreload = true,
-  autoreloadPatterns = {
-    "./**": true,
-    "./**/.*/": false, // any folder starting with a dot is ignored (includes .git for instance)
-    "./dist/": false,
-    "./**/node_modules/": false,
-  },
   explorerGroups = {
     source: {
       "./*.html": true,
@@ -45,36 +44,66 @@ export const startDevServer = async ({
     },
   },
   toolbar = false,
+  autorestart,
 }) => {
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
+  const autorestartProcess = await initProcessAutorestart({
+    signal,
+    handleSIGINT,
+    ...(autorestart
+      ? {
+          enabled: true,
+          logLevel: autorestart.logLevel,
+          urlToRestart: autorestart.url,
+          urlsToWatch: [
+            ...(autorestart.urlsToWatch || []),
+            new URL("package.json", rootDirectoryUrl),
+            new URL("jsenv.config.mjs", rootDirectoryUrl),
+          ],
+        }
+      : {
+          enabled: false,
+        }),
+  })
+  if (autorestartProcess.isPrimary) {
+    return {
+      origin: `${protocol}://127.0.0.1:${port}`,
+      stop: () => {
+        autorestartProcess.stop()
+      },
+    }
+  }
+
   const logger = createLogger({ logLevel })
   const startServerTask = createTaskLog(logger, "start server")
 
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
   const urlGraph = createUrlGraph()
   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,
+        autoreload,
+      }),
       jsenvPluginExplorer({
         groups: explorerGroups,
       }),
       ...(toolbar ? [jsenvPluginToolbar(toolbar)] : []),
     ],
-    scenario: "dev",
-    sourcemaps,
   })
   const server = await startOmegaServer({
     logger,
@@ -101,5 +130,8 @@ export const startDevServer = async ({
       kitchen.pluginController.callHooks("destroy")
     }
   })
-  return server
+  return {
+    origin: server.origin,
+    stop: 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,9 +72,22 @@ 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({
@@ -91,9 +111,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 +126,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,
-  }
-}