rollup 0.48.2 → 0.49.3

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # rollup changelog
 
+## 0.49.3
+
+* Respect `watch` options ([#1596](https://github.com/rollup/rollup/issues/1596))
+* Fix treeshaking regressions ([#1604](https://github.com/rollup/rollup/pull/1604))
+* Allow `-o` to work with `output.format` ([#1606](https://github.com/rollup/rollup/pull/1606))
+
+## 0.49.2
+
+* Fix treeshaking regressions ([#1591](https://github.com/rollup/rollup/pull/1591))
+
+## 0.49.1
+
+* Fix treeshaking regressions ([#1586](https://github.com/rollup/rollup/pull/1586))
+
+## 0.49.0
+
+* Completely update the treeshaking algorithm ([#1582](https://github.com/rollup/rollup/pull/1582))
+* Only flip screen buffer if appropriate ([#1574](https://github.com/rollup/rollup/pull/1574))
+* Guard against two instances creating the same dir ([#1576](https://github.com/rollup/rollup/pull/1576))
+
 ## 0.48.2
 
 * Paths is an output option ([#1569](https://github.com/rollup/rollup/pull/1569))
@@ -45,7 +65,7 @@
 ## 0.46.3
 
 * init for/for-of loop section head with correct scopes ([#1538](https://github.com/rollup/rollup/issues/1538), [#1539](https://github.com/rollup/rollup/issues/1539))
-* Fix namespace imports and re-exports in `es` outpot ([#1511](https://github.com/rollup/rollup/issues/1511))
+* Fix namespace imports and re-exports in `es` output ([#1511](https://github.com/rollup/rollup/issues/1511))
 * Deshadow indirectly imported namespaces ([#1488](https://github.com/rollup/rollup/issues/1488), [#1505](https://github.com/rollup/rollup/issues/1505))
 
 ## 0.46.2

package/bin/rollup

@@ -10,6 +10,8 @@ var path__default = _interopDefault(path);
 var module$1 = _interopDefault(require('module'));
 var os = _interopDefault(require('os'));
 var rollup = require('../dist/rollup.js');
+var assert = _interopDefault(require('assert'));
+var events = _interopDefault(require('events'));
 
 var index$1 = function (args, opts) {
     if (!opts) { opts = {}; }
@@ -248,7 +250,7 @@ function isNumber (x) {
 
 var help = "rollup version __VERSION__\n=====================================\n\nUsage: rollup [options] <entry file>\n\nBasic options:\n\n-v, --version               Show version number\n-h, --help                  Show this help message\n-c, --config                Use this config file (if argument is used but value\n                              is unspecified, defaults to rollup.config.js)\n-w, --watch                 Watch files in bundle and rebuild on changes\n-i, --input                 Input (alternative to <entry file>)\n-o, --output.file <output>  Output (if absent, prints to stdout)\n-f, --output.format [es]    Type of output (amd, cjs, es, iife, umd)\n-e, --external              Comma-separate list of module IDs to exclude\n-g, --globals               Comma-separate list of `module ID:Global` pairs\n                              Any module IDs defined here are added to external\n-n, --name                  Name for UMD export\n-m, --sourcemap             Generate sourcemap (`-m inline` for inline map)\n--amd.id                    ID for AMD module (default is anonymous)\n--amd.define                Function to use in place of `define`\n--no-strict                 Don't emit a `\"use strict\";` in the generated modules.\n--no-indent                 Don't indent result\n--environment <values>      Settings passed to config file (see example)\n--no-conflict               Generate a noConflict method for UMD globals\n--silent                    Don't print warnings\n--intro                     Content to insert at top of bundle (inside wrapper)\n--outro                     Content to insert at end of bundle (inside wrapper)\n--banner                    Content to insert at top of bundle (outside wrapper)\n--footer                    Content to insert at end of bundle (outside wrapper)\n--interop                   Include interop block (true by default)\n\nExamples:\n\n# use settings in config file\nrollup -c\n\n# in config file, process.env.INCLUDE_DEPS === 'true'\n# and process.env.BUILD === 'production'\nrollup -c --environment INCLUDE_DEPS,BUILD:production\n\n# create CommonJS bundle.js from src/main.js\nrollup --format=cjs --output=bundle.js -- src/main.js\n\n# create self-executing IIFE using `window.jQuery`\n# and `window._` as external globals\nrollup -f iife --globals jquery:jQuery,lodash:_ \\\n  -i src/app.js -o build/app.js -m build/app.js.map\n\nNotes:\n\n* When piping to stdout, only inline sourcemaps are permitted\n\nFor more information visit https://github.com/rollup/rollup/wiki\n";
 
-var version = "0.48.2";
+var version = "0.49.3";
 
 var modules = {};
 
@@ -2242,7 +2244,8 @@ function mergeOptions ( config, command ) {
 		context: config.context,
 		moduleContext: config.moduleContext,
 		plugins: config.plugins,
-		onwarn: config.onwarn
+		onwarn: config.onwarn,
+		watch: config.watch
 	};
 
 	// legacy, to ensure e.g. commonjs plugin still works
@@ -2298,14 +2301,21 @@ function mergeOptions ( config, command ) {
 		paths: getOption('paths')
 	};
 
-	const outputOptions = (
-		(command.output || config.output) ?
+	let mergedOutputOptions;
+	if (Array.isArray(config.output)) {
+		mergedOutputOptions = config.output.map((output) => Object.assign({}, output, command.output));
+	} else if (config.output && command.output) {
+		mergedOutputOptions = [Object.assign({}, config.output, command.output)];
+	} else {
+		mergedOutputOptions = (command.output || config.output) ?
 			ensureArray(command.output || config.output) :
 			[{
 				file: command.output ? command.output.file : null,
 				format: command.output ? command.output.format : null
-			}]
-	).map(output => {
+			}];
+	}
+
+	const outputOptions = mergedOutputOptions.map(output => {
 		return Object.assign({}, baseOutputOptions, output);
 	});
 
@@ -3278,17 +3288,369 @@ function build$1 ( inputOptions, outputOptions, warnings, silent ) {
 		.catch( handleError );
 }
 
+var signals$1 = createCommonjsModule(function (module) {
+// This is not the set of all possible signals.
+//
+// It IS, however, the set of all signals that trigger
+// an exit on either Linux or BSD systems.  Linux is a
+// superset of the signal names supported on BSD, and
+// the unknown signals just fail to register, so we can
+// catch that easily enough.
+//
+// Don't bother with SIGKILL.  It's uncatchable, which
+// means that we can't fire any callbacks anyway.
+//
+// If a user does happen to register a handler on a non-
+// fatal signal like SIGWINCH or something, and then
+// exit, it'll end up firing `process.emit('exit')`, so
+// the handler will be fired anyway.
+//
+// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+// artificially, inherently leave the process in a
+// state from which it is not safe to try and enter JS
+// listeners.
+module.exports = [
+  'SIGABRT',
+  'SIGALRM',
+  'SIGHUP',
+  'SIGINT',
+  'SIGTERM'
+];
+
+if (process.platform !== 'win32') {
+  module.exports.push(
+    'SIGVTALRM',
+    'SIGXCPU',
+    'SIGXFSZ',
+    'SIGUSR2',
+    'SIGTRAP',
+    'SIGSYS',
+    'SIGQUIT',
+    'SIGIOT'
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  );
+}
+
+if (process.platform === 'linux') {
+  module.exports.push(
+    'SIGIO',
+    'SIGPOLL',
+    'SIGPWR',
+    'SIGSTKFLT',
+    'SIGUNUSED'
+  );
+}
+});
+
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+
+var signals = signals$1;
+
+var EE = events;
+/* istanbul ignore if */
+if (typeof EE !== 'function') {
+  EE = EE.EventEmitter;
+}
+
+var emitter;
+if (process.__signal_exit_emitter__) {
+  emitter = process.__signal_exit_emitter__;
+} else {
+  emitter = process.__signal_exit_emitter__ = new EE();
+  emitter.count = 0;
+  emitter.emitted = {};
+}
+
+// Because this emitter is a global, we have to check to see if a
+// previous version of this library failed to enable infinite listeners.
+// I know what you're about to say.  But literally everything about
+// signal-exit is a compromise with evil.  Get used to it.
+if (!emitter.infinite) {
+  emitter.setMaxListeners(Infinity);
+  emitter.infinite = true;
+}
+
+var index$22 = function (cb, opts) {
+  assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
+
+  if (loaded === false) {
+    load();
+  }
+
+  var ev = 'exit';
+  if (opts && opts.alwaysLast) {
+    ev = 'afterexit';
+  }
+
+  var remove = function () {
+    emitter.removeListener(ev, cb);
+    if (emitter.listeners('exit').length === 0 &&
+        emitter.listeners('afterexit').length === 0) {
+      unload();
+    }
+  };
+  emitter.on(ev, cb);
+
+  return remove
+};
+
+var unload_1 = unload;
+function unload () {
+  if (!loaded) {
+    return
+  }
+  loaded = false;
+
+  signals.forEach(function (sig) {
+    try {
+      process.removeListener(sig, sigListeners[sig]);
+    } catch (er) {}
+  });
+  process.emit = originalProcessEmit;
+  process.reallyExit = originalProcessReallyExit;
+  emitter.count -= 1;
+}
+
+function emit (event, code, signal) {
+  if (emitter.emitted[event]) {
+    return
+  }
+  emitter.emitted[event] = true;
+  emitter.emit(event, code, signal);
+}
+
+// { <signal>: <listener fn>, ... }
+var sigListeners = {};
+signals.forEach(function (sig) {
+  sigListeners[sig] = function listener () {
+    // If there are no other listeners, an exit is coming!
+    // Simplest way: remove us and then re-send the signal.
+    // We know that this will kill the process, so we can
+    // safely emit now.
+    var listeners = process.listeners(sig);
+    if (listeners.length === emitter.count) {
+      unload();
+      emit('exit', null, sig);
+      /* istanbul ignore next */
+      emit('afterexit', null, sig);
+      /* istanbul ignore next */
+      process.kill(process.pid, sig);
+    }
+  };
+});
+
+var signals_1 = function () {
+  return signals
+};
+
+var load_1 = load;
+
+var loaded = false;
+
+function load () {
+  if (loaded) {
+    return
+  }
+  loaded = true;
+
+  // This is the number of onSignalExit's that are in play.
+  // It's important so that we can count the correct number of
+  // listeners on signals, and don't wait for the other one to
+  // handle it instead of us.
+  emitter.count += 1;
+
+  signals = signals.filter(function (sig) {
+    try {
+      process.on(sig, sigListeners[sig]);
+      return true
+    } catch (er) {
+      return false
+    }
+  });
+
+  process.emit = processEmit;
+  process.reallyExit = processReallyExit;
+}
+
+var originalProcessReallyExit = process.reallyExit;
+function processReallyExit (code) {
+  process.exitCode = code || 0;
+  emit('exit', process.exitCode, null);
+  /* istanbul ignore next */
+  emit('afterexit', process.exitCode, null);
+  /* istanbul ignore next */
+  originalProcessReallyExit.call(process, process.exitCode);
+}
+
+var originalProcessEmit = process.emit;
+function processEmit (ev, arg) {
+  if (ev === 'exit') {
+    if (arg !== undefined) {
+      process.exitCode = arg;
+    }
+    var ret = originalProcessEmit.apply(this, arguments);
+    emit('exit', process.exitCode, null);
+    /* istanbul ignore next */
+    emit('afterexit', process.exitCode, null);
+    return ret
+  } else {
+    return originalProcessEmit.apply(this, arguments)
+  }
+}
+
+index$22.unload = unload_1;
+index$22.signals = signals_1;
+index$22.load = load_1;
+
+var index$23 = createCommonjsModule(function (module) {
+'use strict';
+const x = module.exports;
+const ESC = '\u001B[';
+const isTerminalApp = process.env.TERM_PROGRAM === 'Apple_Terminal';
+
+x.cursorTo = function (x, y) {
+	if (arguments.length === 0) {
+		return ESC + 'H';
+	}
+
+	if (arguments.length === 1) {
+		return ESC + (x + 1) + 'G';
+	}
+
+	return ESC + (y + 1) + ';' + (x + 1) + 'H';
+};
+
+x.cursorMove = (x, y) => {
+	let ret = '';
+
+	if (x < 0) {
+		ret += ESC + (-x) + 'D';
+	} else if (x > 0) {
+		ret += ESC + x + 'C';
+	}
+
+	if (y < 0) {
+		ret += ESC + (-y) + 'A';
+	} else if (y > 0) {
+		ret += ESC + y + 'B';
+	}
+
+	return ret;
+};
+
+x.cursorUp = count => ESC + (typeof count === 'number' ? count : 1) + 'A';
+x.cursorDown = count => ESC + (typeof count === 'number' ? count : 1) + 'B';
+x.cursorForward = count => ESC + (typeof count === 'number' ? count : 1) + 'C';
+x.cursorBackward = count => ESC + (typeof count === 'number' ? count : 1) + 'D';
+
+x.cursorLeft = ESC + 'G';
+x.cursorSavePosition = ESC + (isTerminalApp ? '7' : 's');
+x.cursorRestorePosition = ESC + (isTerminalApp ? '8' : 'u');
+x.cursorGetPosition = ESC + '6n';
+x.cursorNextLine = ESC + 'E';
+x.cursorPrevLine = ESC + 'F';
+x.cursorHide = ESC + '?25l';
+x.cursorShow = ESC + '?25h';
+
+x.eraseLines = count => {
+	let clear = '';
+
+	for (let i = 0; i < count; i++) {
+		clear += x.eraseLine + (i < count - 1 ? x.cursorUp() : '');
+	}
+
+	if (count) {
+		clear += x.cursorLeft;
+	}
+
+	return clear;
+};
+
+x.eraseEndLine = ESC + 'K';
+x.eraseStartLine = ESC + '1K';
+x.eraseLine = ESC + '2K';
+x.eraseDown = ESC + 'J';
+x.eraseUp = ESC + '1J';
+x.eraseScreen = ESC + '2J';
+x.scrollUp = ESC + 'S';
+x.scrollDown = ESC + 'T';
+
+x.clearScreen = '\u001Bc';
+x.beep = '\u0007';
+
+x.image = (buf, opts) => {
+	opts = opts || {};
+
+	let ret = '\u001B]1337;File=inline=1';
+
+	if (opts.width) {
+		ret += `;width=${opts.width}`;
+	}
+
+	if (opts.height) {
+		ret += `;height=${opts.height}`;
+	}
+
+	if (opts.preserveAspectRatio === false) {
+		ret += ';preserveAspectRatio=0';
+	}
+
+	return ret + ':' + buf.toString('base64') + '\u0007';
+};
+
+x.iTerm = {};
+
+x.iTerm.setCwd = cwd => '\u001B]50;CurrentDir=' + (cwd || process.cwd()) + '\u0007';
+});
+
+const SHOW_ALTERNATE_SCREEN = '\u001B[?1049h';
+const HIDE_ALTERNATE_SCREEN = '\u001B[?1049l';
+
+function alternateScreen ( enabled ) {
+	if (!enabled) {
+		let needAnnounce = true;
+		return {
+			open() {},
+			close() {},
+			reset( heading ) {
+				if ( needAnnounce ) {
+					stderr( heading );
+					needAnnounce = false;
+				}
+			}
+		};
+	}
+
+	return {
+		open() {
+			process.stderr.write(SHOW_ALTERNATE_SCREEN);
+		},
+		close() {
+			process.stderr.write(HIDE_ALTERNATE_SCREEN);
+		},
+		reset( heading ) {
+			stderr( `${index$23.eraseScreen}${index$23.cursorTo(0, 0)}${heading}` );
+		}
+	};
+}
+
 function watch$1(configFile, configs, command, silent) {
-	process.stderr.write('\x1b[?1049h'); // alternate screen buffer
+	const isTTY = Boolean(process.stderr.isTTY);
+
+	const screen = alternateScreen(isTTY);
+	screen.open();
 
 	const warnings = batchWarnings();
 
 	let watcher;
 	let configWatcher;
-	let closed = false;
 
 	function start(configs) {
-		stderr(`\x1B[2J\x1B[0f${index$3.underline( `rollup v${rollup.VERSION}` )}`); // clear, move to top-left
+		screen.reset( index$3.underline( `rollup v${rollup.VERSION}` ) );
 
 		configs = configs.map(options => {
 			const merged = mergeOptions(options, command);
@@ -3318,7 +3680,7 @@ function watch$1(configFile, configs, command, silent) {
 		watcher.on('event', event => {
 			switch (event.code) {
 				case 'FATAL':
-					process.stderr.write('\x1b[?1049l'); // reset screen buffer
+					screen.close();
 					handleError(event.error, true);
 					process.exit(1);
 					break;
@@ -3329,11 +3691,11 @@ function watch$1(configFile, configs, command, silent) {
 					break;
 
 				case 'START':
-					stderr(`\x1B[2J\x1B[0f${index$3.underline( `rollup v${rollup.VERSION}` )}`); // clear, move to top-left
+					screen.reset( index$3.underline( `rollup v${rollup.VERSION}` ) );
 					break;
 
 				case 'BUNDLE_START':
-					if ( !silent ) { stderr( index$3.cyan( `\n${index$3.bold( event.input )} → ${index$3.bold( event.output.map( relativeId ).join( ', ' ) )}...` ) ); }
+					if ( !silent ) { stderr( index$3.cyan( `bundles ${index$3.bold( event.input )} → ${index$3.bold( event.output.map( relativeId ).join( ', ' ) )}...` ) ); }
 					break;
 
 				case 'BUNDLE_END':
@@ -3342,24 +3704,31 @@ function watch$1(configFile, configs, command, silent) {
 					break;
 
 				case 'END':
-					if ( !silent ) { stderr( `\nwaiting for changes...` ); }
+					if ( !silent && isTTY ) { stderr( `\nwaiting for changes...` ); }
 			}
 		});
 	}
 
-	const close = () => {
-		if (!closed) {
-			process.stderr.write('\x1b[?1049l'); // reset screen buffer
-			closed = true;
-			watcher.close();
+	// catch ctrl+c, kill, and uncaught errors
+	const removeOnExit = index$22(close);
+	process.on('uncaughtException', close);
 
-			if (configWatcher) { configWatcher.close(); }
-		}
-	};
-	process.on('SIGINT', close); // ctrl-c
-	process.on('SIGTERM', close); // killall node
-	process.on('uncaughtException', close); // on error
-	process.stdin.on('end', close); // in case we ever support stdin!
+	// only listen to stdin if it is a pipe
+	if (!process.stdin.isTTY) {
+		process.stdin.on('end', close); // in case we ever support stdin!
+	}
+
+	function close() {
+		removeOnExit();
+		process.removeListener('uncaughtException', close);
+		// removing a non-existent listener is a no-op
+		process.stdin.removeListener('end', close);
+
+		screen.close();
+		watcher.close();
+
+		if (configWatcher) { configWatcher.close(); }
+	}
 
 	start(configs);