meipian-common/lib/build.js

Meipian common lib developmaent evn

'use strict'

const path = require('path')
const ora = require('ora')
const chalk = require('chalk')
const webpack = require('webpack')
const merge = require('webpack-merge')
const { fspc, tool } = require('meipian-stage-tools')
const mpqiniu = require('meipian-qiniu')
const sassdoc = require('sassdoc')
const mpjsdoc = require('meipian-jsdoc')

//Webpack base config. 
const base = require('./base')

//Meipian.config.js for config's value.
const config = merge({
  isReport: false,
  strict: true,
  isVersion: false
}, base.buildConfig)
const baseWebpack = base.webpack
const packageConfig = base.package

const spinner = ora('  Project version start to build……\n').start()
const CDN_PATH = 'cdn'
const cdnURl = []

if (config.strict) {
  if (!config.domains.cdn) {
    spinner.stop()
    console.log(chalk.red([
      'You must set the url of the CDN'
    ].join('')))
    return
  } else {
    cdnURl.push(config.domains.cdn, CDN_PATH)
  }

  if (!tool.isProjectType(packageConfig.projectTypeName)) {
    spinner.stop()
    console.log(chalk.red([
      'The project type\'s name field in package.json to set: ',
      tool.projectTypeNames().split(',').join(' || ')
    ].join('')))
    return
  } else {
    cdnURl.push(packageConfig.projectTypeName)
  }

  if (!tool.isPlatform(packageConfig.platform)) {
    spinner.stop()
    console.log(chalk.red([
      'The platform field in package.json to set: ',
      tool.platformNames().split(',').join(' || ')
    ].join('')))
    return
  } else {

    if ('all' !== packageConfig.platform) {
      cdnURl.push(packageConfig.platform)
    }
  }

  if (!packageConfig.name) {
    spinner.stop()
    console.log(chalk.red('You must set the project name'))
    return
  } else {
    cdnURl.push(packageConfig.name)
  }

  //Is publish version
  if (config.isVersion) {
    if (!(packageConfig.version)) {
      spinner.stop()
      console.log(chalk.red('You must set the project version'))
      return
    } else {
      cdnURl.push(packageConfig.version)
    }
  }
} else {
  cdnURl.push(config.domains.cdn)
}

//File out put.
exports.output = {
  publicPath: cdnURl.join('/') + '/',
  filename: '[name].js',
  chunkFilename: 'js/[name].[contenthash:13].js'
}

exports.plugins = [
  new webpack.DefinePlugin((() => {
    for (let temp in (config.define || {})) {
      config.define[temp] = JSON.stringify(
        (config.define[temp])
      )
    }
    return config.define
  })()),

  new webpack.BannerPlugin([
    'Developer is: ', packageConfig.author
  ].join('')),

  new webpack.HashedModuleIdsPlugin()
]

exports.optimization = {
  concatenateModules: true,

  splitChunks: {
    cacheGroups: {
      vendor: {
        test: /[\\/]node_modules[\\/]/,
        name: 'vendors',
        priority: -20,
        chunks: 'all'
      }
    }
  }
}

//Is compress file for rese.
if (config.isCompress) {
  exports.devtool = config.isMap ? '#source-map' : false
}

//Project performance testing。
if (config.isReport || process.env.NODE_ENV_REPORT) {
  const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin
  exports.plugins.push(new BundleAnalyzerPlugin())
}

//Complie module
function complie() {
  return new Promise(function(resolve, reject) {
    webpack(merge(baseWebpack, exports, fspc.readConfig.apply(config, [
      process.env.MEIPIAN_PROGRAM_CONFIG, ['entry', 'output']
    ])), function(err, stats) {
      err ? reject(err) : resolve(stats)
    })
  })
}

//Print webpack complie content.
module.exports = Promise.all([fspc.rm(baseWebpack.output.path), complie()]).catch(function(err) {
  spinner.stop()
  throw err
}).then(function(values) {
  let stats = values[1]

  spinner.stop()
  process.stdout.write(stats.toString({
    colors: true,
    modules: true,
    children: false,
    chunks: false,
    chunkModules: false
  }) + '\n\n')

  if (stats.hasErrors()) {
    console.log(chalk.red('  Build failed with errors.\n'))
    process.exit(1)
  }

  console.log(chalk.cyan('  Project version build complete.\n'))
  console.log(chalk.yellow([
    `  Tip: static file root CDN: ${exports.output.publicPath}`, , ,
  ].join('\n')))

  if (config.strict) {
    console.log(chalk.blue([
      `  Upload qinniu: bucket: ${config.domains.bucket}`, ,
    ].join('\n')))

    mpqiniu.apply(null, [{
      bucket: config.domains.bucket,
      src: path.join(process.cwd(), config.output),
      fix: [
        CDN_PATH, packageConfig.projectTypeName,
        packageConfig.platform, packageConfig.name
      ].join('/'),
      rootDir: config.output,
      urls: Object.keys(baseWebpack.entry).map(function(value) {
        return cdnURl.cocat([`${value}/.js`]).join('/')
      }) || [],
      ext: config.extName,
      cdnURL: config.domains.cdn
    }, function() {

      if (config.isAPI) {
        let spinnerAPI = ora('  Generating API……\n').start()

        fspc.rm('./sassdoc').then(function() {

          sassdoc(path.resolve(process.cwd(), config.root)).then(function() {
            spinnerAPI.stop()

            console.log(chalk.green('  Sassdoc API generation completion, output dir: sassdoc\n'))
            mpjsdoc(config.root, fspc.readConfig.apply(config, [
              path.resolve(process.cwd(), './jsdoc.config.js')
            ]))
          })
        })
      }
    }])
  }
})