@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/internal/building/sortObjectByPathnames.js

@@ -1,10 +0,0 @@
-import { comparePathnames } from "@jsenv/filesystem"
-
-export const sortObjectByPathnames = (object) => {
-  const objectSorted = {}
-  const keysSorted = Object.keys(object).sort(comparePathnames)
-  keysSorted.forEach((key) => {
-    objectSorted[key] = object[key]
-  })
-  return objectSorted
-}

package/src/internal/building/sourcemap_loader.js

@@ -1,73 +0,0 @@
-import { resolveUrl } from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
-
-import {
-  dataUrlToRawData,
-  parseDataUrl,
-} from "@jsenv/core/src/internal/dataUrl.utils.js"
-import { fetchUrl } from "@jsenv/core/src/internal/fetchUrl.js"
-import { validateResponse } from "@jsenv/core/src/internal/response_validation.js"
-
-export const loadSourcemap = async ({
-  signal,
-  logger,
-
-  code,
-  url,
-  getSourceMappingUrl,
-} = {}) => {
-  const sourcemapSpecifier = getSourceMappingUrl(code)
-  if (!sourcemapSpecifier) {
-    return null
-  }
-
-  const sourcemapUrl = resolveUrl(sourcemapSpecifier, url)
-  if (sourcemapUrl.startsWith("data:")) {
-    const sourcemapString = dataUrlToRawData(parseDataUrl(sourcemapUrl))
-    return parseSourcemapString(
-      sourcemapString,
-      sourcemapUrl,
-      `inline comment in ${url}`,
-    )
-  }
-
-  const sourcemapResponse = await fetchUrl(sourcemapUrl, {
-    signal,
-    ignoreHttpsError: true,
-  })
-  const { isValid, details } = await validateResponse(sourcemapResponse, {
-    // we could have a better trace
-    // by appending the reference found in code
-    // to an existing urlTrace array
-    // good enough for now
-    urlTrace: url,
-    contentTypeExpected: ["application/json", "application/octet-stream"],
-  })
-  if (!isValid) {
-    logger.warn(
-      createDetailedMessage(`unexpected response for sourcemap`, details),
-    )
-    return null
-  }
-
-  const sourcemapBodyAsText = await sourcemapResponse.text()
-  return parseSourcemapString(sourcemapBodyAsText, sourcemapUrl, url)
-}
-
-const parseSourcemapString = (sourcemapString, sourcemapUrl, importer) => {
-  try {
-    return JSON.parse(sourcemapString)
-  } catch (e) {
-    if (e.name === "SyntaxError") {
-      console.error(
-        createDetailedMessage(`syntax error while parsing sourcemap.`, {
-          ["syntax error stack"]: e.stack,
-          ["sourcemap url"]: sourcemapUrl,
-          ["imported by"]: importer,
-        }),
-      )
-      return null
-    }
-    throw e
-  }
-}

package/src/internal/building/svg/parseSvgRessource.js

@@ -1,111 +0,0 @@
-import {
-  parseSvgString,
-  parseHtmlAstRessources,
-  getHtmlNodeAttributeByName,
-  stringifyHtmlAst,
-  getHtmlNodeLocation,
-} from "@jsenv/core/src/internal/compiling/compileHtml.js"
-import { collectNodesMutations } from "../parsing.utils.js"
-import { getRessourceAsBase64Url } from "../ressource_builder_util.js"
-import { minifyHtml } from "../html/minifyHtml.js"
-
-export const parseSvgRessource = async (
-  svgRessource,
-  notifiers,
-  { minify, minifyHtmlOptions },
-) => {
-  const svgString = String(svgRessource.bufferBeforeBuild)
-  const svgAst = await parseSvgString(svgString)
-  const htmlRessources = parseHtmlAstRessources(svgAst)
-  const mutations = collectSvgMutations(htmlRessources, notifiers, svgRessource)
-
-  return async ({ getUrlRelativeToImporter }) => {
-    mutations.forEach((mutationCallback) => {
-      mutationCallback({ getUrlRelativeToImporter })
-    })
-    const svgAfterTransformation = stringifyHtmlAst(svgAst)
-    // could also benefit of minification https://github.com/svg/svgo
-    if (minify) {
-      svgRessource.buildEnd(
-        await minifyHtml(svgAfterTransformation, minifyHtmlOptions),
-      )
-      return
-    }
-    svgRessource.buildEnd(svgAfterTransformation)
-  }
-}
-
-export const collectSvgMutations = (
-  { images, uses },
-  notifiers,
-  svgRessource,
-) => {
-  const imagesMutations = collectNodesMutations(
-    images,
-    notifiers,
-    svgRessource,
-    [imageHrefVisitor],
-  )
-  const usesMutations = collectNodesMutations(uses, notifiers, svgRessource, [
-    useHrefVisitor,
-  ])
-  const svgMutations = [...imagesMutations, ...usesMutations]
-  return svgMutations
-}
-
-const imageHrefVisitor = (image, { notifyReferenceFound }) => {
-  const hrefAttribute = getHtmlNodeAttributeByName(image, "href")
-  if (!hrefAttribute) {
-    return null
-  }
-
-  const hrefReference = notifyReferenceFound({
-    referenceLabel: "svg image href",
-    ressourceSpecifier: hrefAttribute.value,
-    ...referenceLocationFromHtmlNode(image, "href"),
-  })
-  return ({ getUrlRelativeToImporter }) => {
-    const hrefNewValue = referenceToUrl(hrefReference, getUrlRelativeToImporter)
-    hrefAttribute.value = hrefNewValue
-  }
-}
-
-const useHrefVisitor = (use, { notifyReferenceFound }) => {
-  const hrefAttribute = getHtmlNodeAttributeByName(use, "href")
-  if (!hrefAttribute) {
-    return null
-  }
-  const href = hrefAttribute.value
-  if (href[0] === "#") {
-    return null
-  }
-
-  const { hash } = new URL(href, "file://")
-  const hrefReference = notifyReferenceFound({
-    referenceLabel: "svg use href",
-    ressourceSpecifier: href,
-    ...referenceLocationFromHtmlNode(use, "href"),
-  })
-  return ({ getUrlRelativeToImporter }) => {
-    const hrefNewValue = referenceToUrl(hrefReference, getUrlRelativeToImporter)
-    hrefAttribute.value = `${hrefNewValue}${hash}`
-  }
-}
-
-const referenceToUrl = (reference, getUrlRelativeToImporter) => {
-  const { ressource } = reference
-  if (ressource.isInline) {
-    return getRessourceAsBase64Url(ressource)
-  }
-  return getUrlRelativeToImporter(ressource)
-}
-
-const referenceLocationFromHtmlNode = (htmlNode, htmlAttributeName) => {
-  const locInfo = getHtmlNodeLocation(htmlNode, htmlAttributeName)
-  return locInfo
-    ? {
-        referenceLine: locInfo.line,
-        referenceColumn: locInfo.column,
-      }
-    : {}
-}

package/src/internal/building/url_fetcher.js

@@ -1,85 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-import { urlToExtension, urlToRelativeUrl } from "@jsenv/filesystem"
-
-import { fetchUrl as jsenvFetchUrl } from "@jsenv/core/src/internal/fetchUrl.js"
-import { validateResponse } from "@jsenv/core/src/internal/response_validation.js"
-
-export const createUrlFetcher = ({
-  jsenvRemoteDirectory,
-  asOriginalUrl,
-  asProjectUrl,
-  applyUrlMappings,
-  urlImporterMap,
-  beforeThrowingResponseValidationError,
-}) => {
-  const urlRedirectionMap = {}
-
-  const fetchUrl = async (
-    url,
-    { signal, urlTrace, contentTypeExpected, crossorigin },
-  ) => {
-    const urlToFetch = applyUrlMappings(url)
-    const response = await jsenvFetchUrl(urlToFetch, {
-      signal,
-      ignoreHttpsError: true,
-      credentials:
-        crossorigin === "anonymous" || crossorigin === ""
-          ? "same-origin"
-          : crossorigin === "use-credentials"
-          ? "include"
-          : undefined,
-    })
-    const responseUrl = response.url
-    const originalUrl =
-      asOriginalUrl(responseUrl) || asProjectUrl(responseUrl) || responseUrl
-    const responseValidity = await validateResponse(response, {
-      originalUrl: jsenvRemoteDirectory.isFileUrlForRemoteUrl(originalUrl)
-        ? jsenvRemoteDirectory.remoteUrlFromFileUrl(originalUrl)
-        : originalUrl,
-      urlTrace,
-      contentTypeExpected,
-    })
-    if (!responseValidity.isValid) {
-      const { message, details } = responseValidity
-      if (
-        responseValidity.contentType &&
-        !responseValidity.contentType.isValid &&
-        contentTypeExpected.includes("application/javascript")
-      ) {
-        const importerUrl = urlImporterMap[url].url
-        const urlRelativeToImporter = `./${urlToRelativeUrl(url, importerUrl)}`
-        details.suggestion = `use import.meta.url: new URL("${urlRelativeToImporter}", import.meta.url)`
-        const extension = urlToExtension(url)
-        if (extension === ".css") {
-          details[
-            "suggestion 2"
-          ] = `use import assertion: import css from "${urlRelativeToImporter}" assert { type: "css" }`
-        }
-        if (extension === ".json") {
-          details[
-            "suggestion 2"
-          ] = `use import assertion: import data from "${urlRelativeToImporter}" assert { type: "json" }`
-        }
-      }
-      const responseValidationError = new Error(
-        createDetailedMessage(message, details),
-      )
-      beforeThrowingResponseValidationError(responseValidationError)
-      throw responseValidationError
-    }
-    if (url !== responseUrl) {
-      urlRedirectionMap[url] = responseUrl
-    }
-    return response
-  }
-
-  const getUrlBeforeRedirection = (url) => {
-    const urlBeforeRedirection = urlRedirectionMap[url]
-    return urlBeforeRedirection
-  }
-
-  return {
-    fetchUrl,
-    getUrlBeforeRedirection,
-  }
-}

package/src/internal/building/url_loader.js

@@ -1,127 +0,0 @@
-import { convertJsonTextToJavascriptModule } from "@jsenv/core/src/internal/building/json_module.js"
-import { getJavaScriptSourceMappingUrl } from "@jsenv/core/src/internal/sourceMappingURLUtils.js"
-
-import { loadSourcemap } from "./sourcemap_loader.js"
-
-export const createUrlLoader = ({
-  urlCustomLoaders,
-  allowJson,
-  urlImporterMap,
-
-  asProjectUrl,
-  asOriginalUrl,
-
-  urlFetcher,
-}) => {
-  const urlResponseBodyMap = {}
-
-  const loadUrl = async (url, { signal, logger }) => {
-    const customLoader = urlCustomLoaders[url]
-    if (customLoader) {
-      const result = await customLoader()
-      return result
-    }
-    const response = await urlFetcher.fetchUrl(url, {
-      signal,
-      contentTypeExpected: [
-        "application/javascript",
-        ...(allowJson ? ["application/json"] : []),
-      ],
-      urlTrace: () => {
-        const firstImporter = urlImporterMap[url]
-        url = asOriginalUrl(url) || asProjectUrl(url) || url
-        return createUrlTrace({
-          url: firstImporter.url,
-          line: firstImporter.line,
-          column: firstImporter.column,
-        })
-      },
-    })
-
-    const contentType = response.headers["content-type"]
-    if (contentType === "application/javascript") {
-      const jsText = await response.text()
-      saveUrlResponseBody(response.url, jsText)
-      const map = await loadSourcemap({
-        signal,
-        logger,
-
-        url,
-        code: jsText,
-        getSourceMappingUrl: getJavaScriptSourceMappingUrl,
-      })
-      return {
-        url: response.url,
-        code: jsText,
-        map,
-      }
-    }
-
-    // When json is referenced from js without import assertion and minify is enabled
-    // you can get non-minified json (json with spaces)
-    // We could fix that by removing white spaces here but that means forwarding minify
-    // param and this is only possible in Node.js where minification is less (not?) important
-    const jsonText = await response.text()
-    saveUrlResponseBody(response.url, jsonText)
-    const { code } = convertJsonTextToJavascriptModule({ code: jsonText })
-    return {
-      url: response.url,
-      code,
-      map: null,
-    }
-  }
-
-  const saveUrlResponseBody = (url, responseBodyAsText) => {
-    const urlBeforeRedirection = urlFetcher.getUrlBeforeRedirection(url)
-    if (urlBeforeRedirection) {
-      saveUrlResponseBody(urlBeforeRedirection, responseBodyAsText)
-    }
-
-    urlResponseBodyMap[url] = responseBodyAsText
-    const projectUrl = asProjectUrl(url)
-    if (projectUrl && projectUrl !== url) {
-      urlResponseBodyMap[projectUrl] = responseBodyAsText
-    }
-  }
-
-  const getUrlResponseTextFromMemory = (url) => {
-    return urlResponseBodyMap[url]
-  }
-
-  const createUrlTrace = ({ url, line, column }) => {
-    const trace = [
-      {
-        type: "entry",
-        url: asOriginalUrl(url) || asProjectUrl(url) || url,
-        line,
-        column,
-      },
-    ]
-    const next = (importerUrl) => {
-      const previousImporter = urlImporterMap[importerUrl]
-      if (!previousImporter) {
-        return
-      }
-      trace.push({
-        type: "import",
-        url:
-          asOriginalUrl(previousImporter.url) ||
-          asProjectUrl(previousImporter.url) ||
-          previousImporter.url,
-        line: previousImporter.line,
-        column: previousImporter.column,
-      })
-      next(previousImporter.url)
-    }
-    next(url)
-
-    return trace
-  }
-
-  return {
-    loadUrl,
-    createUrlTrace,
-    getUrlResponseTextFromMemory,
-    getUrlResponseBodyMap: () => urlResponseBodyMap,
-  }
-}

package/src/internal/building/url_trace.js

@@ -1,229 +0,0 @@
-// consider switching to https://babeljs.io/docs/en/babel-code-frame
-// https://github.com/postcss/postcss/blob/fd30d3df5abc0954a0ec642a3cdc644ab2aacf9c/lib/css-syntax-error.js#L43
-// https://github.com/postcss/postcss/blob/fd30d3df5abc0954a0ec642a3cdc644ab2aacf9c/lib/terminal-highlight.js#L50
-// https://github.com/babel/babel/blob/eea156b2cb8deecfcf82d52aa1b71ba4995c7d68/packages/babel-code-frame/src/index.js#L1
-
-import { urlToFileSystemPath } from "@jsenv/filesystem"
-import { ANSI } from "@jsenv/log"
-
-export const stringifyUrlTrace = (trace) => {
-  let string = ""
-  trace.forEach(({ type, url, line, column, source }, index) => {
-    if (index === 0) {
-      string += stringifyUrlSite({ url, line, column, source })
-      return
-    }
-
-    if (type === "import") {
-      string += `\n  imported by ${stringifyUrlSite({
-        url,
-        line,
-        column,
-      })}`
-      return
-    }
-
-    string += `\n  referenced by ${stringifyUrlSite({
-      url,
-      line,
-      column,
-    })}`
-  }, "")
-
-  return string
-}
-
-export const stringifyUrlSite = (
-  { url, line, column, source },
-  {
-    showCodeFrame = true,
-    numberOfSurroundingLinesToShow,
-    lineMaxLength,
-    color,
-  } = {},
-) => {
-  let string = `${humanizeUrl(url)}`
-
-  if (typeof line === "number") {
-    string += `:${line}`
-    if (typeof column === "number") {
-      string += `:${column}`
-    }
-  }
-
-  if (!showCodeFrame || typeof line !== "number" || !source) {
-    return string
-  }
-
-  const sourceLoc = showSourceLocation({
-    source,
-    line,
-    column,
-    numberOfSurroundingLinesToShow,
-    lineMaxLength,
-    color,
-  })
-
-  return `${string}
-${sourceLoc}`
-}
-
-export const humanizeUrl = (url) => {
-  if (url.startsWith("file://")) {
-    // we prefer file system path because vscode reliably make them clickable
-    // and sometimes it won't for file:// urls
-    return urlToFileSystemPath(url)
-  }
-  return url
-}
-
-export const showSourceLocation = ({
-  source,
-  line,
-  column,
-  numberOfSurroundingLinesToShow = 1,
-  lineMaxLength = 120,
-  color = false,
-} = {}) => {
-  let mark = (string) => string
-  let aside = (string) => string
-  if (color) {
-    mark = (string) => ANSI.color(string, ANSI.RED)
-    aside = (string) => ANSI.color(string, ANSI.GREY)
-  }
-
-  const lines = source.split(/\r?\n/)
-  if (line === 0) line = 1
-  let lineRange = {
-    start: line - 1,
-    end: line,
-  }
-  lineRange = moveLineRangeUp(lineRange, numberOfSurroundingLinesToShow)
-  lineRange = moveLineRangeDown(lineRange, numberOfSurroundingLinesToShow)
-  lineRange = lineRangeWithinLines(lineRange, lines)
-  const linesToShow = lines.slice(lineRange.start, lineRange.end)
-  const endLineNumber = lineRange.end
-  const lineNumberMaxWidth = String(endLineNumber).length
-
-  if (column === 0) column = 1
-
-  const columnRange = {}
-  if (column === undefined) {
-    columnRange.start = 0
-    columnRange.end = lineMaxLength
-  } else if (column > lineMaxLength) {
-    columnRange.start = column - Math.floor(lineMaxLength / 2)
-    columnRange.end = column + Math.ceil(lineMaxLength / 2)
-  } else {
-    columnRange.start = 0
-    columnRange.end = lineMaxLength
-  }
-
-  return linesToShow.map((lineSource, index) => {
-    const lineNumber = lineRange.start + index + 1
-    const isMainLine = lineNumber === line
-    const lineSourceTruncated = applyColumnRange(columnRange, lineSource)
-    const lineNumberWidth = String(lineNumber).length
-    // ensure if line moves from 7,8,9 to 10 the display is still great
-    const lineNumberRightSpacing = " ".repeat(
-      lineNumberMaxWidth - lineNumberWidth,
-    )
-    const asideSource = `${lineNumber}${lineNumberRightSpacing} |`
-    const lineFormatted = `${aside(asideSource)} ${lineSourceTruncated}`
-    if (isMainLine) {
-      if (column === undefined) {
-        return `${mark(">")} ${lineFormatted}`
-      }
-      const spacing = stringToSpaces(
-        `${asideSource} ${lineSourceTruncated.slice(
-          0,
-          column - columnRange.start - 1,
-        )}`,
-      )
-      return `${mark(">")} ${lineFormatted}
-  ${spacing}${mark("^")}`
-    }
-    return `  ${lineFormatted}`
-  }).join(`
-`)
-}
-
-const applyColumnRange = ({ start, end }, line) => {
-  if (typeof start !== "number") {
-    throw new TypeError(`start must be a number, received ${start}`)
-  }
-  if (typeof end !== "number") {
-    throw new TypeError(`end must be a number, received ${end}`)
-  }
-  if (end < start) {
-    throw new Error(
-      `end must be greater than start, but ${end} is smaller than ${start}`,
-    )
-  }
-
-  const prefix = "…"
-  const suffix = "…"
-  const lastIndex = line.length
-
-  if (line.length === 0) {
-    // don't show any ellipsis if the line is empty
-    // because it's not truncated in that case
-    return ""
-  }
-
-  const startTruncated = start > 0
-  const endTruncated = lastIndex > end
-
-  let from = startTruncated ? start + prefix.length : start
-  let to = endTruncated ? end - suffix.length : end
-  if (to > lastIndex) to = lastIndex
-
-  if (start >= lastIndex || from === to) {
-    return ""
-  }
-
-  let result = ""
-  while (from < to) {
-    result += line[from]
-    from++
-  }
-
-  if (result.length === 0) {
-    return ""
-  }
-  if (startTruncated && endTruncated) {
-    return `${prefix}${result}${suffix}`
-  }
-  if (startTruncated) {
-    return `${prefix}${result}`
-  }
-  if (endTruncated) {
-    return `${result}${suffix}`
-  }
-  return result
-}
-
-const stringToSpaces = (string) => string.replace(/[^\t]/g, " ")
-
-// const getLineRangeLength = ({ start, end }) => end - start
-
-const moveLineRangeUp = ({ start, end }, number) => {
-  return {
-    start: start - number,
-    end,
-  }
-}
-
-const moveLineRangeDown = ({ start, end }, number) => {
-  return {
-    start,
-    end: end + number,
-  }
-}
-
-const lineRangeWithinLines = ({ start, end }, lines) => {
-  return {
-    start: start < 0 ? 0 : start,
-    end: end > lines.length ? lines.length : end,
-  }
-}

package/src/internal/building/url_versioning.js

@@ -1,65 +0,0 @@
-import { createHash } from "crypto"
-
-// https://github.com/rollup/rollup/blob/19e50af3099c2f627451a45a84e2fa90d20246d5/src/utils/FileEmitter.ts#L47
-export const generateContentHash = (
-  stringOrBuffer,
-  {
-    contentType = "application/octet-stream",
-    lineBreakNormalization = false,
-  } = {},
-) => {
-  const hash = createHash("sha256")
-  hash.update(
-    lineBreakNormalization && contentTypeIsTextual(contentType)
-      ? normalizeLineBreaks(stringOrBuffer)
-      : stringOrBuffer,
-  )
-  return hash.digest("hex").slice(0, 8)
-}
-
-const contentTypeIsTextual = (contentType) => {
-  if (contentType.startsWith("text/")) {
-    return true
-  }
-  // catch things like application/manifest+json, application/importmap+json
-  if (/^application\/\w+\+json$/.test(contentType)) {
-    return true
-  }
-  if (CONTENT_TYPE_AS_TEXT.includes(contentType)) {
-    return true
-  }
-  return false
-}
-
-const CONTENT_TYPE_AS_TEXT = [
-  "application/javascript",
-  "application/json",
-  "image/svg+xml",
-]
-
-const normalizeLineBreaks = (stringOrBuffer) => {
-  if (typeof stringOrBuffer === "string") {
-    const stringWithLinuxBreaks = stringOrBuffer.replace(/\r\n/g, "\n")
-    return stringWithLinuxBreaks
-  }
-  return normalizeLineBreaksForBuffer(stringOrBuffer)
-}
-
-// https://github.com/nodejs/help/issues/1738#issuecomment-458460503
-const normalizeLineBreaksForBuffer = (buffer) => {
-  const int32Array = new Int32Array(buffer, 0, buffer.length)
-  const int32ArrayWithLineBreaksNormalized = int32Array.filter(
-    (element, index, typedArray) => {
-      if (element === 0x0d) {
-        if (typedArray[index + 1] === 0x0a) {
-          // Windows -> Unix
-          return false
-        }
-        // Mac OS -> Unix
-        typedArray[index] = 0x0a
-      }
-      return true
-    },
-  )
-  return Buffer.from(int32ArrayWithLineBreaksNormalized)
-}