index.ts

import path from 'path'
import fs from 'fs'
import { Worker } from 'worker_threads'
import type { MarkRequired } from 'ts-essentials'
import { removeFiles, debouncePromise } from './utils'
import { loadTsupConfig, resolveTsConfig } from './load'
import glob from 'globby'
import { handleError, PrettyError } from './errors'
import resolveFrom from 'resolve-from'
import { parseArgsStringToArgv } from 'string-argv'
import type { ChildProcess } from 'child_process'
import execa from 'execa'
import kill from 'tree-kill'
import { version } from '../package.json'
import { createLogger, setSilent } from './log'
import { DtsConfig, Format, Options } from './options'
import { runEsbuild } from './esbuild'

export type { Format, Options }

export type NormalizedOptions = Omit<
  MarkRequired<Options, 'entryPoints' | 'format' | 'outDir'>,
  'dts'
> & {
  dts?: DtsConfig
}

export const defineConfig = (
  options:
    | Options
    | Options[]
    | ((
        /** The options derived from CLI flags */
        overrideOptions: Options
      ) => Options | Options[])
) => options

const killProcess = ({
  pid,
  signal = 'SIGTERM',
}: {
  pid: number
  signal?: string | number
}) =>
  new Promise<unknown>((resolve) => {
    kill(pid, signal, resolve)
  })

const normalizeOptions = async (
  logger: ReturnType<typeof createLogger>,
  optionsFromConfigFile: Options | undefined,
  optionsOverride: Options
) => {
  const options: Options = {
    ...optionsFromConfigFile,
    ...optionsOverride,
  }

  setSilent(options.silent)

  const input = options.entryPoints

  if (!input || Object.keys(input).length === 0) {
    throw new PrettyError(`No input files, try "tsup <your-file>" instead`)
  }

  if (Array.isArray(input)) {
    options.entryPoints = await glob(input)
    // Ensure entry exists
    if (!options.entryPoints || options.entryPoints.length === 0) {
      throw new PrettyError(`Cannot find ${input}`)
    } else {
      logger.info('CLI', `Building entry: ${options.entryPoints.join(', ')}`)
    }
  } else {
    Object.keys(input).forEach((alias) => {
      const filename = input[alias]!
      if (!fs.existsSync(filename)) {
        throw new PrettyError(`Cannot find ${alias}: ${filename}`)
      }
    })
    logger.info('CLI', `Building entry: ${JSON.stringify(input)}`)
  }

  options.outDir = options.outDir || 'dist'

  // Build in cjs format by default
  if (!options.format) {
    options.format = ['cjs']
  }

  const tsconfig = await resolveTsConfig(process.cwd(), options.tsconfig)
  if (tsconfig) {
    logger.info(
      'CLI',
      `Using tsconfig: ${path.relative(process.cwd(), tsconfig)}`
    )
    options.tsconfig = tsconfig
  } else if (options.tsconfig) {
    throw new PrettyError(`Cannot find tsconfig: ${options.tsconfig}`)
  }

  if (!options.target) {
    options.target = 'node12'
  }

  if (options.dts === true) {
    options.dts = {}
  } else if (typeof options.dts === 'string') {
    options.dts = { entry: options.dts }
  }

  return options as NormalizedOptions
}

export async function build(_options: Options) {
  const config =
    _options.config === false ? {} : await loadTsupConfig(process.cwd())

  const configData =
    typeof config.data === 'function' ? config.data(_options) : config.data

  await Promise.all(
    [...(Array.isArray(configData) ? configData : [configData])].map(
      async (item) => {
        const logger = createLogger(item?.name)
        const options = await normalizeOptions(logger, item, _options)

        logger.info('CLI', `tsup v${version}`)

        if (config.path) {
          logger.info('CLI', `Using tsup config: ${config.path}`)
        }

        if (options.watch) {
          logger.info('CLI', 'Running in watch mode')
        }

        if (!options.dts?.only) {
          let existingOnSuccess: ChildProcess | undefined

          async function killPreviousProcess() {
            if (existingOnSuccess) {
              await killProcess({
                pid: existingOnSuccess.pid,
              })
              existingOnSuccess = undefined
            }
          }

          const debouncedBuildAll = debouncePromise(
            () => {
              return buildAll()
            },
            100,
            handleError
          )

          const buildAll = async () => {
            const killPromise = killPreviousProcess()

            if (options.clean) {
              const extraPatterns = Array.isArray(options.clean)
                ? options.clean
                : []
              await removeFiles(
                ['**/*', '!**/*.d.ts', ...extraPatterns],
                options.outDir
              )
              logger.info('CLI', 'Cleaning output folder')
            }

            const css: Map<string, string> = new Map()
            await Promise.all([
              ...options.format.map((format, index) =>
                runEsbuild(options, {
                  format,
                  css: index === 0 ? css : undefined,
                  logger,
                })
              ),
            ])
            await killPromise
            if (options.onSuccess) {
              const parts = parseArgsStringToArgv(options.onSuccess)
              const exec = parts[0]
              const args = parts.splice(1)
              existingOnSuccess = execa(exec, args, {
                stdio: 'inherit',
              })
            }
          }

          const startWatcher = async () => {
            if (!options.watch) return

            const { watch } = await import('chokidar')

            const customIgnores = options.ignoreWatch
              ? Array.isArray(options.ignoreWatch)
                ? options.ignoreWatch
                : [options.ignoreWatch]
              : []

            const ignored = [
              '**/{.git,node_modules}/**',
              options.outDir,
              ...customIgnores,
            ]

            const watchPaths =
              typeof options.watch === 'boolean'
                ? '.'
                : Array.isArray(options.watch)
                ? options.watch.filter(
                    (path): path is string => typeof path === 'string'
                  )
                : options.watch

            logger.info(
              'CLI',
              `Watching for changes in ${
                Array.isArray(watchPaths)
                  ? watchPaths.map((v) => '"' + v + '"').join(' | ')
                  : '"' + watchPaths + '"'
              }`
            )
            logger.info(
              'CLI',
              `Ignoring changes in ${ignored
                .map((v) => '"' + v + '"')
                .join(' | ')}`
            )

            const watcher = watch(watchPaths, {
              ignoreInitial: true,
              ignorePermissionErrors: true,
              ignored,
            })
            watcher.on('all', async (type, file) => {
              logger.info('CLI', `Change detected: ${type} ${file}`)
              debouncedBuildAll()
            })
          }

          logger.info('CLI', `Target: ${options.target}`)

          await buildAll()

          startWatcher()
        }

        if (options.dts) {
          const hasTypescript = resolveFrom.silent(process.cwd(), 'typescript')
          if (!hasTypescript) {
            throw new Error(`You need to install "typescript" in your project`)
          }

          const worker = new Worker(path.join(__dirname, './rollup.js'))
          worker.postMessage({
            configName: item?.name,
            options: {
              ...options, // functions cannot be cloned
              esbuildPlugins: undefined,
              esbuildOptions: undefined,
            },
          })
          worker.on('message', (data) => {
            if (data === 'error') {
              process.exitCode = 1
            } else if (data === 'success') {
              process.exitCode = 0
            }
          })
        }
      }
    )
  )
}