@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/url_utils.test.js

@@ -1,39 +0,0 @@
-import { assert } from "@jsenv/assert"
-
-import { setUrlExtension } from "./url_utils.js"
-
-{
-  const actual = setUrlExtension(`http://example.com/file.jsx`, ".js")
-  const expected = "http://example.com/file.js"
-  assert({ actual, expected })
-}
-
-{
-  const actual = setUrlExtension(`http://example.com/file.mjsx?foo=bar`, ".js")
-  const expected = "http://example.com/file.js?foo=bar"
-  assert({ actual, expected })
-}
-
-{
-  const actual = setUrlExtension(`http://example.com/file.?foo=bar`, ".js")
-  const expected = "http://example.com/file.js?foo=bar"
-  assert({ actual, expected })
-}
-
-{
-  const actual = setUrlExtension(`http://example.com/file?foo=bar`, ".js")
-  const expected = "http://example.com/file.js?foo=bar"
-  assert({ actual, expected })
-}
-
-{
-  const actual = setUrlExtension(`http://example.com/file.js?foo=bar`, ".")
-  const expected = "http://example.com/file.?foo=bar"
-  assert({ actual, expected })
-}
-
-{
-  const actual = setUrlExtension(`http://example.com/file.js?foo=bar`, "")
-  const expected = "http://example.com/file?foo=bar"
-  assert({ actual, expected })
-}

package/src/internal/windows_file_path_utils.js

@@ -1,16 +0,0 @@
-export const startsWithWindowsDriveLetter = (string) => {
-  const firstChar = string[0]
-  if (!/[a-zA-Z]/.test(firstChar)) return false
-
-  const secondChar = string[1]
-  if (secondChar !== ":") return false
-
-  return true
-}
-
-export const windowsFilePathToUrl = (windowsFilePath) => {
-  return `file:///${replaceBackSlashesWithSlashes(windowsFilePath)}`
-}
-
-export const replaceBackSlashesWithSlashes = (string) =>
-  string.replace(/\\/g, "/")

package/src/jsenv_file_urls.js

@@ -1,35 +0,0 @@
-import { resolveUrl, fileSystemPathToUrl } from "@jsenv/filesystem"
-
-import { require } from "./internal/require.js"
-
-export const jsenvCoreDirectoryUrl = String(new URL("../", import.meta.url))
-
-export const jsenvDistDirectoryUrl = String(
-  new URL("./dist/", jsenvCoreDirectoryUrl),
-)
-
-export const jsenvHelpersDirectoryInfo = {
-  url: resolveUrl("./helpers/", jsenvCoreDirectoryUrl),
-}
-
-export const sourcemapMainFileInfo = {
-  url: fileSystemPathToUrl(require.resolve("source-map/dist/source-map.js")),
-}
-
-export const sourcemapMappingFileInfo = {
-  url: fileSystemPathToUrl(require.resolve("source-map/lib/mappings.wasm")),
-}
-
-export const jsenvSystemJsFileInfo = {
-  url: resolveUrl("./src/internal/runtime_client/s.js", jsenvCoreDirectoryUrl),
-  jsenvRelativeUrl: "./src/internal/runtime_client/s.js",
-}
-
-export const jsenvResolveImportUrlHelper = {
-  url: resolveUrl(
-    "./src/internal/building/url_versioning/resolve_import_url_helper.js",
-    jsenvCoreDirectoryUrl,
-  ),
-  jsenvRelativeUrl:
-    "./src/internal/building/url_versioning/resolve_import_url_helper.js",
-}

package/src/jsenv_service_worker_finalizer.js

@@ -1,55 +0,0 @@
-import { resolveUrl, urlToRelativeUrl } from "@jsenv/filesystem"
-
-import { generateContentHash } from "@jsenv/core/src/internal/building/url_versioning/url_versioning.js"
-
-export const jsenvServiceWorkerFinalizer = (
-  code,
-  { serviceWorkerBuildRelativeUrl, buildFileContents, lineBreakNormalization },
-) => {
-  const generatedUrlsConfig = {}
-  Object.keys(buildFileContents).forEach((buildRelativeUrl) => {
-    if (buildRelativeUrl.endsWith(".map")) {
-      return
-    }
-
-    const buildUrl = resolveUrl(buildRelativeUrl, "file://")
-    const serviceWorkerBuildUrl = resolveUrl(
-      serviceWorkerBuildRelativeUrl,
-      "file://",
-    )
-    const urlRelativeToServiceWorker = urlToRelativeUrl(
-      buildUrl,
-      serviceWorkerBuildUrl,
-    )
-    if (urlRelativeToServiceWorker === "") {
-      // don't put the service worker itself
-      return
-    }
-    const versioned = fileNameContainsHash(buildRelativeUrl)
-    const buildFileContent = buildFileContents[buildRelativeUrl]
-
-    generatedUrlsConfig[urlRelativeToServiceWorker] = {
-      versioned,
-      ...(versioned
-        ? {}
-        : {
-            // when url is not versioned we compute a "version" for that url anyway
-            // so that service worker source still changes and navigator
-            // detect there is a change
-            version: generateContentHash(buildFileContent, {
-              lineBreakNormalization,
-            }),
-          }),
-    }
-  })
-  // TODO: ideally should use magic string to prepend code
-  // but it means composing 2 source maps, something not already available in jsenv codebase
-
-  return `
-self.generatedUrlsConfig = ${JSON.stringify(generatedUrlsConfig, null, "  ")};
-${code}
-`
-}
-
-const fileNameContainsHash = (fileName) =>
-  /_[a-z0-9]{8,}(\..*?)?$/.test(fileName)

package/src/json_to_js_module.js

@@ -1,13 +0,0 @@
-export const jsonToJsModule = async ({ code, url }) => {
-  const codeAsJson = JSON.stringify(code)
-    .replace(/\u2028/g, "\\u2028")
-    .replace(/\u2029/g, "\\u2029")
-  return {
-    compiledSource: `export default ${codeAsJson}`,
-    contentType: "application/javascript",
-    sources: [url],
-    sourcesContent: [code],
-    assets: [],
-    assetsContent: [],
-  }
-}

package/src/node_runtime.js

@@ -1,227 +0,0 @@
-import { Script } from "node:vm"
-import { loggerToLogLevel } from "@jsenv/logger"
-
-import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/jsenv_file_urls.js"
-import { escapeRegexpSpecialCharacters } from "./internal/regexp_escape.js"
-import { createControllableNodeProcess } from "./internal/node_launcher/node_controllable_process.js"
-import { getNodeRuntimeReport } from "./internal/node_launcher/node_runtime_report.js"
-
-export const nodeRuntime = {
-  name: "node",
-  version: process.version.slice(1),
-}
-nodeRuntime.launch = async ({
-  signal = new AbortController().signal,
-  logger,
-  logProcessCommand,
-
-  projectDirectoryUrl,
-  compileServerId,
-  compileServerOrigin,
-  jsenvDirectoryRelativeUrl,
-
-  measurePerformance,
-  collectPerformance,
-  collectCoverage = false,
-  coverageForceIstanbul,
-  coverageConfig,
-
-  moduleOutFormat,
-  forceCompilation,
-
-  debugPort,
-  debugMode,
-  debugModeInheritBreak,
-  env,
-  inheritProcessEnv,
-  commandLineOptions = [],
-  stdin,
-  stdout,
-  stderr,
-  stopAfterExecute,
-
-  remap = true,
-}) => {
-  env = {
-    ...env,
-    COVERAGE_ENABLED: collectCoverage,
-    JSENV: true,
-  }
-
-  if (coverageForceIstanbul) {
-    // if we want to force istanbul, we will set process.env.NODE_V8_COVERAGE = ''
-    // into the child_process
-    env.NODE_V8_COVERAGE = ""
-  }
-
-  commandLineOptions = [
-    "--experimental-import-meta-resolve",
-    ...commandLineOptions,
-  ]
-
-  const logLevel = loggerToLogLevel(logger)
-  const {
-    execArgv,
-    stoppedCallbackList,
-    errorCallbackList,
-    outputCallbackList,
-    stop,
-    requestActionOnChildProcess,
-  } = await createControllableNodeProcess({
-    signal,
-    logLevel,
-    debugPort,
-    debugMode,
-    debugModeInheritBreak,
-    env,
-    inheritProcessEnv,
-    commandLineOptions,
-    stdin,
-    stdout,
-    stderr,
-    logProcessCommand,
-  })
-
-  const execute = async ({ signal, fileRelativeUrl, executionId }) => {
-    const executeParams = {
-      projectDirectoryUrl,
-      compileServerOrigin,
-      jsenvDirectoryRelativeUrl,
-      jsenvCoreDirectoryUrl,
-
-      fileRelativeUrl,
-      executionId,
-      exitAfterAction: stopAfterExecute,
-
-      measurePerformance,
-      collectPerformance,
-      collectCoverage,
-      coverageConfig,
-
-      remap,
-    }
-
-    // https://nodejs.org/docs/latest-v15.x/api/cli.html#cli_node_v8_coverage_dir
-    // instrumentation CAN be handed by process.env.NODE_V8_COVERAGE
-    // "transform-instrument" becomes non mandatory
-    const coverageHandledFromOutside =
-      !coverageForceIstanbul && process.env.NODE_V8_COVERAGE
-    const nodeRuntimeReport = await getNodeRuntimeReport({
-      runtime: nodeRuntime,
-      compileServerId,
-      compileServerOrigin,
-
-      moduleOutFormat,
-      forceCompilation,
-      coverageHandledFromOutside,
-    })
-    const { compileProfile, compileId } = nodeRuntimeReport
-    let executionResult
-    if (compileId) {
-      executionResult = await requestActionOnChildProcess({
-        signal,
-        actionType:
-          compileProfile.moduleOutFormat === "systemjs"
-            ? "execute-using-systemjs"
-            : "execute-using-dynamic-import",
-        actionParams: {
-          compileId,
-          importDefaultExtension:
-            compileProfile.missingFeatures["import_default_extension"],
-          ...executeParams,
-        },
-      })
-    } else {
-      executionResult = await requestActionOnChildProcess({
-        signal,
-        actionType: "execute-using-dynamic-import",
-        actionParams: executeParams,
-      })
-    }
-    executionResult = transformExecutionResult(executionResult, {
-      compileServerOrigin,
-      projectDirectoryUrl,
-    })
-    return executionResult
-  }
-
-  return {
-    options: {
-      execArgv,
-      // for now do not pass env, it make debug logs to verbose
-      // because process.env is very big
-      // env,
-    },
-    stoppedCallbackList,
-    errorCallbackList,
-    outputCallbackList,
-    stop,
-    execute,
-  }
-}
-
-const transformExecutionResult = (
-  executionResult,
-  { compileServerOrigin, projectDirectoryUrl },
-) => {
-  const { status } = executionResult
-
-  if (status === "errored") {
-    const { exceptionSource, ...rest } = executionResult
-    const error = evalSource(exceptionSource)
-    const errorTransformed = transformError(error, {
-      compileServerOrigin,
-      projectDirectoryUrl,
-    })
-    return {
-      status,
-      error: errorTransformed,
-      ...rest,
-    }
-  }
-
-  return executionResult
-}
-
-const transformError = (
-  error,
-  { compileServerOrigin, projectDirectoryUrl },
-) => {
-  if (!error) {
-    return error
-  }
-
-  if (!(error instanceof Error)) {
-    return error
-  }
-
-  const compileServerOriginRegexp = new RegExp(
-    escapeRegexpSpecialCharacters(`${compileServerOrigin}/`),
-    "g",
-  )
-  // const serverUrlRegExp = new RegExp(
-  //   `(${escapeRegexpSpecialCharacters(`${compileServerOrigin}/`)}[^\\s]+)`,
-  //   "g",
-  // )
-  error.message = error.message.replace(
-    compileServerOriginRegexp,
-    projectDirectoryUrl,
-  )
-  error.stack = error.stack.replace(
-    compileServerOriginRegexp,
-    projectDirectoryUrl,
-  )
-  // const projectDirectoryPath = urlToFileSystemPath(projectDirectoryUrl)
-  // const projectDirectoryPathRegexp = new RegExp(
-  //   `(?<!file:\/\/)${escapeRegexpSpecialCharacters(projectDirectoryPath)}`,
-  //   "g",
-  // )
-  // error.stack = error.stack.replace(projectDirectoryPathRegexp, projectDirectoryUrl)
-  // error.message = error.message.replace(projectDirectoryPathRegexp, projectDirectoryUrl)
-  return error
-}
-
-const evalSource = (code, href) => {
-  const script = new Script(code, { filename: href })
-  return script.runInThisContext()
-}

package/src/require_using_child_process.js

@@ -1,67 +0,0 @@
-import { launchAndExecute } from "./internal/executing/launch_and_execute.js"
-import { createControllableNodeProcess } from "./internal/node_launcher/node_controllable_process.js"
-
-export const requireUsingChildProcess = async (
-  fileUrl,
-  {
-    logLevel,
-    debugPort,
-    debugMode,
-    debugModeInheritBreak,
-    commandLineOptions = [],
-    env,
-    stdin,
-    stdout,
-    stderr,
-  } = {},
-) => {
-  const result = await launchAndExecute({
-    stopAfterExecute: true,
-    fileRelativeUrl: String(fileUrl),
-    runtime: {
-      name: "node",
-      version: process.version.slice(1),
-      launch: async () => {
-        const controllableNodeProcess = await createControllableNodeProcess({
-          logLevel,
-          debugPort,
-          debugMode,
-          debugModeInheritBreak,
-          env,
-          commandLineOptions,
-          stdin,
-          stdout,
-          stderr,
-        })
-
-        return {
-          ...controllableNodeProcess,
-          execute: async ({ signal }) => {
-            try {
-              const namespace =
-                await controllableNodeProcess.requestActionOnChildProcess({
-                  signal,
-                  actionType: "execute-using-require",
-                  actionParams: { fileUrl },
-                })
-
-              return {
-                status: "ok",
-                namespace,
-              }
-            } catch (e) {
-              return {
-                status: "errored",
-                error: e,
-              }
-            }
-          },
-        }
-      },
-    },
-  })
-  if (result.status === "errored") {
-    throw result.error
-  }
-  return result.namespace
-}

package/src/text_to_js_module.js

@@ -1,13 +0,0 @@
-export const textToJsModule = async ({ code, url }) => {
-  const codeAsJson = JSON.stringify(code)
-    .replace(/\u2028/g, "\\u2028")
-    .replace(/\u2029/g, "\\u2029")
-  return {
-    compiledSource: `export default ${codeAsJson}`,
-    contentType: "application/javascript",
-    sources: [url],
-    sourcesContent: [code],
-    assets: [],
-    assetsContent: [],
-  }
-}