@jsenv/bundling/src/jsenv-rollup-plugin.js

/* eslint-disable import/max-dependencies */
import { statSync } from "fs"
import { resolve } from "url"
import { fileRead, fileWrite } from "@dmail/helper"
import { createOperation } from "@dmail/cancellation"
import {
  hrefToPathname,
  hrefToScheme,
  pathnameToRelativePath,
  pathnameIsInside,
  hrefToOrigin,
} from "@jsenv/href"
import {
  pathnameToOperatingSystemPath,
  operatingSystemPathToPathname,
  isWindowsPath,
} from "@jsenv/operating-system-path"
import { resolveImport, composeTwoImportMaps, normalizeImportMap } from "@jsenv/import-map"
import { generateImportMapForPackage } from "@jsenv/node-module-import-map"
import { jsenvBundlingProjectPathname, jsenvBundlingProjectPath } from "./jsenv-bundling-project.js"
import { generateBabelPluginMapOption } from "./babel-plugin-map/babel-plugin-map.js"
import { fetchUsingHttp } from "./helpers/fetchUsingHttp.js"
import { writeSourceMappingURL, parseSourceMappingURL } from "./helpers/source-mapping-url.js"

const {
  readProjectImportMap,
  babelHelperMap,
  generateBabelHelper,
  cleanCompileCacheFolderIfObsolete,
  getOrGenerateCompiledFile,
  transformJs,
  transformResultToCompilationResult,
  compilationResultToTransformResult,
  findAsyncPluginNameInBabelPluginMap,
} = import.meta.require("@jsenv/core")
const { minify: minifyCode } = import.meta.require("terser")

export const createJsenvRollupPlugin = async ({
  cancellationToken,
  projectPathname,
  bundleIntoRelativePath,
  importDefaultExtension,
  importMapRelativePath,
  importMapForBundle,
  importAbstractMap,
  importFallbackMap,
  cache,
  cacheRelativePath,
  babelPluginMap,
  convertMap,
  featureNameArray,
  minify,
  format,
  detectAndTransformIfNeededAsyncInsertedByRollup = format === "global",
  entryPointMap,
  logger,
}) => {
  const fakeOrigin = "http://example.com"

  const arrayOfHrefToSkipTransform = []
  const arrayOfAbstractHref = []

  const getArrayOfAbstractHref = () => arrayOfAbstractHref

  const importMapAbstractPath = "/.jsenv/importMap.json"
  const bundleConstantAbstractPath = "/.jsenv/BUNDLE_CONSTANTS.js"

  babelPluginMap = generateBabelPluginMapOption({
    projectPathname,
    format,
    babelPluginMap,
    featureNameArray,
  })

  const bundleConstantsHref = `file://${jsenvBundlingProjectPathname}${bundleConstantAbstractPath}`
  const importMapHref = `file://${projectPathname}${importMapRelativePath}`

  importFallbackMap = {
    ...importFallbackMap,
    // importMap is optionnal
    [importMapHref]: () => `export default {}`,
  }

  const chunkId = `${Object.keys(entryPointMap)[0]}.js`
  importAbstractMap = {
    ...importAbstractMap,
    [bundleConstantsHref]: () => `export const chunkId = ${JSON.stringify(chunkId)}`,
  }

  const importMapForBundling = {
    imports: {
      [bundleConstantAbstractPath]: bundleConstantsHref,
      [importMapAbstractPath]: importMapHref,
    },
  }

  Object.keys(babelHelperMap).forEach((babelHelperName) => {
    const babelHelperPath = babelHelperMap[babelHelperName]
    if (babelHelperPath.startsWith("@jsenv/core")) {
      // nothing to do
    } else {
      importAbstractMap[babelHelperPath] = () => generateBabelHelper(babelHelperName)
    }
  })

  const importMapForProject = await readProjectImportMap({
    projectPathname,
    jsenvProjectPathname: jsenvBundlingProjectPathname,
    importMapRelativePath,
    logger,
  })
  const importMap = normalizeImportMap(
    [
      await generateImportMapForPackage({
        projectPath: jsenvBundlingProjectPath,
        rootProjectPath: pathnameToOperatingSystemPath(projectPathname),
        onWarn: ({ message }) => logger.warn(message),
      }),
      importMapForBundling,
      importMapForProject,
      importMapForBundle,
    ].reduce((previous, current) => composeTwoImportMaps(previous, current), {}),
    fakeOrigin,
  )

  const compileCacheFolderRelativePath = `${bundleIntoRelativePath}${cacheRelativePath}`
  if (cache) {
    const cacheMeta = {
      featureNameArray,
      convertMap,

      // importMap,
      // importMap influences how the files are resolved
      // but not how they are compiled and cached

      // format,
      // not needed because derived from bundleIntoRelativePath

      // babelPluginMap,
      // not needed because derived from featureNameArray

      // minify,
      // not needed, the bundle itself is not cached
      // and only the bundle is minified
    }
    await cleanCompileCacheFolderIfObsolete({
      projectPathname,
      compileCacheFolderRelativePath,
      cacheMeta,
      cleanCallback: (cacheFolderPath) => {
        logger.warn(`remove cache folder ${cacheFolderPath}`)
      },
    })
  }

  const jsenvRollupPlugin = {
    name: "jsenv",

    resolveId: (specifier, importer) => {
      let importerHref
      if (importer) {
        if (isWindowsPath(importer)) {
          importer = operatingSystemPathToPathname(importer)
        }
        // 99% of the time importer is an operating system path
        // here we ensure / is resolved against project by forcing an url resolution
        // prefixing with origin
        if (importer.startsWith(`${projectPathname}/`)) {
          importerHref = `${fakeOrigin}${pathnameToRelativePath(importer, projectPathname)}`
        } else if (hrefToScheme(importer)) {
          if (importer.startsWith(`file://${projectPathname}/`)) {
            importerHref = `${fakeOrigin}${pathnameToRelativePath(
              hrefToPathname(importer),
              projectPathname,
            )}`
          } else {
            // there is already a scheme (http, https, file), keep it
            // it means there is an absolute import starting with file:// or http:// for instance.
            importerHref = importer
          }
        } else {
          throw createImporterOutsideProjectError({ importer, projectPathname })
        }
      } else {
        importerHref = fakeOrigin
      }

      const resolvedHref = resolveImport({
        specifier,
        importer: importerHref,
        importMap,
        defaultExtension: importDefaultExtension,
      })

      let href
      if (resolvedHref.startsWith("file://")) {
        if (!pathnameIsInside(hrefToPathname(resolvedHref), projectPathname)) {
          throw new Error(
            createMustBeInsideProjectMessage({
              href: resolvedHref,
              specifier,
              importer,
              projectPathname,
            }),
          )
        }
        href = resolvedHref
      } else if (hrefToOrigin(resolvedHref) === fakeOrigin) {
        href = `file://${projectPathname}${hrefToPathname(resolvedHref)}`
      } else {
        // allow external import like import "https://cdn.com/jquery.js"
        href = resolvedHref
      }

      if (href.startsWith("file://")) {
        // TODO: open an issue rollup side
        // to explain the issue here
        // which is that if id is not an os path
        // sourcemap will be broken
        // (likely because they apply node.js path.resolve)
        // they could either use an other resolution system
        // or provide the ability to change how it's resolved
        // so that the sourcemap.sources does not get broken

        // rollup works with operating system path
        // return os path when possible
        // to ensure we can predict sourcemap.sources returned by rollup
        const filePathame = hrefToPathname(href)
        const filePath = pathnameToOperatingSystemPath(filePathame)
        if (href in importAbstractMap) {
          return filePath
        }
        // file presence is optionnal
        if (href in importFallbackMap) {
          return filePath
        }

        let stats
        try {
          stats = statSync(filePath)
        } catch (e) {
          if (e.code === "ENOENT") {
            throw new Error(
              createFileNotFoundForImportMessage({
                path: filePath,
                specifier,
                importer,
              }),
            )
          }
          throw e
        }

        if (!stats.isFile()) {
          throw new Error(
            createUnexpectedStatsForImportMessage({
              path: filePath,
              stats,
              specifier,
              importer,
            }),
          )
        }

        return filePath
      }

      return href
    },

    // https://rollupjs.org/guide/en#resolvedynamicimport
    // resolveDynamicImport: (specifier, importer) => {

    // },

    load: async (rollupId) => {
      const href = rollupIdToHref(rollupId)

      if (href in importAbstractMap) {
        const generateSourceForImport = importAbstractMap[href]
        if (typeof generateSourceForImport !== "function") {
          throw new Error(
            `importAbstractMap values must be functions, found ${generateSourceForImport} for ${href}`,
          )
        }

        return generateAbstractSourceForImport(href, generateSourceForImport)
      }

      const response = await fetchHref(href)
      const responseStatus = response.status

      if (!responseStatusIsOk(responseStatus)) {
        if (responseStatus === 404 && href in importFallbackMap) {
          return generateAbstractSourceForImport(href, importFallbackMap[href])
        }
        throw new Error(
          createUnexpectedResponseStatusMessage({
            responseStatus,
            href,
          }),
        )
      }

      let source = response.body

      if (href.endsWith(".json")) {
        source = `export default ${source}`
      }

      const sourcemapParsingResult = parseSourceMappingURL(source)

      if (!sourcemapParsingResult) {
        return { code: source }
      }

      if (sourcemapParsingResult.sourcemapString) {
        return { code: source, map: JSON.parse(sourcemapParsingResult.sourcemapString) }
      }

      const resolvedSourceMappingURL = resolve(href, sourcemapParsingResult.sourcemapURL)
      const sourcemapResponse = await fetchHref(resolvedSourceMappingURL)
      const sourcemapResponseStatus = sourcemapResponse.status
      if (!responseStatusIsOk(sourcemapResponse)) {
        logger.warn(
          createUnexpectedResponseStatusMessage({
            responseStatus: sourcemapResponseStatus,
            href: resolvedSourceMappingURL,
          }),
        )
        return { code: source }
      }

      return { code: source, map: JSON.parse(sourcemapResponse.body) }
    },

    // resolveImportMeta: () => {}

    transform: async (source, rollupId) => {
      const sourceHref = rollupIdToHref(rollupId)

      if (arrayOfHrefToSkipTransform.includes(sourceHref)) {
        return null
      }

      const transform = async () => {
        const { code, map } = await transformJs({
          source,
          sourceHref,
          projectPathname,
          babelPluginMap,
          convertMap,
          // false, rollup will take care to transform module into whatever format
          transformModuleIntoSystemFormat: false,
        })
        return { code, map }
      }

      if (!cache || !sourceHref.startsWith(`file://${projectPathname}/`)) {
        return transform()
      }

      const sourcePathname = hrefToPathname(sourceHref)
      const sourceRelativePath = pathnameToRelativePath(sourcePathname, projectPathname)

      const { compileResult } = await getOrGenerateCompiledFile({
        projectPathname,
        compileCacheFolderRelativePath,
        sourceRelativePath,
        compile: async () => {
          const transformResult = await transform()
          return transformResultToCompilationResult(transformResult, {
            source,
            sourceHref,
            projectPathname,
          })
        },
      })

      return compilationResultToTransformResult(compileResult)
    },

    renderChunk: (source) => {
      if (!minify) return null

      // https://github.com/terser-js/terser#minify-options
      const minifyOptions = format === "global" ? { toplevel: false } : { toplevel: true }
      const result = minifyCode(source, {
        sourceMap: true,
        ...minifyOptions,
      })
      if (result.error) {
        throw result.error
      } else {
        return result
      }
    },

    writeBundle: async (bundle) => {
      if (detectAndTransformIfNeededAsyncInsertedByRollup) {
        await transformAsyncInsertedByRollup({
          projectPathname,
          bundleIntoRelativePath,
          babelPluginMap,
          bundle,
        })
      }

      Object.keys(bundle).forEach((bundleFilename) => {
        logger.info(`-> ${projectPathname}${bundleIntoRelativePath}/${bundleFilename}`)
      })
    },
  }

  const markHrefAsAbstract = (href) => {
    if (!arrayOfAbstractHref.includes(href)) {
      arrayOfAbstractHref.push(href)
    }
  }

  const generateAbstractSourceForImport = async (href, generateSource) => {
    markHrefAsAbstract(href)

    const returnValue = await generateSource()

    if (typeof returnValue === "string") {
      return { code: returnValue }
    }

    const { skipTransform, code, map } = returnValue

    if (skipTransform) {
      arrayOfHrefToSkipTransform.push(href)
    }
    return { code, map }
  }

  const rollupIdToHref = (rollupId) => {
    if (isWindowsPath(rollupId)) {
      return `file://${operatingSystemPathToPathname(rollupId)}`
    }

    if (hrefToScheme(rollupId)) {
      return rollupId
    }

    return `file://${operatingSystemPathToPathname(rollupId)}`
  }

  const fetchHref = async (href) => {
    // this code allow you to have http/https dependency for convenience
    // but maybe we should warn about this.
    // it could also be vastly improved using a basic in memory cache
    if (href.startsWith("http://")) {
      const response = await fetchUsingHttp(href, { cancellationToken })
      return response
    }

    if (href.startsWith("https://")) {
      const response = await fetchUsingHttp(href, { cancellationToken })
      return response
    }

    if (href.startsWith("file:///")) {
      try {
        const code = await createOperation({
          cancellationToken,
          start: () => fileRead(pathnameToOperatingSystemPath(hrefToPathname(href))),
        })
        return {
          status: 200,
          body: code,
        }
      } catch (e) {
        if (e.code === "ENOENT") {
          return {
            status: 404,
          }
        }
        return {
          status: 500,
        }
      }
    }

    throw new Error(`unsupported href: ${href}`)
  }

  return {
    jsenvRollupPlugin,
    getArrayOfAbstractHref,
  }
}

const responseStatusIsOk = (responseStatus) => responseStatus >= 200 && responseStatus < 300

const createFileNotFoundForImportMessage = ({
  path,
  specifier,
  importer,
}) => `import file not found.
--- path ---
${path}
--- specifier ---
${specifier}
--- importer ---
${importer}`

const createUnexpectedStatsForImportMessage = ({
  path,
  stats,
  specifier,
  importer,
}) => `unexpected import file stats.
--- path ---
${path}
--- found ---
${stats.isDirectory()} ? 'directory' : 'not-a-file'
--- specifier ---
${specifier}
--- importer ---
${importer}`

const createUnexpectedResponseStatusMessage = ({
  responseStatus,
  href,
}) => `unexpected response status.
--- response status ---
${responseStatus}
--- href ---
${href}`

const createMustBeInsideProjectMessage = ({ href, specifier, importer, projectPathname }) => `
source must be inside project.
--- href ---
${href}
--- specifier ---
${specifier}
--- importer ---
${importer}
--- project path ---
${pathnameToOperatingSystemPath(projectPathname)}`

const createImporterOutsideProjectError = ({ importer, projectPathname }) =>
  new Error(`importer must be inside project
  importer: ${importer}
  project: ${pathnameToOperatingSystemPath(projectPathname)}`)

const transformAsyncInsertedByRollup = async ({
  projectPathname,
  bundleIntoRelativePath,
  babelPluginMap,
  bundle,
}) => {
  const bundleFolderPathname = `${projectPathname}${bundleIntoRelativePath}`
  const asyncPluginName = findAsyncPluginNameInBabelPluginMap(babelPluginMap)

  if (!asyncPluginName) return

  // we have to do this because rollup ads
  // an async wrapper function without transpiling it
  // if your bundle contains a dynamic import
  await Promise.all(
    Object.keys(bundle).map(async (bundleFilename) => {
      const bundleInfo = bundle[bundleFilename]

      const { code, map } = await transformJs({
        projectPathname,
        source: bundleInfo.code,
        sourceHref: `file://${operatingSystemPathToPathname(bundleFilename)}`,
        sourceMap: bundleInfo.map,
        babelPluginMap: { [asyncPluginName]: babelPluginMap[asyncPluginName] },
        transformModuleIntoSystemFormat: false, // already done by rollup
        transformGenerator: false, // already done
      })

      await Promise.all([
        fileWrite(
          pathnameToOperatingSystemPath(`${bundleFolderPathname}/${bundleFilename}`),
          writeSourceMappingURL(code, `./${bundleFilename}.map`),
        ),
        fileWrite(
          pathnameToOperatingSystemPath(`${bundleFolderPathname}/${bundleFilename}.map`),
          JSON.stringify(map),
        ),
      ])
    }),
  )
}