@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/internal/building/build_stats.js

@@ -1,100 +0,0 @@
-import { resolveUrl, urlToExtension } from "@jsenv/filesystem"
-
-import { isReferencedOnlyByRessourceHint } from "./ressource_builder_util.js"
-
-export const createBuildStats = ({
-  buildFileContents,
-  ressourceBuilder,
-  buildDuration,
-}) => {
-  const projectFileContents = getProjectFileContents(ressourceBuilder)
-  const projectFileSizeInfo = sizeInfoFromFileContents(projectFileContents)
-
-  const { sourceFileContents, sourcemapFileContents } =
-    extractSourcemapFiles(buildFileContents)
-  const buildFileSizeInfo = sizeInfoFromFileContents(sourceFileContents)
-  const sourcemapFileSizeInfo = sizeInfoFromFileContents(sourcemapFileContents)
-
-  return {
-    projectFileSizes: projectFileSizeInfo.fileSizes,
-    projectTotalFileSize: projectFileSizeInfo.totalSize,
-    buildFileSizes: buildFileSizeInfo.fileSizes,
-    buildFileTotalSize: buildFileSizeInfo.totalSize,
-    buildSourcemapFileSizes: sourcemapFileSizeInfo.fileSizes,
-    buildSourcemapFileTotalSize: sourcemapFileSizeInfo.totalSize,
-    buildDuration,
-  }
-}
-
-const extractSourcemapFiles = (fileContents) => {
-  const sourceFileContents = {}
-  const sourcemapFileContents = {}
-  Object.keys(fileContents).forEach((key) => {
-    const url = resolveUrl(key, "http://example.com")
-    if (urlToExtension(url) === ".map") {
-      sourcemapFileContents[key] = fileContents[key]
-    } else {
-      sourceFileContents[key] = fileContents[key]
-    }
-  })
-  return {
-    sourceFileContents,
-    sourcemapFileContents,
-  }
-}
-
-const sizeInfoFromFileContents = (fileContents) => {
-  const fileSizes = {}
-  let totalSize = 0
-  Object.keys(fileContents).forEach((key) => {
-    const fileSize = Buffer.byteLength(fileContents[key])
-    fileSizes[key] = fileSize
-    totalSize += fileSize
-  })
-  return { fileSizes, totalSize }
-}
-
-const getProjectFileContents = (ressourceBuilder) => {
-  const projectFileContents = {}
-  const { ressourceMap } = ressourceBuilder.inspect()
-
-  Object.keys(ressourceMap).forEach((url) => {
-    const ressource = ressourceMap[url]
-    const {
-      isInline,
-      isExternal,
-      isPlaceholder,
-      isSourcemap,
-      bufferBeforeBuild,
-    } = ressource
-    if (isInline) {
-      // inline ressources are not files
-      return
-    }
-    if (isExternal) {
-      // external ressource are not handled, we would not have the bufferBeforeBuild
-      return
-    }
-    if (isReferencedOnlyByRessourceHint(ressource)) {
-      // ressource is only referenced by ressource hint (link preload for example)
-      // it's never actually loaded
-      // -> we don't gave the bufferBeforeBuild (the ressource file content)
-      return
-    }
-    if (isPlaceholder) {
-      // placeholders (used for sourcemap files)
-      // means the file did not exists in the project is there is a placeholder
-      // to generate it in the build
-      return
-    }
-    if (isSourcemap && !bufferBeforeBuild) {
-      // sourcemap generated by rollup do not have bufferBeforeBuild
-      return
-    }
-    if (!bufferBeforeBuild) {
-      throw new Error(`bufferBeforeBuild missing for ${url}`)
-    }
-    projectFileContents[url] = bufferBeforeBuild
-  })
-  return projectFileContents
-}

package/src/internal/building/build_url_generator.js

@@ -1,153 +0,0 @@
-import { urlToBasename, urlToExtension } from "@jsenv/filesystem"
-
-import { generateContentHash } from "./url_versioning.js"
-
-export const createBuildUrlGenerator = ({
-  entryPointUrls,
-  asOriginalUrl,
-  lineBreakNormalization,
-}) => {
-  const availableNameGenerator = createAvailableNameGenerator()
-
-  const prepareBuildUrlForRessource = (ressource) => {
-    const buildRelativeUrlPattern = getBuildRelativeUrlPattern({
-      entryPointUrls,
-      asOriginalUrl,
-      availableNameGenerator,
-      ressource,
-    })
-    const buildRelativeUrlWithoutHash = buildRelativeUrlPattern.replace(
-      "_[hash]",
-      "",
-    )
-    return {
-      buildRelativeUrlPattern,
-      buildRelativeUrlWithoutHash,
-    }
-  }
-
-  const computeBuildRelativeUrl = (ressource) => {
-    const buildRelativeUrl = renderFileNamePattern(
-      ressource.buildRelativeUrlPattern,
-      {
-        hash: () =>
-          generateContentHash(ressource.bufferAfterBuild, {
-            contentType: ressource.contentType,
-            lineBreakNormalization,
-          }),
-      },
-    )
-    return buildRelativeUrl
-  }
-
-  return { prepareBuildUrlForRessource, computeBuildRelativeUrl }
-}
-
-const getBuildRelativeUrlPattern = ({
-  entryPointUrls,
-  asOriginalUrl,
-  availableNameGenerator,
-  ressource,
-}) => {
-  if (ressource.isEntryPoint) {
-    const originalUrl = asOriginalUrl(ressource.url)
-    const entryPointBuildRelativeUrlPattern = entryPointUrls[originalUrl]
-    return entryPointBuildRelativeUrlPattern
-  }
-
-  // inline ressource
-  // TODO: should inherit importer directory location because inline
-  if (ressource.isInline) {
-    // const importerBuildRelativeUrlWithoutHash =
-    //   ressource.importer.buildRelativeUrlWithoutHash
-    const name = urlToBasename(ressource.url)
-    const extension = urlToExtension(ressource.url)
-    // no need to ensure name is unique because it's already done
-    return `${name}_[hash]${extension}`
-  }
-
-  // importmap.
-  // the goal is to put the importmap at the same relative path
-  // than in the project to avoid having to re-resolve mappings
-  if (ressource.contentType === "application/importmap+json") {
-    const name = availableNameGenerator.getAvailableNameInDirectory(
-      urlToBasename(ressource.url),
-      "/",
-    )
-    const extension = urlToExtension(ressource.url)
-    return `${name}_[hash]${extension}`
-  }
-
-  // service worker:
-  // - MUST be at the root (same level than the HTML file)
-  //   otherwise it might be registered for the scope "/assets/" instead of "/"
-  // - MUST not be versioned
-  if (ressource.isServiceWorker) {
-    const name = availableNameGenerator.getAvailableNameInDirectory(
-      urlToBasename(ressource.url),
-      "/",
-    )
-    const extension = urlToExtension(ressource.url)
-    return `${name}${extension}`
-  }
-
-  if (ressource.isWorker) {
-    const name = availableNameGenerator.getAvailableNameInDirectory(
-      urlToBasename(ressource.url),
-      "/",
-    )
-    const extension = urlToExtension(ressource.url)
-    return `${name}_[hash]${extension}`
-  }
-
-  if (ressource.isJsModule) {
-    const name = availableNameGenerator.getAvailableNameInDirectory(
-      urlToBasename(ressource.url),
-      "/",
-    )
-    return `${name}_[hash].js`
-  }
-
-  const name = availableNameGenerator.getAvailableNameInDirectory(
-    urlToBasename(ressource.url),
-    "assets/",
-  )
-  const extension = urlToExtension(ressource.url)
-  return ressource.urlVersioningDisabled
-    ? `assets/${name}${extension}`
-    : `assets/${name}_[hash]${extension}`
-}
-
-const createAvailableNameGenerator = () => {
-  const cache = {}
-  const getAvailableNameInDirectory = (name, directory) => {
-    let names = cache[directory]
-    if (!names) {
-      names = []
-      cache[directory] = names
-    }
-
-    let nameCandidate = name
-    let integer = 1
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      if (!names.includes(nameCandidate)) {
-        names.push(nameCandidate)
-        return nameCandidate
-      }
-      integer++
-      nameCandidate = `${name}${integer}`
-    }
-  }
-
-  return {
-    getAvailableNameInDirectory,
-  }
-}
-
-const renderFileNamePattern = (pattern, replacements) => {
-  return pattern.replace(/\[(\w+)\]/g, (_match, type) => {
-    const replacement = replacements[type](_match)
-    return replacement
-  })
-}

package/src/internal/building/css/applyPostCss.js

@@ -1,55 +0,0 @@
-import { urlToFileSystemPath } from "@jsenv/filesystem"
-
-export const applyPostCss = async ({
-  code,
-  url,
-  map,
-  sourcemapMethod = "comment",
-  plugins,
-  // https://github.com/postcss/postcss#options
-  options = {},
-}) => {
-  const { default: postcss } = await import("postcss")
-
-  try {
-    const cssFileUrl = urlToFileUrl(url)
-    const result = await postcss(plugins).process(code, {
-      collectUrls: true,
-      from: urlToFileSystemPath(cssFileUrl),
-      to: urlToFileSystemPath(cssFileUrl),
-      map: {
-        annotation: sourcemapMethod === "comment",
-        inline: sourcemapMethod === "inline",
-        // https://postcss.org/api/#sourcemapoptions
-        ...(map ? { prev: JSON.stringify(map) } : {}),
-      },
-      ...options,
-    })
-    return {
-      code: result.css,
-      map: result.map.toJSON(),
-      postCssMessages: result.messages,
-    }
-  } catch (error) {
-    if (error.name === "CssSyntaxError") {
-      console.error(String(error))
-      throw error
-    }
-    throw error
-  }
-}
-
-// the goal of this function is to take an url that is likely an http url
-// info a file:// url
-// for instance http://example.com/dir/file.js
-// must becomes file:///dir/file.js
-// but in windows it must be file://C:/dir/file.js
-const filesystemRootUrl = new URL("/", import.meta.url)
-const urlToFileUrl = (url) => {
-  if (url.startsWith("file://")) {
-    return url
-  }
-  const origin = new URL(url).origin
-  const afterOrigin = url.slice(origin.length)
-  return new URL(afterOrigin, filesystemRootUrl).href
-}

package/src/internal/building/css/moveCssUrls.js

@@ -1,44 +0,0 @@
-import { urlToRelativeUrl } from "@jsenv/filesystem"
-
-import { applyPostCss } from "./applyPostCss.js"
-import { postCssPluginUrlVisitor } from "./postcss_plugin_url_visitor.js"
-
-export const moveCssUrls = async ({
-  code,
-  from,
-  to,
-  map,
-  sourcemapMethod,
-} = {}) => {
-  const fromDirectoryUrl = new URL("./", from).href
-  const toDirectoryUrl = new URL("./", to).href
-  // same directory, nothing to do
-  if (fromDirectoryUrl === toDirectoryUrl) {
-    return { code, map }
-  }
-
-  const result = await applyPostCss({
-    code,
-    url: from,
-    map,
-    sourcemapMethod,
-    plugins: [
-      postCssPluginUrlVisitor({
-        urlVisitor: ({ specifier }) => {
-          if (specifier[0] === "#") {
-            return null
-          }
-          const url = new URL(specifier, fromDirectoryUrl).href
-          const relativeUrl = urlToRelativeUrl(url, toDirectoryUrl)
-          return relativeUrl
-        },
-      }),
-    ],
-  })
-  code = result.code
-  map = result.map
-  return {
-    code,
-    map,
-  }
-}

package/src/internal/building/css/parseCssRessource.js

@@ -1,259 +0,0 @@
-import {
-  urlToFilename,
-  urlToRelativeUrl,
-  resolveUrl,
-  fileSystemPathToUrl,
-} from "@jsenv/filesystem"
-
-import {
-  generateSourcemapUrl,
-  getCssSourceMappingUrl,
-  setCssSourceMappingUrl,
-} from "@jsenv/core/src/internal/sourceMappingURLUtils.js"
-import { getRessourceAsBase64Url } from "../ressource_builder_util.js"
-import { parseCssUrls } from "./parseCssUrls.js"
-import { replaceCssUrls } from "./replaceCssUrls.js"
-import { moveCssUrls } from "./moveCssUrls.js"
-
-export const parseCssRessource = async (
-  cssRessource,
-  { notifyReferenceFound },
-  {
-    jsenvRemoteDirectory,
-    asProjectUrl,
-    asOriginalUrl,
-    minify,
-    minifyCssOptions,
-    cssConcatenation,
-  },
-) => {
-  const cssString = String(cssRessource.bufferBeforeBuild)
-  const cssSourcemapUrl = getCssSourceMappingUrl(cssString)
-  const cssUrl = cssRessource.url
-  let code = cssString
-  let map
-  let sourcemapReference
-  if (cssSourcemapUrl) {
-    sourcemapReference = notifyReferenceFound({
-      referenceLabel: "css sourcemaping comment",
-      contentTypeExpected: ["application/json", "application/octet-stream"],
-      ressourceSpecifier: cssSourcemapUrl,
-      // we don't really know the line or column
-      // but let's asusme it the last line and first column
-      referenceLine: cssString.split(/\r?\n/).length - 1,
-      referenceColumn: 0,
-      isSourcemap: true,
-    })
-    await sourcemapReference.ressource.getBufferAvailablePromise()
-    map = JSON.parse(String(sourcemapReference.ressource.bufferBeforeBuild))
-  } else {
-    sourcemapReference = notifyReferenceFound({
-      referenceLabel: "css sourcemaping comment",
-      contentType: "application/octet-stream",
-      ressourceSpecifier: urlToRelativeUrl(
-        generateSourcemapUrl(cssUrl),
-        cssUrl,
-      ),
-      isPlaceholder: true,
-      isSourcemap: true,
-    })
-  }
-
-  const { atImports, urlDeclarations } = await parseCssUrls({
-    code,
-    url: cssUrl,
-  })
-  const urlNodeReferenceMapping = new Map()
-  const atImportReferences = []
-  atImports.forEach((atImport) => {
-    const importReference = notifyReferenceFound({
-      referenceLabel: "css @import",
-      ressourceSpecifier: atImport.specifier,
-      ...cssNodeToReferenceLocation(atImport.urlDeclarationNode),
-    })
-    urlNodeReferenceMapping.set(atImport.urlNode, importReference)
-    atImportReferences.push(importReference)
-  })
-  urlDeclarations.forEach((urlDeclaration) => {
-    if (urlDeclaration.specifier[0] === "#") {
-      return
-    }
-    const urlReference = notifyReferenceFound({
-      referenceLabel: "css url",
-      ressourceSpecifier: urlDeclaration.specifier,
-      ...cssNodeToReferenceLocation(urlDeclaration.urlDeclarationNode),
-    })
-    urlNodeReferenceMapping.set(urlDeclaration.urlNode, urlReference)
-  })
-
-  return async ({ getUrlRelativeToImporter, buildDirectoryUrl }) => {
-    const sourcemapRessource = sourcemapReference.ressource
-    const cssCompiledUrl = cssRessource.url
-    const cssOriginalUrl = asOriginalUrl(cssCompiledUrl)
-
-    const replaceCssResult = await replaceCssUrls({
-      url: asProjectUrl(cssCompiledUrl),
-      code,
-      map,
-      urlVisitor: ({ urlNode }) => {
-        const nodeCandidates = Array.from(urlNodeReferenceMapping.keys())
-        const urlNodeFound = nodeCandidates.find((urlNodeCandidate) =>
-          isSameCssDocumentUrlNode(urlNodeCandidate, urlNode),
-        )
-        if (!urlNodeFound) {
-          return urlNode.value
-        }
-        // url node nous dit quel référence y correspond
-        const urlNodeReference = urlNodeReferenceMapping.get(urlNodeFound)
-        const cssUrlRessource = urlNodeReference.ressource
-        const { isExternal } = cssUrlRessource
-        if (isExternal) {
-          return urlNode.value
-        }
-        const { isInline } = cssUrlRessource
-        if (isInline) {
-          return getRessourceAsBase64Url(cssUrlRessource)
-        }
-        return getUrlRelativeToImporter(cssUrlRessource)
-      },
-      cssConcatenation,
-      loadCssImport: async (path) => {
-        // const cssFileUrl = asProjectUrl(url)
-        const importedCssFileUrl = fileSystemPathToUrl(path)
-        const atImportReference = atImportReferences.find(
-          (atImportReference) => {
-            return (
-              asProjectUrl(atImportReference.ressource.url) ===
-              importedCssFileUrl
-            )
-          },
-        )
-        atImportReference.inlinedCallback()
-        let code = String(atImportReference.ressource.bufferAfterBuild)
-        const from = resolveUrl(
-          atImportReference.ressource.buildRelativeUrl,
-          buildDirectoryUrl,
-        )
-        const to = resolveUrl(
-          cssRessource.buildRelativeUrlWithoutHash,
-          buildDirectoryUrl,
-        )
-        const moveResult = await moveCssUrls({
-          code,
-          from,
-          to,
-          // moveCssUrls will change the css source code
-          // Ideally we should update the sourcemap referenced by css
-          // to target the one after css urls are moved.
-          // It means we should force sourcemap ressource to the new one
-          // until it's supported we prevent postcss from updating the
-          // sourcemap comment, othwise css would reference a sourcemap
-          // that won't by in the build directory
-          sourcemapMethod: null,
-        })
-        code = moveResult.code
-        return code
-      },
-      cssMinification: minify,
-      cssMinificationOptions: minifyCssOptions,
-    })
-    code = replaceCssResult.code
-    map = replaceCssResult.map
-    cssRessource.buildEnd(code)
-
-    // In theory code should never be modified once buildEnd() is called
-    // because buildRelativeUrl might be versioned based on file content
-    // There is an exception for sourcemap because we want to update sourcemap.file
-    // to the cached filename of the css file.
-    // To achieve that we set/update the sourceMapping url comment in compiled css file.
-    // This is totally fine to do that because sourcemap and css file lives togethers
-    // so this comment changes nothing regarding cache invalidation and is not important
-    // to decide buildRelativeUrl for this css file.
-    const cssBuildUrl = resolveUrl(
-      cssRessource.buildRelativeUrl,
-      buildDirectoryUrl,
-    )
-    const sourcemapPrecomputedBuildUrl = generateSourcemapUrl(cssBuildUrl)
-    map.file = urlToFilename(cssBuildUrl)
-    if (map.sources) {
-      map.sources = map.sources.map((source) => {
-        const sourceUrl = resolveUrl(source, cssOriginalUrl)
-        if (jsenvRemoteDirectory.isFileUrlForRemoteUrl(sourceUrl)) {
-          const sourceRemoteUrl =
-            jsenvRemoteDirectory.remoteUrlFromFileUrl(sourceUrl)
-          return sourceRemoteUrl
-        }
-        const sourceUrlRelativeToSourceMap = urlToRelativeUrl(
-          sourceUrl,
-          sourcemapPrecomputedBuildUrl,
-        )
-        return sourceUrlRelativeToSourceMap
-      })
-    }
-    const mapSource = JSON.stringify(map, null, "  ")
-    sourcemapRessource.buildEnd(mapSource)
-
-    const sourcemapBuildUrl = resolveUrl(
-      sourcemapRessource.buildRelativeUrl,
-      buildDirectoryUrl,
-    )
-    const sourcemapUrlForCss = urlToRelativeUrl(sourcemapBuildUrl, cssBuildUrl)
-    const codeWithSourcemapComment = setCssSourceMappingUrl(
-      code,
-      sourcemapUrlForCss,
-    )
-    cssRessource.bufferAfterBuild = codeWithSourcemapComment
-  }
-}
-
-const cssNodeToReferenceLocation = (node) => {
-  const { line, column } = node.source.start
-  return {
-    referenceLine: line,
-    referenceColumn: column,
-  }
-}
-
-const isSameCssDocumentUrlNode = (firstUrlNode, secondUrlNode) => {
-  if (!compareUrlNodeTypes(firstUrlNode.type, secondUrlNode.type)) {
-    return false
-  }
-  if (!compareUrlNodeValue(firstUrlNode.value, secondUrlNode.value)) {
-    return false
-  }
-  // maybe this sourceIndex should be removed in case there is some css transformation one day?
-  // it does not seems to change though as if it was refering the original file source index
-  if (firstUrlNode.sourceIndex !== secondUrlNode.sourceIndex) {
-    return false
-  }
-  return true
-}
-
-// minification may change url node type from string to word
-// that's still the same node
-const compareUrlNodeTypes = (firstUrlNodeType, secondUrlNodeType) => {
-  if (firstUrlNodeType === secondUrlNodeType) {
-    return true
-  }
-  if (firstUrlNodeType === "word" && secondUrlNodeType === "string") {
-    return true
-  }
-  if (firstUrlNodeType === "string" && secondUrlNodeType === "word") {
-    return true
-  }
-  return false
-}
-
-// minification may change url node value from './whatever.png' to 'whatever.png'
-// the value still revolves to the same ressource
-const compareUrlNodeValue = (firstUrlNodeValue, secondUrlNodeValue) => {
-  const firstValueNormalized = urlToRelativeUrl(
-    resolveUrl(firstUrlNodeValue, "file:///"),
-    "file:///",
-  )
-  const secondValueNormalized = urlToRelativeUrl(
-    resolveUrl(secondUrlNodeValue, "file:///"),
-    "file:///",
-  )
-  return firstValueNormalized === secondValueNormalized
-}

package/src/internal/building/css/parseCssUrls.js

@@ -1,38 +0,0 @@
-import { applyPostCss } from "./applyPostCss.js"
-import { postCssPluginUrlVisitor } from "./postcss_plugin_url_visitor.js"
-
-export const parseCssUrls = async ({ code, url = "file:///file.css" }) => {
-  const atImports = []
-  const urlDeclarations = []
-  await applyPostCss({
-    code,
-    url,
-    plugins: [
-      postCssPluginUrlVisitor({
-        urlVisitor: ({
-          type,
-          specifier,
-          atImportNode,
-          declarationNode,
-          urlNode,
-        }) => {
-          if (type === "import") {
-            atImports.push({
-              specifier,
-              urlNode,
-              urlDeclarationNode: atImportNode,
-            })
-          }
-          if (type === "asset") {
-            urlDeclarations.push({
-              specifier,
-              urlNode,
-              urlDeclarationNode: declarationNode,
-            })
-          }
-        },
-      }),
-    ],
-  })
-  return { atImports, urlDeclarations }
-}