@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/dev_server.js

@@ -1,295 +0,0 @@
-import { setupRoutes } from "@jsenv/server"
-import {
-  normalizeStructuredMetaMap,
-  collectFiles,
-  urlToRelativeUrl,
-} from "@jsenv/filesystem"
-
-import { REDIRECTOR_BUILD_URL } from "@jsenv/core/dist/build_manifest.js"
-import { setUrlSearchParamsDescriptor } from "@jsenv/core/src/internal/url_utils.js"
-import { jsenvCoreDirectoryUrl } from "./internal/jsenvCoreDirectoryUrl.js"
-import {
-  assertProjectDirectoryUrl,
-  assertProjectDirectoryExists,
-} from "./internal/argUtils.js"
-import {
-  startCompileServer,
-  assertAndNormalizeJsenvDirectoryRelativeUrl,
-} from "./internal/compiling/startCompileServer.js"
-import {
-  sourcemapMainFileInfo,
-  sourcemapMappingFileInfo,
-} from "./internal/jsenvInternalFiles.js"
-import { jsenvExplorableConfig } from "./jsenvExplorableConfig.js"
-
-const EXPLORING_HTML_URL = new URL(
-  "./src/internal/dev_server/exploring/exploring.html",
-  jsenvCoreDirectoryUrl,
-).href
-
-export const startDevServer = async ({
-  signal = new AbortController().signal,
-  handleSIGINT = true,
-  port,
-  ip,
-  protocol,
-  http2 = false, // disable by default for now because it is buggy on safari
-  certificate,
-  privateKey,
-  plugins,
-  customServices,
-
-  projectDirectoryUrl,
-  explorableConfig = jsenvExplorableConfig,
-  mainFileRelativeUrl,
-  jsenvDirectoryRelativeUrl,
-  jsenvToolbar = true,
-  livereloading = true,
-  inlineImportMapIntoHTML = true,
-  keepProcessAlive = true,
-
-  babelPluginMap,
-  workers,
-  serviceWorkers,
-  importMapInWebWorkers,
-  customCompilers,
-  preservedUrls,
-  runtimeSupportDuringDev = {
-    // this allows to compile nothing or almost nothing when opening files
-    // with a recent chrome. Without this we would compile all the things not yet unsupported
-    // by Firefox and Safari such as top level await, importmap, etc
-    chrome: "96",
-  },
-  logLevel,
-  compileServerCanReadFromFilesystem,
-  compileServerCanWriteOnFilesystem,
-  sourcemapMethod,
-  livereloadWatchConfig,
-  livereloadLogLevel,
-  jsenvDirectoryClean,
-}) => {
-  projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
-  await assertProjectDirectoryExists({ projectDirectoryUrl })
-  if (mainFileRelativeUrl === undefined) {
-    mainFileRelativeUrl = urlToRelativeUrl(
-      EXPLORING_HTML_URL,
-      projectDirectoryUrl,
-    )
-  }
-  jsenvDirectoryRelativeUrl = assertAndNormalizeJsenvDirectoryRelativeUrl({
-    projectDirectoryUrl,
-    jsenvDirectoryRelativeUrl,
-  })
-  const compileServer = await startCompileServer({
-    signal,
-    handleSIGINT,
-    keepProcessAlive,
-    logLevel,
-    port,
-    ip,
-    protocol,
-    http2,
-    certificate,
-    privateKey,
-    plugins,
-    customServices: {
-      ...customServices,
-      "jsenv:redirector": await createRedirectorService({
-        projectDirectoryUrl,
-        mainFileRelativeUrl,
-      }),
-      "jsenv:exploring_json": createExploringJsonService({
-        projectDirectoryUrl,
-        jsenvDirectoryRelativeUrl,
-        mainFileRelativeUrl,
-        explorableConfig,
-        livereloading,
-      }),
-      "jsenv:explorables_json": createExplorableJsonService({
-        projectDirectoryUrl,
-        jsenvDirectoryRelativeUrl,
-        explorableConfig,
-      }),
-    },
-
-    projectDirectoryUrl,
-    livereloadSSE: livereloading,
-    jsenvEventSourceClientInjection: true,
-    jsenvToolbarInjection: jsenvToolbar,
-    jsenvDirectoryRelativeUrl,
-    inlineImportMapIntoHTML,
-
-    compileServerCanReadFromFilesystem,
-    compileServerCanWriteOnFilesystem,
-    customCompilers,
-    preservedUrls,
-    sourcemapMethod,
-    babelPluginMap,
-    workers,
-    serviceWorkers,
-    importMapInWebWorkers,
-    runtimeSupport: runtimeSupportDuringDev,
-    livereloadWatchConfig,
-    livereloadLogLevel,
-    jsenvDirectoryClean,
-  })
-
-  return compileServer
-}
-
-const createRedirectorService = async ({
-  projectDirectoryUrl,
-  mainFileRelativeUrl,
-}) => {
-  const redirectorRelativeUrlForProject = urlToRelativeUrl(
-    REDIRECTOR_BUILD_URL,
-    projectDirectoryUrl,
-  )
-  return setupRoutes({
-    "/": (request) => {
-      const redirectTarget = mainFileRelativeUrl
-      return {
-        status: 307,
-        headers: {
-          location: setUrlSearchParamsDescriptor(
-            `${request.origin}/${redirectorRelativeUrlForProject}`,
-            {
-              redirect: redirectTarget,
-            },
-          ),
-        },
-      }
-    },
-    // compile server (compiled file service to be precised)
-    // is already implementing this redirection when a compile id do not exists
-    // and "redirect" is not a valid compile id
-    // That being said I prefer to keep it to be explicit and shortcircuit the logic
-    "/.jsenv/redirect/:rest*": (request) => {
-      const redirectTarget = request.ressource.slice("/.jsenv/redirect/".length)
-      return {
-        status: 307,
-        headers: {
-          location: setUrlSearchParamsDescriptor(
-            `${request.origin}/${redirectorRelativeUrlForProject}`,
-            {
-              redirect: redirectTarget,
-            },
-          ),
-        },
-      }
-    },
-    "/.jsenv/force/:rest*": (request) => {
-      const redirectTarget = request.ressource.slice("/.jsenv/force/".length)
-      return {
-        status: 307,
-        headers: {
-          location: setUrlSearchParamsDescriptor(
-            `${request.origin}/${redirectorRelativeUrlForProject}`,
-            {
-              redirect: redirectTarget,
-              force_compilation: 1,
-            },
-          ),
-        },
-      }
-    },
-  })
-}
-
-const createExploringJsonService = ({
-  projectDirectoryUrl,
-  jsenvDirectoryRelativeUrl,
-  explorableConfig,
-  livereloading,
-  mainFileRelativeUrl,
-}) => {
-  return (request) => {
-    if (
-      request.ressource !== "/.jsenv/exploring.json" ||
-      request.method !== "GET"
-    ) {
-      return null
-    }
-    const data = {
-      projectDirectoryUrl,
-      jsenvDirectoryRelativeUrl,
-      jsenvCoreDirectoryRelativeUrl: urlToRelativeUrl(
-        jsenvCoreDirectoryUrl,
-        projectDirectoryUrl,
-      ),
-      exploringHtmlFileRelativeUrl: mainFileRelativeUrl,
-      sourcemapMainFileRelativeUrl: urlToRelativeUrl(
-        sourcemapMainFileInfo.url,
-        jsenvCoreDirectoryUrl,
-      ),
-      sourcemapMappingFileRelativeUrl: urlToRelativeUrl(
-        sourcemapMappingFileInfo.url,
-        jsenvCoreDirectoryUrl,
-      ),
-      explorableConfig,
-      livereloading,
-    }
-    const json = JSON.stringify(data)
-    return {
-      status: 200,
-      headers: {
-        "cache-control": "no-store",
-        "content-type": "application/json",
-        "content-length": Buffer.byteLength(json),
-      },
-      body: json,
-    }
-  }
-}
-
-const createExplorableJsonService = ({
-  projectDirectoryUrl,
-  jsenvDirectoryRelativeUrl,
-  explorableConfig,
-}) => {
-  return async (request) => {
-    if (
-      request.ressource !== "/.jsenv/explorables.json" ||
-      request.method !== "GET"
-    ) {
-      return null
-    }
-    const structuredMetaMapRelativeForExplorable = {}
-    Object.keys(explorableConfig).forEach((explorableGroup) => {
-      const explorableGroupConfig = explorableConfig[explorableGroup]
-      structuredMetaMapRelativeForExplorable[explorableGroup] = {
-        "**/.jsenv/": false, // temporary (in theory) to avoid visting .jsenv directory in jsenv itself
-        ...explorableGroupConfig,
-        [jsenvDirectoryRelativeUrl]: false,
-      }
-    })
-    const structuredMetaMapForExplorable = normalizeStructuredMetaMap(
-      structuredMetaMapRelativeForExplorable,
-      projectDirectoryUrl,
-    )
-    const matchingFileResultArray = await collectFiles({
-      directoryUrl: projectDirectoryUrl,
-      structuredMetaMap: structuredMetaMapForExplorable,
-      predicate: (meta) =>
-        Object.keys(meta).some((explorableGroup) =>
-          Boolean(meta[explorableGroup]),
-        ),
-    })
-    const explorableFiles = matchingFileResultArray.map(
-      ({ relativeUrl, meta }) => ({
-        relativeUrl,
-        meta,
-      }),
-    )
-    const json = JSON.stringify(explorableFiles)
-    return {
-      status: 200,
-      headers: {
-        "cache-control": "no-store",
-        "content-type": "application/json",
-        "content-length": Buffer.byteLength(json),
-      },
-      body: json,
-    }
-  }
-}

package/src/execute.js

@@ -1,184 +0,0 @@
-import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
-
-import { normalizeRuntimeSupport } from "@jsenv/core/src/internal/runtime_support/runtime_support.js"
-import {
-  assertProjectDirectoryUrl,
-  assertProjectDirectoryExists,
-} from "./internal/argUtils.js"
-import { startCompileServer } from "./internal/compiling/startCompileServer.js"
-import { launchAndExecute } from "./internal/executing/launchAndExecute.js"
-
-export const execute = async ({
-  signal = new AbortController().signal,
-  handleSIGINT = true,
-
-  logLevel = "warn",
-  compileServerLogLevel = logLevel,
-  launchAndExecuteLogLevel = logLevel,
-
-  projectDirectoryUrl,
-  jsenvDirectoryRelativeUrl,
-  jsenvDirectoryClean,
-
-  importDefaultExtension,
-
-  fileRelativeUrl,
-  runtime,
-  runtimeParams,
-
-  allocatedMs,
-  mirrorConsole = true,
-  captureConsole,
-  inheritCoverage,
-  collectCoverage,
-  measurePerformance,
-  collectPerformance,
-  collectCompileServerInfo = false,
-  stopAfterExecute = false,
-  stopAfterExecuteReason,
-  gracefulStopAllocatedMs,
-  ignoreError = false,
-
-  protocol,
-  privateKey,
-  certificate,
-  ip,
-  port,
-  babelPluginMap,
-  customCompilers,
-  preservedUrls,
-  workers,
-  serviceWorkers,
-  importMapInWebWorkers,
-  compileServerCanReadFromFilesystem,
-  compileServerCanWriteOnFilesystem,
-
-  runtimeConsoleCallback,
-  runtimeStartedCallback,
-  runtimeStoppedCallback,
-  runtimeErrorAfterExecutionCallback,
-  runtimeDisconnectCallback,
-}) => {
-  projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
-  await assertProjectDirectoryExists({ projectDirectoryUrl })
-  if (typeof fileRelativeUrl !== "string") {
-    throw new TypeError(
-      `fileRelativeUrl must be a string, got ${fileRelativeUrl}`,
-    )
-  }
-  fileRelativeUrl = fileRelativeUrl.replace(/\\/g, "/")
-  if (typeof runtime !== "object") {
-    throw new TypeError(`runtime must be an object, got ${runtime}`)
-  }
-  if (typeof runtime.launch !== "function") {
-    throw new TypeError(
-      `runtime.launch must be a function, got ${runtime.launch}`,
-    )
-  }
-  const executeOperation = Abort.startOperation()
-  executeOperation.addAbortSignal(signal)
-  if (handleSIGINT) {
-    executeOperation.addAbortSource((abort) => {
-      return raceProcessTeardownEvents(
-        {
-          SIGINT: true,
-        },
-        abort,
-      )
-    })
-  }
-  try {
-    const compileServer = await startCompileServer({
-      signal: executeOperation.signal,
-      logLevel: compileServerLogLevel,
-
-      projectDirectoryUrl,
-      jsenvDirectoryRelativeUrl,
-      jsenvDirectoryClean,
-
-      importDefaultExtension,
-
-      protocol,
-      privateKey,
-      certificate,
-      ip,
-      port,
-      babelPluginMap,
-      runtimeSupport: normalizeRuntimeSupport({
-        [runtime.name]: runtime.version,
-      }),
-      customCompilers,
-      preservedUrls,
-      workers,
-      serviceWorkers,
-      importMapInWebWorkers,
-      compileServerCanReadFromFilesystem,
-      compileServerCanWriteOnFilesystem,
-    })
-    executeOperation.addEndCallback(async () => {
-      await compileServer.stop("execution done")
-    })
-
-    const result = await launchAndExecute({
-      signal: executeOperation.signal,
-      launchAndExecuteLogLevel,
-
-      runtime,
-      runtimeParams: {
-        projectDirectoryUrl,
-        compileServerOrigin: compileServer.origin,
-        compileServerId: compileServer.id,
-        jsenvDirectoryRelativeUrl: compileServer.jsenvDirectoryRelativeUrl,
-        ...runtimeParams,
-      },
-      executeParams: {
-        fileRelativeUrl,
-      },
-
-      allocatedMs,
-      mirrorConsole,
-      captureConsole,
-      inheritCoverage,
-      collectCoverage,
-      measurePerformance,
-      collectPerformance,
-
-      stopAfterExecute,
-      stopAfterExecuteReason,
-      gracefulStopAllocatedMs,
-
-      runtimeConsoleCallback,
-      runtimeStartedCallback,
-      runtimeStoppedCallback,
-      runtimeErrorAfterExecutionCallback,
-      runtimeDisconnectCallback,
-    })
-
-    if (collectCompileServerInfo) {
-      result.compileServerOrigin = compileServer.origin
-      result.jsenvDirectoryRelativeUrl = compileServer.jsenvDirectoryRelativeUrl
-    }
-
-    if (result.status === "errored") {
-      if (ignoreError) {
-        return result
-      }
-      /*
-    Warning: when node launched with --unhandled-rejections=strict, despites
-    this promise being rejected by throw result.error node will compltely ignore it.
-
-    The error can be logged by doing
-    ```js
-    process.setUncaughtExceptionCaptureCallback((error) => {
-      console.error(error.stack)
-    })
-    ```
-    But it feels like a hack.
-    */
-      throw result.error
-    }
-    return result
-  } finally {
-    await executeOperation.end()
-  }
-}

package/src/importUsingChildProcess.js

@@ -1,68 +0,0 @@
-import { launchAndExecute } from "./internal/executing/launchAndExecute.js"
-import { createControllableNodeProcess } from "./internal/node_launcher/createControllableNodeProcess.js"
-
-export const importUsingChildProcess = async (
-  fileUrl,
-  {
-    logLevel,
-    debugPort,
-    debugMode,
-    debugModeInheritBreak,
-    commandLineOptions = [],
-    env,
-    stdin,
-    stdout,
-    stderr,
-  } = {},
-) => {
-  fileUrl = String(fileUrl)
-  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-import",
-                  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/internal/argUtils.js

@@ -1,12 +0,0 @@
-import {
-  assertAndNormalizeDirectoryUrl,
-  assertDirectoryPresence,
-} from "@jsenv/filesystem"
-
-export const assertProjectDirectoryUrl = ({ projectDirectoryUrl }) => {
-  return assertAndNormalizeDirectoryUrl(projectDirectoryUrl)
-}
-
-export const assertProjectDirectoryExists = ({ projectDirectoryUrl }) => {
-  assertDirectoryPresence(projectDirectoryUrl)
-}

package/src/internal/babel_plugin_replace_expressions.js

@@ -1,101 +0,0 @@
-// heavily inspired from https://github.com/jviide/babel-plugin-transform-replace-expressions
-// last known commit: 57b608e0eeb8807db53d1c68292621dfafb5599c
-
-export const babelPluginReplaceExpressions = (api, options) => {
-  const { traverse, parse, types } = api
-  const { replaceMap = {}, allowConflictingReplacements = false } = options
-
-  const replacementMap = new Map()
-  const valueExpressionSet = new Set()
-
-  return {
-    name: "transform-replace-expressions",
-
-    pre: (state) => {
-      // https://github.com/babel/babel/blob/d50e78d45b608f6e0f6cc33aeb22f5db5027b153/packages/babel-traverse/src/path/replacement.js#L93
-      const parseExpression = (value) => {
-        const expressionNode = parse(value, state.opts).program.body[0]
-          .expression
-        traverse.removeProperties(expressionNode)
-        return expressionNode
-      }
-
-      Object.keys(replaceMap).forEach((key) => {
-        const keyExpressionNode = parseExpression(key)
-        const candidateArray = replacementMap.get(keyExpressionNode.type) || []
-        const value = replaceMap[key]
-        const valueExpressionNode = parseExpression(value)
-
-        const equivalentKeyExpressionIndex = candidateArray.findIndex(
-          (candidate) =>
-            types.isNodesEquivalent(
-              candidate.keyExpressionNode,
-              keyExpressionNode,
-            ),
-        )
-        if (
-          !allowConflictingReplacements &&
-          equivalentKeyExpressionIndex > -1
-        ) {
-          throw new Error(
-            `Expressions ${candidateArray[equivalentKeyExpressionIndex].key} and ${key} conflict`,
-          )
-        }
-
-        const newCandidate = {
-          key,
-          value,
-          keyExpressionNode,
-          valueExpressionNode,
-        }
-        if (equivalentKeyExpressionIndex > -1) {
-          candidateArray[equivalentKeyExpressionIndex] = newCandidate
-        } else {
-          candidateArray.push(newCandidate)
-        }
-        replacementMap.set(keyExpressionNode.type, candidateArray)
-      })
-
-      replacementMap.forEach((candidateArray) => {
-        candidateArray.forEach((candidate) => {
-          valueExpressionSet.add(candidate.valueExpressionNode)
-        })
-      })
-    },
-    visitor: {
-      Expression(path) {
-        if (valueExpressionSet.has(path.node)) {
-          path.skip()
-          return
-        }
-
-        const candidateArray = replacementMap.get(path.node.type)
-        if (!candidateArray) {
-          return
-        }
-
-        const candidateFound = candidateArray.find((candidate) => {
-          return types.isNodesEquivalent(candidate.keyExpressionNode, path.node)
-        })
-        if (candidateFound) {
-          try {
-            types.validate(
-              path.parent,
-              path.key,
-              candidateFound.valueExpressionNode,
-            )
-          } catch (err) {
-            if (!(err instanceof TypeError)) {
-              throw err
-            }
-            path.skip()
-            return
-          }
-
-          path.replaceWith(candidateFound.valueExpressionNode)
-          return
-        }
-      },
-    },
-  }
-}