@huzan/hz-lib/scripts/publish.js

'use strict'

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

const shell = require('shelljs')
const {join} = require('path')
const spawn = require('cross-spawn')
const signale = require('signale')
const inquirer = require('inquirer')
const constants = require('../config/constants')
const {runForPkgs} = require('../config/build')
const {findPkgs} = require('../config/utils')
const getUserConfig = require('../config/get-user-config')

function getUpdatedRepos(lernaPath, args = '') {
    const ret = shell.exec(`${lernaPath} changed --include-merged-tags ${args}`, {silent: false})
        .stdout

    return ret
        .split('\n')
        .map((line) => line.replace('- ', ''))
        .filter((line) => line !== '')
}

async function publish({cwd = process.cwd()}) {
    // if (
    //     !shell
    //         .exec('npm config get registry', {silent: true})
    //         .stdout.includes('https://registry.npmjs.org/')
    // ) {
    //     signale.error('Failed: set npm registry to https://registry.npmjs.org/ first')
    //     process.exit(1)
    // }

    const user = shell.exec('npm whoami --registry https://registry.npmjs.org/', {silent: true})
        .stdout

    if (user.trim() !== constants.username) {
        signale.error(`
            npm账号不对，请用公司账号登录
        `)
        process.exit(1)
    }

    const lernaPath = join(__dirname, '../node_modules/.bin/lerna')
    const updatedRepos = getUpdatedRepos(lernaPath)
    const rootUserConfig = getUserConfig({cwd})

    const forceUpdatePkgs = []
    const publishPkgNames = []

    const pkgs = findPkgs({
        cwd,
        packagesPatterns: rootUserConfig.packagesPatterns,
        ignoreNoBuild: false,
        cb: (pkg) => {
            const {pkgPath} = pkg
            const {pkgJson} = pkg
            const userConfig = getUserConfig({cwd: pkgPath})

            if (pkgJson && !userConfig.noPublish) {
                const update = updatedRepos.findIndex((repo) => repo === pkgJson.name) > -1

                if (update) {
                    publishPkgNames.push(pkgJson.name)
                } else {
                    forceUpdatePkgs.push({
                        name: pkgJson.name,
                        value: pkgJson.name,
                        version: pkgJson.version,
                        pkgPath,
                        pkgJson,
                        update,
                    })
                }
            }
            pkg.name = pkg.pkgJson.name

            return pkg
        },
    })

    if (publishPkgNames.length) {
        signale.info(`有改动的包: ${publishPkgNames.join(', ')}`)
    } else {
        signale.info(`没有改动的包`)
    }

    let forceUpdateNames = []

    if (forceUpdatePkgs.length) {
        const res = await inquirer.prompt([
            {
                name: 'isForceUpdate',
                message: `是否需要强制更新包`,
                default: false,
                type: 'confirm',
            },
            {
                name: 'forceUpdateNames',
                message: `选择强制更新的包`,
                type: 'checkbox',
                choices: forceUpdatePkgs,
                when: (answers) => answers.isForceUpdate,
            },
        ])

        forceUpdateNames = res.forceUpdateNames || []
    }

    let publishRepos = []

    if (forceUpdateNames.length) {
        publishRepos = getUpdatedRepos(lernaPath, `--force-publish=${forceUpdateNames.join(',')}`)
    } else {
        publishRepos = getUpdatedRepos(lernaPath)
    }

    if (!publishRepos.length) {
        signale.warn('没有要更新的包')
        process.exit(1)
    }
    const publishPackages = []

    pkgs.forEach((pkg) => {
        const index = publishRepos.indexOf(pkg.name)
        if (index > -1) {
            publishPackages.push(pkg)
        }
    })

    try {
        await runForPkgs({
            cwd,
            watch: false,
            pkgs: publishPackages,
            rootUserConfig,
        })
    } catch (e) {
        signale.error(e)
        process.exit(1)
    }

    const {useConventionalCommits} = await inquirer.prompt({
        message: '是否使用常规提交',
        default: true,
        type: 'confirm',
        name: 'useConventionalCommits',
    })

    const versionArgs = ['publish', '--include-merged-tags']

    if (useConventionalCommits) {
        versionArgs.push('--conventional-commits')
    }

    if (publishRepos.length) {
        versionArgs.push(`--force-publish=${publishRepos.join(',')}`)
    }

    signale.info(`要发布的包: ${publishRepos.join(', ')}`)
    const cp = spawn(lernaPath, versionArgs, {
        stdio: 'inherit',
        cwd,
    })
    cp.on('error', (err) => {
        signale.error(err)
    })
    cp.on('close', async (code) => {
        signale.info('code', code)
        if (code === 1) {
            signale.error('Failed: lerna publish')
            process.exit(1)
        }

        const {isSyncTaobao} = await inquirer.prompt({
            message: '是否同步淘宝源',
            default: true,
            type: 'confirm',
            name: 'isSyncTaobao',
        })

        if (isSyncTaobao) {
            syncTaobao(publishRepos, cwd)
        }
    })
}

function syncTaobao(publishRepos = [], cwd = process.cwd()) {
    if (!publishRepos.length) {
        signale.error('not find publishRepos')
        process.exit(1)
    }

    signale.info(`同步淘宝源: ${publishRepos.join(', ')}`)

    const cnpmPath = join(__dirname, '../node_modules/.bin/cnpm')

    const {status, error} = spawn.sync(cnpmPath, ['sync', ...publishRepos], {
        stdio: 'inherit',
        cwd,
    })

    if (status === 1) {
        signale.error(error || 'sync error')
        process.exit(1)
    }

    signale.success('同步成功')
}

// function publishToNpm(publishRepos) {
//     publishRepos.forEach((updatePkg) => {
//         shell.cd(updatePkg.pkgPath)
//         const {version} = updatePkg
//         if (version.includes('-rc.') || version.includes('-beta.') || version.includes('-alpha.')) {
//             signale.info(`[${updatePkg.value}] npm publish --tag next`)
//             shell.exec(`npm publish --tag next`)
//         } else {
//             signale.info(`[${updatePkg.value}] npm publish`)
//             shell.exec(`npm publish`)
//         }
//     })
// }

module.exports = publish