@huzan/hz-lib/config/build.js

'use strict'

/**
 * 文件说明:
 * ----------------------------------------
 * 创建用户: leo
 * 创建日期 2019/1/3
 */

const {existsSync, readdirSync, statSync} = require('fs')
const {join} = require('path')
const rimraf = require('rimraf')
const assert = require('assert')
const {merge, get} = require('lodash')
const signale = require('signale')
const chalk = require('chalk')
const inquirer = require('inquirer')
const {fork} = require('child_process')
const {babelBuild} = require('./babel')
const rollup = require('./rollup')
const {getExistFile, findPkgs, getConfig} = require('./utils')
const getUserConfig = require('./get-user-config')
const constants = require('./constants')

function getBundleOpts(opts) {
    const {cwd, buildArgs = {}} = opts
    const entry = getExistFile({
        cwd,
        files: ['src/index.tsx', 'src/index.ts', 'src/index.jsx', 'src/index.js'],
        returnRelative: true,
    })
    const userConfig = getUserConfig({cwd})
    const userConfigs = Array.isArray(userConfig) ? userConfig : [userConfig]

    return userConfigs.map((config) => {
        const bundleOpts = merge(
            {
                entry,
            },
            buildArgs,
            config,
        )

        if (typeof bundleOpts.esm === 'string') {
            bundleOpts.esm = {type: bundleOpts.esm}
        }
        if (typeof bundleOpts.cjs === 'string') {
            bundleOpts.cjs = {type: bundleOpts.cjs}
        }

        return bundleOpts
    })
}

let workers = []

function forkRollupBuild(option, pkg) {
    return new Promise((resolve, reject) => {
        try {
            const child = fork(join(__dirname, './fork-rollup.js'))

            child.on('exit', (code) => {
                if (code === 1) {
                    reject(
                        new Error(`[forkRollupBuild: ${pkg} type: ${option.type}] exit: ${code}`),
                    )
                } else {
                    signale.info(`[forkRollupBuild: ${pkg} type: ${option.type}] exit: ${code}`)
                    resolve()
                }
            })

            child.on('error', (code) => {
                reject(new Error(`[forkRollupBuild: ${pkg} type: ${option.type}] error: ${code}`))
            })

            child.on('close', (code) => {
                if (code === 1) {
                    reject(
                        new Error(`[forkRollupBuild: ${pkg} type: ${option.type}] close: ${code}`),
                    )
                } else {
                    signale.info(`[forkRollupBuild: ${pkg} type: ${option.type}] close: ${code}`)
                    resolve()
                }
            })

            signale.info(`[forkRollupBuild: ${pkg} type: ${option.type}] forked`)

            child.send(option)

            workers.push(child)
        } catch (e) {
            signale.error(e)
            process.exit()
        }
    })
}

process.on('SIGINT', () => {
    process.exit()
})

process.on('exit', () => {
    workers.forEach((worker) => {
        try {
            worker.kill()
        } catch (e) {
            signale.error('exit', e)
        }
    })

    workers = null
})

process.on('error', () => {
    workers.forEach((worker) => {
        try {
            worker.kill()
        } catch (e) {
            signale.error('error', e)
        }
    })

    workers = null
})

function validateBundleOpts(bundleOpts, {cwd, rootPath}) {
    if (bundleOpts.cjs && bundleOpts.cjs.lazy && bundleOpts.cjs.type === 'rollup') {
        throw new Error(
            `
                cjs.lazy don't support rollup.
            `.trim(),
        )
    }
    if (!bundleOpts.esm && !bundleOpts.cjs && !bundleOpts.umd) {
        throw new Error(
            `
                None format of ${chalk.cyan('cjs | esm | umd')} is configured
            `.trim(),
        )
    }
    if (bundleOpts.entry) {
        const tsConfigPath = join(cwd, 'tsconfig.json')
        const tsConfig =
            existsSync(tsConfigPath) || (rootPath && existsSync(join(rootPath, 'tsconfig.json')))
        if (
            !tsConfig &&
            ((Array.isArray(bundleOpts.entry) && bundleOpts.entry.some(isTypescriptFile)) ||
                (!Array.isArray(bundleOpts.entry) && isTypescriptFile(bundleOpts.entry)))
        ) {
            signale.info(
                `Project using ${chalk.cyan(
                    'typescript',
                )} but tsconfig.json not exists. Use default config.`,
            )
        }
    }
}

function isTypescriptFile(filePath) {
    return filePath.endsWith('.ts') || filePath.endsWith('.tsx')
}

async function build(opts, extraOpts = {}) {
    const {cwd, watch, rootPath, targetDir = 'lib/'} = opts
    const {pkg} = extraOpts

    function log(msg) {
        signale.info(`${pkg ? `[${pkg}] ` : ''}${msg}`)
    }

    const bundleOptsArray = getBundleOpts(opts)
    const buildArr = []

    for (const bundleOpts of bundleOptsArray) {
        validateBundleOpts(bundleOpts, {cwd, rootPath})

        log(`Clean ${targetDir} directory`)
        rimraf.sync(join(cwd, targetDir))

        if (bundleOpts.umd) {
            log('Build umd')
            buildArr.push(
                rollup({
                    cwd,
                    type: 'umd',
                    targetDir,
                    entry: bundleOpts.entry,
                    watch,
                    bundleOpts,
                }),
            )
        }

        if (bundleOpts.cjs) {
            const {cjs} = bundleOpts
            log(`Build cjs with ${cjs.type}`)
            if (cjs.type === 'babel') {
                buildArr.push(
                    babelBuild({
                        cwd,
                        watch,
                        rootPath,
                        type: 'cjs',
                        bundleOpts,
                        libTargetDir: bundleOpts.libTargetDir,
                    }),
                )
            } else {
                const option = {
                    cwd,
                    type: 'cjs',
                    targetDir,
                    entry: bundleOpts.entry,
                    watch,
                    bundleOpts,
                }

                if (get(bundleOpts, 'cjs.forkRollupBuild')) {
                    buildArr.push(forkRollupBuild(option, pkg))
                } else {
                    buildArr.push(rollup(option))
                }
            }
        }

        if (bundleOpts.esm) {
            const {esm} = bundleOpts
            log(`Build esm with ${esm.type}`)
            if (esm && esm.type === 'babel') {
                buildArr.push(
                    babelBuild({
                        cwd,
                        watch,
                        rootPath,
                        type: 'esm',
                        bundleOpts,
                        libTargetDir: bundleOpts.libTargetDir,
                    }),
                )
            } else {
                const option = {
                    cwd,
                    type: 'esm',
                    targetDir,
                    entry: bundleOpts.entry,
                    watch,
                    bundleOpts,
                }

                if (get(bundleOpts, 'esm.forkRollupBuild')) {
                    buildArr.push(forkRollupBuild(option, pkg))
                } else {
                    buildArr.push(rollup(option))
                }
            }
        }
    }

    await Promise.all(buildArr)
}

async function buildForLerna(opts) {
    const {cwd} = opts

    const userConfig = getUserConfig({cwd})
    const pkgs = readdirSync(join(opts.cwd, 'packages'))
    const buildArr = []

    for (const pkg of pkgs) {
        if (process.env.PACKAGE && pkg !== process.env.PACKAGE) continue
        const pkgPath = join(opts.cwd, 'packages', pkg)
        if (!statSync(pkgPath).isDirectory()) continue
        assert.ok(
            existsSync(join(pkgPath, 'package.json')),
            `package.json not found in packages/${pkg}`,
        )
        process.chdir(pkgPath)
        buildArr.push(
            build(
                {
                    ...opts,
                    buildArgs: merge(opts.buildArgs, userConfig),
                    cwd: pkgPath,
                    rootPath: cwd,
                },
                {
                    pkg,
                },
            ),
        )
    }

    await Promise.all(buildArr)
}

async function runForInquirer(opts) {
    const {cwd, defaultCheck = true} = opts

    const userConfig = getUserConfig({cwd})

    const pkgs = findPkgs({
        cwd,
        packagesPatterns: userConfig.packagesPatterns,
        cb: (pkg) => {
            pkg.checked = defaultCheck
            pkg.name = pkg.pkgJson.name
            pkg.value = pkg.pkgJson.name

            return pkg
        },
    })

    if (!pkgs.length) {
        signale.info('没有要编译的包')
        process.exit(0)
    }

    const {checkPkgs = []} = await inquirer.prompt([
        {
            name: 'checkPkgs',
            message: '选择要运行的包',
            type: 'checkbox',
            choices: pkgs,
        },
    ])

    if (!checkPkgs.length) {
        signale.error('没有要运行的包')
        process.exit(1)
    }

    const buildArr = []

    for (const checkPkgName of checkPkgs) {
        const pkg = pkgs.find((item) => item.name === checkPkgName)
        if (!statSync(pkg.pkgPath).isDirectory()) continue

        process.chdir(pkg.pkgPath)

        buildArr.push(
            build(
                {
                    ...opts,
                    buildArgs: merge(opts.buildArgs, userConfig),
                    cwd: pkg.pkgPath,
                    rootPath: cwd,
                },
                {
                    pkg: pkg.name,
                },
            ),
        )
    }

    await Promise.all(buildArr)
}

exports.runForInquirer = runForInquirer

async function runForLerna(opts) {
    const useLerna = existsSync(join(opts.cwd, 'lerna.json'))
    if (useLerna && process.env.LERNA !== 'none') {
        await buildForLerna(opts)
    } else {
        await build(opts)
    }
}

exports.runForLerna = runForLerna

async function runForPkgs(opts) {
    const {cwd, pkgs, rootUserConfig = getUserConfig({cwd})} = opts

    const runPkgs = []

    pkgs.forEach((pkg) => {
        if (get(pkg, 'pkgJson.hzLib.noBuild', false) !== true) {
            runPkgs.push(pkg)
        }
    })

    if (!runPkgs.length) {
        signale.info('没有要编译的包')

        return
    }

    const buildArr = []

    for (const pkg of runPkgs) {
        if (!statSync(pkg.pkgPath).isDirectory()) continue
        process.chdir(pkg.pkgPath)
        buildArr.push(
            build(
                {
                    ...opts,
                    buildArgs: merge(opts.buildArgs, rootUserConfig),
                    cwd: pkg.pkgPath,
                    rootPath: cwd,
                },
                {
                    pkg: pkg.name,
                },
            ),
        )
    }

    await Promise.all(buildArr)
}

exports.runForPkgs = runForPkgs

async function run(opts) {
    const {cwd} = opts

    const {runLibs = []} =
        getConfig({
            cwd,
            files: constants.localConfigFile,
            returnRelative: false,
        }) || {}

    if (runLibs.length) {
        const userConfig = getUserConfig({cwd})
        const pkgs = findPkgs({
            cwd,
            packagesPatterns: userConfig.packagesPatterns,
            cb: (pkg) => {
                pkg.name = pkg.pkgJson.name

                return pkg
            },
        })

        if (!pkgs.length) {
            signale.info('没有要编译的包')
            process.exit(0)
        }

        const buildArr = []

        for (const pkg of pkgs) {
            const index = runLibs.indexOf(pkg.name)
            if (index > -1 && statSync(pkg.pkgPath).isDirectory()) {
                process.chdir(pkg.pkgPath)
                buildArr.push(
                    build(
                        {
                            ...opts,
                            buildArgs: merge(opts.buildArgs, userConfig),
                            cwd: pkg.pkgPath,
                            rootPath: cwd,
                        },
                        {
                            pkg: pkg.name,
                        },
                    ),
                )
            }
        }

        await Promise.all(buildArr)
    } else {
        runForInquirer(opts)
    }
}

exports.run = run