@jsenv/core 26.0.1 → 27.0.0-alpha.10

package/src/internal/import_resolution/default_extension.js

@@ -1,40 +0,0 @@
-export const applyDefaultExtension = (specifier, importer) => {
-  if (!importer) {
-    return specifier
-  }
-
-  const importerExtension = urlToExtension(importer)
-  const fakeUrl = new URL(specifier, importer).href
-  const specifierExtension = urlToExtension(fakeUrl)
-  if (specifierExtension !== "") {
-    return specifier
-  }
-
-  // I guess typescript still expect default extension to be .ts
-  // in a tsx file.
-  if (importerExtension === "tsx") {
-    return `${specifier}.ts`
-  }
-
-  // extension magic
-  return `${specifier}${importerExtension}`
-}
-
-const urlToExtension = (url) => {
-  return pathnameToExtension(urlToPathname(url))
-}
-
-const urlToPathname = (url) => new URL(url).pathname
-
-const pathnameToExtension = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/")
-  if (slashLastIndex !== -1) {
-    pathname = pathname.slice(slashLastIndex + 1)
-  }
-
-  const dotLastIndex = pathname.lastIndexOf(".")
-  if (dotLastIndex === -1) return ""
-  // if (dotLastIndex === pathname.length - 1) return ""
-  const extension = pathname.slice(dotLastIndex)
-  return extension
-}

package/src/internal/import_resolution/import_resolver_importmap.js

@@ -1,64 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-import { resolveImport } from "@jsenv/importmap/src/resolveImport.js"
-
-import { tryToFindProjectRelativeUrl } from "@jsenv/core/src/internal/runtime_client/module_registration.js"
-
-import { applyDefaultExtension } from "./default_extension.js"
-
-export const createImportResolverForImportmap = async ({
-  // projectDirectoryUrl,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  importMap,
-  importMapUrl,
-  importDefaultExtension,
-  onBareSpecifierError = () => {},
-}) => {
-  const _resolveImport = (specifier, importer) => {
-    if (importDefaultExtension) {
-      specifier = applyDefaultExtension(specifier, importer)
-    }
-    return resolveImport({
-      specifier,
-      importer,
-      importMap,
-      createBareSpecifierError: ({ specifier, importer }) => {
-        const bareSpecifierError = createBareSpecifierError({
-          specifier,
-          importer:
-            tryToFindProjectRelativeUrl(importer, {
-              compileServerOrigin,
-              compileDirectoryRelativeUrl,
-            }) || importer,
-          importMapUrl:
-            tryToFindProjectRelativeUrl(importMapUrl, {
-              compileServerOrigin,
-              compileDirectoryRelativeUrl,
-            }) || importMapUrl,
-          importMap,
-        })
-        onBareSpecifierError(bareSpecifierError)
-        return bareSpecifierError
-      },
-    })
-  }
-
-  return { resolveImport: _resolveImport }
-}
-
-const createBareSpecifierError = ({ specifier, importer, importMapUrl }) => {
-  const detailedMessage = createDetailedMessage("Unmapped bare specifier.", {
-    specifier,
-    importer,
-    ...(importMapUrl
-      ? {
-          "how to fix": `Add a mapping for "${specifier}" into the importmap file at "${importMapUrl}"`,
-        }
-      : {
-          "how to fix": `Add an importmap with a mapping for "${specifier}"`,
-          "suggestion": `Generate importmap using https://github.com/jsenv/importmap-node-module`,
-        }),
-  })
-
-  return new Error(detailedMessage)
-}

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/jsenv_file_urls.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/jsenv_file_urls.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/jsenv_builds.js

@@ -1,19 +0,0 @@
-import { readFile } from "@jsenv/filesystem"
-
-import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/jsenv_file_urls.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_params_assertions.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/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/fetching.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/byte_as_file_size.js

@@ -1,9 +0,0 @@
-import { require } from "@jsenv/core/src/internal/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/ms_as_duration.js

@@ -1,12 +0,0 @@
-import { require } from "@jsenv/core/src/internal/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/eval_source.js

@@ -1,6 +0,0 @@
-import { Script } from "node:vm"
-
-export const evalSource = (code, filePath) => {
-  const script = new Script(code, { filename: filePath })
-  return script.runInThisContext()
-}

package/src/internal/node_launcher/fetch_source.js

@@ -1,8 +0,0 @@
-import { fetchUrl } from "@jsenv/core/src/internal/fetching.js"
-
-export const fetchSource = (url, options) => {
-  return fetchUrl(url, {
-    ignoreHttpsError: true,
-    ...options,
-  })
-}

package/src/internal/node_launcher/node_error_stack_remap.js

@@ -1,22 +0,0 @@
-import { ensureWindowsDriveLetter, resolveUrl } from "@jsenv/filesystem"
-
-import { require } from "@jsenv/core/src/internal/require.js"
-import { installErrorStackRemapping } from "@jsenv/core/src/internal/error_stack_remap/install_error_stack_remapping.js"
-
-import { fetchSource } from "./fetch_source.js"
-
-export const installNodeErrorStackRemapping = ({
-  projectDirectoryUrl,
-  ...options
-}) => {
-  const { SourceMapConsumer } = require("source-map")
-
-  return installErrorStackRemapping({
-    SourceMapConsumer,
-    fetchFile: fetchSource,
-    resolveFile: (specifier, importer = projectDirectoryUrl) => {
-      return ensureWindowsDriveLetter(resolveUrl(specifier, importer), importer)
-    },
-    ...options,
-  })
-}