@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' } ) {
	if ( mode !== 'watch' && mode !== 'build' ) {
		mode = 'build';
	}

	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,
		} ) );
};

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 ) {
	return [
		// Use the Node.js resolution algorithm with Rollup
		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
		rollupCommonJS( {
			// Convert only imported npm modules
			include: 'node_modules/**',
		} ),
		// Prepends import '@babel/polyfill';
		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
		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
		minify(),
	];
};

const getInputOptions = function( source, external ) {
	return {
		input: source,
		external: external,
		plugins: getPluginsOption( source ),
	};
};

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, external } = config;

					const watcher = rollup.watch( Object.assign(
						getInputOptions( source, external ),
						{
							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, external } = config;

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