@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/internal/building/buildToCompilationResult.js

@@ -1,183 +0,0 @@
-/*
-
-One thing to keep in mind:
-the sourcemap.sourcesContent will contains a json file transformed to js
-while urlResponseBodyMap will contain the json file raw source because the corresponding
-json file etag is used to invalidate the cache
-
-*/
-
-import { readFileSync } from "fs"
-import {
-  urlToRelativeUrl,
-  urlToFileSystemPath,
-  resolveUrl,
-} from "@jsenv/filesystem"
-import { setJavaScriptSourceMappingUrl } from "../sourceMappingURLUtils.js"
-
-export const buildToCompilationResult = (
-  { rollupBuild, urlResponseBodyMap },
-  { mainFileName, projectDirectoryUrl, compiledFileUrl, sourcemapFileUrl },
-) => {
-  if (typeof projectDirectoryUrl !== "string") {
-    throw new TypeError(
-      `projectDirectoryUrl must be a string, got ${projectDirectoryUrl}`,
-    )
-  }
-  if (typeof compiledFileUrl !== "string") {
-    throw new TypeError(
-      `compiledFileUrl must be a string, got ${compiledFileUrl}`,
-    )
-  }
-  if (typeof sourcemapFileUrl !== "string") {
-    throw new TypeError(
-      `sourcemapFileUrl must be a string, got ${sourcemapFileUrl}`,
-    )
-  }
-
-  const sources = []
-  const sourcesContent = []
-
-  if (mainFileName === undefined) {
-    mainFileName = Object.keys(rollupBuild).find(
-      (key) => rollupBuild[key].isEntry,
-    )
-  }
-
-  const trackDependencies = (dependencyMap) => {
-    Object.keys(dependencyMap).forEach((moduleUrl) => {
-      // do not track dependency outside project
-      if (!moduleUrl.startsWith(projectDirectoryUrl)) {
-        return
-      }
-
-      if (!sources.includes(moduleUrl)) {
-        sources.push(moduleUrl)
-        sourcesContent.push(dependencyMap[moduleUrl])
-      }
-    })
-  }
-
-  const assets = []
-  const assetsContent = []
-
-  const mainRollupFile = rollupBuild[mainFileName]
-  const mainFile = parseRollupFile(mainRollupFile, {
-    urlResponseBodyMap,
-    sourcemapFileUrl,
-    sourcemapFileRelativeUrlForModule: urlToRelativeUrl(
-      sourcemapFileUrl,
-      compiledFileUrl,
-    ),
-  })
-  // mainFile.sourcemap.file = fileUrlToRelativePath(originalFileUrl, sourcemapFileUrl)
-  trackDependencies(mainFile.dependencyMap)
-  assets.push(sourcemapFileUrl)
-  assetsContent.push(JSON.stringify(mainFile.sourcemap, null, "  "))
-
-  Object.keys(rollupBuild).forEach((fileName) => {
-    if (fileName === mainFileName) return
-
-    const rollupFile = rollupBuild[fileName]
-    if (rollupFile.type === "asset") return
-
-    const file = parseRollupFile(rollupFile, {
-      urlResponseBodyMap,
-      compiledFileUrl,
-      sourcemapFileUrl: resolveUrl(rollupFile.map.file, compiledFileUrl),
-    })
-    trackDependencies(file.dependencyMap)
-    assets.push(resolveUrl(fileName), compiledFileUrl)
-    assetsContent.push(file.content)
-    assets.push(resolveUrl(`${fileName}.map`, compiledFileUrl))
-    assetsContent.push(JSON.stringify(rollupFile.sourcemap, null, "  "))
-  })
-
-  return {
-    contentType: "application/javascript",
-    compiledSource: mainFile.content,
-    sources,
-    sourcesContent,
-    assets,
-    assetsContent,
-  }
-}
-
-const parseRollupFile = (
-  rollupFile,
-  {
-    urlResponseBodyMap,
-    sourcemapFileUrl,
-    sourcemapFileRelativeUrlForModule = `./${rollupFile.fileName}.map`,
-  },
-) => {
-  const dependencyMap = {}
-  const mainModuleSourcemap = rollupFile.map
-
-  mainModuleSourcemap.sources.forEach((source, index) => {
-    const moduleUrl = resolveUrl(source, sourcemapFileUrl)
-    dependencyMap[moduleUrl] = getModuleContent({
-      urlResponseBodyMap,
-      mainModuleSourcemap,
-      moduleUrl,
-      moduleIndex: index,
-    })
-  })
-
-  const sourcemap = rollupFile.map
-
-  const content = setJavaScriptSourceMappingUrl(
-    rollupFile.code,
-    sourcemapFileRelativeUrlForModule,
-  )
-
-  return {
-    dependencyMap,
-    content,
-    sourcemap,
-  }
-}
-
-const getModuleContent = ({
-  urlResponseBodyMap,
-  mainModuleSourcemap,
-  moduleUrl,
-  moduleIndex,
-}) => {
-  if (moduleUrl in urlResponseBodyMap) {
-    return urlResponseBodyMap[moduleUrl]
-  }
-
-  // try to read it from mainModuleSourcemap
-  const sourcesContent = mainModuleSourcemap.sourcesContent || []
-  if (moduleIndex in sourcesContent) {
-    const contentFromRollupSourcemap = sourcesContent[moduleIndex]
-    if (
-      contentFromRollupSourcemap !== null &&
-      contentFromRollupSourcemap !== undefined
-    ) {
-      return contentFromRollupSourcemap
-    }
-  }
-
-  // try to get it from filesystem
-  if (moduleUrl.startsWith("file:///")) {
-    const moduleFilePath = urlToFileSystemPath(moduleUrl)
-    // this could be async but it's ok for now
-    // making it async could be harder than it seems
-    // because sourcesContent must be in sync with sources
-    try {
-      const moduleFileBuffer = readFileSync(moduleFilePath)
-      const moduleFileString = String(moduleFileBuffer)
-      return moduleFileString
-    } catch (e) {
-      if (e && e.code === "ENOENT") {
-        throw new Error(`module file not found at ${moduleUrl}`)
-      }
-      throw e
-    }
-  }
-
-  // it's an external ressource like http, throw
-  throw new Error(`cannot fetch module content from ${moduleUrl}`)
-}

package/src/internal/building/buildUsingRollup.js

@@ -1,359 +0,0 @@
-import {
-  urlToFileSystemPath,
-  ensureEmptyDirectory,
-  readFile,
-  urlToRelativeUrl,
-  writeFile,
-  resolveUrl,
-} from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
-
-import { humanizeUrl } from "@jsenv/core/src/internal/building/url_trace.js"
-
-import { createRollupPlugins } from "./rollup_plugin_jsenv.js"
-
-export const buildUsingRollup = async ({
-  buildOperation,
-  logger,
-
-  entryPoints,
-  projectDirectoryUrl,
-  buildDirectoryUrl,
-  buildDirectoryClean,
-  assetManifestFile,
-  assetManifestFileRelativeUrl,
-
-  urlMappings,
-  importResolutionMethod,
-  importMapFileRelativeUrl,
-  importDefaultExtension,
-  externalImportSpecifiers,
-  preservedUrls,
-  importPaths,
-
-  format,
-  systemJsUrl,
-  globals,
-  preservedDynamicImports,
-  serviceWorkerFinalizer,
-
-  node,
-  browser,
-  compileServer,
-  compileProfile,
-  compileId,
-
-  urlVersioning,
-  lineBreakNormalization,
-  useImportMapToMaximizeCacheReuse,
-  preserveEntrySignatures,
-  treeshake,
-  jsConcatenation,
-  cssConcatenation,
-
-  minify,
-  minifyHtmlOptions,
-  minifyJsOptions,
-  minifyCssOptions,
-
-  writeOnFileSystem,
-  sourcemapExcludeSources,
-}) => {
-  const {
-    rollupPlugins,
-    getLastErrorMessage,
-    getResult,
-    asOriginalUrl,
-    asProjectUrl,
-  } = await createRollupPlugins({
-    buildOperation,
-    logger,
-
-    projectDirectoryUrl,
-    entryPoints,
-    buildDirectoryUrl,
-
-    format,
-    systemJsUrl,
-    globals,
-    preservedDynamicImports,
-
-    urlMappings,
-    importResolutionMethod,
-    importMapFileRelativeUrl,
-    importDefaultExtension,
-    externalImportSpecifiers,
-    importPaths,
-    preservedUrls,
-    serviceWorkerFinalizer,
-
-    node,
-    browser,
-    compileServer,
-    compileProfile,
-    compileId,
-
-    urlVersioning,
-    lineBreakNormalization,
-    jsConcatenation,
-    cssConcatenation,
-    useImportMapToMaximizeCacheReuse,
-
-    minify,
-    minifyJsOptions,
-    minifyCssOptions,
-    minifyHtmlOptions,
-  })
-
-  try {
-    await useRollup({
-      buildOperation,
-      logger,
-
-      rollupPlugins,
-      compileProfile,
-      format,
-      sourcemapExcludeSources,
-      preserveEntrySignatures,
-      treeshake,
-      // jsConcatenation,
-      buildDirectoryUrl,
-      buildDirectoryClean,
-
-      asOriginalUrl,
-    })
-  } catch (e) {
-    if (e.plugin === "jsenv") {
-      const jsenvPluginErrorMessage = getLastErrorMessage()
-      if (jsenvPluginErrorMessage) {
-        // rollup is adding properties to the original error
-        // making it a bit harder to read
-        // It does not add useful information so we restore the error
-        delete e.code
-        delete e.hook
-        delete e.id
-        delete e.watchFiles
-        delete e.plugin
-        e.message = jsenvPluginErrorMessage
-        throw e
-      }
-      throw e
-    }
-    if (e.code === "MISSING_EXPORT") {
-      let message = e.message
-      message = message.replace(e.id, (url) =>
-        humanizeUrl(asOriginalUrl(url) || url),
-      )
-      message = message.replace(/(www|http:|https:)+[^\s]+[\w]/g, (url) =>
-        humanizeUrl(asOriginalUrl(url) || url),
-      )
-      const importedFileRollupUrl = e.message.match(/not exported by (.*?),/)[1]
-      const convertSuggestion = await getConvertSuggestion({
-        importedFileRollupUrl,
-        asProjectUrl,
-        asOriginalUrl,
-        projectDirectoryUrl,
-      })
-      const detailedMessage = createDetailedMessage(message, {
-        frame: e.frame,
-        ...convertSuggestion,
-      })
-      throw new Error(detailedMessage, { cause: e })
-    }
-    throw e
-  }
-
-  const {
-    rollupBuild,
-    urlResponseBodyMap,
-    buildMappings,
-    buildManifest,
-    buildImportMap,
-    buildFileContents,
-    buildInlineFileContents,
-    buildStats,
-  } = await getResult()
-
-  if (writeOnFileSystem) {
-    if (buildDirectoryClean) {
-      await ensureEmptyDirectory(buildDirectoryUrl)
-    }
-
-    if (assetManifestFile) {
-      const assetManifestFileUrl = resolveUrl(
-        assetManifestFileRelativeUrl,
-        buildDirectoryUrl,
-      )
-      await writeFile(
-        assetManifestFileUrl,
-        JSON.stringify(buildManifest, null, "  "),
-      )
-    }
-
-    const buildRelativeUrls = Object.keys(buildFileContents)
-    await Promise.all(
-      buildRelativeUrls.map(async (buildRelativeUrl) => {
-        const fileBuildUrl = resolveUrl(buildRelativeUrl, buildDirectoryUrl)
-        await writeFile(fileBuildUrl, buildFileContents[buildRelativeUrl])
-      }),
-    )
-  }
-
-  return {
-    rollupBuild,
-    urlResponseBodyMap,
-    buildMappings,
-    buildManifest,
-    buildImportMap,
-    buildFileContents,
-    buildInlineFileContents,
-    buildStats,
-  }
-}
-
-const useRollup = async ({
-  buildOperation,
-  logger,
-  rollupPlugins,
-  compileProfile,
-  format,
-  sourcemapExcludeSources,
-  preserveEntrySignatures,
-  treeshake,
-  // jsConcatenation,
-  buildDirectoryUrl,
-  asOriginalUrl,
-}) => {
-  buildOperation.throwIfAborted()
-  const { rollup } = await import("rollup")
-  const { importAssertions } = await import("acorn-import-assertions")
-
-  const rollupInputOptions = {
-    // about cache here, we should/could reuse previous rollup call
-    // to get the cache from the entryPoints
-    // as shown here: https://rollupjs.org/guide/en#cache
-    // it could be passed in arguments to this function
-    // however parallelism and having different rollup options per
-    // call make it a bit complex
-    // cache: null
-    // https://rollupjs.org/guide/en#experimentaltoplevelawait
-    //  experimentalTopLevelAwait: true,
-    // if we want to ignore some warning
-    // please use https://rollupjs.org/guide/en#onwarn
-    // to be very clear about what we want to ignore
-    onwarn: (warning) => {
-      if (warning.code === "THIS_IS_UNDEFINED") {
-        return
-      }
-      if (
-        warning.code === "EMPTY_BUNDLE" &&
-        warning.chunkName === "__empty__"
-      ) {
-        return
-      }
-      // ignore file name conflict when sourcemap or importmap are re-emitted
-      if (
-        warning.code === "FILE_NAME_CONFLICT" &&
-        (warning.message.includes(".map") ||
-          warning.message.includes(".importmap"))
-      ) {
-        return
-      }
-      warning.message = warning.message.replace(
-        /http:\/\/jsenv.com\/[^\s]+[\w]/g,
-        (url) => {
-          return humanizeUrl(asOriginalUrl(url) || url)
-        },
-      )
-      if (warning.code === "CIRCULAR_DEPENDENCY") {
-        warning.cycle.forEach((url, index) => {
-          warning.cycle[index] = humanizeUrl(asOriginalUrl(url) || url)
-        })
-      }
-      logger.warn(String(warning))
-    },
-    // on passe input: [] car c'est le plugin jsenv qui se chargera d'emit des chunks
-    // en fonction de entryPoints
-    // on fait cela car sinon rollup est pénible si on passe un input de type html
-    input: [],
-    preserveEntrySignatures,
-    treeshake,
-    plugins: rollupPlugins,
-    acornInjectPlugins: [importAssertions],
-  }
-  const rollupOutputOptions = {
-    // https://rollupjs.org/guide/en#experimentaltoplevelawait
-    // experimentalTopLevelAwait: true,
-    // https://rollupjs.org/guide/en/#outputgeneratedcode
-    generatedCode: {
-      arrowFunctions:
-        compileProfile &&
-        !compileProfile.missingFeatures["transform-arrow-functions"],
-      constBindings:
-        compileProfile &&
-        !compileProfile.missingFeatures["transform-block-scoping"],
-      objectShorthand:
-        compileProfile &&
-        !compileProfile.missingFeatures["transform-shorthand-properties"],
-      reservedNamesAsProps:
-        compileProfile &&
-        !compileProfile.missingFeatures["transform-reserved-words"],
-    },
-    // https://rollupjs.org/guide/en#output-dir
-    dir: urlToFileSystemPath(buildDirectoryUrl),
-    // https://rollupjs.org/guide/en#output-format
-    format: formatToRollupFormat(format),
-    // https://rollupjs.org/guide/en#output-sourcemap
-    sourcemap: true,
-    sourcemapExcludeSources,
-    // preserveModules: !jsConcatenation,
-  }
-
-  buildOperation.throwIfAborted()
-  const rollupReturnValue = await rollup(rollupInputOptions)
-
-  buildOperation.throwIfAborted()
-  const rollupOutputArray = await rollupReturnValue.generate(
-    rollupOutputOptions,
-  )
-
-  return rollupOutputArray
-}
-
-const formatToRollupFormat = (format) => {
-  if (format === "global") return "esm" // will be handled by rollup_plugin_iife
-  if (format === "commonjs") return "cjs"
-  if (format === "systemjs") return "system"
-  if (format === "esmodule") return "esm"
-  throw new Error(`unexpected format, got ${format}`)
-}
-
-const getConvertSuggestion = async ({
-  importedFileRollupUrl,
-  asProjectUrl,
-  asOriginalUrl,
-  projectDirectoryUrl,
-}) => {
-  const importedFileUrl = asProjectUrl(importedFileRollupUrl)
-  const importedFileContent = await readFile(importedFileUrl)
-  const looksLikeCommonJs =
-    importedFileContent.includes("module.exports = ") ||
-    importedFileContent.includes("exports.")
-
-  if (!looksLikeCommonJs) {
-    return null
-  }
-
-  const importerFileOriginalUrl = asOriginalUrl(importedFileUrl)
-  const importedFileOriginalRelativeUrl = urlToRelativeUrl(
-    importerFileOriginalUrl,
-    projectDirectoryUrl,
-  )
-  return {
-    suggestion: `The file seems written in commonjs, you should use "customCompiler" to convert it to js module
-{
-  "./${importedFileOriginalRelativeUrl}": commonJsToJavaScriptModule
-}
-As documented in https://github.com/jsenv/jsenv-core/blob/master/docs/shared-parameters.md#customcompilers`,
-  }
-}

package/src/internal/building/build_logs.js

@@ -1,133 +0,0 @@
-import { ANSI, UNICODE } from "@jsenv/log"
-
-import { getHtmlNodeLocation } from "@jsenv/core/src/internal/compiling/compileHtml.js"
-import { byteAsFileSize } from "../logs/byteAsFileSize.js"
-import { msAsDuration } from "../logs/msAsDuration.js"
-import { stringifyUrlSite } from "./url_trace.js"
-
-export const formatBuildStartLog = ({ entryPoints }) => {
-  const entryFileRelativeUrls = Object.keys(entryPoints)
-  if (entryFileRelativeUrls.length === 1) {
-    return `
-building ${entryFileRelativeUrls[0]}...`
-  }
-
-  return `
-building ${entryFileRelativeUrls.length} entry files...`
-}
-
-export const formatUseImportMapFromHtml = (importMapInfoFromHtml) => {
-  return `
-use importmap from html ${showHtmlSourceLocation(importMapInfoFromHtml)}`
-}
-
-export const formatImportmapOutsideCompileDirectory = ({
-  importMapInfo,
-  compileDirectoryUrl,
-}) => {
-  return `
-WARNING: importmap file is outside compile directory.
-That's unusual you should certainly make importmap file relative.
-${showHtmlSourceLocation(importMapInfo)}
---- compile directory url ---
-${compileDirectoryUrl}
-`
-}
-
-export const formatRessourceHintNeverUsedWarning = (linkInfo) => {
-  return `
-WARNING: Ressource never used for ${
-    linkInfo.rel
-  } link in ${showHtmlSourceLocation(linkInfo)}
-`
-}
-
-export const formatBuildDoneInfo = ({
-  buildStats,
-  buildDirectoryRelativeUrl,
-}) => {
-  return `${formatBuildDoneDetails({ buildStats, buildDirectoryRelativeUrl })}
-${formatBuildSummary({ buildStats })}
-${UNICODE.OK} build end
-`
-}
-
-const formatBuildDoneDetails = ({ buildStats, buildDirectoryRelativeUrl }) => {
-  const { buildFileSizes } = buildStats
-  const buildFiles = Object.keys(buildFileSizes).map((key) => {
-    const buildFileSize = buildFileSizes[key]
-    return `${buildDirectoryRelativeUrl}${key} (${byteAsFileSize(
-      buildFileSize,
-    )})`
-  })
-  const buildFileCount = buildFiles.length
-  const { buildSourcemapFileSizes } = buildStats
-  const sourcemapFileCount = Object.keys(buildSourcemapFileSizes).length
-  let buildFilesDescription =
-    buildFileCount === 1 ? "build file" : `build files`
-  if (sourcemapFileCount === 1) {
-    buildFilesDescription += ` (excluding sourcemap file)`
-  } else if (sourcemapFileCount > 1) {
-    buildFilesDescription += ` (excluding sourcemap files)`
-  }
-  let message = `--- ${buildFilesDescription} ---
-${buildFiles.join("\n")}`
-  return message
-}
-
-const formatBuildSummary = ({ buildStats }) => {
-  const {
-    buildDuration,
-    projectFileSizes,
-    projectTotalFileSize,
-    buildFileSizes,
-    buildFileTotalSize,
-    buildSourcemapFileSizes,
-    buildSourcemapFileTotalSize,
-  } = buildStats
-
-  const projectFileCount = Object.keys(projectFileSizes).length
-  const buildFileCount = Object.keys(buildFileSizes).length
-  const buildSourcemapFileCount = Object.keys(buildSourcemapFileSizes).length
-
-  return `------- build summary -------
-${formatSummaryContent({
-  "project files": `${projectFileCount} (${byteAsFileSize(
-    projectTotalFileSize,
-  )})`,
-  "build files": `${buildFileCount} (${byteAsFileSize(buildFileTotalSize)})`,
-  ...(buildSourcemapFileCount === 0
-    ? {}
-    : {
-        "build sourcemap files": `${buildSourcemapFileCount} (${byteAsFileSize(
-          buildSourcemapFileTotalSize,
-        )})`,
-      }),
-  "build duration": msAsDuration(buildDuration),
-})}
-------------------------------`
-}
-
-const formatSummaryContent = (summaryData) => {
-  return Object.keys(summaryData).map((key) => {
-    return `${ANSI.color(`${key}:`, ANSI.GREY)} ${summaryData[key]}`
-  }).join(`
-`)
-}
-
-const showHtmlSourceLocation = ({
-  htmlNode,
-  htmlUrl,
-  htmlSource,
-  htmlAttributeName,
-}) => {
-  const { line, column } =
-    getHtmlNodeLocation(htmlNode, htmlAttributeName) || {}
-
-  return stringifyUrlSite({
-    url: htmlUrl,
-    line,
-    column,
-    source: htmlSource,
-  })
-}