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

package/src/dev/plugins/autoreload/sse_service.js

@@ -1,149 +0,0 @@
-import { createSSERoom } from "@jsenv/server"
-import { registerDirectoryLifecycle } from "@jsenv/filesystem"
-import {
-  createCallbackList,
-  createCallbackListNotifiedOnce,
-} from "@jsenv/abort"
-
-export const createSSEService = ({
-  rootDirectoryUrl,
-  autoreloadPatterns,
-  onFileChange,
-  hotUpdateCallbackList,
-}) => {
-  const destroyCallbackList = createCallbackListNotifiedOnce()
-  const projectFileModified = createCallbackList()
-  const projectFileRemoved = createCallbackList()
-  const projectFileAdded = createCallbackList()
-  const watchProjectFiles = (callback) => {
-    const removeModifiedCallback = projectFileModified.add((relativeUrl) => {
-      callback({
-        event: "modified",
-        relativeUrl,
-      })
-    })
-    const removeRemovedCallback = projectFileRemoved.add((relativeUrl) => {
-      callback({
-        event: "removed",
-        relativeUrl,
-      })
-    })
-    const removeAddedCallback = projectFileRemoved.add((relativeUrl) => {
-      callback({
-        event: "added",
-        relativeUrl,
-      })
-    })
-    return () => {
-      removeModifiedCallback()
-      removeRemovedCallback()
-      removeAddedCallback()
-    }
-  }
-  // wait 100ms to actually start watching
-  // otherwise server starting is delayed by the filesystem scan done in
-  // registerDirectoryLifecycle
-  const timeout = setTimeout(() => {
-    const unregisterDirectoryLifecyle = registerDirectoryLifecycle(
-      rootDirectoryUrl,
-      {
-        watchDescription: {
-          ...autoreloadPatterns,
-          ".jsenv/": false,
-        },
-        updated: ({ relativeUrl }) => {
-          projectFileModified.notify(relativeUrl)
-        },
-        removed: ({ relativeUrl }) => {
-          projectFileRemoved.notify(relativeUrl)
-        },
-        added: ({ relativeUrl }) => {
-          projectFileAdded.notify(relativeUrl)
-        },
-        keepProcessAlive: false,
-        recursive: true,
-      },
-    )
-    destroyCallbackList.add(unregisterDirectoryLifecyle)
-  }, 100)
-  destroyCallbackList.add(() => {
-    clearTimeout(timeout)
-  })
-
-  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: () => {
-        const removeHotUpdateCallback = hotUpdateCallbackList.add(
-          (hotUpdate) => {
-            if (hotUpdate.declined) {
-              sseRoom.sendEvent({
-                type: "reload",
-                data: JSON.stringify({
-                  cause: hotUpdate.cause,
-                  type: "full",
-                  typeReason: hotUpdate.reason,
-                  declinedBy: hotUpdate.declinedBy,
-                }),
-              })
-            } else {
-              sseRoom.sendEvent({
-                type: "reload",
-                data: JSON.stringify({
-                  cause: hotUpdate.cause,
-                  type: "hot",
-                  typeReason: hotUpdate.reason,
-                  hotInstructions: hotUpdate.instructions,
-                }),
-              })
-            }
-          },
-        )
-        const stopWatching = watchProjectFiles(({ relativeUrl, event }) => {
-          onFileChange({ relativeUrl, event })
-        })
-        return () => {
-          removeHotUpdateCallback()
-          stopWatching()
-        }
-      },
-    })
-
-    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/execute/runtimes/node/controlled_process.js

@@ -1,316 +0,0 @@
-import { fork } from "node:child_process"
-import { urlToFileSystemPath } from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
-import {
-  Abort,
-  raceCallbacks,
-  createCallbackListNotifiedOnce,
-} from "@jsenv/abort"
-import { uneval } from "@jsenv/uneval"
-
-import { memoize } from "@jsenv/utils/memoize/memoize.js"
-
-import { createChildExecOptions } from "./child_exec_options.js"
-import { ExecOptions } from "./exec_options.js"
-import { killProcessTree } from "./kill_process_tree.js"
-
-const NODE_CONTROLLABLE_FILE_URL = new URL(
-  "./controllable_file.mjs",
-  import.meta.url,
-).href
-
-export const createControlledProcess = async ({
-  signal = new AbortController().signal,
-  logger,
-  logProcessCommand = false,
-
-  onStop,
-  onError,
-  onConsole,
-
-  debugPort,
-  debugMode,
-  debugModeInheritBreak,
-  commandLineOptions = [],
-  env,
-  inheritProcessEnv = true,
-
-  stdin = "pipe",
-  stdout = "pipe",
-  stderr = "pipe",
-}) => {
-  if (env !== undefined && typeof env !== "object") {
-    throw new TypeError(`env must be an object, got ${env}`)
-  }
-  const cleanupCallbackList = createCallbackListNotifiedOnce()
-  const cleanup = async (reason) => {
-    await cleanupCallbackList.notify({ reason })
-  }
-
-  const childExecOptions = await createChildExecOptions({
-    signal,
-    debugPort,
-    debugMode,
-    debugModeInheritBreak,
-  })
-  const execArgv = ExecOptions.toExecArgv({
-    ...childExecOptions,
-    ...ExecOptions.fromExecArgv(commandLineOptions),
-  })
-  const envForChildProcess = {
-    ...(inheritProcessEnv ? process.env : {}),
-    ...env,
-  }
-  logger[logProcessCommand ? "info" : "debug"](
-    `${process.argv[0]} ${execArgv.join(" ")} ${urlToFileSystemPath(
-      NODE_CONTROLLABLE_FILE_URL,
-    )}`,
-  )
-  const childProcess = fork(urlToFileSystemPath(NODE_CONTROLLABLE_FILE_URL), {
-    execArgv,
-    // silent: true
-    stdio: ["pipe", "pipe", "pipe", "ipc"],
-    env: envForChildProcess,
-  })
-  logger.debug(
-    createDetailedMessage(`child process forked (pid ${childProcess.pid})`, {
-      "execArgv": execArgv.join(`\n`),
-      "custom env": JSON.stringify(env, null, "  "),
-    }),
-  )
-  // if we pass stream, pipe them https://github.com/sindresorhus/execa/issues/81
-  if (typeof stdin === "object") {
-    stdin.pipe(childProcess.stdin)
-  }
-  if (typeof stdout === "object") {
-    childProcess.stdout.pipe(stdout)
-  }
-  if (typeof stderr === "object") {
-    childProcess.stderr.pipe(stderr)
-  }
-  const childProcessReadyPromise = new Promise((resolve) => {
-    onceProcessMessage(childProcess, "ready", resolve)
-  })
-  const removeOutputListener = installProcessOutputListener(
-    childProcess,
-    ({ type, text }) => {
-      onConsole({ type, text })
-    },
-  )
-  const stop = memoize(async ({ gracefulStopAllocatedMs } = {}) => {
-    // all libraries are facing problem on windows when trying
-    // to kill a process spawning other processes.
-    // "killProcessTree" is theorically correct but sometimes keep process handing forever.
-    // Inside GitHub workflow the whole Virtual machine gets unresponsive and ends up being killed
-    // There is no satisfying solution to this problem so we stick to the basic
-    // childProcess.kill()
-    if (process.platform === "win32") {
-      childProcess.kill()
-      return
-    }
-    if (gracefulStopAllocatedMs) {
-      try {
-        await killProcessTree(childProcess.pid, {
-          signal: GRACEFUL_STOP_SIGNAL,
-          timeout: gracefulStopAllocatedMs,
-        })
-        return
-      } catch (e) {
-        if (e.code === "TIMEOUT") {
-          logger.debug(
-            `kill with SIGTERM because gracefulStop still pending after ${gracefulStopAllocatedMs}ms`,
-          )
-          await killProcessTree(childProcess.pid, {
-            signal: GRACEFUL_STOP_FAILED_SIGNAL,
-          })
-          return
-        }
-        throw e
-      }
-    }
-    await killProcessTree(childProcess.pid, { signal: STOP_SIGNAL })
-    return
-  })
-  raceCallbacks(
-    {
-      // https://nodejs.org/api/child_process.html#child_process_event_disconnect
-      // disconnect: (cb) => {
-      //   return onceProcessEvent(childProcess, "disconnect", cb)
-      // },
-      // https://nodejs.org/api/child_process.html#child_process_event_error
-      error: (cb) => {
-        return onceProcessEvent(childProcess, "error", cb)
-      },
-      exit: (cb) => {
-        return onceProcessEvent(childProcess, "exit", (code, signal) => {
-          cb({ code, signal })
-        })
-      },
-    },
-    (winner) => {
-      const raceEffects = {
-        // disconnect: () => {
-        //   stoppedCallbackList.notify()
-        // },
-        error: (error) => {
-          removeOutputListener()
-          if (
-            !childProcess.connected &&
-            error.code === "ERR_IPC_DISCONNECTED"
-          ) {
-            return
-          }
-          onError(error)
-        },
-        exit: async ({ code, signal }) => {
-          // process.exit(1) in child process or process.exitCode = 1 + process.exit()
-          // means there was an error even if we don't know exactly what.
-          if (
-            code !== null &&
-            code !== 0 &&
-            code !== SIGINT_EXIT_CODE &&
-            code !== SIGTERM_EXIT_CODE &&
-            code !== SIGABORT_EXIT_CODE
-          ) {
-            onError(createExitWithFailureCodeError(code))
-          }
-          await cleanup("process exit")
-          onStop({ code, signal })
-        },
-      }
-      raceEffects[winner.name](winner.data)
-    },
-  )
-  const requestActionOnChildProcess = async ({
-    signal,
-    actionType,
-    actionParams,
-  }) => {
-    const actionOperation = Abort.startOperation()
-    actionOperation.addAbortSignal(signal)
-    try {
-      const result = await new Promise(async (resolve, reject) => {
-        actionOperation.throwIfAborted()
-        await childProcessReadyPromise
-        onceProcessMessage(
-          childProcess,
-          "action-result",
-          ({ status, value }) => {
-            if (status === "action-completed") {
-              resolve(value)
-            } else {
-              reject(value)
-            }
-          },
-        )
-        logger.debug(
-          createDetailedMessage(`ask child process to perform an action`, {
-            actionType,
-            actionParams: JSON.stringify(actionParams, null, "  "),
-          }),
-        )
-        try {
-          actionOperation.throwIfAborted()
-          await sendToProcess(childProcess, "action", {
-            actionType,
-            actionParams,
-          })
-        } catch (e) {
-          if (Abort.isAbortError(e) && actionOperation.signal.aborted) {
-            throw e
-          }
-          logger.error(
-            createDetailedMessage(`error while sending message to child`, {
-              ["error stack"]: e.stack,
-            }),
-          )
-          throw e
-        }
-      })
-      return result
-    } finally {
-      await actionOperation.end()
-    }
-  }
-  return {
-    execArgv,
-    stop,
-    requestActionOnChildProcess,
-  }
-}
-
-// https://nodejs.org/api/process.html#process_signal_events
-const SIGINT_SIGNAL_NUMBER = 2
-const SIGABORT_SIGNAL_NUMBER = 6
-const SIGTERM_SIGNAL_NUMBER = 15
-const SIGINT_EXIT_CODE = 128 + SIGINT_SIGNAL_NUMBER
-const SIGABORT_EXIT_CODE = 128 + SIGABORT_SIGNAL_NUMBER
-const SIGTERM_EXIT_CODE = 128 + SIGTERM_SIGNAL_NUMBER
-// http://man7.org/linux/man-pages/man7/signal.7.html
-// https:// github.com/nodejs/node/blob/1d9511127c419ec116b3ddf5fc7a59e8f0f1c1e4/lib/internal/child_process.js#L472
-const GRACEFUL_STOP_SIGNAL = "SIGTERM"
-const STOP_SIGNAL = "SIGKILL"
-// it would be more correct if GRACEFUL_STOP_FAILED_SIGNAL was SIGHUP instead of SIGKILL.
-// but I'm not sure and it changes nothing so just use SIGKILL
-const GRACEFUL_STOP_FAILED_SIGNAL = "SIGKILL"
-
-const sendToProcess = async (childProcess, type, data) => {
-  const source = uneval(data, { functionAllowed: true })
-  return new Promise((resolve, reject) => {
-    childProcess.send({ type, data: source }, (error) => {
-      if (error) {
-        reject(error)
-      } else {
-        resolve()
-      }
-    })
-  })
-}
-
-const installProcessOutputListener = (childProcess, callback) => {
-  // beware that we may receive ansi output here, should not be a problem but keep that in mind
-  const stdoutDataCallback = (chunk) => {
-    callback({ type: "log", text: String(chunk) })
-  }
-  childProcess.stdout.on("data", stdoutDataCallback)
-  const stdErrorDataCallback = (chunk) => {
-    callback({ type: "error", text: String(chunk) })
-  }
-  childProcess.stderr.on("data", stdErrorDataCallback)
-  return () => {
-    childProcess.stdout.removeListener("data", stdoutDataCallback)
-    childProcess.stderr.removeListener("data", stdoutDataCallback)
-  }
-}
-
-const createExitWithFailureCodeError = (code) => {
-  if (code === 12) {
-    return new Error(
-      `child exited with 12: forked child wanted to use a non available port for debug`,
-    )
-  }
-  const error = new Error(`child exited with ${code}`)
-  error.exitCode = code
-  return error
-}
-
-const onceProcessMessage = (childProcess, type, callback) => {
-  const onmessage = (message) => {
-    if (message.type === type) {
-      childProcess.removeListener("message", onmessage)
-      // eslint-disable-next-line no-eval
-      callback(message.data ? eval(`(${message.data})`) : "")
-    }
-  }
-  childProcess.on("message", onmessage)
-  return () => {
-    childProcess.removeListener("message", onmessage)
-  }
-}
-
-const onceProcessEvent = (childProcess, type, callback) => {
-  childProcess.once(type, callback)
-  return () => {
-    childProcess.removeListener(type, callback)
-  }
-}

package/src/omega/core_plugins/babel/new_stylesheet/client/.eslintrc.cjs

@@ -1,24 +0,0 @@
-const eslintConfig = require("../../../../../../.eslintrc.cjs")
-
-// babel helpers are copy pasted from the babel repository
-Object.assign(eslintConfig.rules, {
-  "eqeqeq": ["off"],
-  "no-eq-null": ["off"],
-  "no-undef-init": ["off"],
-  "dot-notation": ["off"],
-  "consistent-return": ["off"],
-  "one-var": ["off"],
-  "object-shorthand": ["off"],
-  "no-return-assign": ["off"],
-  "prefer-template": ["off"],
-  "prefer-rest-params": ["off"],
-  "no-void": ["off"],
-  "no-implicit-coercion": ["off"],
-  "prefer-spread": ["off"],
-  "no-loop-func": ["off"],
-  "no-negated-condition": ["off"],
-  "no-func-assign": ["off"],
-  "no-else-return": ["off"],
-})
-
-module.exports = eslintConfig

package/src/omega/core_plugins/file_urls/jsenv_plugin_file_urls.js

@@ -1,67 +0,0 @@
-import { readFileSync } from "node:fs"
-import { urlToContentType } from "@jsenv/server"
-import {
-  urlIsInsideOf,
-  urlToRelativeUrl,
-  fileSystemRootUrl,
-} from "@jsenv/filesystem"
-import { ContentType } from "@jsenv/utils/src/content_type.js"
-
-export const jsenvPluginFileUrls = () => {
-  return [jsenvPluginResolveAbsoluteFileUrls(), jsenvPluginLoadFileUrls()]
-}
-
-const jsenvPluginResolveAbsoluteFileUrls = () => {
-  return {
-    name: "jsenv:resolve_absolute_file_urls",
-    appliesDuring: {
-      // during dev and test it's a browser running the code
-      // so absolute file urls needs to be relativized
-      dev: true,
-      test: true,
-      // during build it's fine to use file:// urls
-      build: false,
-    },
-    resolve: ({ specifier }, { rootDirectoryUrl }) => {
-      if (!specifier.startsWith("/@fs/")) {
-        return null
-      }
-      const url = new URL(specifier.slice("/@fs".length), rootDirectoryUrl).href
-      return url
-    },
-    formatReferencedUrl: ({ url }, { rootDirectoryUrl }) => {
-      if (!url.startsWith("file:")) {
-        return null
-      }
-      const specifier = urlIsInsideOf(url, rootDirectoryUrl)
-        ? `/${urlToRelativeUrl(url, rootDirectoryUrl)}`
-        : `/@fs/${url.slice(fileSystemRootUrl.length)}`
-      return specifier
-    },
-  }
-}
-
-const jsenvPluginLoadFileUrls = () => {
-  return {
-    name: "jsenv:load_file_urls",
-    appliesDuring: "*",
-    load: ({ url }) => {
-      if (!url.startsWith("file:")) {
-        return null
-      }
-      const urlObject = new URL(url)
-      const fileBuffer = readFileSync(urlObject)
-      const contentType = urlToContentType(url)
-      if (ContentType.isTextual(contentType)) {
-        return {
-          contentType,
-          content: String(fileBuffer),
-        }
-      }
-      return {
-        contentType,
-        content: fileBuffer,
-      }
-    },
-  }
-}

package/src/omega/core_plugins/filesystem_magic/jsenv_plugin_filesystem_magic.js

@@ -1,58 +0,0 @@
-// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/plugins/resolve.ts
-
-import { realpathSync } from "node:fs"
-import { pathToFileURL } from "node:url"
-import { urlToExtension } from "@jsenv/filesystem"
-import { applyFileSystemMagicResolution } from "@jsenv/node-esm-resolution"
-
-export const jsenvPluginFileSystemMagic = ({
-  magicExtensions = ["inherit"],
-  magicDirectoryIndex = true,
-  preservesSymlink = true,
-} = {}) => {
-  return {
-    name: "jsenv:filesystem_magic",
-    appliesDuring: "*",
-    normalize: ({ parentUrl, url }) => {
-      // http, https, data, about, etc
-      if (!url.startsWith("file:")) {
-        return null
-      }
-      const urlObject = new URL(url)
-      const { search, hash } = urlObject
-      urlObject.search = ""
-      urlObject.hash = ""
-      const filesystemResolution = applyFileSystemMagicResolution(
-        urlObject.href,
-        {
-          magicDirectoryIndex,
-          magicExtensions: getExtensionsToTry(magicExtensions, parentUrl),
-        },
-      )
-      if (!filesystemResolution.found) {
-        return null
-      }
-      const fileUrlRaw = filesystemResolution.url
-      const fileUrl = `${fileUrlRaw}${search}${hash}`
-      if (preservesSymlink) {
-        return fileUrl
-      }
-      const realPath = realpathSync(urlObject)
-      const realFileUrl = `${pathToFileURL(realPath)}${search}${hash}`
-      return realFileUrl
-    },
-  }
-}
-
-const getExtensionsToTry = (magicExtensions, importer) => {
-  const extensionsSet = new Set()
-  magicExtensions.forEach((magicExtension) => {
-    if (magicExtension === "inherit") {
-      const importerExtension = urlToExtension(importer)
-      extensionsSet.add(importerExtension)
-    } else {
-      extensionsSet.add(magicExtension)
-    }
-  })
-  return Array.from(extensionsSet.values())
-}