@jsenv/core 27.0.0-alpha.8 → 27.0.0-alpha.80

package/src/dev/plugins/explorer/jsenv_plugin_explorer.js

@@ -1,8 +1,8 @@
 import { readFileSync } from "node:fs"
-import { urlToContentType } from "@jsenv/server"
-import { collectFiles, normalizeStructuredMetaMap } from "@jsenv/filesystem"
+import { DATA_URL } from "@jsenv/urls"
+import { collectFiles } from "@jsenv/filesystem"
 
-import { DataUrl } from "@jsenv/utils/urls/data_url.js"
+import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
 
 export const jsenvPluginExplorer = ({ groups }) => {
   const htmlClientFileUrl = new URL("./client/explorer.html", import.meta.url)
@@ -17,21 +17,17 @@ export const jsenvPluginExplorer = ({ groups }) => {
       if (request.ressource !== "/") {
         return null
       }
-      const structuredMetaMapRelativeForExplorable = {}
+      const associationsForExplorable = {}
       Object.keys(groups).forEach((groupName) => {
         const groupConfig = groups[groupName]
-        structuredMetaMapRelativeForExplorable[groupName] = {
+        associationsForExplorable[groupName] = {
           "**/.jsenv/": false, // avoid visting .jsenv directory in jsenv itself
           ...groupConfig,
         }
       })
-      const structuredMetaMapForExplorable = normalizeStructuredMetaMap(
-        structuredMetaMapRelativeForExplorable,
-        rootDirectoryUrl,
-      )
       const matchingFileResultArray = await collectFiles({
         directoryUrl: rootDirectoryUrl,
-        structuredMetaMap: structuredMetaMapForExplorable,
+        associations: associationsForExplorable,
         predicate: (meta) =>
           Object.keys(meta).some((group) => Boolean(meta[group])),
       })
@@ -41,9 +37,9 @@ export const jsenvPluginExplorer = ({ groups }) => {
       }))
       let html = String(readFileSync(new URL(htmlClientFileUrl)))
       html = html.replace(
-        "FAVICON_HREF",
-        DataUrl.stringify({
-          contentType: urlToContentType(faviconClientFileUrl),
+        "virtual:FAVICON_HREF",
+        DATA_URL.stringify({
+          contentType: CONTENT_TYPE.fromUrlExtension(faviconClientFileUrl),
           base64Flag: true,
           data: readFileSync(new URL(faviconClientFileUrl)).toString("base64"),
         }),

package/src/dev/plugins/toolbar/jsenv_plugin_toolbar.js

@@ -20,7 +20,7 @@ export const jsenvPluginToolbar = ({ logs = false } = {}) => {
     appliesDuring: {
       dev: true,
     },
-    transform: {
+    transformUrlContent: {
       html: ({ url, content }, { referenceUtils }) => {
         if (url === toolbarHtmlClientFileUrl) {
           return null
@@ -28,10 +28,12 @@ export const jsenvPluginToolbar = ({ logs = false } = {}) => {
         const htmlAst = parseHtmlString(content)
         const [toolbarInjectorReference] = referenceUtils.inject({
           type: "js_import_export",
+          expectedType: "js_module",
           specifier: toolbarInjectorClientFileUrl,
         })
         const [toolbarClientFileReference] = referenceUtils.inject({
           type: "iframe_src",
+          expectedType: "html",
           specifier: toolbarHtmlClientFileUrl,
         })
         injectScriptAsEarlyAsPossible(

package/src/dev/start_dev_server.js

@@ -1,21 +1,27 @@
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { createLogger } from "@jsenv/logger"
+import { parentPort } from "node:worker_threads"
 
-import { createTaskLog } from "@jsenv/utils/logs/task_log.js"
+import {
+  assertAndNormalizeDirectoryUrl,
+  registerDirectoryLifecycle,
+} from "@jsenv/filesystem"
+import { createLogger, loggerToLevels, createTaskLog } from "@jsenv/log"
+import { getCallerPosition } from "@jsenv/urls"
+import { initReloadableProcess } from "@jsenv/utils/process_reload/process_reload.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"
+// 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 +29,43 @@ export const startDevServer = async ({
   certificate,
   privateKey,
   keepProcessAlive = true,
-
   rootDirectoryUrl,
-  plugins = [],
+  devServerFiles = {
+    "./package.json": true,
+    "./jsenv.config.mjs": true,
+  },
+  devServerMainFile = getCallerPosition().url,
+  // force disable server autoreload when this code is executed:
+  // - inside a forked child process
+  // - inside a worker thread
+  // (because node cluster won't work)
+  devServerAutoreload = typeof process.send !== "function" &&
+    !parentPort &&
+    !process.env.VSCODE_INSPECTOR_OPTIONS,
+  clientFiles = {
+    "./src/": true,
+    "./test/": true,
+  },
+  cooldownBetweenFileEvents,
+  clientAutoreload = true,
 
   sourcemaps = "inline",
-  autoreload = true,
-  autoreloadPatterns = {
-    "./**": true,
-    "./**/.*/": false, // any folder starting with a dot is ignored (includes .git for instance)
-    "./dist/": false,
-    "./**/node_modules/": false,
+  // default runtimeCompat assume dev server will be request by recent browsers
+  // Used by "jsenv_plugin_node_runtime.js" to deactivate itself
+  // If dev server can be requested by Node.js to exec files
+  // we would add "node" to the potential runtimes. For now it's out of the scope of the dev server
+  // and "jsenv_plugin_node_runtime.js" applies only during build made for node.js
+  runtimeCompat = {
+    chrome: "100",
+    firefox: "100",
+    safari: "15.5",
   },
+  plugins = [],
+  urlAnalysis = {},
+  htmlSupervisor = true,
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  transpilation,
   explorerGroups = {
     source: {
       "./*.html": true,
@@ -44,40 +75,130 @@ export const startDevServer = async ({
       "./test/**/*.test.html": true,
     },
   },
-  toolbar = false,
+  // toolbar = false,
+  writeGeneratedFiles = true,
 }) => {
   const logger = createLogger({ logLevel })
-  const startServerTask = createTaskLog(logger, "start server")
-
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
-  const urlGraph = createUrlGraph()
+  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 startDevServerTask = createTaskLog("start dev server", {
+    disabled: !loggerToLevels(logger).info,
+  })
+
+  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",
+    runtimeCompat,
+    sourcemaps,
+    writeGeneratedFiles,
     plugins: [
       ...plugins,
-      ...getCorePlugins(),
-      ...(autoreload
-        ? [
-            jsenvPluginAutoreload({
-              rootDirectoryUrl,
-              urlGraph,
-              autoreloadPatterns,
-            }),
-          ]
-        : []),
+      ...getCorePlugins({
+        rootDirectoryUrl,
+        urlGraph,
+        scenario: "dev",
+        runtimeCompat,
+
+        urlAnalysis,
+        htmlSupervisor,
+        nodeEsmResolution,
+        fileSystemMagicResolution,
+        transpilation,
+        clientAutoreload,
+        clientFileChangeCallbackList,
+        clientFilesPruneCallbackList,
+      }),
       jsenvPluginExplorer({
         groups: explorerGroups,
       }),
-      ...(toolbar ? [jsenvPluginToolbar(toolbar)] : []),
+      // ...(toolbar ? [jsenvPluginToolbar(toolbar)] : []),
     ],
-    scenario: "dev",
-    sourcemaps,
   })
   const server = await startOmegaServer({
-    logger,
+    logLevel: omegaServerLogLevel,
     keepProcessAlive,
     listenAnyIp,
     port,
@@ -90,7 +211,7 @@ export const startDevServer = async ({
     kitchen,
     scenario: "dev",
   })
-  startServerTask.done()
+  startDevServerTask.done()
   logger.info(``)
   Object.keys(server.origins).forEach((key) => {
     logger.info(`- ${server.origins[key]}`)
@@ -98,8 +219,14 @@ export const startDevServer = async ({
   logger.info(``)
   server.addEffect(() => {
     return () => {
-      kitchen.pluginController.callHooks("destroy")
+      kitchen.pluginController.callHooks("destroy", {})
     }
   })
-  return server
+  return {
+    origin: server.origin,
+    stop: () => {
+      stopWatchingClientFiles()
+      server.stop()
+    },
+  }
 }

package/src/execute/execute.js

@@ -1,10 +1,9 @@
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 
 import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { createLogger } from "@jsenv/logger"
-
+import { createLogger } from "@jsenv/log"
+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 +22,18 @@ export const execute = async ({
   collectConsole,
   collectCoverage,
   coverageTempDirectoryUrl,
+  collectPerformance = false,
   runtime,
   runtimeParams,
 
-  plugins = [],
   scenario = "dev",
   sourcemaps = "inline",
+  plugins = [],
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  transpilation,
+  htmlSupervisor = true,
+  writeGeneratedFiles = false,
 
   port,
   protocol,
@@ -53,6 +58,7 @@ export const execute = async ({
     })
   }
 
+  let resultTransformer = (result) => result
   runtimeParams = {
     rootDirectoryUrl,
     fileRelativeUrl,
@@ -60,19 +66,34 @@ export const execute = async ({
   }
   if (runtime.needsServer) {
     const urlGraph = createUrlGraph()
+    const runtimeCompat = { [runtime.name]: runtime.version }
     const kitchen = createKitchen({
       signal,
       logger,
       rootDirectoryUrl,
       urlGraph,
-      plugins: [...plugins, ...getCorePlugins()],
       scenario,
       sourcemaps,
+      runtimeCompat,
+      writeGeneratedFiles,
+      plugins: [
+        ...plugins,
+        ...getCorePlugins({
+          rootDirectoryUrl,
+          urlGraph,
+          scenario,
+          runtimeCompat,
+
+          htmlSupervisor,
+          nodeEsmResolution,
+          fileSystemMagicResolution,
+          transpilation,
+        }),
+      ],
     })
-    const serverLogger = createLogger({ logLevel: "warn" })
     const server = await startOmegaServer({
       signal: executeOperation.signal,
-      logger: serverLogger,
+      logLevel: "warn",
       rootDirectoryUrl,
       urlGraph,
       kitchen,
@@ -91,9 +112,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 +127,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,7 @@
 import cuid from "cuid"
 import { Abort, raceCallbacks } from "@jsenv/abort"
-import { resolveUrl, writeFile } from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
+import { resolveUrl } from "@jsenv/urls"
+import { writeFile } from "@jsenv/filesystem"
 
 export const run = async ({
   signal = new AbortController().signal,
@@ -12,15 +12,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 +102,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 +111,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 +138,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 +170,3 @@ const createTimedoutResult = () => {
     status: "timedout",
   }
 }
-const createErroredExecutionResult = ({ error }) => {
-  return {
-    status: "errored",
-    error,
-  }
-}