@runforest/js/index.js

const path  = require( 'path' );
const chalk = require( 'chalk' );

// Fix rollup watcher chokidar path issue.
const _tmpCwd = process.cwd();
process.chdir( __dirname );

// Require rollup.
const rollup = require( 'rollup' );

// Revert rollup watcher chokidar path issue fix.
process.chdir( _tmpCwd );

// Rollup dependencies.
const rollupNodeResolve = require( 'rollup-plugin-node-resolve' );
const rollupCommonJS    = require( 'rollup-plugin-commonjs' );
const babel             = require( 'rollup-plugin-babel' );
const Observable        = require( 'zen-observable' );
const minify            = require('./rollup-minify');

/**
 * Returns current local time string.
 *
 * @returns {String}
 */
const currentLocalTime = function() {
	return ( new Date() ).toLocaleTimeString();
};

const logPrefix = function() {
	return chalk`{gray ${ currentLocalTime() }} {bold [JS]}`;
};

const formatError = function( error ) {
	if ( error.formatted ) {
		return chalk`{red ${error.formatted}}`;
	}

	if ( error.message ) {
		return chalk`{red ${error.message}}`;
	}

	return error.toString();
};

const validate = function( {
	source,
	destination,
	globals,
	external,
	mode = 'build',
	includeBabelPolyfill = true,
} ) {
	if ( mode !== 'watch' && mode !== 'build' ) {
		mode = 'build';
	}

	if ( includeBabelPolyfill === false || includeBabelPolyfill === 'false' ) {
		includeBabelPolyfill = false;
	} else {
		includeBabelPolyfill = true;
	}

	return new Promise( function( resolve, reject ) {
		if ( ! source ) {
			return reject( chalk`${ logPrefix() } {red Source is required!}` );
		}

		if ( ! destination ) {
			return reject( chalk`${ logPrefix() } {red Destination is required!}` );
		}

		return resolve();
	} )
		.then( () => ( {
			source,
			destination,
			globals,
			external,
			mode,
			includeBabelPolyfill,
		} ) );
};

const rollupPluginPrependBabelPolyfill = function(source) {
	return {
		name: 'prepend-babel-polyfill',
		transform(code, id) {
			if (!String.prototype.endsWith.call(id, source)) {
				return;
			}

			return {
				code: 'import \'@runforest/js/babel-polyfill.js\';\n' + code,
			};
		},
	};
};

const getPluginsOption = function( { source, includeBabelPolyfill } ) {
	const plugins = [];

	// Use the Node.js resolution algorithm with Rollup
	plugins.push(rollupNodeResolve({
			// some package.json files have a `browser` field which
			// specifies alternative files to load for people bundling
			// for the browser. If that's you, use this option, otherwise
			// pkg.browser will be ignored
			browser: true,
			// Additional options
			customResolveOptions: {
				// Set node_modules as module directory
				moduleDirectory: 'node_modules',
			},
	}));

	// Convert CommonJS modules to ES2015
	plugins.push(rollupCommonJS({
		// Convert only imported npm modules
		include: 'node_modules/**',
	}));

	if (includeBabelPolyfill) {
		// Prepends import '@babel/polyfill';
		plugins.push(rollupPluginPrependBabelPolyfill(source));
	}

	// Babel is a toolchain that is mainly used to convert ECMAScript 2015+
	// code into a backwards compatible version of JavaScript in current
	// and older browsers or environments
	plugins.push(babel({
		// Do not transform npm modules
		exclude: 'node_modules/**',
		presets: [[
			// @babel/preset-env is a smart preset that allows you to use
			// the latest JavaScript without needing to micromanage which
			// syntax transforms (and optionally, browser polyfills) are
			// needed by your target environment(s).
			require( '@babel/preset-env' ),
			{
				// The starting point where the config search for
				// browserslist will start, and ascend to the system root
				// until found
				configPath: source,
				// Disable transformation of ES6 module syntax because that
				// is what rollup do
				modules: false,
				// @babel/polyfill insertion is handled by the plugin above
				useBuiltIns: 'entry',
			},
		]],
	}));

	// ECMAScript 2015+ minifier
	plugins.push(minify());

	return plugins;
};

const getInputOptions = function( config ) {
	const { source, external } = config;

	return {
		input: source,
		external: external,
		plugins: getPluginsOption( config ),
	};
};

const getOutputOptions = function( source, destination, globals ) {
	return {
		format: 'iife',
		file: path.resolve( destination, path.basename( source ) ),
		globals: globals,
		sourcemap: true,
	};
};

module.exports = function( config ) {
	return new Observable( function( observer ) {
		validate( config )
			.then( function( config ) {
				return new Promise( function( resolve, reject ) {
					const { mode } = config;

					if ( 'watch' !== mode ) {
						return resolve( config );
					}

					const { source, destination, globals } = config;

					const watcher = rollup.watch( Object.assign(
						getInputOptions( config ),
						{
							output: getOutputOptions( source, destination, globals ),
							watch: {
								chokidar: true,
								exclude: 'node_modules/**',
							},
						}
					) );

					let waitingMessageTimeout;

					watcher.on( 'event', function( event ) {
						clearTimeout( waitingMessageTimeout );

						switch ( event.code ) {
							case 'START':
								observer.next( 'Start compiling...' );

								break;

							case 'BUNDLE_START':
								observer.next(
									chalk`Compiling {blue ${ event.input }}...`
								);
								break;

							case 'BUNDLE_END':
								const destinations = event.output
									.map( ( dest ) => path.relative( process.cwd(), dest ) )
									.join( ', ' );

								observer.next(
									chalk`{blue ${ event.input }} is compiled to ` +
									chalk`{green ${ destinations }}.`
								);
								break;

							case 'END':
								waitingMessageTimeout = setTimeout( () => {
									observer.next( 'Waiting...' );
								}, 2000 );
								break;

							case 'ERROR':
								if ( event.error ) {
									observer.next( formatError( event.error ) );
								} else {
									observer.next(
										chalk`{red Unknown error!}\n` +
										formatError( event )
									);
								}
								break;

							default:
								watcher.close();
								if ( event.error ) {
									reject( event.error );
								} else {
									reject(
										chalk`{red Unknown unrecoverable error!}\n` +
										formatError( event )
									);
								}

								break;
						}
					} );
				} );
			} )
			.then( function( config ) {
				const { mode } = config;

				if ( 'build' !== mode ) {
					return Promise.resolve( config );
				}

				const { source, destination, globals } = config;

				return rollup.rollup( getInputOptions( config ) )
					.then(
						( bundle ) =>
							bundle.write( getOutputOptions( source, destination, globals ) )
					);
			} )
			.then( function() {
				observer.complete();
			} )
			.catch( function( error ) {
				observer.error( error );
			} );
	} );
};