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

import {
  operatingSystemPathToPathname,
  pathnameToOperatingSystemPath,
} from "@jsenv/operating-system-path"
import { generateGroupMap } from "@jsenv/grouping"
import {
  catchAsyncFunctionCancellation,
  createProcessInterruptionCancellationToken,
} from "@dmail/cancellation"
import { LOG_LEVEL_ERRORS_WARNINGS_AND_LOGS } from "./logger.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,
  importMapRelativePath = DEFAULT_IMPORT_MAP_RELATIVE_PATH,
  importDefaultExtension,
  importMapForBundle,
  specifierMap,
  specifierDynamicMap,
  nativeModulePredicate = DEFAULT_NATIVE_MODULE_PREDICATE,
  entryPointMap = DEFAULT_ENTRY_POINT_MAP,
  babelPluginMap = DEFAULT_BABEL_PLUGIN_MAP,
  convertMap,
  logLevel = LOG_LEVEL_ERRORS_WARNINGS_AND_LOGS,
  minify = false,
  writeOnFileSystem = true,
  throwUnhandled = true,
  format,
  formatOutputOptions = {},
  // balancing
  compileGroupCount = 1,
  platformAlwaysInsidePlatformScoreMap,
  balancerTemplateRelativePath,
  balancerDataClientPathname,
  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)

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

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

    if (!balancerTemplateRelativePath) {
      throw createFormatIncompatibleWithBalancingError({ format })
    }

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

    return await Promise.all([
      generateEntryPointsFolders({
        cancellationToken,
        projectPathname,
        bundleIntoRelativePath,
        importDefaultExtension,
        importMapRelativePath,
        importMapForBundle,
        specifierMap,
        specifierDynamicMap,
        nativeModulePredicate,
        entryPointMap,
        babelPluginMap,
        convertMap,
        minify,
        logLevel,
        writeOnFileSystem,
        format,
        formatOutputOptions,
        groupMap,
      }),
      generateEntryPointsBalancerFiles({
        cancellationToken,
        projectPathname,
        bundleIntoRelativePath,
        importDefaultExtension,
        importMapRelativePath,
        importMapForBundle,
        specifierMap,
        specifierDynamicMap,
        nativeModulePredicate,
        entryPointMap,
        babelPluginMap,
        convertMap,
        minify,
        logLevel,
        writeOnFileSystem,
        format,
        balancerTemplateRelativePath,
        balancerDataClientPathname,
        groupMap,
      }),
    ])
  })

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

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

const generateEntryPointsBalancerFiles = ({
  cancellationToken,
  projectPathname,
  bundleIntoRelativePath,
  importDefaultExtension,
  importMapRelativePath,
  importMapForBundle,
  specifierMap,
  specifierDynamicMap,
  nativeModulePredicate,
  entryPointMap,
  babelPluginMap,
  convertMap,
  minify,
  logLevel,
  writeOnFileSystem,
  format,
  balancerTemplateRelativePath,
  balancerDataClientPathname,
  groupMap,
}) =>
  Promise.all(
    Object.keys(entryPointMap).map(async (entryPointName) =>
      bundleBalancer({
        cancellationToken,
        projectPathname,
        bundleIntoRelativePath,
        importDefaultExtension,
        importMapRelativePath,
        importMapForBundle,
        specifierMap,
        specifierDynamicMap,
        nativeModulePredicate,
        entryPointMap: {
          [entryPointName]: balancerTemplateRelativePath,
        },
        babelPluginMap,
        convertMap,
        minify,
        logLevel,
        format,
        balancerDataClientPathname,
        groupMap,
        writeOnFileSystem,
      }),
    ),
  )

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