@jsenv/core 26.0.1 → 27.0.0-alpha.10

package/src/internal/runtime_client/s.js.md

@@ -1 +0,0 @@
-s.js exists to ease jsenv ability to find the file.

package/src/internal/runtime_support/jsenv_runtime_support.js

@@ -1,15 +0,0 @@
-export const jsenvBrowserRuntimeSupport = {
-  android: "0.0.0",
-  chrome: "0.0.0",
-  edge: "0.0.0",
-  electron: "0.0.0",
-  firefox: "0.0.0",
-  ios: "0.0.0",
-  opera: "0.0.0",
-  rhino: "0.0.0",
-  safari: "0.0.0",
-}
-
-export const jsenvNodeRuntimeSupport = {
-  node: "0.0.0",
-}

package/src/internal/runtime_support/runtime_support.js

@@ -1,70 +0,0 @@
-import { findLowestVersion } from "../semantic_versioning/lowest_version.js"
-
-export const isNodePartOfSupportedRuntimes = (runtimeSupport) => {
-  return Boolean(runtimeSupport.node)
-}
-
-export const isBrowserPartOfSupportedRuntimes = (runtimeSupport) => {
-  return Boolean(
-    runtimeSupport.android ||
-      runtimeSupport.chrome ||
-      runtimeSupport.edge ||
-      runtimeSupport.electron ||
-      runtimeSupport.firefox ||
-      runtimeSupport.ios ||
-      runtimeSupport.opera ||
-      runtimeSupport.safari,
-  )
-}
-
-export const normalizeRuntimeSupport = (runtimeSupport) => {
-  const runtimeSupportNormalized = {}
-
-  Object.keys(runtimeSupport).forEach((runtimeName) => {
-    const runtimeNameNormalized = normalizeRuntimeName(runtimeName)
-    const runtimeVersion = normalizeRuntimeVersion(runtimeSupport[runtimeName])
-    mergeRuntimeSupport(runtimeSupportNormalized, {
-      [runtimeNameNormalized]: runtimeVersion,
-    })
-  })
-
-  return runtimeSupportNormalized
-}
-
-const normalizeRuntimeName = (name) => {
-  return runtimeNameMapping[name] || name
-}
-
-const runtimeNameMapping = {
-  chromium: "chrome",
-  webkit: "safari",
-}
-
-const normalizeRuntimeVersion = (version) => {
-  if (version.indexOf(".") > -1) {
-    const parts = version.split(".")
-    // remove extraneous .
-    return parts.slice(0, 3).join(".")
-  }
-
-  if (version.indexOf("_") > -1) {
-    const parts = version.split("_")
-    // remove extraneous _
-    return parts.slice(0, 3).join("_")
-  }
-
-  return version
-}
-
-const mergeRuntimeSupport = (runtimeSupport, childRuntimeSupport) => {
-  Object.keys(childRuntimeSupport).forEach((runtimeName) => {
-    const childRuntimeVersion = normalizeRuntimeVersion(
-      childRuntimeSupport[runtimeName],
-    )
-    const childRuntimeNameNormalized = normalizeRuntimeName(runtimeName)
-    const runtimeVersion = runtimeSupport[childRuntimeNameNormalized]
-    runtimeSupport[childRuntimeNameNormalized] = runtimeVersion
-      ? findLowestVersion(runtimeVersion, childRuntimeVersion)
-      : childRuntimeVersion
-  })
-}

package/src/internal/semantic_versioning/compare_versions.js

@@ -1,28 +0,0 @@
-import { versionFromValue } from "./version_from_value.js"
-
-export const compareTwoVersions = (versionA, versionB) => {
-  const semanticVersionA = versionFromValue(versionA)
-  const semanticVersionB = versionFromValue(versionB)
-  const majorDiff = semanticVersionA.major - semanticVersionB.major
-  if (majorDiff > 0) {
-    return majorDiff
-  }
-  if (majorDiff < 0) {
-    return majorDiff
-  }
-  const minorDiff = semanticVersionA.minor - semanticVersionB.minor
-  if (minorDiff > 0) {
-    return minorDiff
-  }
-  if (minorDiff < 0) {
-    return minorDiff
-  }
-  const patchDiff = semanticVersionA.patch - semanticVersionB.patch
-  if (patchDiff > 0) {
-    return patchDiff
-  }
-  if (patchDiff < 0) {
-    return patchDiff
-  }
-  return 0
-}

package/src/internal/semantic_versioning/highest_version.js

@@ -1,11 +0,0 @@
-import { versionIsBelow } from "./is_below.js"
-
-export const findHighestVersion = (...values) => {
-  if (values.length === 0) throw new Error(`missing argument`)
-  return values.reduce((highestVersion, value) => {
-    if (versionIsBelow(highestVersion, value)) {
-      return value
-    }
-    return highestVersion
-  })
-}

package/src/internal/semantic_versioning/is_above.js

@@ -1,5 +0,0 @@
-import { compareTwoVersions } from "./compare_versions.js"
-
-export const versionIsAbove = (versionSupposedAbove, versionSupposedBelow) => {
-  return compareTwoVersions(versionSupposedAbove, versionSupposedBelow) > 0
-}

package/src/internal/semantic_versioning/is_below.js

@@ -1,5 +0,0 @@
-import { compareTwoVersions } from "./compare_versions.js"
-
-export const versionIsBelow = (versionSupposedBelow, versionSupposedAbove) => {
-  return compareTwoVersions(versionSupposedBelow, versionSupposedAbove) < 0
-}

package/src/internal/semantic_versioning/is_equal.js

@@ -1,3 +0,0 @@
-export const versionIsEqual = (versionA, versionB) => {
-  return String(versionA) === String(versionB)
-}

package/src/internal/semantic_versioning/lowest_version.js

@@ -1,11 +0,0 @@
-import { versionIsAbove } from "./is_above.js"
-
-export const findLowestVersion = (...values) => {
-  if (values.length === 0) throw new Error(`missing argument`)
-  return values.reduce((lowestVersion, value) => {
-    if (versionIsAbove(lowestVersion, value)) {
-      return value
-    }
-    return lowestVersion
-  })
-}

package/src/internal/semantic_versioning/version_from_value.js

@@ -1,42 +0,0 @@
-export const versionFromValue = (value) => {
-  if (typeof value === "number") {
-    return numberToVersion(value)
-  }
-  if (typeof value === "string") {
-    return stringToVersion(value)
-  }
-  throw new TypeError(`version must be a number or a string, got ${value}`)
-}
-
-const numberToVersion = (number) => {
-  return {
-    major: number,
-    minor: 0,
-    patch: 0,
-  }
-}
-
-const stringToVersion = (string) => {
-  if (string.indexOf(".") > -1) {
-    const parts = string.split(".")
-    return {
-      major: Number(parts[0]),
-      minor: parts[1] ? Number(parts[1]) : 0,
-      patch: parts[2] ? Number(parts[2]) : 0,
-    }
-  }
-
-  if (isNaN(string)) {
-    return {
-      major: 0,
-      minor: 0,
-      patch: 0,
-    }
-  }
-
-  return {
-    major: Number(string),
-    minor: 0,
-    patch: 0,
-  }
-}

package/src/internal/sourcemap_utils.js

@@ -1,112 +0,0 @@
-export const generateSourcemapUrl = (url) => {
-  // we want to remove eventual search params from url
-  const urlString = String(url)
-  const urlObject = new URL(url)
-  const origin = urlString.startsWith("file://") ? "file://" : urlObject.origin
-  const pathname = urlObject.pathname
-  const sourcemapUrl = `${origin}${pathname}.map`
-  return sourcemapUrl
-}
-
-export const getJavaScriptSourceMappingUrl = (javaScriptSource) => {
-  let sourceMappingUrl
-  replaceSourceMappingUrl(
-    javaScriptSource,
-    javascriptSourceMappingUrlCommentRegexp,
-    (value) => {
-      sourceMappingUrl = value
-    },
-  )
-  return sourceMappingUrl
-}
-
-export const setJavaScriptSourceMappingUrl = (
-  javaScriptSource,
-  sourceMappingFileUrl,
-) => {
-  let replaced
-  const sourceAfterReplace = replaceSourceMappingUrl(
-    javaScriptSource,
-    javascriptSourceMappingUrlCommentRegexp,
-    () => {
-      replaced = true
-      return sourceMappingFileUrl
-        ? writeJavaScriptSourceMappingURL(sourceMappingFileUrl)
-        : ""
-    },
-  )
-  if (replaced) {
-    return sourceAfterReplace
-  }
-
-  return sourceMappingFileUrl
-    ? `${javaScriptSource}
-${writeJavaScriptSourceMappingURL(sourceMappingFileUrl)}`
-    : javaScriptSource
-}
-
-export const getCssSourceMappingUrl = (cssSource) => {
-  let sourceMappingUrl
-  replaceSourceMappingUrl(
-    cssSource,
-    cssSourceMappingUrlCommentRegExp,
-    (value) => {
-      sourceMappingUrl = value
-    },
-  )
-  return sourceMappingUrl
-}
-
-export const setCssSourceMappingUrl = (cssSource, sourceMappingFileUrl) => {
-  let replaced
-  const sourceAfterReplace = replaceSourceMappingUrl(
-    cssSource,
-    cssSourceMappingUrlCommentRegExp,
-    () => {
-      replaced = true
-      return sourceMappingFileUrl
-        ? writeCssSourceMappingUrl(sourceMappingFileUrl)
-        : ""
-    },
-  )
-  if (replaced) {
-    return sourceAfterReplace
-  }
-  return sourceMappingFileUrl
-    ? `${cssSource}
-${writeCssSourceMappingUrl(sourceMappingFileUrl)}`
-    : cssSource
-}
-
-const javascriptSourceMappingUrlCommentRegexp =
-  /\/\/ ?# ?sourceMappingURL=([^\s'"]+)/g
-const cssSourceMappingUrlCommentRegExp =
-  /\/\*# ?sourceMappingURL=([^\s'"]+) \*\//g
-
-// ${"//#"} is to avoid a parser thinking there is a sourceMappingUrl for this file
-const writeJavaScriptSourceMappingURL = (value) =>
-  `${"//#"} sourceMappingURL=${value}`
-const writeCssSourceMappingUrl = (value) => `/*# sourceMappingURL=${value} */`
-
-export const sourcemapToBase64Url = (sourcemap) => {
-  const asBase64 = Buffer.from(JSON.stringify(sourcemap)).toString("base64")
-  return `data:application/json;charset=utf-8;base64,${asBase64}`
-}
-
-const replaceSourceMappingUrl = (source, regexp, callback) => {
-  let lastSourceMappingUrl
-  let matchSourceMappingUrl
-  while ((matchSourceMappingUrl = regexp.exec(source))) {
-    lastSourceMappingUrl = matchSourceMappingUrl
-  }
-  if (lastSourceMappingUrl) {
-    const index = lastSourceMappingUrl.index
-    const before = source.slice(0, index)
-    const after = source.slice(index)
-    const mappedAfter = after.replace(regexp, (match, firstGroup) => {
-      return callback(firstGroup)
-    })
-    return `${before}${mappedAfter}`
-  }
-  return source
-}

package/src/internal/template_string_escape.js

@@ -1,20 +0,0 @@
-// https://github.com/mgenware/string-to-template-literal/blob/main/src/main.ts#L1
-
-export const escapeTemplateStringSpecialCharacters = (string) => {
-  string = String(string)
-  let i = 0
-  let escapedString = ""
-
-  while (i < string.length) {
-    const char = string[i]
-    i++
-    escapedString += isTemplateStringSpecialChar(char) ? `\\${char}` : char
-  }
-
-  return escapedString
-}
-
-const isTemplateStringSpecialChar = (char) =>
-  templateStringSpecialChars.indexOf(char) > -1
-
-const templateStringSpecialChars = ["\\", "`", "$"]

package/src/internal/url_conversion.js

@@ -1,313 +0,0 @@
-import {
-  resolveDirectoryUrl,
-  urlToRelativeUrl,
-  urlIsInsideOf,
-  resolveUrl,
-} from "@jsenv/filesystem"
-
-// use a fake and predictable compile server origin
-// because rollup will check the dependencies url
-// when computing the file hash
-// https://github.com/rollup/rollup/blob/d6131378f9481a442aeaa6d4e608faf3303366dc/src/Chunk.ts#L483
-// this way file hash remains the same when file content does not change
-const STATIC_COMPILE_SERVER_AUTHORITY = "//jsenv.com"
-
-export const createUrlConverter = ({
-  projectDirectoryUrl,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  urlMappings,
-}) => {
-  const compileServerOriginForRollup = String(
-    new URL(STATIC_COMPILE_SERVER_AUTHORITY, compileServerOrigin),
-  ).slice(0, -1)
-  urlMappings = normalizeUrlMappings(urlMappings, projectDirectoryUrl)
-  const mappingsRevertMap = {}
-
-  const asRollupUrl = (url) => {
-    if (url.startsWith(`${compileServerOrigin}/`)) {
-      return `${compileServerOriginForRollup}/${url.slice(
-        `${compileServerOrigin}/`.length,
-      )}`
-    }
-    return url
-  }
-
-  const asProjectUrl = (url) => {
-    return projectUrlFromUrl(asServerUrl(url) || url, {
-      projectDirectoryUrl,
-      compileServerOrigin,
-    })
-  }
-
-  const asServerUrl = (url) => {
-    if (url.startsWith(`${compileServerOriginForRollup}/`)) {
-      return `${compileServerOrigin}/${url.slice(
-        `${compileServerOriginForRollup}/`.length,
-      )}`
-    }
-    return serverUrlFromUrl(url, { projectDirectoryUrl, compileServerOrigin })
-  }
-
-  const asCompiledUrl = (url) => {
-    const projectCompiledUrl = compiledProjectUrlFromUrl(
-      asProjectUrl(url) || url,
-      {
-        projectDirectoryUrl,
-        compileServerOrigin,
-        compileDirectoryRelativeUrl,
-      },
-    )
-    return projectCompiledUrl
-  }
-
-  const asCompiledServerUrl = (url) => {
-    const projectCompiledUrl = asCompiledUrl(url)
-    return asServerUrl(projectCompiledUrl)
-  }
-
-  const asOriginalUrl = (url) => {
-    const projectOriginalUrl = originalProjectUrlFromUrl(
-      asProjectUrl(url) || url,
-      {
-        projectDirectoryUrl,
-        compileServerOrigin,
-        compileDirectoryRelativeUrl,
-      },
-    )
-    const withoutMapping = mappingsRevertMap[projectOriginalUrl]
-    return withoutMapping || projectOriginalUrl
-  }
-
-  const asOriginalServerUrl = (url) => {
-    const projectOriginalUrl = asOriginalUrl(url)
-    return projectOriginalUrl ? asServerUrl(projectOriginalUrl) : null
-  }
-
-  // Url can
-  // - come from rollup "load" hook and be compiled
-  // - come from rollup "load" hook and be the original url
-  // - come from asset builder and be compiled
-  // - come from asset builder and be the original url
-  // We first want to ensure we are talking about the same url
-  // so we get the originalProjectUrl
-  // then we should return a mapped url, keeping in mind that
-  // if the url was compiled it should remain compiled
-  const applyUrlMappings = (url) => {
-    const originalProjectUrl = asOriginalUrl(url)
-    const urlMapping = urlMappings[originalProjectUrl]
-    if (!urlMapping) {
-      return url
-    }
-
-    mappingsRevertMap[urlMapping] = originalProjectUrl
-    const isInsideProject =
-      url === projectDirectoryUrl || urlIsInsideOf(url, projectDirectoryUrl)
-    const projectUrl = isInsideProject ? url : asProjectUrl(url)
-    const compileDirectoryUrl = resolveUrl(
-      compileDirectoryRelativeUrl,
-      projectDirectoryUrl,
-    )
-    const isCompiled =
-      projectUrl === compileDirectoryUrl ||
-      urlIsInsideOf(projectUrl, compileDirectoryUrl)
-    if (isCompiled && isInsideProject) {
-      return asCompiledUrl(urlMapping)
-    }
-    if (isCompiled) {
-      return asCompiledServerUrl(urlMapping)
-    }
-    if (isInsideProject) {
-      return asProjectUrl(urlMapping)
-    }
-    return asServerUrl(urlMapping)
-  }
-
-  return {
-    compileServerOriginForRollup,
-    asRollupUrl,
-    asProjectUrl,
-    asServerUrl,
-
-    asCompiledUrl,
-    asCompiledServerUrl,
-    asOriginalUrl,
-    asOriginalServerUrl,
-    applyUrlMappings,
-  }
-}
-
-const normalizeUrlMappings = (urlMappings, baseUrl) => {
-  const urlMappingsNormalized = {}
-  Object.keys(urlMappings).forEach((key) => {
-    const value = urlMappings[key]
-    const keyNormalized = resolveUrl(key, baseUrl)
-    const valueNormalized = resolveUrl(value, baseUrl)
-    urlMappingsNormalized[keyNormalized] = valueNormalized
-  })
-  return urlMappingsNormalized
-}
-
-export const serverUrlToCompileInfo = (
-  url,
-  { compileServerOrigin, jsenvDirectoryRelativeUrl },
-) => {
-  const jsenvDirectoryServerUrl = resolveDirectoryUrl(
-    jsenvDirectoryRelativeUrl,
-    compileServerOrigin,
-  )
-  // not inside compile directory -> nothing to compile
-  if (!url.startsWith(jsenvDirectoryServerUrl)) {
-    return { insideCompileDirectory: false }
-  }
-  const afterJsenvDirectory = url.slice(jsenvDirectoryServerUrl.length)
-  // serve files inside /.jsenv/* directly without compilation
-  // this is just to allow some files to be written inside outDirectory and read directly
-  if (!afterJsenvDirectory.includes("/") || afterJsenvDirectory[0] === "/") {
-    return { insideCompileDirectory: true }
-  }
-  const parts = afterJsenvDirectory.split("/")
-  const compileId = parts[0]
-  // no compileId, we don't know what to compile (not supposed so happen)
-  if (compileId === "") {
-    return { insideCompileDirectory: true, compileId: null }
-  }
-  const afterCompileId = parts.slice(1).join("/")
-  // note: afterCompileId can be '' (but not supposed to happen)
-  return { insideCompileDirectory: true, compileId, afterCompileId }
-}
-
-// tries to convert an url into an url that is inside projectDirectoryUrl
-const projectUrlFromUrl = (
-  url,
-  { projectDirectoryUrl, compileServerOrigin },
-) => {
-  if (url.startsWith(projectDirectoryUrl)) {
-    return url
-  }
-
-  const serverUrl = serverUrlFromUrl(url, {
-    projectDirectoryUrl,
-    compileServerOrigin,
-  })
-  if (serverUrl) {
-    return `${projectDirectoryUrl}${serverUrl.slice(
-      `${compileServerOrigin}/`.length,
-    )}`
-  }
-
-  return null
-}
-
-// tries to convert an url into an url that is inside compileServerOrigin
-const serverUrlFromUrl = (
-  url,
-  { projectDirectoryUrl, compileServerOrigin },
-) => {
-  if (url.startsWith(`${compileServerOrigin}/`)) {
-    return url
-  }
-
-  if (url.startsWith(projectDirectoryUrl)) {
-    return `${compileServerOrigin}/${url.slice(projectDirectoryUrl.length)}`
-  }
-
-  return null
-}
-
-// tries to convert an url into an url inside compileServerOrigin
-// AND return the compiled url is the url is the original version
-const compiledProjectUrlFromUrl = (
-  url,
-  { projectDirectoryUrl, compileServerOrigin, compileDirectoryRelativeUrl },
-) => {
-  const projectUrl = projectUrlFromUrl(url, {
-    projectDirectoryUrl,
-    compileServerOrigin,
-  })
-  if (!projectUrl) {
-    return null
-  }
-
-  const compileDirectoryUrl = resolveUrl(
-    compileDirectoryRelativeUrl,
-    projectDirectoryUrl,
-  )
-  if (
-    projectUrl === compileDirectoryUrl ||
-    urlIsInsideOf(projectUrl, compileDirectoryUrl)
-  ) {
-    return projectUrl
-  }
-
-  const projectRelativeUrl = urlToRelativeUrl(projectUrl, projectDirectoryUrl)
-  if (projectRelativeUrl) {
-    return resolveUrl(projectRelativeUrl, compileDirectoryUrl)
-  }
-
-  return null
-}
-
-// tries to convert an url into an url that is inside projectDirectoryUrl
-// AND return the original url if the url is the compiled version
-const originalProjectUrlFromUrl = (
-  url,
-  {
-    projectDirectoryUrl,
-    compileServerOrigin,
-    jsenvDirectoryRelativeUrl,
-    compileDirectoryRelativeUrl,
-  },
-) => {
-  const projectUrl = projectUrlFromUrl(url, {
-    projectDirectoryUrl,
-    compileServerOrigin,
-  })
-  if (!projectUrl) {
-    return null
-  }
-
-  if (!compileDirectoryRelativeUrl) {
-    const serverUrl = serverUrlFromUrl(projectUrl, {
-      projectDirectoryUrl,
-      compileServerOrigin,
-    })
-    compileDirectoryRelativeUrl = extractCompileDirectoryRelativeUrl({
-      serverUrl,
-      compileServerOrigin,
-      jsenvDirectoryRelativeUrl,
-    })
-    if (!compileDirectoryRelativeUrl) {
-      return projectUrl
-    }
-  }
-
-  const compileDirectoryUrl = resolveUrl(
-    compileDirectoryRelativeUrl,
-    projectDirectoryUrl,
-  )
-  if (projectUrl === compileDirectoryUrl) {
-    return projectDirectoryUrl
-  }
-  if (!urlIsInsideOf(projectUrl, compileDirectoryUrl)) {
-    return projectUrl
-  }
-
-  const relativeUrl = urlToRelativeUrl(projectUrl, compileDirectoryUrl)
-  return resolveUrl(relativeUrl, projectDirectoryUrl)
-}
-
-const extractCompileDirectoryRelativeUrl = ({
-  serverUrl,
-  compileServerOrigin,
-  jsenvDirectoryRelativeUrl,
-}) => {
-  const compileInfo = serverUrlToCompileInfo(serverUrl, {
-    compileServerOrigin,
-    jsenvDirectoryRelativeUrl,
-  })
-  if (compileInfo.compiledId) {
-    return `${jsenvDirectoryRelativeUrl}${compileInfo.compileId}/`
-  }
-  return null
-}

package/src/internal/url_utils.js

@@ -1,33 +0,0 @@
-import { urlToOrigin, urlToRessource, urlToExtension } from "@jsenv/filesystem"
-
-export const setUrlExtension = (url, extension) => {
-  const origin = urlToOrigin(url)
-  const currentExtension = urlToExtension(url)
-  const ressource = urlToRessource(url)
-  const [pathname, search] = ressource.split("?")
-  const pathnameWithoutExtension = currentExtension
-    ? pathname.slice(0, -currentExtension.length)
-    : pathname
-  const newPathname = `${pathnameWithoutExtension}${extension}`
-  return `${origin}${newPathname}${search ? `?${search}` : ""}`
-}
-
-export const getUrlSearchParamsDescriptor = (url) => {
-  const urlObject = new URL(url)
-  const { searchParams } = urlObject
-  const searchParamsDescriptor = {}
-  Array.from(searchParams.keys()).forEach((key) => {
-    const value = searchParams.getAll(key)
-    searchParamsDescriptor[key] = value.length === 1 ? value[0] : value
-  })
-  return searchParamsDescriptor
-}
-
-export const setUrlSearchParamsDescriptor = (url, searchParamsDescriptor) => {
-  const urlObject = new URL(url)
-  const { searchParams } = urlObject
-  Object.keys(searchParamsDescriptor).forEach((key) => {
-    searchParams.set(key, searchParamsDescriptor[key])
-  })
-  return String(urlObject)
-}