@jsenv/bundling/src/bundle-to-compilation-result.js

/*

bundleToCompilationResult does two things:

1. Change every relative path inside rollup sourcemap to an "absolute" version.
Something like `../../importMap.json` becomes `/importMap.json`.
In the process // sourceMappingURL comment of the file referencing the sourcemap is updated.

We need this because vscode is configured with
```json
{
  "sourceMapPathOverrides": {
    "/*": "${workspaceFolder}/*"
  },
```
And we need to do that because I struggled to make vscode work with relative notations.

2. Return { compiledSource, sources, sourcesContent, assets, assetsContent }
It is usefull because this object can be used to create a cache for the bundle.
This object is used by serveCompiledFile.

One thing to keep in mind:
the sourcemap.sourcesContent will contains a json file transformed to js
while sourcesContent will contain the json file raw source because the corresponding
json file etag is used to invalidate the cache
*/

import { readFileSync } from "fs"
import { dirname, resolve } from "path"
import {
  pathnameToOperatingSystemPath,
  pathnameIsInside,
  pathnameToRelativePathname,
  operatingSystemPathToPathname,
} from "@jsenv/operating-system-path"
import { writeOrUpdateSourceMappingURL } from "./helpers/source-mapping-url.js"

export const bundleToCompilationResult = (
  { rollupBundle, relativePathAbstractArray },
  {
    projectPathname,
    compileIntoRelativePath,
    entryRelativePath,
    sourcemapAssetPath,
    sourcemapPath = sourcemapAssetPath,
  },
) => {
  const sources = []
  const sourcesContent = []
  const assets = []
  const assetsContent = []

  const output = rollupBundle.output
  const main = output[0]
  const mainRollupSourcemap = main.map

  const mainDependencyMap = rollupSourcemapToDependencyMap({
    rollupSourcemap: mainRollupSourcemap,
    projectPathname,
    compileIntoRelativePath,
    entryRelativePath,
    relativePathAbstractArray,
  })

  const addDependencyMap = (dependencyMap) => {
    Object.keys(dependencyMap).forEach((relativePath) => {
      if (relativePathAbstractArray.includes(relativePath)) return
      if (sources.includes(relativePath)) return

      sources.push(relativePath)
      sourcesContent.push(dependencyMap[relativePath])
    })
  }

  // main file
  const mainSourceContent = writeOrUpdateSourceMappingURL(main.code, sourcemapPath)
  // main sourcemap
  assets.push(sourcemapAssetPath.slice(2))
  const mainSourcemap = {
    ...mainRollupSourcemap,
    ...dependencyMapToSourcemapSubset(mainDependencyMap),
  }
  assetsContent.push(JSON.stringify(mainSourcemap, null, "  "))
  // main dependencies
  addDependencyMap(mainDependencyMap)

  output.slice(1).forEach((chunk) => {
    const chunkRollupSourcemap = chunk.map
    const chunkDependencyMap = rollupSourcemapToDependencyMap({
      rollupSourcemap: chunkRollupSourcemap,
      projectPathname,
      compileIntoRelativePath,
      entryRelativePath,
      relativePathAbstractArray,
    })

    // chunk file
    assets.push(chunk.fileName)
    const chunkSourceContent = writeOrUpdateSourceMappingURL(chunk.code, `./${chunk.fileName}.map`)
    assetsContent.push(chunkSourceContent)
    // chunk sourcemap
    assets.push(`${chunk.fileName}.map`)
    const chunkSourcemap = {
      ...chunkRollupSourcemap,
      ...dependencyMapToSourcemapSubset(chunkDependencyMap),
    }
    assetsContent.push(JSON.stringify(chunkSourcemap, null, "  "))
    // chunk dependencies
    addDependencyMap(chunkDependencyMap)
  })

  return {
    contentType: "application/javascript",
    compiledSource: mainSourceContent,
    sources,
    sourcesContent,
    assets,
    assetsContent,
  }
}

const dependencyMapToSourcemapSubset = (dependencyMap) => {
  const sources = Object.keys(dependencyMap)
  const sourcesContent = sources.map((source) => {
    // for sourcemap the source content of a json file is the js
    // transformation of that json
    if (source.endsWith(".json")) return `export default ${dependencyMap[source]}`
    return dependencyMap[source]
  })
  return {
    sources,
    sourcesContent,
  }
}

const rollupSourcemapToDependencyMap = ({
  rollupSourcemap,
  projectPathname,
  compileIntoRelativePath,
  entryRelativePath,
  relativePathAbstractArray,
}) => {
  const dependencyMap = {}

  rollupSourcemap.sources.forEach((sourceRelativeToEntry, index) => {
    const sourcePath = resolve(
      dirname(
        pathnameToOperatingSystemPath(
          `${projectPathname}${compileIntoRelativePath}${entryRelativePath}`,
        ),
      ),
      sourceRelativeToEntry,
    )
    const sourcePathname = operatingSystemPathToPathname(sourcePath)

    if (!pathnameIsInside(sourcePathname, projectPathname)) {
      throw createSourceOutsideProjectError({
        sourcePath,
        projectPathname,
        source: sourceRelativeToEntry,
        file: entryRelativePath,
      })
    }

    const sourceRelativePath = pathnameToRelativePathname(sourcePathname, projectPathname)
    const isAbstract = relativePathAbstractArray.includes(sourceRelativePath)

    let dependencyContent
    const sourcesContent = rollupSourcemap.sourcesContent || []
    if (index in sourcesContent) {
      // abstract ressource cannot be found on filesystem
      // so trust what we found in sourcesContent
      if (isAbstract) {
        dependencyContent = sourcesContent[index]
      }
      // .json file source content is not the one inside the file
      // because jsenv-rollup-plugin transforms it to
      // export default, so we must set back the
      // right file content
      else if (sourceRelativePath.endsWith(".json")) {
        dependencyContent = readSourceContent({
          projectPathname,
          sourceRelativePath,
          entryRelativePath,
        })
      } else {
        dependencyContent = sourcesContent[index]
      }
    } else {
      if (isAbstract) {
        throw createAbstractSourceMissingError({ sourceRelativePath, entryRelativePath })
      }
      dependencyContent = readSourceContent({
        projectPathname,
        sourceRelativePath,
        entryRelativePath,
      })
    }

    dependencyMap[sourceRelativePath] = dependencyContent
  })

  return dependencyMap
}

const readSourceContent = ({ projectPathname, sourceRelativePath, entryRelativePath }) => {
  const sourcePath = pathnameToOperatingSystemPath(`${projectPathname}${sourceRelativePath}`)
  // 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 buffer = readFileSync(sourcePath)
    return String(buffer)
  } catch (e) {
    if (e && e.code === "ENOENT") {
      throw createSourceNotFoundError({
        sourcePath,
        projectPathname,
        source: sourceRelativePath,
        file: entryRelativePath,
      })
    }
    throw e
  }
}

const createAbstractSourceMissingError = ({ source, file }) =>
  new Error(`an abstract file source content is missing.
source: ${source}
file: ${file}`)

const createSourceNotFoundError = ({ sourcePath, projectPathname, source, file }) =>
  new Error(`a file source cannot be found.
source path: ${sourcePath}
project path: ${pathnameToOperatingSystemPath(projectPathname)}
source: ${source}
file: ${file}`)

const createSourceOutsideProjectError = ({ sourcePath, projectPathname, source, file }) =>
  new Error(`a file source is not inside project.
source path: ${sourcePath}
project path: ${pathnameToOperatingSystemPath(projectPathname)}
source: ${source}
file: ${file}`)