@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/internal/import-resolution/import-resolver-node.js

@@ -1,254 +0,0 @@
-import { createRequire } from "node:module"
-import {
-  urlToExtension,
-  resolveUrl,
-  urlToRelativeUrl,
-  readFile,
-} from "@jsenv/filesystem"
-import { isSpecifierForNodeCoreModule } from "@jsenv/importmap/src/isSpecifierForNodeCoreModule.js"
-
-import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
-
-import { applyDefaultExtension } from "./default-extension.js"
-
-export const createImportResolverForNode = async ({
-  projectDirectoryUrl,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  importDefaultExtension,
-}) => {
-  if (typeof import.meta.resolve === "undefined") {
-    throw new Error(
-      `import.meta.resolve is undefined, code must be executed with --experimental-import-meta-resolve`,
-    )
-  }
-
-  const defaultModuleResolution = await determineModuleSystem(
-    projectDirectoryUrl,
-  )
-
-  const resolveImport = async (specifier, importer) => {
-    if (isSpecifierForNodeCoreModule(specifier)) {
-      return specifier
-    }
-
-    if (importDefaultExtension) {
-      specifier = applyDefaultExtension(specifier, importer)
-    }
-
-    if (specifier.startsWith("http:") || specifier.startsWith("https:")) {
-      return specifier
-    }
-
-    // handle self reference inside jsenv itself, it is not allowed by Node.js
-    // for some reason
-    if (specifier.startsWith("@jsenv/core/")) {
-      if (projectDirectoryUrl === jsenvCoreDirectoryUrl) {
-        specifier = resolveUrl(
-          specifier.slice("@jsenv/core/".length),
-          projectDirectoryUrl,
-        )
-      }
-    }
-
-    const moduleResolutionAlgorithm = importer
-      ? moduleResolutionFromImporter(importer) || defaultModuleResolution
-      : defaultModuleResolution
-
-    importer =
-      importer || resolveUrl(compileDirectoryRelativeUrl, compileServerOrigin)
-
-    if (moduleResolutionAlgorithm === "esm") {
-      return resolveUsingNodeEsModuleAlgorithm(specifier, {
-        projectDirectoryUrl,
-        compileServerOrigin,
-        compileDirectoryRelativeUrl,
-        importer,
-      })
-    }
-
-    return resolveUsingNodeCommonJsAlgorithm(specifier, {
-      projectDirectoryUrl,
-      compileServerOrigin,
-      compileDirectoryRelativeUrl,
-      importer,
-    })
-  }
-
-  return { resolveImport, asProjectUrl, asOriginalUrl }
-}
-
-// https://nodejs.org/dist/latest-v16.x/docs/api/packages.html#packages_determining_module_system)
-const determineModuleSystem = async (projectDirectoryUrl) => {
-  const inputTypeIsModule = process.execArgv.some(
-    (argv) => argv === "--input-type=module",
-  )
-  if (inputTypeIsModule) {
-    return "esm"
-  }
-
-  return moduleResolutionFromProjectPackage(projectDirectoryUrl)
-}
-
-const moduleResolutionFromProjectPackage = async (projectDirectoryUrl) => {
-  const packageJsonFileUrl = new URL("package.json", projectDirectoryUrl)
-  let packageJson
-  try {
-    packageJson = await readFile(packageJsonFileUrl, {
-      as: "json",
-    })
-  } catch (e) {
-    if (e && e.code === "ENOENT") {
-      return "esm"
-    }
-  }
-  if (packageJson.type === "module") {
-    return "esm"
-  }
-  return "commonjs"
-}
-
-const moduleResolutionFromImporter = (importer) => {
-  if (urlToExtension(importer) === ".cjs") {
-    return "commonjs"
-  }
-
-  if (urlToExtension(importer) === ".mjs") {
-    return "esm"
-  }
-
-  // we should read the nearest package.json and search for type
-  return undefined
-}
-
-const resolveUsingNodeEsModuleAlgorithm = async (
-  specifier,
-  {
-    projectDirectoryUrl,
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-    importer,
-  },
-) => {
-  const importerFileUrl =
-    asOriginalUrl(importer, {
-      projectDirectoryUrl,
-      compileServerOrigin,
-      compileDirectoryRelativeUrl,
-    }) || importer
-
-  const importResolution = await import.meta.resolve(specifier, importerFileUrl)
-  return transformResolvedUrl(importResolution, {
-    importer,
-    projectDirectoryUrl,
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-  })
-}
-
-const resolveUsingNodeCommonJsAlgorithm = (
-  specifier,
-  {
-    projectDirectoryUrl,
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-    importer,
-  },
-) => {
-  const importerFileUrl =
-    asOriginalUrl(importer, {
-      projectDirectoryUrl,
-      compileDirectoryRelativeUrl,
-      compileServerOrigin,
-    }) || importer
-  const require = createRequire(importerFileUrl)
-  const requireResolution = require.resolve(specifier)
-  return transformResolvedUrl(requireResolution, {
-    importer,
-    projectDirectoryUrl,
-    compileDirectoryRelativeUrl,
-    compileServerOrigin,
-  })
-}
-
-const transformResolvedUrl = (
-  url,
-  {
-    importer,
-    projectDirectoryUrl,
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-  },
-) => {
-  const compileServerUrl = compileServerUrlFromOriginalUrl(url, {
-    importer,
-    projectDirectoryUrl,
-    compileDirectoryRelativeUrl,
-    compileServerOrigin,
-  })
-  return compileServerUrl
-}
-
-const asProjectUrl = (url, { projectDirectoryUrl, compileServerOrigin }) => {
-  if (url.startsWith(projectDirectoryUrl)) {
-    return url
-  }
-
-  if (url.startsWith(compileServerOrigin)) {
-    return `${projectDirectoryUrl}${url.slice(
-      `${compileServerOrigin}/`.length,
-    )}`
-  }
-
-  return null
-}
-
-const asOriginalUrl = (
-  url,
-  { projectDirectoryUrl, compileDirectoryRelativeUrl, compileServerOrigin },
-) => {
-  if (!url.startsWith(`${compileServerOrigin}/`)) {
-    return url
-  }
-
-  if (url === compileServerOrigin) {
-    return projectDirectoryUrl
-  }
-
-  const afterOrigin = url.slice(`${compileServerOrigin}/`.length)
-  if (!afterOrigin.startsWith(compileDirectoryRelativeUrl)) {
-    return url
-  }
-
-  const afterCompileDirectory = afterOrigin.slice(
-    compileDirectoryRelativeUrl.length,
-  )
-  return resolveUrl(afterCompileDirectory, projectDirectoryUrl)
-}
-
-const compileServerUrlFromOriginalUrl = (
-  url,
-  {
-    importer,
-    projectDirectoryUrl,
-    compileDirectoryRelativeUrl,
-    compileServerOrigin,
-  },
-) => {
-  if (!url.startsWith(projectDirectoryUrl)) {
-    return url
-  }
-
-  // si l'importer était compilé, compile aussi le fichier
-  const compileDirectoryServerUrl = resolveUrl(
-    compileDirectoryRelativeUrl,
-    compileServerOrigin,
-  )
-  if (importer.startsWith(compileDirectoryServerUrl)) {
-    const projectRelativeUrl = urlToRelativeUrl(url, projectDirectoryUrl)
-    return resolveUrl(projectRelativeUrl, compileDirectoryServerUrl)
-  }
-
-  const projectRelativeUrl = urlToRelativeUrl(url, projectDirectoryUrl)
-  return resolveUrl(projectRelativeUrl, compileDirectoryServerUrl)
-}

package/src/internal/import-resolution/importmap_default.js

@@ -1,37 +0,0 @@
-/**
- * allows the following:
- *
- * import "@jsenv/core/helpers/regenerator-runtime/regenerator-runtime.js"
- * -> searches a file inside @jsenv/core/*
- *
- */
-
-import { urlToRelativeUrl, urlIsInsideOf, resolveUrl } from "@jsenv/filesystem"
-
-import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
-
-export const getDefaultImportmap = (
-  url,
-  { projectDirectoryUrl, compileDirectoryUrl },
-) => {
-  const jsenvCoreDirectoryRelativeUrl = urlToRelativeUrl(
-    jsenvCoreDirectoryUrl,
-    projectDirectoryUrl,
-  )
-  let jsenvCoreUrl
-  if (compileDirectoryUrl && urlIsInsideOf(url, compileDirectoryUrl)) {
-    jsenvCoreUrl = resolveUrl(
-      jsenvCoreDirectoryRelativeUrl,
-      compileDirectoryUrl,
-    )
-  } else {
-    jsenvCoreUrl = jsenvCoreDirectoryUrl
-  }
-  const jsenvCoreRelativeUrl = urlToRelativeUrl(jsenvCoreUrl, url)
-  const importmap = {
-    imports: {
-      "@jsenv/core/": `./${jsenvCoreRelativeUrl}`,
-    },
-  }
-  return importmap
-}

package/src/internal/jsenvCoreDirectoryUrl.js

@@ -1,11 +0,0 @@
-export const jsenvCoreDirectoryUrl = String(
-  new URL(
-    // get ride of src/internal/jsenvCoreDirectoryUrl.js
-    "../../",
-    import.meta.url,
-  ),
-)
-
-export const jsenvDistDirectoryUrl = String(
-  new URL("./dist/", jsenvCoreDirectoryUrl),
-)

package/src/internal/jsenvInternalFiles.js

@@ -1,36 +0,0 @@
-import { resolveUrl, fileSystemPathToUrl } from "@jsenv/filesystem"
-import { require } from "./require.js"
-import { jsenvCoreDirectoryUrl } from "./jsenvCoreDirectoryUrl.js"
-
-export const jsenvHelpersDirectoryInfo = {
-  url: resolveUrl("./helpers/", jsenvCoreDirectoryUrl),
-}
-
-export const jsenvNodeSystemFileInfo = {
-  jsenvRelativeUrl: "./src/internal/node-launcher/node-js-file.js",
-  url: resolveUrl(
-    "./src/internal/node-launcher/node-js-file.js",
-    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/s.js", jsenvCoreDirectoryUrl),
-  jsenvRelativeUrl: "./src/internal/runtime/s.js",
-}
-
-export const jsenvResolveImportUrlHelper = {
-  url: resolveUrl(
-    "./src/internal/building/resolve_import_url_helper.js",
-    jsenvCoreDirectoryUrl,
-  ),
-  jsenvRelativeUrl: "./src/internal/building/resolve_import_url_helper.js",
-}

package/src/internal/jsenv_builds.js

@@ -1,19 +0,0 @@
-import { readFile } from "@jsenv/filesystem"
-
-import { jsenvCoreDirectoryUrl } from "./jsenvCoreDirectoryUrl.js"
-
-export const getJsenvBuildUrl = async (buildRelativeUrlWithoutHash) => {
-  try {
-    const manifest = await readFile(
-      new URL("./dist/manifest.json", jsenvCoreDirectoryUrl),
-      { as: "json" },
-    )
-    const buildRelativeUrl = manifest[buildRelativeUrlWithoutHash]
-    return new URL(buildRelativeUrl, jsenvCoreDirectoryUrl).href
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      return null
-    }
-    throw e
-  }
-}

package/src/internal/jsenv_remote_directory.js

@@ -1,156 +0,0 @@
-import {
-  urlIsInsideOf,
-  urlToRelativeUrl,
-  urlToRessource,
-  normalizeStructuredMetaMap,
-  urlToMeta,
-  writeFile,
-} from "@jsenv/filesystem"
-import { validateResponseIntegrity } from "@jsenv/integrity"
-
-import { fetchUrl } from "@jsenv/core/src/internal/fetchUrl.js"
-
-import { originDirectoryConverter } from "./origin_directory_converter.js"
-
-export const createJsenvRemoteDirectory = ({
-  projectDirectoryUrl,
-  jsenvDirectoryRelativeUrl,
-  preservedUrls,
-}) => {
-  const jsenvRemoteDirectoryUrl = `${projectDirectoryUrl}${jsenvDirectoryRelativeUrl}.remote/`
-  const structuredMetaMap = normalizeStructuredMetaMap(
-    { preserved: preservedUrls },
-    projectDirectoryUrl,
-  )
-  const isPreservedUrl = (url) => {
-    const meta = urlToMeta({ url, structuredMetaMap })
-    return Boolean(meta.preserved)
-  }
-
-  const jsenvRemoteDirectory = {
-    isPreservedUrl,
-
-    isRemoteUrl: (url) => {
-      return url.startsWith("http://") || url.startsWith("https://")
-    },
-
-    isFileUrlForRemoteUrl: (url) => {
-      return urlIsInsideOf(url, jsenvRemoteDirectoryUrl)
-    },
-
-    fileUrlFromRemoteUrl: (remoteUrl) => {
-      const origin = originFromUrlOrUrlPattern(remoteUrl)
-      const ressource = urlToRessource(remoteUrl)
-      const [pathname, search = ""] = ressource.split("?")
-      const directoryName = originDirectoryConverter.toDirectoryName(origin)
-      const fileRelativeUrl = `${directoryName}${
-        pathname === "" ? "/" : pathname
-      }`
-      const fileUrl = `${jsenvRemoteDirectoryUrl}${fileRelativeUrl}${search}`
-      return fileUrl
-    },
-
-    remoteUrlFromFileUrl: (fileUrl) => {
-      const fileRelativeUrl = urlToRelativeUrl(fileUrl, jsenvRemoteDirectoryUrl)
-      const firstSlashIndex = fileRelativeUrl.indexOf("/")
-      const directoryName = fileRelativeUrl.slice(0, firstSlashIndex)
-      const origin = originDirectoryConverter.fromDirectoryName(directoryName)
-      const ressource = fileRelativeUrl.slice(firstSlashIndex)
-      const remoteUrlObject = new URL(ressource, origin)
-      remoteUrlObject.searchParams.delete("integrity")
-      const remoteUrl = remoteUrlObject.href
-      return remoteUrl
-    },
-
-    loadFileUrlFromRemote: async (url, request) => {
-      const urlObject = new URL(url)
-      const integrity = urlObject.searchParams.get("integrity")
-      if (integrity) {
-        urlObject.searchParams.delete("integrity")
-      }
-      const remoteUrl = jsenvRemoteDirectory.remoteUrlFromFileUrl(
-        urlObject.href,
-      )
-      const requestHeadersToForward = { ...request.headers }
-      delete requestHeadersToForward.host
-      const response = await fetchUrl(remoteUrl, {
-        mode: "cors",
-        headers: requestHeadersToForward,
-      })
-      if (response.status !== 200) {
-        throw createRemoteFetchError({
-          code: "UNEXPECTED_STATUS",
-          message: `unexpected status for ressource "${remoteUrl}", received ${response.status}`,
-        })
-      }
-      const responseBodyAsBuffer = Buffer.from(await response.arrayBuffer())
-      if (integrity) {
-        try {
-          validateResponseIntegrity(
-            {
-              url: response.url,
-              type: response.type,
-              dataRepresentation: responseBodyAsBuffer,
-            },
-            integrity,
-          )
-        } catch (e) {
-          throw createRemoteFetchError({
-            code: e.code,
-            message: e.message,
-          })
-        }
-      }
-      await writeFile(url, responseBodyAsBuffer)
-      return responseBodyAsBuffer
-    },
-  }
-
-  return jsenvRemoteDirectory
-}
-
-const createRemoteFetchError = ({ message, code }) => {
-  const error = new Error(message)
-  error.code = "UNEXPECTED_REMOTE_URL_RESPONSE"
-  error.asResponse = () => {
-    const data = {
-      code,
-      message,
-    }
-    const json = JSON.stringify(data)
-    return {
-      status: 502,
-      statusText: "Bad Gateway",
-      headers: {
-        "cache-control": "no-store",
-        "content-length": Buffer.byteLength(json),
-        "content-type": "application/json",
-      },
-      body: json,
-    }
-  }
-  return error
-}
-
-const originFromUrlOrUrlPattern = (url) => {
-  if (url.startsWith("http://")) {
-    const slashAfterProtocol = url.indexOf("/", "http://".length + 1)
-    if (slashAfterProtocol === -1) {
-      return url
-    }
-    const origin = url.slice(0, slashAfterProtocol)
-    return origin
-  }
-  if (url.startsWith("https://")) {
-    const slashAfterProtocol = url.indexOf("/", "https://".length + 1)
-    if (slashAfterProtocol === -1) {
-      return url
-    }
-    const origin = url.slice(0, slashAfterProtocol)
-    return origin
-  }
-  if (url.startsWith("file://")) {
-    return "file://"
-  }
-  return new URL(url).origin
-}

package/src/internal/logs/byte.js

@@ -1,10 +0,0 @@
-import { createRequire } from "module"
-
-const require = createRequire(import.meta.url)
-
-// https://github.com/visionmedia/bytes.js/
-const bytes = require("bytes")
-
-export const formatByte = (metricValue) => {
-  return bytes(metricValue, { decimalPlaces: 2, unitSeparator: " " })
-}

package/src/internal/logs/byteAsFileSize.js

@@ -1,9 +0,0 @@
-import { require } from "../require.js"
-
-const bytes = require("bytes")
-
-// https://github.com/visionmedia/bytes.js
-
-export const byteAsFileSize = (metricValue) => {
-  return bytes(metricValue, { decimalPlaces: 2, unitSeparator: " " })
-}

package/src/internal/logs/msAsDuration.js

@@ -1,12 +0,0 @@
-import { require } from "../require.js"
-
-const humanizeDuration = require("humanize-duration")
-
-export const msAsDuration = (ms) => {
-  return humanizeDuration(ms, {
-    largest: 2,
-    maxDecimalPoints: ms < 0.1 ? 3 : ms < 1000 ? 2 : ms < 60000 ? 1 : 0,
-    delimiter: " and ",
-    // units: ["s"]
-  })
-}

package/src/internal/memoize.js

@@ -1,24 +0,0 @@
-export const memoize = (compute) => {
-  let memoized = false
-  let memoizedValue
-
-  const fnWithMemoization = (...args) => {
-    if (memoized) {
-      return memoizedValue
-    }
-    // if compute is recursive wait for it to be fully done before storing the lockValue
-    // so set locked later
-    memoizedValue = compute(...args)
-    memoized = true
-    return memoizedValue
-  }
-
-  fnWithMemoization.forget = () => {
-    const value = memoizedValue
-    memoized = false
-    memoizedValue = undefined
-    return value
-  }
-
-  return fnWithMemoization
-}

package/src/internal/node_launcher/node_runtime_report.js

@@ -1,77 +0,0 @@
-import { scanNodeRuntimeFeatures } from "@jsenv/core/src/internal/features/node_feature_detection/node_feature_detection.js"
-
-export const getNodeRuntimeReport = async ({
-  runtime,
-  compileServerId,
-  compileServerOrigin,
-
-  moduleOutFormat,
-  forceCompilation,
-  coverageHandledFromOutside,
-}) => {
-  const cache = cacheFromParams({
-    runtime,
-    compileServerId,
-    compileServerOrigin,
-
-    moduleOutFormat,
-    forceCompilation,
-    coverageHandledFromOutside,
-  })
-  const entry = cache.read()
-  if (entry) {
-    return entry
-  }
-  const nodeRuntimeFeaturesReport = await scanNodeRuntimeFeatures({
-    compileServerOrigin,
-    moduleOutFormat,
-    forceCompilation,
-    coverageHandledFromOutside,
-  })
-  cache.write(nodeRuntimeFeaturesReport)
-  return nodeRuntimeFeaturesReport
-}
-
-let currentCacheParams
-let currentCacheValue
-const cacheFromParams = ({
-  compileServerId,
-  compileServerOrigin,
-
-  moduleOutFormat,
-  forceCompilation,
-  coverageHandledFromOutside,
-}) => {
-  const params = {
-    compileServerId,
-    compileServerOrigin,
-
-    moduleOutFormat,
-    forceCompilation,
-    coverageHandledFromOutside,
-  }
-  if (!currentCacheParams) {
-    currentCacheParams = params
-    return {
-      read: () => null,
-      write: (value) => {
-        currentCacheValue = value
-      },
-    }
-  }
-  if (JSON.stringify(currentCacheParams) !== JSON.stringify(params)) {
-    return {
-      read: () => null,
-      write: (value) => {
-        currentCacheParams = params
-        currentCacheValue = value
-      },
-    }
-  }
-  return {
-    read: () => currentCacheValue,
-    write: (value) => {
-      currentCacheValue = value
-    },
-  }
-}

package/src/internal/node_launcher/processOptions.js

@@ -1,46 +0,0 @@
-export const processOptionsFromExecArgv = (execArgv) => {
-  const processOptions = {}
-
-  let i = 0
-  while (i < execArgv.length) {
-    const execArg = execArgv[i]
-    const option = processOptionFromExecArg(execArg)
-    processOptions[option.name] = option.value
-    i++
-  }
-
-  return processOptions
-}
-
-const processOptionFromExecArg = (execArg) => {
-  const equalCharIndex = execArg.indexOf("=")
-  if (equalCharIndex === -1) {
-    return {
-      name: execArg,
-      value: "",
-    }
-  }
-
-  const name = execArg.slice(0, equalCharIndex)
-  const value = execArg.slice(equalCharIndex + 1)
-  return {
-    name,
-    value,
-  }
-}
-
-export const execArgvFromProcessOptions = (processOptions) => {
-  const execArgv = []
-  Object.keys(processOptions).forEach((processOptionName) => {
-    const processOptionValue = processOptions[processOptionName]
-    if (processOptionValue === "unset") {
-      return
-    }
-    if (processOptionValue === "") {
-      execArgv.push(processOptionName)
-      return
-    }
-    execArgv.push(`${processOptionName}=${processOptionValue}`)
-  })
-  return execArgv
-}