unique-interface/scripts/build/config.js

无UI组件库

const Path = require("path");
const webpack = require("webpack");
const fs = require('fs-extra');
const UglifyJsPlugin = require('uglifyjs-webpack-plugin');

const builds = {
    'unique-interface.js': {},
    'unique-interface.min.js': {},
}

const configPath = Path.resolve('ui.config.js');
const localExist = fs.existsSync(configPath);
let entry = Path.resolve("./src/index.js");
let dist = Path.resolve("./dist/");
if(localExist){
    const local = require(configPath);
    entry = Path.resolve(local.targetDir, 'src/index.js');
    dist = Path.resolve(local.targetDir, 'dist');
}

const defaultConfig = function(){
    return {
        mode: 'development',
        context: Path.resolve(__dirname, "../.."),
        entry: entry,
        resolve: {
            modules: [
                Path.resolve(__dirname, "../../node_modules"),
                "node_modules",
                "src",
                "."
            ],
        },
        output: {
            path: dist,
            library: 'unique-interface',
            libraryTarget: 'umd',
            libraryExport: 'default'
        },
        plugins: [],
        module: {
            rules: [
                {
                    test: /\.js$/,
                    exclude: /node_modules/,
                    use: [ "babel-loader" ]
                },
                {
                    test: /\.less$/,
                    use: [ "style-loader", "css-loader", "postcss-loader", "less-loader" ]
                },
                {
                    test: /\.html$/,
                    use: [{
                        loader: "html-loader",
                        options: {
                            minimize: true,
                            collapseWhitespace: true,
                            collapseInlineTagWhitespace: true,
                            conservativeCollapse: false
                        }
                    }]
                },
            ]
        }
    };
}

const series = {
    min: {
        mode: 'production',
        plugins: [
            // new webpack.HashedModuleIdsPlugin(),
            new webpack.DefinePlugin({
                'process.env': { NODE_ENV: '"production"' }
            }),
            new UglifyJsPlugin({
                cache: true,
                uglifyOptions: {
                    ecma: 5,
                    compress: { warnings: false },
                },
            })
        ]
    }
};

var typer = function(value){
    return ({}).toString.apply(value).split(' ')[1].slice(0, -1);
};
var merge = function(target, source){
    var key, type, value;
    for(key in source){
        type = typer(source[key]);
        switch(type === typer(target[key]) && type){
            case 'Object':
                merge(target[key], source[key]);
                break;
            case 'Array':
                source[key].forEach(function(item){
                    target[key].push(item);
                });
                break;
            default:
                target[key] = source[key];
                break;
        }
    }
    return target;
};

function getConfig(){
    const config = [];
    for(let name in builds){
        let nameArr = name.split('.');
        builds[name].output = { filename: name };
        let conf = merge(defaultConfig(), builds[name]);
        for(let key in series){
            if(~nameArr.indexOf(key))merge(conf, series[key]);
        }
        config.push(conf);
    }
    return config;
}

module.exports = getConfig();