@jsenv/core 27.0.0-alpha.9 → 27.0.0-alpha.92

package/src/build/version_generator.js

@@ -0,0 +1,60 @@
+import { createHash } from "node:crypto"
+
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
+
+// https://github.com/rollup/rollup/blob/19e50af3099c2f627451a45a84e2fa90d20246d5/src/utils/FileEmitter.ts#L47
+// https://github.com/rollup/rollup/blob/5a5391971d695c808eed0c5d7d2c6ccb594fc689/src/Chunk.ts#L870
+export const createVersionGenerator = () => {
+  const hash = createHash("sha256")
+
+  const augmentWithContent = ({
+    content,
+    contentType = "application/octet-stream",
+    lineBreakNormalization = false,
+  }) => {
+    hash.update(
+      lineBreakNormalization && CONTENT_TYPE.isTextual(contentType)
+        ? normalizeLineBreaks(content)
+        : content,
+    )
+  }
+
+  const augmentWithDependencyVersion = (version) => {
+    hash.update(version)
+  }
+
+  return {
+    augmentWithContent,
+    augmentWithDependencyVersion,
+    generate: () => {
+      return hash.digest("hex").slice(0, 8)
+    },
+  }
+}
+
+const normalizeLineBreaks = (stringOrBuffer) => {
+  if (typeof stringOrBuffer === "string") {
+    const stringWithLinuxBreaks = stringOrBuffer.replace(/\r\n/g, "\n")
+    return stringWithLinuxBreaks
+  }
+  return normalizeLineBreaksForBuffer(stringOrBuffer)
+}
+
+// https://github.com/nodejs/help/issues/1738#issuecomment-458460503
+const normalizeLineBreaksForBuffer = (buffer) => {
+  const int32Array = new Int32Array(buffer, 0, buffer.length)
+  const int32ArrayWithLineBreaksNormalized = int32Array.filter(
+    (element, index, typedArray) => {
+      if (element === 0x0d) {
+        if (typedArray[index + 1] === 0x0a) {
+          // Windows -> Unix
+          return false
+        }
+        // Mac OS -> Unix
+        typedArray[index] = 0x0a
+      }
+      return true
+    },
+  )
+  return Buffer.from(int32ArrayWithLineBreaksNormalized)
+}

package/src/dev/plugins/explorer/client/explorer.html

@@ -4,7 +4,7 @@
     <title>Exploring</title>
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta charset="utf-8" />
-    <link rel="icon" href="FAVICON_HREF" />
+    <link rel="icon" href="ignore:FAVICON_HREF" />
     <style>
       button:focus,
       a:focus,

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

@@ -1,8 +1,7 @@
 import { readFileSync } from "node:fs"
-import { urlToContentType } from "@jsenv/server"
-import { collectFiles, normalizeStructuredMetaMap } from "@jsenv/filesystem"
-
-import { DataUrl } from "@jsenv/utils/urls/data_url.js"
+import { DATA_URL } from "@jsenv/urls"
+import { collectFiles } from "@jsenv/filesystem"
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
 
 export const jsenvPluginExplorer = ({ groups }) => {
   const htmlClientFileUrl = new URL("./client/explorer.html", import.meta.url)
@@ -17,21 +16,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 +36,9 @@ export const jsenvPluginExplorer = ({ groups }) => {
       }))
       let html = String(readFileSync(new URL(htmlClientFileUrl)))
       html = html.replace(
-        "FAVICON_HREF",
-        DataUrl.stringify({
-          contentType: urlToContentType(faviconClientFileUrl),
+        "ignore:FAVICON_HREF",
+        DATA_URL.stringify({
+          contentType: CONTENT_TYPE.fromUrlExtension(faviconClientFileUrl),
           base64Flag: true,
           data: readFileSync(new URL(faviconClientFileUrl)).toString("base64"),
         }),

package/src/dev/plugins/toolbar/client/util/fetching.js

@@ -1,4 +1,4 @@
-import { memoize } from "@jsenv/utils/memoize/memoize.js"
+import { memoize } from "@jsenv/utils/src/memoize/memoize.js"
 
 const fetchPolyfill = async (...args) => {
   const { fetchUsingXHR } = await loadPolyfill()

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

@@ -1,9 +1,9 @@
 import {
   parseHtmlString,
   stringifyHtmlAst,
-  injectScriptAsEarlyAsPossible,
+  injectScriptNodeAsEarlyAsPossible,
   createHtmlNode,
-} from "@jsenv/utils/html_ast/html_ast.js"
+} from "@jsenv/ast"
 
 export const jsenvPluginToolbar = ({ logs = false } = {}) => {
   const toolbarInjectorClientFileUrl = new URL(
@@ -20,7 +20,7 @@ export const jsenvPluginToolbar = ({ logs = false } = {}) => {
     appliesDuring: {
       dev: true,
     },
-    transform: {
+    transformUrlContent: {
       html: ({ url, content }, { referenceUtils }) => {
         if (url === toolbarHtmlClientFileUrl) {
           return null
@@ -28,13 +28,15 @@ 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(
+        injectScriptNodeAsEarlyAsPossible(
           htmlAst,
           createHtmlNode({
             "tagName": "script",

package/src/dev/start_dev_server.js

@@ -1,21 +1,28 @@
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { createLogger } from "@jsenv/logger"
+import { findFreePort } from "@jsenv/server"
+import {
+  assertAndNormalizeDirectoryUrl,
+  registerDirectoryLifecycle,
+} from "@jsenv/filesystem"
+import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
+import { createLogger, loggerToLevels, createTaskLog } from "@jsenv/log"
+import { getCallerPosition } from "@jsenv/urls"
 
-import { createTaskLog } from "@jsenv/utils/logs/task_log.js"
+import { createReloadableWorker } from "@jsenv/core/src/helpers/worker_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 = true,
+  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 +30,42 @@ 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
+  // - debugged by vscode
+  // otherwise we get net:ERR_CONNECTION_REFUSED
+  devServerAutoreload = typeof process.send !== "function" &&
+    !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,138 @@ 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 operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+  if (handleSIGINT) {
+    operation.addAbortSource((abort) => {
+      return raceProcessTeardownEvents(
+        {
+          SIGINT: true,
+        },
+        abort,
+      )
+    })
+  }
+  if (port === 0) {
+    port = await findFreePort(port, { signal: operation.signal })
+  }
+
+  const reloadableWorker = createReloadableWorker(devServerMainFile)
+  if (devServerAutoreload && reloadableWorker.isPrimary) {
+    const devServerFileChangeCallback = ({ relativeUrl, event }) => {
+      const url = new URL(relativeUrl, rootDirectoryUrl).href
+      logger.info(`file ${event} ${url} -> restarting server...`)
+      reloadableWorker.reload()
+    }
+    const stopWatchingDevServerFiles = 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" })
+        },
+      },
+    )
+    operation.addAbortCallback(() => {
+      stopWatchingDevServerFiles()
+      reloadableWorker.terminate()
+    })
+
+    const worker = await reloadableWorker.load()
+    if (!keepProcessAlive) {
+      worker.unref()
+    }
+    return {
+      origin: `${protocol}://127.0.0.1:${port}`,
+      stop: () => {
+        stopWatchingDevServerFiles()
+        reloadableWorker.terminate()
+      },
+    }
+  }
+
+  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 +219,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 +227,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,
-  }
-}