@jsenv/bundling/src/generate-bundle.js

/* eslint-disable import/max-dependencies */
import {
  operatingSystemPathToPathname,
  pathnameToOperatingSystemPath,
} from "@jsenv/operating-system-path"
import { generateGroupMap } from "@jsenv/core"
import {
  catchAsyncFunctionCancellation,
  createProcessInterruptionCancellationToken,
} from "@dmail/cancellation"
import { jsenvBundlingRelativePathInception } from "./jsenv-bundling-project.js"
import { assertFile, assertFolder } from "./filesystem-assertions.js"
import { bundleWithoutBalancing } from "./bundle-without-balancing.js"
import { bundleWithBalancing } from "./bundle-with-balancing.js"
import { bundleBalancer } from "./bundle-balancer.js"
import { removeFolder } from "./removeFolder.js"
import {
  DEFAULT_IMPORT_MAP_RELATIVE_PATH,
  DEFAULT_ENTRY_POINT_MAP,
  DEFAULT_NATIVE_MODULE_PREDICATE,
  DEFAULT_BABEL_PLUGIN_MAP,
  DEFAULT_PLATFORM_SCORE_MAP,
} from "./generate-bundle-constant.js"

export const generateBundle = ({
  projectPath,
  bundleIntoRelativePath,
  cleanBundleInto = false,
  cache = false,
  cacheRelativePath = "/.cache",
  importDefaultExtension,
  importMapRelativePath = DEFAULT_IMPORT_MAP_RELATIVE_PATH,
  importMapForBundle = {},
  importAbstractMap = {},
  importFallbackMap = {},
  nativeModulePredicate = DEFAULT_NATIVE_MODULE_PREDICATE,
  entryPointMap = DEFAULT_ENTRY_POINT_MAP,
  babelPluginMap = DEFAULT_BABEL_PLUGIN_MAP,
  convertMap,
  logLevel,
  minify = false,
  writeOnFileSystem = true,
  throwUnhandled = true,
  format,
  formatOutputOptions = {},
  // balancing
  compileGroupCount = 1,
  platformAlwaysInsidePlatformScoreMap,
  balancerTemplateRelativePath,
  defaultBalancerTemplateHref,
  balancerDataAbstractPath,
  platformScoreMap = DEFAULT_PLATFORM_SCORE_MAP,
}) => {
  const promise = catchAsyncFunctionCancellation(async () => {
    if (typeof projectPath !== "string")
      throw new TypeError(`projectPath must be a string, got ${projectPath}`)
    if (typeof bundleIntoRelativePath !== "string")
      throw new TypeError(`bundleIntoRelativePath must be a string, got ${bundleIntoRelativePath}`)
    if (typeof entryPointMap !== "object")
      throw new TypeError(`entryPointMap must be an object, got ${entryPointMap}`)
    if (typeof compileGroupCount !== "number")
      throw new TypeError(`compileGroupCount must be a number, got ${compileGroupCount}`)
    if (compileGroupCount < 1)
      throw new Error(`compileGroupCount must be >= 1, got ${compileGroupCount}`)

    const cancellationToken = createProcessInterruptionCancellationToken()
    const projectPathname = operatingSystemPathToPathname(projectPath)

    await assertFolder(projectPath)

    if (cleanBundleInto) {
      await removeFolder(
        pathnameToOperatingSystemPath(`${projectPathname}${bundleIntoRelativePath}`),
      )
    }

    if (compileGroupCount === 1) {
      return bundleWithoutBalancing({
        cancellationToken,
        projectPathname,
        bundleIntoRelativePath,
        cache,
        cacheRelativePath,
        importDefaultExtension,
        importMapRelativePath,
        importMapForBundle,
        importAbstractMap,
        importFallbackMap,
        nativeModulePredicate,
        entryPointMap,
        babelPluginMap,
        convertMap,
        minify,
        logLevel,
        format,
        formatOutputOptions,
        writeOnFileSystem,
      })
    }

    if (typeof balancerTemplateRelativePath === "undefined") {
      if (!defaultBalancerTemplateHref) {
        throw createFormatIncompatibleWithBalancingError({ format })
      }
      balancerTemplateRelativePath = jsenvBundlingRelativePathInception({
        jsenvBundlingRelativePath: defaultBalancerTemplateHref,
        projectPathname,
      })
    }
    const balancerTemplatePathname = `${projectPathname}${balancerTemplateRelativePath}`
    const balancerTemplateHref = `file://${balancerTemplatePathname}`

    await assertFile(pathnameToOperatingSystemPath(balancerTemplatePathname))

    const groupMap = generateGroupMap({
      babelPluginMap,
      platformScoreMap,
      groupCount: compileGroupCount,
      platformAlwaysInsidePlatformScoreMap,
    })

    return await Promise.all([
      generateEntryPointsFolders({
        cancellationToken,
        projectPathname,
        bundleIntoRelativePath,
        cache,
        cacheRelativePath,
        importDefaultExtension,
        importMapRelativePath,
        importMapForBundle,
        importAbstractMap,
        importFallbackMap,
        nativeModulePredicate,
        entryPointMap,
        babelPluginMap,
        convertMap,
        minify,
        logLevel,
        writeOnFileSystem,
        format,
        formatOutputOptions,
        groupMap,
      }),
      generateEntryPointsBalancerFiles({
        cancellationToken,
        projectPathname,
        bundleIntoRelativePath,
        cache,
        cacheRelativePath,
        importDefaultExtension,
        importMapRelativePath,
        importMapForBundle,
        importAbstractMap,
        importFallbackMap,
        nativeModulePredicate,
        entryPointMap,
        babelPluginMap,
        convertMap,
        minify,
        logLevel,
        writeOnFileSystem,
        format,
        balancerTemplateHref,
        balancerDataAbstractPath,
        groupMap,
      }),
    ])
  })

  if (!throwUnhandled) return promise
  return promise.catch((e) => {
    setTimeout(() => {
      throw e
    })
  })
}

const generateEntryPointsFolders = async ({
  cancellationToken,
  projectPathname,
  bundleIntoRelativePath,
  cache,
  cacheRelativePath,
  importDefaultExtension,
  importMapRelativePath,
  importMapForBundle,
  importAbstractMap,
  importFallbackMap,
  nativeModulePredicate,
  entryPointMap,
  babelPluginMap,
  convertMap,
  minify,
  logLevel,
  writeOnFileSystem,
  format,
  formatOutputOptions,
  groupMap,
}) =>
  Promise.all(
    Object.keys(groupMap).map(async (compileId) =>
      bundleWithBalancing({
        cancellationToken,
        projectPathname,
        bundleIntoRelativePath,
        cache,
        cacheRelativePath,
        importDefaultExtension,
        importMapRelativePath,
        importMapForBundle,
        importAbstractMap,
        importFallbackMap,
        nativeModulePredicate,
        entryPointMap,
        babelPluginMap,
        convertMap,
        minify,
        logLevel,
        format,
        formatOutputOptions,
        groupMap,
        compileId,
        writeOnFileSystem,
      }),
    ),
  )

const generateEntryPointsBalancerFiles = ({
  cancellationToken,
  projectPathname,
  bundleIntoRelativePath,
  cache,
  cacheRelativePath,
  importDefaultExtension,
  importMapRelativePath,
  importMapForBundle,
  importAbstractMap,
  importFallbackMap,
  nativeModulePredicate,
  entryPointMap,
  babelPluginMap,
  convertMap,
  minify,
  logLevel,
  writeOnFileSystem,
  format,
  balancerTemplateHref,
  balancerDataAbstractPath,
  groupMap,
}) =>
  Promise.all(
    Object.keys(entryPointMap).map(async (entryPointName) =>
      bundleBalancer({
        cancellationToken,
        projectPathname,
        bundleIntoRelativePath,
        cache,
        cacheRelativePath,
        importDefaultExtension,
        importMapRelativePath,
        importMapForBundle,
        importAbstractMap,
        importFallbackMap,
        nativeModulePredicate,
        entryPointMap: {
          [entryPointName]: balancerTemplateHref,
        },
        babelPluginMap,
        convertMap,
        minify,
        logLevel,
        format,
        balancerDataAbstractPath,
        groupMap,
        writeOnFileSystem,
      }),
    ),
  )

const createFormatIncompatibleWithBalancingError = ({ format }) =>
  new Error(`format not compatible with balancing.
format: ${format}`)