@jsenv/core 27.0.0-alpha.3 → 27.0.0-alpha.32

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/babel_helper/babel_helper_directory.js

@@ -1,29 +0,0 @@
-// https://github.com/babel/babel/blob/99f4f6c3b03c7f3f67cf1b9f1a21b80cfd5b0224/packages/babel-core/src/tools/build-external-helpers.js
-// the list of possible helpers:
-// https://github.com/babel/babel/blob/99f4f6c3b03c7f3f67cf1b9f1a21b80cfd5b0224/packages/babel-helpers/src/helpers.js#L13
-
-const babelHelperClientDirectoryUrl = new URL("./client/", import.meta.url).href
-
-// we cannot use "@jsenv/core/src/*" because babel helper might be injected
-// into node_modules not depending on "@jsenv/core"
-export const getBabelHelperFileUrl = (babelHelperName) => {
-  const babelHelperFileUrl = new URL(
-    `./${babelHelperName}/${babelHelperName}.js`,
-    babelHelperClientDirectoryUrl,
-  ).href
-  return babelHelperFileUrl
-}
-
-export const babelHelperNameFromUrl = (url) => {
-  if (!url.startsWith(babelHelperClientDirectoryUrl)) {
-    return null
-  }
-  const afterBabelHelperDirectory = url.slice(
-    babelHelperClientDirectoryUrl.length,
-  )
-  const babelHelperName = afterBabelHelperDirectory.slice(
-    0,
-    afterBabelHelperDirectory.indexOf("/"),
-  )
-  return babelHelperName
-}

package/src/omega/core_plugins/babel/babel_helper/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/babel/babel_helper/client/AsyncGenerator/AsyncGenerator.js

@@ -1,81 +0,0 @@
-import AwaitValue from "../AwaitValue/AwaitValue.js"
-
-export default function AsyncGenerator(gen) {
-  var front, back
-  function send(key, arg) {
-    return new Promise(function (resolve, reject) {
-      var request = {
-        key: key,
-        arg: arg,
-        resolve: resolve,
-        reject: reject,
-        next: null,
-      }
-      if (back) {
-        back = back.next = request
-      } else {
-        front = back = request
-        resume(key, arg)
-      }
-    })
-  }
-  function resume(key, arg) {
-    try {
-      var result = gen[key](arg)
-      var value = result.value
-      var wrappedAwait = value instanceof AwaitValue
-      Promise.resolve(wrappedAwait ? value.wrapped : value).then(
-        function (arg) {
-          if (wrappedAwait) {
-            resume(key === "return" ? "return" : "next", arg)
-            return
-          }
-          settle(result.done ? "return" : "normal", arg)
-        },
-        function (err) {
-          resume("throw", err)
-        },
-      )
-    } catch (err) {
-      settle("throw", err)
-    }
-  }
-  function settle(type, value) {
-    switch (type) {
-      case "return":
-        front.resolve({ value: value, done: true })
-        break
-      case "throw":
-        front.reject(value)
-        break
-      default:
-        front.resolve({ value: value, done: false })
-        break
-    }
-    front = front.next
-    if (front) {
-      resume(front.key, front.arg)
-    } else {
-      back = null
-    }
-  }
-  this._invoke = send
-  // Hide "return" method if generator return is not supported
-  if (typeof gen.return !== "function") {
-    this.return = undefined
-  }
-}
-AsyncGenerator.prototype[
-  (typeof Symbol === "function" && Symbol.asyncIterator) || "@@asyncIterator"
-] = function () {
-  return this
-}
-AsyncGenerator.prototype.next = function (arg) {
-  return this._invoke("next", arg)
-}
-AsyncGenerator.prototype.throw = function (arg) {
-  return this._invoke("throw", arg)
-}
-AsyncGenerator.prototype.return = function (arg) {
-  return this._invoke("return", arg)
-}

package/src/omega/core_plugins/babel/babel_helper/client/AwaitValue/AwaitValue.js

@@ -1,3 +0,0 @@
-export default function _AwaitValue (value) {
-  this.wrapped = value
-}

package/src/omega/core_plugins/babel/babel_helper/client/applyDecoratorDescriptor/applyDecoratorDescriptor.js

@@ -1,33 +0,0 @@
-/* eslint-disable no-void */
-export default function _applyDecoratedDescriptor(
-  target,
-  property,
-  decorators,
-  descriptor,
-  context,
-) {
-  var desc = {}
-  Object.keys(descriptor).forEach(function (key) {
-    desc[key] = descriptor[key]
-  })
-  desc.enumerable = Boolean(desc.enumerable)
-  desc.configurable = Boolean(desc.configurable)
-  if ("value" in desc || desc.initializer) {
-    desc.writable = true
-  }
-  desc = decorators
-    .slice()
-    .reverse()
-    .reduce(function (desc, decorator) {
-      return decorator(target, property, desc) || desc
-    }, desc)
-  if (context && desc.initializer !== void 0) {
-    desc.value = desc.initializer ? desc.initializer.call(context) : void 0
-    desc.initializer = undefined
-  }
-  if (desc.initializer === void 0) {
-    Object.defineProperty(target, property, desc)
-    desc = null
-  }
-  return desc
-}

package/src/omega/core_plugins/babel/babel_helper/client/arrayLikeToArray/arrayLikeToArray.js

@@ -1,7 +0,0 @@
-/* eslint-disable no-eq-null, eqeqeq */
-export default function arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length
-  var arr2 = new Array(len)
-  for (var i = 0; i < len; i++) arr2[i] = arr[i]
-  return arr2
-}

package/src/omega/core_plugins/babel/babel_helper/client/arrayWithHoles/arrayWithHoles.js

@@ -1,4 +0,0 @@
-// eslint-disable-next-line consistent-return
-export default (arr) => {
-  if (Array.isArray(arr)) return arr
-}

package/src/omega/core_plugins/babel/babel_helper/client/arrayWithoutHoles/arrayWithoutHoles.js

@@ -1,6 +0,0 @@
-import arrayLikeToArray from "../arrayLikeToArray/arrayLikeToArray.js"
-
-// eslint-disable-next-line consistent-return
-export default (arr) => {
-  if (Array.isArray(arr)) return arrayLikeToArray(arr)
-}

package/src/omega/core_plugins/babel/babel_helper/client/assertThisInitialized/assertThisInitialized.js

@@ -1,7 +0,0 @@
-export default (self) => {
-  // eslint-disable-next-line no-void
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called")
-  }
-  return self
-}

package/src/omega/core_plugins/babel/babel_helper/client/asyncGeneratorDelegate/asyncGeneratorDelegate.js

@@ -1,40 +0,0 @@
-export default function _asyncGeneratorDelegate(inner, awaitWrap) {
-  var iter = {},
-    waiting = false
-  function pump(key, value) {
-    waiting = true
-    value = new Promise(function (resolve) {
-      resolve(inner[key](value))
-    })
-    return { done: false, value: awaitWrap(value) }
-  }
-  iter[(typeof Symbol !== "undefined" && Symbol.iterator) || "@@iterator"] = function () {
-    return this
-  }
-  iter.next = function (value) {
-    if (waiting) {
-      waiting = false
-      return value
-    }
-    return pump("next", value)
-  }
-  if (typeof inner.throw === "function") {
-    iter.throw = function (value) {
-      if (waiting) {
-        waiting = false
-        throw value
-      }
-      return pump("throw", value)
-    }
-  }
-  if (typeof inner.return === "function") {
-    iter.return = function (value) {
-      if (waiting) {
-        waiting = false
-        return value
-      }
-      return pump("return", value)
-    }
-  }
-  return iter
-}

package/src/omega/core_plugins/babel/babel_helper/client/asyncIterator/asyncIterator.js

@@ -1,65 +0,0 @@
-export default function _asyncIterator(iterable) {
-  var method,
-    async,
-    sync,
-    retry = 2;
-
-  if (typeof Symbol !== "undefined") {
-    async = Symbol.asyncIterator;
-    sync = Symbol.iterator;
-  }
-
-  while (retry--) {
-    if (async && (method = iterable[async]) != null) {
-      return method.call(iterable);
-    }
-    if (sync && (method = iterable[sync]) != null) {
-      return new AsyncFromSyncIterator(method.call(iterable));
-    }
-
-    async = "@@asyncIterator";
-    sync = "@@iterator";
-  }
-
-  throw new TypeError("Object is not async iterable");
-}
-
-function AsyncFromSyncIterator(s) {
-  AsyncFromSyncIterator = function (s) {
-    this.s = s;
-    this.n = s.next;
-  };
-  AsyncFromSyncIterator.prototype = {
-    /* SyncIterator */ s: null,
-    /* SyncIterator.[[Next]] */ n: null,
-    next: function () {
-      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
-    },
-    return: function (value) {
-      var ret = this.s.return;
-      if (ret === undefined) {
-        return Promise.resolve({ value: value, done: true });
-      }
-      return AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
-    },
-    throw: function (value) {
-      var thr = this.s.return;
-      if (thr === undefined) return Promise.reject(value);
-      return AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
-    },
-  };
-
-  function AsyncFromSyncIteratorContinuation(r) {
-    // This step is _before_ calling AsyncFromSyncIteratorContinuation in the spec.
-    if (Object(r) !== r) {
-      return Promise.reject(new TypeError(r + " is not an object."));
-    }
-
-    var done = r.done;
-    return Promise.resolve(r.value).then(function (value) {
-      return { value: value, done: done };
-    });
-  }
-
-  return new AsyncFromSyncIterator(s);
-}

package/src/omega/core_plugins/babel/babel_helper/client/asyncToGenerator/asyncToGenerator.js

@@ -1,34 +0,0 @@
-export default function (fn) {
-  return function () {
-    var self = this
-    // eslint-disable-next-line prefer-rest-params
-    var args = arguments
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args)
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value)
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err)
-      }
-      _next(undefined)
-    })
-  }
-}
-
-const asyncGeneratorStep = (gen, resolve, reject, _next, _throw, key, arg) => {
-  var info
-  var value
-  try {
-    info = gen[key](arg)
-    value = info.value
-  } catch (error) {
-    reject(error)
-    return
-  }
-  if (info.done) {
-    resolve(value)
-  } else {
-    Promise.resolve(value).then(_next, _throw)
-  }
-}

package/src/omega/core_plugins/babel/babel_helper/client/awaitAsyncGenerator/awaitAsyncGenerator.js

@@ -1,5 +0,0 @@
-import AwaitValue from "../AwaitValue/AwaitValue.js"
-
-export default function (value) {
-  return new AwaitValue(value)
-}

package/src/omega/core_plugins/babel/babel_helper/client/classApplyDescriptorDestructureSet/classApplyDescriptorDestructureSet.js

@@ -1,20 +0,0 @@
-export default function _classApplyDescriptorDestructureSet(receiver, descriptor) {
-  if (descriptor.set) {
-    if (!("__destrObj" in descriptor)) {
-      descriptor.__destrObj = {
-        // eslint-disable-next-line accessor-pairs
-        set value(v) {
-          descriptor.set.call(receiver, v)
-        },
-      }
-    }
-    return descriptor.__destrObj
-  }
-  if (!descriptor.writable) {
-    // This should only throw in strict mode, but class bodies are
-    // always strict and private fields can only be used inside
-    // class bodies.
-    throw new TypeError("attempted to set read only private field")
-  }
-  return descriptor
-}