@jsenv/core 27.0.0-alpha.11 → 27.0.0-alpha.14

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/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/import_assertions/helpers/json_module.js

@@ -1,12 +0,0 @@
-export const convertJsonTextToJavascriptModule = ({ content }) => {
-  // here we could do the following
-  // return export default jsonText
-  // This would return valid js, that would be minified later
-  // however we will prefer using JSON.parse because it's faster
-  // for js engine to parse JSON than JS
-
-  return {
-    contentType: "application/javascript",
-    content: `export default JSON.parse(${JSON.stringify(content.trim())})`,
-  }
-}

package/src/omega/core_plugins/import_assertions/helpers/text_module.js

@@ -1,6 +0,0 @@
-export const convertTextToJavascriptModule = ({ content }) => {
-  return {
-    contentType: "application/javascript",
-    content: `export default ${JSON.stringify(content)}`,
-  }
-}

package/src/omega/core_plugins/import_assertions/jsenv_plugin_import_assertions.js

@@ -1,211 +0,0 @@
-import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
-import { ContentType } from "@jsenv/utils/src/content_type.js"
-import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
-import { injectQueryParamsIntoSpecifier } from "@jsenv/utils/urls/url_utils.js"
-import { JS_QUOTES } from "@jsenv/utils/string/js_quotes.js"
-
-import { babelPluginMetadataImportAssertions } from "./helpers/babel_plugin_metadata_import_assertions.js"
-import { convertJsonTextToJavascriptModule } from "./helpers/json_module.js"
-import { convertTextToJavascriptModule } from "./helpers/text_module.js"
-
-export const jsenvPluginImportAssertions = () => {
-  const importAssertions = [
-    {
-      name: "jsenv:import_assertions",
-      appliesDuring: "*",
-      transform: {
-        js_module: async (
-          { url, generatedUrl, content },
-          { scenario, isSupportedOnRuntime, referenceUtils },
-        ) => {
-          const importTypesToHandle = getImportTypesToHandle({
-            scenario,
-            isSupportedOnRuntime,
-          })
-          if (importTypesToHandle.length === 0) {
-            return null
-          }
-          const { metadata } = await applyBabelPlugins({
-            babelPlugins: [babelPluginMetadataImportAssertions],
-            url,
-            generatedUrl,
-            content,
-          })
-          const { importAssertions } = metadata
-          const magicSource = createMagicSource(content)
-          importAssertions.forEach((importAssertion) => {
-            const assertType = importAssertion.assert.type
-            if (!importTypesToHandle.includes(assertType)) {
-              return
-            }
-            const { path } = importAssertion
-            const { node } = path
-            const importType = `${assertType}_module`
-            if (node.type === "CallExpression") {
-              const importSpecifierPath = path.get("arguments")[0]
-              const specifier = importSpecifierPath.node.value
-              const newSpecifier = injectQueryParamsIntoSpecifier(specifier, {
-                [importType]: "",
-              })
-              const [newReference, newUrlInfo] = referenceUtils.updateSpecifier(
-                JSON.stringify(specifier),
-                newSpecifier,
-              )
-              newUrlInfo.data.importType = importType
-              magicSource.replace({
-                start: importSpecifierPath.node.start,
-                end: importSpecifierPath.node.end,
-                replacement: newReference.generatedSpecifier,
-              })
-              const secondArgPath = path.get("arguments")[1]
-              magicSource.remove({
-                start: secondArgPath.node.start,
-                end: secondArgPath.node.end,
-              })
-              return
-            }
-            const importSpecifierPath = path.get("source")
-            const specifier = importSpecifierPath.node.value
-            const newSpecifier = injectQueryParamsIntoSpecifier(specifier, {
-              [importType]: "",
-            })
-            const [newReference, newUrlInfo] = referenceUtils.updateSpecifier(
-              JSON.stringify(specifier),
-              newSpecifier,
-            )
-            newUrlInfo.data.importType = importType
-            magicSource.replace({
-              start: importSpecifierPath.node.start,
-              end: importSpecifierPath.node.end,
-              replacement: newReference.generatedSpecifier,
-            })
-            const assertionsPath = path.get("assertions")[0]
-            magicSource.remove({
-              start: assertionsPath.node.start,
-              end: assertionsPath.node.end,
-            })
-          })
-          return magicSource.toContentAndSourcemap()
-        },
-      },
-    },
-  ]
-
-  const importTypeJson = {
-    name: "jsenv:import_type_json",
-    appliesDuring: "*",
-    finalize: ({ url, contentType, content }) => {
-      if (!new URL(url).searchParams.has("json_module")) {
-        return null
-      }
-      if (contentType !== "application/json") {
-        throw new Error(
-          `Unexpected content type on ${url}, should be "application/json" but got ${contentType}`,
-        )
-      }
-      return convertJsonTextToJavascriptModule({
-        content,
-      })
-    },
-  }
-
-  // not standard but I expect this to happen one day?
-  const importTypeText = {
-    name: "jsenv:import_type_text",
-    appliesDuring: "*",
-    finalize: ({ url, contentType, content }) => {
-      if (!new URL(url).searchParams.has("text_module")) {
-        return null
-      }
-      if (ContentType.isTextual(contentType)) {
-        throw new Error(
-          `Unexpected content type on ${url}, should be "text/*" but got ${contentType}`,
-        )
-      }
-      return convertTextToJavascriptModule({
-        content,
-      })
-    },
-  }
-
-  return [
-    importAssertions,
-    importTypeJson,
-    jsenvPluginImportTypeCss(),
-    importTypeText,
-  ]
-}
-
-const jsenvPluginImportTypeCss = () => {
-  const inlineContentClientFileUrl = new URL(
-    "../inline/client/inline_content.js",
-    import.meta.url,
-  ).href
-
-  return {
-    name: "jsenv:import_type_css",
-    appliesDuring: "*",
-    // load the original css url
-    load: ({ data }, { urlGraph, load }) => {
-      if (data.importType !== "css_module") {
-        return null
-      }
-      return load({
-        reference: data.originalReference,
-        urlInfo: urlGraph.getUrlInfo(data.originalReference.url),
-      })
-    },
-    transform: ({ url, data, contentType, content }, { referenceUtils }) => {
-      if (data.importType !== "css_module") {
-        return null
-      }
-      if (contentType !== "text/css") {
-        throw new Error(
-          `Unexpected content type on ${url}, should be "text/css" but got ${contentType}`,
-        )
-      }
-      const [reference] = referenceUtils.inject({
-        type: "js_import_export",
-        specifier: inlineContentClientFileUrl,
-      })
-      const cssText = JS_QUOTES.escapeSpecialChars(content, {
-        // If template string is choosen and runtime do not support template literals
-        // it's ok because "jsenv:new_inline_content" plugin executes after this one
-        // and convert template strings into raw strings
-        canUseTemplateString: true,
-      })
-      return {
-        type: "js_module",
-        contentType: "application/javascript",
-        content: `import { InlineContent } from ${reference.generatedSpecifier}
-
-const css = new InlineContent(${cssText}, { type: "text/css" })
-const stylesheet = new CSSStyleSheet()
-stylesheet.replaceSync(css.text)
-export default stylesheet`,
-      }
-    },
-  }
-}
-
-const getImportTypesToHandle = ({ scenario, isSupportedOnRuntime }) => {
-  // during build always replace import assertions with the js:
-  // - means rollup can bundle more js file together
-  // - means url versioning can work for css inlined in js
-  // - avoid rollup to see import assertions
-  //   We would have to tell rollup to ignore import with assertion
-  if (scenario === "build") {
-    return ["json", "css", "text"]
-  }
-  const importTypes = []
-  if (!isSupportedOnRuntime("import_type_json")) {
-    importTypes.push("json")
-  }
-  if (!isSupportedOnRuntime("import_type_css")) {
-    importTypes.push("css")
-  }
-  if (!isSupportedOnRuntime("import_type_text")) {
-    importTypes.push("text")
-  }
-  return importTypes
-}

package/src/omega/core_plugins/inline/jsenv_plugin_inline.js

@@ -1,13 +0,0 @@
-import { jsenvPluginJsAndCssInsideHtml } from "./jsenv_plugin_js_and_css_inside_html.js"
-import { jsenvPluginNewInlineContent } from "./jsenv_plugin_new_inline_content.js"
-import { jsenvPluginDataUrls } from "./jsenv_plugin_data_urls.js"
-import { jsenvPluginInlineQueryParam } from "./jsenv_plugin_inline_query_param.js"
-
-export const jsenvPluginInline = ({ allowEscapeForVersioning } = {}) => {
-  return [
-    jsenvPluginJsAndCssInsideHtml(),
-    jsenvPluginNewInlineContent({ allowEscapeForVersioning }),
-    jsenvPluginDataUrls(),
-    jsenvPluginInlineQueryParam(),
-  ]
-}