meipian-common/lib/base.js

Meipian common lib developmaent evn

'use strict'
const path = require('path')
const merge = require('webpack-merge')
const HtmlWebpackPlugin = require('html-webpack-plugin')
const { fspc, tool } = require('meipian-stage-tools')

//Package.json file
const packageConfig = merge({
  platform: ''
}, require(process.env.MEIPIAN_PROJECT_PACKAGE_CONFIG))
const meipianConfig = packageConfig.meipian || {}
const MEIPIAN_NODE_ENV = process.env.MEIPIAN_NODE_ENV

const config = merge({
  root: 'src',
  output: 'view',
  extName: ('server' === MEIPIAN_NODE_ENV) ? 'html' : 'htm',
  domains: {},
  define: {},
  pages: {},
  remUnit: 100,
  isExtract: false,
  minCommFileChunks: 2,
  template: 'template.html',
  isCompress: ('production' === MEIPIAN_NODE_ENV) ? true : false,
  isMap: ('production' === MEIPIAN_NODE_ENV) ? true : false,
  isCssModule: false,
  isPx2rem: false,
  isAPI: true
}, (meipianConfig.global || {}), (meipianConfig[process.env.MEIPIAN_CONFIG_FILE] || {}))

const rootPath = path.resolve(config.root)
const ENTRY_EXT = '.js'
const entryFiles = (() => {
  let fileAry = fspc.files(rootPath, new RegExp(ENTRY_EXT + '$'))
  let obj = {}

  //Push entry's name
  fileAry.map((value) => {
    return obj[path.basename(value, ENTRY_EXT)] = path.join(rootPath, value)
  })
  return obj
})()

const hashName = '[name].[hash:7].[ext]'
let cssLoader = (config.isCssModule) ? 'css-loader?modules' : 'css-loader'
const DATABASE64_SIZE = 10000

const postcssConfig = function() {
  let loaders = []

  if (config.isPx2rem) {
    loaders.push({
      loader: 'px2rem-loader',
      options: {
        remUnit: config.remUnit
      }
    })
  } else if (tool.isMobilePlatform(packageConfig.platform)) {
    loaders.push({
      loader: 'px2rem-loader',
      options: {
        remUnit: config.remUnit
      }
    })
  }

  loaders.push({
    loader: 'postcss-loader',
    options: {
      config: {
        path: path.resolve(__dirname, '../.postcssrc.js')
      },
      sourceMap: config.isExtract ? false : true
    }
  })

  return loaders
}

if (config.isCompress) {
  cssLoader = cssLoader + ((cssLoader.indexOf('?') < 0) ? '?' : '&') + 'minimize'
}

process.noDeprecation = true

//Build config
config.cssLoader = function() {
  return [cssLoader, ...postcssConfig()]
}

//Meipian node env
module.exports.MEIPIAN_NODE_ENV = MEIPIAN_NODE_ENV
module.exports.package = packageConfig

module.exports.buildConfig = config

module.exports.webpack = merge({
  entry: entryFiles,
  mode: config.isCompress ? 'production' : 'development',

  output: {
    path: path.resolve(config.output),
    filename: 'js/[name].js',
    chunkFilename: 'js/[name].js'
  },

  resolve: {
    extensions: [
      '.js', '.vue', '.json', '.hbs', '.ejs', '.jsx', '.jade'
    ],
    alias: {
      '@': rootPath
    }
  },

  node: {
    setImmediate: false,
    dgram: 'empty',
    fs: 'empty',
    net: 'empty',
    tls: 'empty',
    child_process: 'empty'
  },

  //Loader module for network file and other module's file.
  module: {
    rules: [{
      test: /\.js$/,
      loader: 'babel-loader',
      include: [
        path.resolve(rootPath)
      ],
      exclude: /node_module/
    }, {
      test: /\.css$/,
      use: ['style-loader', cssLoader, ...postcssConfig()]
    }, {
      test: /\.less$/,
      use: ['style-loader', cssLoader, ...postcssConfig(), 'less-loader']
    }, {
      test: /\.(scss|sass)$/,
      use: ['style-loader', cssLoader, ...postcssConfig(), 'resolve-url-loader', 'sass-loader?sourceMap']
    }, {
      test: /\.(stylus|styl)$/,
      use: ['style-loader', cssLoader, ...postcssConfig(), 'stylus-loader']
    }, {
      test: /\.(png|jpe?g|gif|svg)(\?.*)?$/,
      loader: 'url-loader',
      options: {
        limit: DATABASE64_SIZE,
        name: ['img', hashName].join('/')
      }
    }, {
      test: /\.(mp4|webm|ogg|mp3|wav|flac|aac)(\?.*)?$/,
      loader: 'url-loader',
      options: {
        limit: DATABASE64_SIZE,
        name: ['media', hashName].join('/')
      }
    }, {
      test: /\.(woff2?|eot|ttf|otf)(\?.*)?$/,
      loader: 'url-loader',
      options: {
        limit: DATABASE64_SIZE,
        name: ['fonts', hashName].join('/')
      }
    }]
  },

  plugins: [
    ...(function() {
      let entryNames = Object.keys(entryFiles)

      return entryNames.map((value, idx) => {
        let tempAry = entryNames.slice(0)

        tempAry.splice(idx, 1)

        return new HtmlWebpackPlugin({
          title: ((config.pages[value] || {}).title) || '',
          filename: value + '.' + (config.extName),
          template: path.resolve(config.template),
          chunksSortMode: 'dependency',
          excludeChunks: tempAry
        })
      })
    })()
  ]
})