@jsenv/core 27.0.0-alpha.81 → 27.0.0-alpha.84

package/src/helpers/command/command.js

@@ -0,0 +1,73 @@
+import { exec } from "node:child_process"
+import { createDetailedMessage, createLogger, UNICODE } from "@jsenv/log"
+
+export const executeCommand = (
+  command,
+  {
+    logLevel = "info",
+    signal = new AbortController().signal,
+    onStdout = () => {},
+    onStderr = () => {},
+    cwd,
+    env,
+    timeout,
+  } = {},
+) => {
+  const logger = createLogger({ logLevel })
+
+  return new Promise((resolve, reject) => {
+    logger.debug(`${UNICODE.COMMAND} ${command}`)
+    const commandProcess = exec(command, {
+      signal,
+      cwd:
+        cwd && typeof cwd === "string" && cwd.startsWith("file:")
+          ? new URL(cwd)
+          : cwd,
+      env,
+      timeout,
+      silent: true,
+    })
+    commandProcess.on("error", (error) => {
+      if (error && error.code === "ETIMEDOUT") {
+        logger.error(`timeout after ${timeout} ms`)
+        reject(error)
+      } else {
+        reject(error)
+      }
+    })
+    const stdoutDatas = []
+    commandProcess.stdout.on("data", (data) => {
+      stdoutDatas.push(data)
+      logger.debug(data)
+      onStderr(data)
+    })
+    let stderrDatas = []
+    commandProcess.stderr.on("data", (data) => {
+      stderrDatas.push(data)
+      logger.debug(data)
+      onStdout(data)
+    })
+    if (commandProcess.stdin) {
+      commandProcess.stdin.on("error", (error) => {
+        reject(error)
+      })
+    }
+    commandProcess.on("exit", (exitCode, signal) => {
+      if (signal) {
+        reject(new Error(`killed with ${signal}`))
+      }
+      if (exitCode) {
+        reject(
+          new Error(
+            createDetailedMessage(`failed with exit code ${exitCode}`, {
+              "command stderr": stderrDatas.join(""),
+              // "command stdout": stdoutDatas.join(""),
+            }),
+          ),
+        )
+        return
+      }
+      resolve({ exitCode, signal })
+    })
+  })
+}

package/src/helpers/event_source/event_source.js

@@ -0,0 +1,197 @@
+/* eslint-env browser */
+
+export const createEventSourceConnection = (
+  eventSourceUrl,
+  events = {},
+  { retryMaxAttempt = Infinity, retryAllocatedMs = Infinity, lastEventId } = {},
+) => {
+  const { EventSource } = window
+  if (typeof EventSource !== "function") {
+    return () => {}
+  }
+
+  const eventSourceOrigin = new URL(eventSourceUrl).origin
+  Object.keys(events).forEach((eventName) => {
+    const eventCallback = events[eventName]
+    events[eventName] = (e) => {
+      if (e.origin === eventSourceOrigin) {
+        if (e.lastEventId) {
+          lastEventId = e.lastEventId
+        }
+        eventCallback(e)
+      }
+    }
+  })
+
+  const status = {
+    value: "default",
+    goTo: (value) => {
+      if (value === status.value) {
+        return
+      }
+      status.value = value
+      status.onchange()
+    },
+    onchange: () => {},
+  }
+  let _disconnect = () => {}
+
+  const attemptConnection = (url) => {
+    const eventSource = new EventSource(url, {
+      withCredentials: true,
+    })
+    _disconnect = () => {
+      if (status.value !== "connecting" && status.value !== "connected") {
+        console.warn(
+          `disconnect() ignored because connection is ${status.value}`,
+        )
+        return
+      }
+      eventSource.onerror = undefined
+      eventSource.close()
+      Object.keys(events).forEach((eventName) => {
+        eventSource.removeEventListener(eventName, events[eventName])
+      })
+      status.goTo("disconnected")
+    }
+    let retryCount = 0
+    let firstRetryMs = Date.now()
+    eventSource.onerror = (errorEvent) => {
+      if (errorEvent.target.readyState === EventSource.CONNECTING) {
+        if (retryCount > retryMaxAttempt) {
+          console.info(`could not connect after ${retryMaxAttempt} attempt`)
+          _disconnect()
+          return
+        }
+
+        if (retryCount === 0) {
+          firstRetryMs = Date.now()
+        } else {
+          const allRetryDuration = Date.now() - firstRetryMs
+          if (retryAllocatedMs && allRetryDuration > retryAllocatedMs) {
+            console.info(
+              `could not connect in less than ${retryAllocatedMs} ms`,
+            )
+            _disconnect()
+            return
+          }
+        }
+
+        retryCount++
+        status.goTo("connecting")
+        return
+      }
+
+      if (errorEvent.target.readyState === EventSource.CLOSED) {
+        _disconnect()
+        return
+      }
+    }
+    eventSource.onopen = () => {
+      status.goTo("connected")
+    }
+    Object.keys(events).forEach((eventName) => {
+      eventSource.addEventListener(eventName, events[eventName])
+    })
+    if (!events.hasOwnProperty("welcome")) {
+      eventSource.addEventListener("welcome", (e) => {
+        if (e.origin === eventSourceOrigin && e.lastEventId) {
+          lastEventId = e.lastEventId
+        }
+      })
+    }
+    status.goTo("connecting")
+  }
+
+  let connect = () => {
+    attemptConnection(eventSourceUrl)
+    connect = () => {
+      attemptConnection(
+        lastEventId
+          ? addLastEventIdIntoUrlSearchParams(eventSourceUrl, lastEventId)
+          : eventSourceUrl,
+      )
+    }
+  }
+
+  const removePageUnloadListener = listenPageUnload(() => {
+    if (status.value === "connecting" || status.value === "connected") {
+      _disconnect()
+    }
+  })
+
+  const destroy = () => {
+    removePageUnloadListener()
+    _disconnect()
+  }
+
+  return {
+    status,
+    connect,
+    disconnect: () => _disconnect(),
+    destroy,
+  }
+}
+
+const addLastEventIdIntoUrlSearchParams = (url, lastEventId) => {
+  if (url.indexOf("?") === -1) {
+    url += "?"
+  } else {
+    url += "&"
+  }
+  return `${url}last-event-id=${encodeURIComponent(lastEventId)}`
+}
+
+// const listenPageMightFreeze = (callback) => {
+//   const removePageHideListener = listenEvent(window, "pagehide", (pageHideEvent) => {
+//     if (pageHideEvent.persisted === true) {
+//       callback(pageHideEvent)
+//     }
+//   })
+//   return removePageHideListener
+// }
+
+// const listenPageFreeze = (callback) => {
+//   const removeFreezeListener = listenEvent(document, "freeze", (freezeEvent) => {
+//     callback(freezeEvent)
+//   })
+//   return removeFreezeListener
+// }
+
+// const listenPageIsRestored = (callback) => {
+//   const removeResumeListener = listenEvent(document, "resume", (resumeEvent) => {
+//     removePageshowListener()
+//     callback(resumeEvent)
+//   })
+//   const removePageshowListener = listenEvent(window, "pageshow", (pageshowEvent) => {
+//     if (pageshowEvent.persisted === true) {
+//       removePageshowListener()
+//       removeResumeListener()
+//       callback(pageshowEvent)
+//     }
+//   })
+//   return () => {
+//     removeResumeListener()
+//     removePageshowListener()
+//   }
+// }
+
+const listenPageUnload = (callback) => {
+  const removePageHideListener = listenEvent(
+    window,
+    "pagehide",
+    (pageHideEvent) => {
+      if (pageHideEvent.persisted !== true) {
+        callback(pageHideEvent)
+      }
+    },
+  )
+  return removePageHideListener
+}
+
+const listenEvent = (emitter, event, callback) => {
+  emitter.addEventListener(event, callback)
+  return () => {
+    emitter.removeEventListener(event, callback)
+  }
+}

package/src/helpers/event_source/sse_service.js

@@ -0,0 +1,53 @@
+import { createSSERoom } from "@jsenv/server"
+import { createCallbackListNotifiedOnce } from "@jsenv/abort"
+
+export const createSSEService = ({ serverEventCallbackList }) => {
+  const destroyCallbackList = createCallbackListNotifiedOnce()
+
+  const cache = []
+  const sseRoomLimit = 100
+  const getOrCreateSSERoom = (request) => {
+    const htmlFileRelativeUrl = request.ressource.slice(1)
+    const cacheEntry = cache.find(
+      (cacheEntryCandidate) =>
+        cacheEntryCandidate.htmlFileRelativeUrl === htmlFileRelativeUrl,
+    )
+    if (cacheEntry) {
+      return cacheEntry.sseRoom
+    }
+    const sseRoom = createSSERoom({
+      retryDuration: 2000,
+      historyLength: 100,
+      welcomeEventEnabled: true,
+      effect: () => {
+        return serverEventCallbackList.add((event) => {
+          sseRoom.sendEvent(event)
+        })
+      },
+    })
+    const removeSSECleanupCallback = destroyCallbackList.add(() => {
+      removeSSECleanupCallback()
+      sseRoom.close()
+    })
+    cache.push({
+      htmlFileRelativeUrl,
+      sseRoom,
+      cleanup: () => {
+        removeSSECleanupCallback()
+        sseRoom.close()
+      },
+    })
+    if (cache.length >= sseRoomLimit) {
+      const firstCacheEntry = cache.shift()
+      firstCacheEntry.cleanup()
+    }
+    return sseRoom
+  }
+
+  return {
+    getOrCreateSSERoom,
+    destroy: () => {
+      destroyCallbackList.notify()
+    },
+  }
+}

package/src/helpers/worker_reload.js

@@ -0,0 +1,57 @@
+import { fileURLToPath } from "node:url"
+import { Worker, workerData } from "node:worker_threads"
+
+// https://nodejs.org/api/worker_threads.html
+export const createReloadableWorker = (workerFileUrl, options = {}) => {
+  const workerFilePath = fileURLToPath(workerFileUrl)
+  const isPrimary = !workerData || workerData.workerFilePath !== workerFilePath
+  let worker
+
+  const terminate = async () => {
+    if (worker) {
+      let _worker = worker
+      worker = null
+      const exitPromise = new Promise((resolve) => {
+        _worker.once("exit", resolve)
+      })
+      _worker.terminate()
+      await exitPromise
+    }
+  }
+
+  const load = async () => {
+    if (!isPrimary) {
+      throw new Error(`worker can be loaded from primary file only`)
+    }
+    worker = new Worker(workerFilePath, {
+      ...options,
+      workerData: {
+        ...options.workerData,
+        workerFilePath,
+      },
+    })
+
+    worker.once("error", (error) => {
+      console.error(error)
+    })
+    await new Promise((resolve) => {
+      worker.once("online", resolve)
+    })
+    worker.once("exit", () => {
+      worker = null
+    })
+    return worker
+  }
+
+  const reload = async () => {
+    await terminate()
+    await load()
+  }
+
+  return {
+    isPrimary,
+    load,
+    reload,
+    terminate,
+  }
+}

package/src/omega/compat/runtime_compat.js

@@ -1,4 +1,5 @@
-import { findHighestVersion } from "@jsenv/utils/semantic_versioning/highest_version.js"
+import { findHighestVersion } from "@jsenv/utils/src/semantic_versioning/highest_version.js"
+
 import { featureCompats } from "./features_compats.js"
 
 export const RUNTIME_COMPAT = {

package/src/omega/kitchen.js

@@ -8,7 +8,8 @@ import {
 } from "@jsenv/urls"
 import { writeFileSync, ensureWindowsDriveLetter } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/log"
-import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
+
 import { createPluginController } from "../plugins/plugin_controller.js"
 import { urlSpecifierEncoding } from "./url_specifier_encoding.js"
 import { createUrlInfoTransformer } from "./url_graph/url_info_transformations.js"

package/src/omega/server/user_agent.js

@@ -1,4 +1,5 @@
-import { memoizeByFirstArgument } from "@jsenv/utils/memoize/memoize_by_first_argument.js"
+import { memoizeByFirstArgument } from "@jsenv/utils/src/memoize/memoize_by_first_argument.js"
+
 import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
 
 export const parseUserAgentHeader = memoizeByFirstArgument((userAgent) => {

package/src/omega/url_graph/sort_by_dependencies.js

@@ -0,0 +1,27 @@
+export const sortByDependencies = (nodes) => {
+  const visited = []
+  const sorted = []
+  const circular = []
+  const visit = (url) => {
+    const isSorted = sorted.includes(url)
+    if (isSorted) {
+      return
+    }
+    const isVisited = visited.includes(url)
+    if (isVisited) {
+      circular.push(url)
+      sorted.push(url)
+    } else {
+      visited.push(url)
+      nodes[url].dependencies.forEach((dependencyUrl) => {
+        visit(dependencyUrl, url)
+      })
+      sorted.push(url)
+    }
+  }
+  Object.keys(nodes).forEach((url) => {
+    visit(url)
+  })
+  sorted.circular = circular
+  return sorted
+}

package/src/omega/url_graph/url_info_transformations.js

@@ -1,12 +1,12 @@
+import { pathToFileURL } from "node:url"
 import { bufferToEtag } from "@jsenv/filesystem"
-import { urlToRelativeUrl } from "@jsenv/urls"
-
-import { composeTwoSourcemaps } from "@jsenv/utils/sourcemap/sourcemap_composition_v3.js"
+import { urlToRelativeUrl, isFileSystemPath } from "@jsenv/urls"
 import {
+  composeTwoSourcemaps,
   SOURCEMAP,
-  sourcemapToBase64Url,
-  generateSourcemapUrl,
-} from "@jsenv/utils/sourcemap/sourcemap_utils.js"
+  generateSourcemapFileUrl,
+  generateSourcemapDataUrl,
+} from "@jsenv/sourcemap"
 
 export const createUrlInfoTransformer = ({
   logger,
@@ -23,18 +23,25 @@ export const createUrlInfoTransformer = ({
     sourcemaps === "programmatic"
 
   const normalizeSourcemap = (urlInfo, sourcemap) => {
+    let { sources } = sourcemap
+    if (sources) {
+      sources = sources.map((source) => {
+        if (source && isFileSystemPath(source)) {
+          return String(pathToFileURL(source))
+        }
+        return source
+      })
+    }
     const wantSourcesContent =
       // for inline content (<script> insdide html)
       // chrome won't be able to fetch the file as it does not exists
       // so sourcemap must contain sources
       sourcemapsSourcesContent ||
       urlInfo.isInline ||
-      (sourcemap.sources &&
-        sourcemap.sources.some(
-          (source) => !source || !source.startsWith("file:"),
-        ))
-    if (sourcemap.sources && sourcemap.sources.length > 1) {
-      sourcemap.sources = sourcemap.sources.map(
+      (sources &&
+        sources.some((source) => !source || !source.startsWith("file:")))
+    if (sources && sources.length > 1) {
+      sourcemap.sources = sources.map(
         (source) => new URL(source, urlInfo.originalUrl).href,
       )
       if (!wantSourcesContent) {
@@ -65,7 +72,9 @@ export const createUrlInfoTransformer = ({
     // when jsenv is done cooking the file
     //   during build it's urlInfo.url to be inside the build
     //   but otherwise it's generatedUrl to be inside .jsenv/ directory
-    urlInfo.sourcemapGeneratedUrl = generateSourcemapUrl(urlInfo.generatedUrl)
+    urlInfo.sourcemapGeneratedUrl = generateSourcemapFileUrl(
+      urlInfo.generatedUrl,
+    )
     const [sourcemapReference, sourcemapUrlInfo] = injectSourcemapPlaceholder({
       urlInfo,
       specifier: urlInfo.sourcemapGeneratedUrl,
@@ -154,7 +163,8 @@ export const createUrlInfoTransformer = ({
       }
       sourcemapUrlInfo.content = JSON.stringify(sourcemap, null, "  ")
       if (sourcemaps === "inline") {
-        sourcemapReference.generatedSpecifier = sourcemapToBase64Url(sourcemap)
+        sourcemapReference.generatedSpecifier =
+          generateSourcemapDataUrl(sourcemap)
       }
       if (sourcemaps === "file" || sourcemaps === "inline") {
         urlInfo.content = SOURCEMAP.writeComment({

package/src/plugins/autoreload/dev_sse/client/event_source_client.js

@@ -1,4 +1,4 @@
-import { createEventSourceConnection } from "@jsenv/utils/event_source/event_source.js"
+import { createEventSourceConnection } from "@jsenv/core/src/helpers/event_source/event_source.js"
 import { urlHotMetas } from "../../../import_meta_hot/client/import_meta_hot.js"
 import {
   isAutoreloadEnabled,

package/src/plugins/autoreload/dev_sse/client/reload.js

@@ -1,4 +1,4 @@
-import { htmlAttributeSrcSet } from "@jsenv/utils/html_ast/html_attribute_src_set.js"
+import { htmlAttributeSrcSet } from "@jsenv/utils/src/html_ast/html_attribute_src_set.js"
 
 import { injectQuery, compareTwoUrlPaths } from "./url_helpers.js"
 

package/src/plugins/autoreload/dev_sse/jsenv_plugin_dev_sse_client.js

@@ -3,7 +3,7 @@ import {
   stringifyHtmlAst,
   injectScriptAsEarlyAsPossible,
   createHtmlNode,
-} from "@jsenv/utils/html_ast/html_ast.js"
+} from "@jsenv/utils/src/html_ast/html_ast.js"
 
 export const jsenvPluginDevSSEClient = () => {
   const eventSourceClientFileUrl = new URL(

package/src/plugins/autoreload/dev_sse/jsenv_plugin_dev_sse_server.js

@@ -1,7 +1,7 @@
 import { urlToRelativeUrl } from "@jsenv/urls"
 import { createCallbackList } from "@jsenv/abort"
 
-import { createSSEService } from "@jsenv/utils/event_source/sse_service.js"
+import { createSSEService } from "@jsenv/core/src/helpers/event_source/sse_service.js"
 
 export const jsenvPluginDevSSEServer = ({
   rootDirectoryUrl,

package/src/plugins/bundling/css/bundle_css.js

@@ -6,10 +6,11 @@
  *   It can be quite challenging, see "bundle_sourcemap.js"
  */
 
-import { applyPostCss } from "@jsenv/utils/css_ast/apply_post_css.js"
-import { postCssPluginUrlVisitor } from "@jsenv/utils/css_ast/postcss_plugin_url_visitor.js"
-import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
-import { sortByDependencies } from "@jsenv/utils/graph/sort_by_dependencies.js"
+import { createMagicSource } from "@jsenv/sourcemap"
+import { applyPostCss } from "@jsenv/utils/src/css_ast/apply_post_css.js"
+import { postCssPluginUrlVisitor } from "@jsenv/utils/src/css_ast/postcss_plugin_url_visitor.js"
+
+import { sortByDependencies } from "@jsenv/core/src/omega/url_graph/sort_by_dependencies.js"
 
 // Do not use until https://github.com/parcel-bundler/parcel-css/issues/181
 export const bundleCss = async ({ cssUrlInfos, context }) => {

package/src/plugins/bundling/js_module/bundle_js_module.js

@@ -4,8 +4,8 @@ import { URL_META } from "@jsenv/url-meta"
 import { isFileSystemPath } from "@jsenv/urls"
 import { createDetailedMessage } from "@jsenv/log"
 import { babelHelperNameFromUrl } from "@jsenv/babel-plugins"
-import { applyRollupPlugins } from "@jsenv/utils/js_ast/apply_rollup_plugins.js"
-import { sourcemapConverter } from "@jsenv/utils/sourcemap/sourcemap_converter.js"
+import { sourcemapConverter } from "@jsenv/sourcemap"
+import { applyRollupPlugins } from "@jsenv/utils/src/js_ast/apply_rollup_plugins.js"
 import { fileUrlConverter } from "@jsenv/core/src/omega/file_url_converter.js"
 
 const globalThisClientFileUrl = new URL(

package/src/plugins/commonjs_globals/jsenv_plugin_commonjs_globals.js

@@ -7,8 +7,8 @@
  * - global
  */
 
-import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
-import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
+import { createMagicSource } from "@jsenv/sourcemap"
+import { applyBabelPlugins } from "@jsenv/utils/src/js_ast/apply_babel_plugins.js"
 
 export const jsenvPluginCommonJsGlobals = () => {
   const transformCommonJsGlobals = async (urlInfo, { scenario }) => {

package/src/plugins/file_urls/jsenv_plugin_file_urls.js

@@ -6,12 +6,11 @@ import {
   urlToFilename,
   ensurePathnameTrailingSlash,
 } from "@jsenv/urls"
-
 import {
   applyFileSystemMagicResolution,
   getExtensionsToTry,
 } from "@jsenv/node-esm-resolution"
-import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
 
 export const jsenvPluginFileUrls = ({
   magicExtensions = ["inherit", ".js"],

package/src/plugins/html_supervisor/jsenv_plugin_html_supervisor.js

@@ -17,7 +17,7 @@ import {
   getHtmlNodeTextNode,
   removeHtmlNodeText,
   setHtmlNodeGeneratedText,
-} from "@jsenv/utils/html_ast/html_ast.js"
+} from "@jsenv/utils/src/html_ast/html_ast.js"
 import { generateInlineContentUrl } from "@jsenv/urls"
 
 export const jsenvPluginHtmlSupervisor = ({

package/src/plugins/import_meta_hot/html_hot_dependencies.js

@@ -1,8 +1,8 @@
 import {
   getHtmlNodeAttributeByName,
   parseLinkNode,
-} from "@jsenv/utils/html_ast/html_ast.js"
-import { htmlAttributeSrcSet } from "@jsenv/utils/html_ast/html_attribute_src_set.js"
+} from "@jsenv/utils/src/html_ast/html_ast.js"
+import { htmlAttributeSrcSet } from "@jsenv/utils/src/html_ast/html_attribute_src_set.js"
 
 // Some "smart" default applied to decide what should hot reload / fullreload:
 // By default:

package/src/plugins/import_meta_hot/jsenv_plugin_import_meta_hot.js

@@ -1,6 +1,7 @@
-import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
-import { parseHtmlString } from "@jsenv/utils/html_ast/html_ast.js"
-import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
+import { createMagicSource } from "@jsenv/sourcemap"
+import { parseHtmlString } from "@jsenv/utils/src/html_ast/html_ast.js"
+import { applyBabelPlugins } from "@jsenv/utils/src/js_ast/apply_babel_plugins.js"
+
 import { collectHotDataFromHtmlAst } from "./html_hot_dependencies.js"
 import { babelPluginMetadataImportMetaHot } from "./babel_plugin_metadata_import_meta_hot.js"
 

package/src/plugins/import_meta_scenarios/jsenv_plugin_import_meta_scenarios.js

@@ -9,8 +9,8 @@
  * - replaced by undefined (import.meta.dev but it's build; the goal is to ensure it's tree-shaked)
  */
 
-import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
-import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
+import { createMagicSource } from "@jsenv/sourcemap"
+import { applyBabelPlugins } from "@jsenv/utils/src/js_ast/apply_babel_plugins.js"
 
 export const jsenvPluginImportMetaScenarios = () => {
   return {

package/src/plugins/importmap/jsenv_plugin_importmap.js

@@ -22,7 +22,7 @@ import {
   composeTwoImportMaps,
   normalizeImportMap,
 } from "@jsenv/importmap"
-
+import { generateInlineContentUrl } from "@jsenv/urls"
 import {
   parseHtmlString,
   stringifyHtmlAst,
@@ -33,8 +33,7 @@ import {
   setHtmlNodeGeneratedText,
   getHtmlNodeTextNode,
   removeHtmlNode,
-} from "@jsenv/utils/html_ast/html_ast.js"
-import { generateInlineContentUrl } from "@jsenv/urls"
+} from "@jsenv/utils/src/html_ast/html_ast.js"
 
 export const jsenvPluginImportmap = () => {
   let finalImportmap = null