react-ui-playground/tool/webpackTask.js

A pruned live jsx editor from React.

'use strict';

const path = require('path'),
    webpack = require('webpack');

const pkgInfo = require('./../package.json');

const banner = `/**
* ${pkgInfo.name} v${pkgInfo.version}
*
* Copyright 2016-present, ${pkgInfo.author.name}, contributors.
* All rights reserved.
*
* This source code is licensed under the ${pkgInfo.license} license found in the
* LICENSE file in the root directory of this source tree.
*
*/`;

/**
 * Merge object deeply.
 * @param {object} target Target Object
 * @param {object} obj Source object.
 * @return {object} Merged object.
 */
const mergeObject = (target, obj) => {

    if (typeof target != 'object' || typeof obj != 'object') return;

    Object.keys(obj).forEach((key) => {

        if (target.hasOwnProperty(key)) {
            if (Array.isArray(target[key]) && Array.isArray(obj[key])) {
                target[key] = obj[key].concat(target[key]);
            } else if (typeof target[key] == 'object' && typeof obj[key] == 'object') {
                mergeObject(target[key], obj[key]);
            } else {
                target[key] = obj[key];
            }
        } else {
            target[key] = obj[key];
        }
    });

    return target;
};


/**
 * Build nested loaders string.
 * @deprecated
 * @param {object} loaders Loader objects.
 * @return {string} Loader string for webpack loader url.
 */
const buildLoaderString = (loaders) => {
    const result = [];
    Object.keys(loaders).forEach((key) => {

        const params = [];

        if (loaders[key] && typeof loaders[key] == 'object') {

            Object.keys(loaders[key]).forEach((paramName) => {
                const value = loaders[key][paramName];
                params.push(paramName + (value ? '=' + value.toString() : ''));
            });

        }

        result.push(
            key + (params.length ? '?' + params.join('&') : '')
        )
    });
    return result.join('!');
};


/**
 * Default webpack options for the project.
 */
const getWebpackOptions = function () {
    return {
        externals: {
            'react': 'React',
            'react-dom': 'ReactDOM'
        },
        entry: '',
        output: {},
        module: {
            rules: [
                {
                    test: /\.js$/,
                    include: [
                        path.resolve(__dirname, '../src')
                    ],
                    exclude: [
                        path.resolve(__dirname, '../node_modules')
                    ],
                    use: [
                        {
                            loader: 'babel-loader'
                        }
                    ]
                }, {
                    test: /\.(css)$/,

                    use: [
                        {
                            loader: 'style-loader'
                        },
                        {
                            loader: 'css-loader',
                            options: {
                                minimize: true
                            }
                        }
                    ]
                }, {
                    test: /\.(tmpl|txt)$/,
                    exclude: /node_modules/,
                    loader: 'raw-loader'
                }
            ]
        },
        plugins: [
            //new webpack.optimize.OccurrenceOrderPlugin(),
            new webpack.BannerPlugin({
                banner: banner,
                raw: true,
                entryOnly: true
            })
        ],

        target: 'web'
    };
};

/**
 * @module WebpackTask
 * @exports WebpackTask
 * @param options {object} Webpack options
 * @param process {function|null}
 * @return {Promise}
 */
module.exports = (options, process) => {

    options = mergeObject(getWebpackOptions(), options);

    if (typeof process === 'function') {
        process(options);
    }

    return new Promise((resolve, reject) => {
        webpack(options, (err, stats) => {
            if (err) {
                reject(err);
            } else if (stats.compilation.errors.length) {
                var messages = [];
                stats.compilation.errors.forEach((e) => {
                    messages.push(e.message);
                });
                reject(messages.join('\n'));
            } else {
                resolve();
            }
        });
    });
};