@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/building/build_using_rollup.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}": commonJsToJsModule
-}
-As documented in https://github.com/jsenv/jsenv-core/blob/master/docs/shared-parameters.md#customcompilers`,
-  }
-}

package/src/internal/building/css/apply_post_css.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/jsenv_parse_css.js

@@ -1,260 +0,0 @@
-import {
-  urlToFilename,
-  urlToRelativeUrl,
-  resolveUrl,
-  fileSystemPathToUrl,
-} from "@jsenv/filesystem"
-
-import {
-  generateSourcemapUrl,
-  getCssSourceMappingUrl,
-  setCssSourceMappingUrl,
-} from "@jsenv/core/src/internal/sourcemap_utils.js"
-
-import { getRessourceAsBase64Url } from "../ressource_builder_util.js"
-import { parseCssUrls } from "./parse_css_urls.js"
-import { replaceCssUrls } from "./replace_css_urls.js"
-import { moveCssUrls } from "./move_css_urls.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
-}