rollup 0.41.2 → 0.41.6

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # rollup changelog
 
+## 0.41.6
+
+* Preserve `originalSourceMap` on incremental rebuilds for loaders with sourcemaps ([#1336](https://github.com/rollup/rollup/issues/1336))
+
+## 0.41.5
+
+* Wrap ternary consequent/alternate sequences in parens ([#1273](https://github.com/rollup/rollup/issues/1273))
+* Fix erroneous warning on multiple `export * from` declarations with defaults ([#1278](https://github.com/rollup/rollup/issues/1278))
+* Prevent variable conflicts with `treeshake: false` ([#1268](https://github.com/rollup/rollup/issues/1268))
+* Allow missing `source` when collapsing sourcemaps ([#1254](https://github.com/rollup/rollup/issues/1254))
+* Allow plugins to log with strings ([#1316](https://github.com/rollup/rollup/pull/1316))
+
+## 0.41.4
+
+* Fix cases of multiple `export * from 'external'` declarations ([#1252](https://github.com/rollup/rollup/issues/1252))
+* Fix 'TODO' error message ([#1257](https://github.com/rollup/rollup/issues/1257))
+
+## 0.41.3
+
+* Don't treat `this.foo` as possible namespace ([#1258](https://github.com/rollup/rollup/issues/1258))
+
 ## 0.41.2
 
 * Optimize `namespace['foo']` references ([#1240](https://github.com/rollup/rollup/pull/1240))

package/README.md

@@ -26,123 +26,88 @@
   </a>
 </p>
 
-> *I roll up, I roll up, I roll up, Shawty I roll up*
->
-> *I roll up, I roll up, I roll up*
-> &ndash;[Wiz Khalifa](https://www.youtube.com/watch?v=UhQz-0QVmQ0)
+## Overview
 
+Rollup is a module bundler for JavaScript which compiles small pieces of code into a something larger and more complex, such as a library or application. It uses the new standardized format for code modules included in the ES6 revision of JavaScript, instead of previous idiosyncratic solutions such as CommonJS and AMD.
 
-## Quickstart
+## Quick Start Guide
 
-Rollup can be used via a [JavaScript API](https://github.com/rollup/rollup/wiki/JavaScript-API) or a [Command Line Interface](https://github.com/rollup/rollup/wiki/Command-Line-Interface). Install with `npm install -g rollup` and run `rollup --help` to get started.
+Install with `npm install --global rollup`. Rollup can be used either through a [command line interface](https://github.com/rollup/rollup/wiki/Command-Line-Interface) with an optional configuration file, or else through its [JavaScript API](https://github.com/rollup/rollup/wiki/JavaScript-API). Run `rollup --help` to see the available options and parameters. The [starter project template](https://github.com/rollup/rollup-starter-project) demonstrates common configuration options, and more detailed instructions are available throughout the [user guide](http://rollupjs.org/guide/).
 
-If the command line's not your jam, there's also a [step-by-step tutorial video series](https://code.lengstorf.com/learn-rollup-js/) (with accompanying written walkthrough).
+### Commands
 
-[Dive into the wiki](https://github.com/rollup/rollup/wiki) when you're ready to learn more about Rollup and ES6 modules.
+These commands assume the entry point to your application is named main.js, and that you'd like all imports compiled into a single file named bundle.js.
 
+For browsers:
 
-## A next-generation ES6 module bundler
-
-When you're developing software, it's much easier to break your library or application apart into separate pieces that you can work on separately. It's also very likely that you'll have dependencies on third party libraries. The result is lots of small files – but that's bad news for browsers, which get slowed down by having to make many requests. (It's also [bad news for Node!](https://kev.inburke.com/kevin/node-require-is-dog-slow/))
-
-The solution is to write your code as **modules**, and use a **module bundler** to concatenate everything into a single file. [Browserify](http://browserify.org/) and [Webpack](http://webpack.github.io/) are examples of module bundlers.
-
-So far, so good, **but there's a problem**. When you include a library in your bundle...
-
-```js
-var utils = require( 'utils' );
-
-var query = 'Rollup';
-utils.ajax( 'https://api.example.com?search=' + query ).then( handleResponse );
+```bash
+# compile to a <script> containing a self-executing function
+$ rollup main.js --format iife --output bundle.js
 ```
 
-...you include the *whole* library, including lots of code you're not actually using.
+For Node.js:
 
-**ES6 modules solve this problem.** Instead of importing the whole of `utils`, we can just import the `ajax` function we need:
+```bash
+# compile to a CommonJS module
+$ rollup main.js --format cjs --output bundle.js
+```
 
-```js
-import { ajax } from 'utils';
+For both browsers and Node.js:
 
-var query = 'Rollup';
-ajax( 'https://api.example.com?search=' + query ).then( handleResponse );
+```bash
+# UMD format requires a bundle name
+$ rollup main.js --format umd --name "myBundle" --output bundle.js
 ```
 
-Rollup statically analyses your code, and your dependencies, and includes the bare minimum in your bundle.
-
+## Why
 
-## Shouldn't we be writing those utilities as small modules anyway?
+Developing software is usually easier if you break your project into smaller separate pieces, since that often removes unexpected interactions and dramatically reduces the complexity of the problems you'll need to solve, and simply writing smaller projects in the first place [isn't necessarily the answer](https://medium.com/@Rich_Harris/small-modules-it-s-not-quite-that-simple-3ca532d65de4). Unfortunately, JavaScript has not historically included this capability as a core feature in the language.
 
-[Not always, no.](https://medium.com/@Rich_Harris/small-modules-it-s-not-quite-that-simple-3ca532d65de4)
+This finally changed with the ES6 revision of JavaScript, which includes a syntax for importing and exporting functions and data so they can be shared between separate scripts. The specification is now fixed, but it is not yet implemented in browsers or Node.js. Rollup allows you to write your code using the new module system, and will then compile it back down to existing supported formats such as CommonJS modules, AMD modules, and IIFE-style scripts. This means that you get to *write future-proof code*, and you also get the tremendous benefits of...
 
+## Tree Shaking
 
-## Don't minifiers already do this?
+In addition to enabling the use of ES6 modules, Rollup also statically analyzes the code you are importing, and will exclude anything that isn't actually used. This allows you to build on top of existing tools and modules without adding extra dependencies or bloating the size of your project.
 
-If you minify code with something like [UglifyJS](https://github.com/mishoo/UglifyJS2) (and you should!) then some unused code will be removed:
+For example, with CommonJS, the *entire tool or library must be imported*.
 
 ```js
-(function () {
-  function foo () {
-    console.log( 'this function was included!' );
-  }
-
-  function bar () {
-    console.log( 'this function was not' );
-    baz();
-  }
-
-  function baz () {
-    console.log( 'neither was this' );
-  }
-
-  foo();
-})();
+// import the entire utils object with CommonJS
+var utils = require( 'utils' );
+var query = 'Rollup';
+// use the ajax method of the utils object
+utils.ajax( 'https://api.example.com?search=' + query ).then( handleResponse );
 ```
 
-A minifier can detect that `foo` gets called, but that `bar` doesn't. When we remove `bar`, it turns out that we can also remove `baz`.
-
-But because of the limitations of static analysis, and the dynamic nature of JavaScript, it can't do the same thing with code like this:
+But with ES6 modules, instead of importing the whole `utils` object, we can just import the one `ajax` function we need:
 
 ```js
-(function () {
-  var obj = {
-    foo: function () {
-      console.log( 'this method was included!' );
-    },
-
-    bar: function () {
-      console.log( 'so was this :-(' );
-      this.baz();
-    },
-
-    baz: function () {
-      console.log( 'and this :-(' );
-    }
-  };
-
-  obj.foo();
-})();
+// import the ajax function with an ES6 import statement
+import { ajax } from 'utils';
+var query = 'Rollup';
+// call the ajax function
+ajax( 'https://api.example.com?search=' + query ).then( handleResponse );
 ```
 
-Unfortunately, **traditional modules – CommonJS and AMD – result in code more like the second example than the first, making them next-to-impossible to optimise**. Rather than *excluding dead code*, we should be *including live code* (aka 'tree-shaking'). That's only possible with ES6 modules.
-
-
-## Can I use it with my non-ES6 dependencies?
-
-[Yes!](https://github.com/rollup/rollup/wiki/Bundling-CommonJS-modules) Rollup can't work its tree-shaking magic on CommonJS modules, but it can convert them to ES6 via [plugins](https://github.com/rollup/rollup/wiki/Plugins).
+Because Rollup includes the bare minimum, it results in lighter, faster, and less complicated libraries and applications. Since this approach is based on explicit `import` and `export` statements, it is vastly more effective than simply running an automated minifier to detect unused variables in the compiled output code.
 
+ES6 modules let you freely and seamlessly combine the most useful individual functions from your favorite libraries, without weighing down your project with all the other unused code. This will eventually be possible natively, but Rollup lets you do it today.
 
-## Can I distribute my package as an ES6 module?
+## Compatibility
 
-If your `package.json` has a `jsnext:main` field, ES6-aware tools like Rollup can import the ES6 version of the package instead of the legacy CommonJS or UMD version. You'll be writing your code in a more future-proof way, and helping to bring an end to the [dark days of JavaScript package management](https://medium.com/@trek/last-week-i-had-a-small-meltdown-on-twitter-about-npms-future-plans-around-front-end-packaging-b424dd8d367a). [Learn more here.](https://github.com/rollup/rollup/wiki/jsnext:main)
+### Importing CommonJS
 
-See [rollup-starter-project](https://github.com/rollup/rollup-starter-project) for inspiration on how to get started.
+Rollup can import existing CommonJS modules [through a plugin](https://github.com/rollup/rollup-plugin-commonjs).
 
+### Publishing ES6 Modules
 
-## How does this compare to JSPM/SystemJS?
+To make sure your ES6 modules are immediately usable by tools that work with CommonJS such as Node.js and webpack, you can use Rollup to compile to UMD or CommonJS format, and then point to that compiled version with the `main` property in your `package.json` file. If your `package.json` file also has a `module` field, ES6-aware tools like Rollup and [webpack 2](https://webpack.js.org/) will [import the ES6 module version](https://github.com/rollup/rollup/wiki/pkg.module) directly.
 
-[JSPM](http://jspm.io/) is awesome, and [it uses Rollup](https://github.com/systemjs/builder/pull/205) in its builder! In addition to bundling modules, it also combines a repository with a package manager and a client-side module loader. JSPM allows you to use any module format and even develop without a build step, so it's a great choice for creating applications. Stand-alone Rollup doesn't use the complex SystemJS format, making it a better choice for creating libraries.
+## Links
 
+- step-by-step [tutorial video series](https://code.lengstorf.com/learn-rollup-js/), with accompanying written walkthrough
+- miscellaneous issues in the [wiki](https://github.com/rollup/rollup/wiki)
 
 ## License
 
-Released under the [MIT license](https://github.com/rollup/rollup/blob/master/LICENSE.md).
+[MIT](https://github.com/rollup/rollup/blob/master/LICENSE.md)

package/bin/rollup

@@ -247,7 +247,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 <output>    Output (if absent, prints to stdout)\n-f, --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-u, --id                 ID for AMD module (default is anonymous)\n-m, --sourcemap          Generate sourcemap (`-m inline` for inline map)\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\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.41.2";
+var version = "0.41.6";
 
 var path$1 = path__default;
 var Module = module$1;
@@ -362,7 +362,7 @@ Object.defineProperty(module, 'exports', {
 });
 
 var index$10 = function () {
-	return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+	return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
 };
 
 var ansiRegex = index$10();
@@ -566,7 +566,7 @@ var errorSymbol = process.stderr.isTTY ? "🚨   " : "Error: ";
 var stderr = console.error.bind( console ); // eslint-disable-line no-console
 
 function log ( object, symbol ) {
-	var message = object.plugin ? ("(" + (object.plugin) + " plugin) " + (object.message)) : object.message;
+	var message = (object.plugin ? ("(" + (object.plugin) + " plugin) " + (object.message)) : object.message) || object;
 
 	stderr( ("" + symbol + (index$3.bold( message ))) );
 

package/dist/rollup.browser.js

@@ -1,6 +1,6 @@
 /*
-	Rollup.js v0.41.2
-	Fri Jan 13 2017 14:29:29 GMT-0500 (EST) - commit e2d9b6bb059a881068b574b2af407ee40ff999cf
+	Rollup.js v0.41.6
+	Thu Mar 16 2017 00:50:36 GMT-0400 (EDT) - commit a96a923d631b9d2c471137542b9c4f578b8faa53
 
 
 	https://github.com/rollup/rollup
@@ -6047,12 +6047,14 @@ function callHasEffects ( scope, callee, isNew ) {
 			}
 		}
 
-		else {
-			if ( !node.gatherPossibleValues ) {
-				throw new Error( 'TODO' );
-			}
+		else if ( node.gatherPossibleValues ) {
 			node.gatherPossibleValues( values );
 		}
+
+		else {
+			// probably an error in the user's code — err on side of caution
+			return true;
+		}
 	}
 
 	return false;
@@ -6263,10 +6265,18 @@ var ConditionalExpression = (function (Node) {
 			else if ( this.testValue ) {
 				code.remove( this.start, this.consequent.start );
 				code.remove( this.consequent.end, this.end );
+				if ( this.consequent.type === 'SequenceExpression' ) {
+					code.insertRight( this.consequent.start, '(' );
+					code.insertLeft( this.consequent.end, ')' );
+				}
 				this.consequent.render( code, es );
 			} else {
 				code.remove( this.start, this.alternate.start );
 				code.remove( this.alternate.end, this.end );
+				if ( this.alternate.type === 'SequenceExpression' ) {
+					code.insertRight( this.alternate.start, '(' );
+					code.insertLeft( this.alternate.end, ')' );
+				}
 				this.alternate.render( code, es );
 			}
 		}
@@ -6436,6 +6446,8 @@ var ExportDefaultDeclaration = (function (Node) {
 					var hasEffects = this.declaration.hasEffects( this.module.scope );
 					code.remove( this.start, hasEffects ? declaration_start : this.next || this.end );
 				}
+			} else if (name === this.declaration.name) {
+				code.remove( this.start, this.next || this.end );
 			} else {
 				code.overwrite( this.start, declaration_start, ((this.module.bundle.varOrConst) + " " + name + " = ") );
 			}
@@ -7060,7 +7072,7 @@ var MemberExpression = (function (Node) {
 		// TODO this code is a bit inefficient
 		var keypath = new Keypath( this );
 
-		if ( !keypath.computed ) {
+		if ( !keypath.computed && keypath.root.type === 'Identifier' ) {
 			var declaration = scope.findDeclaration( keypath.root.name );
 
 			while ( declaration.isNamespace && keypath.parts.length ) {
@@ -8119,6 +8131,7 @@ Module.prototype.toJSON = function toJSON () {
 		dependencies: this.dependencies.map( function (module) { return module.id; } ),
 		code: this.code,
 		originalCode: this.originalCode,
+		originalSourceMap: this.originalSourceMap,
 		ast: this.astClone,
 		sourceMapChain: this.sourceMapChain,
 		resolvedIds: this.resolvedIds
@@ -8132,8 +8145,8 @@ Module.prototype.trace = function trace ( name ) {
 	}
 
 	if ( name in this.imports ) {
-		var importDeclaration = this.imports[ name ];
-			var otherModule = importDeclaration.module;
+			var importDeclaration = this.imports[ name ];
+		var otherModule = importDeclaration.module;
 
 		if ( importDeclaration.name === '*' && !otherModule.isExternal ) {
 			return otherModule.namespace();
@@ -8158,6 +8171,12 @@ Module.prototype.trace = function trace ( name ) {
 Module.prototype.traceExport = function traceExport ( name ) {
 		var this$1 = this;
 
+	// export * from 'external'
+	if ( name[0] === '*' ) {
+		var module = this.bundle.moduleById.get( name.slice( 1 ) );
+		return module.traceExport( '*' );
+	}
+
 	// export { foo } from './other.js'
 	var reexportDeclaration = this.reexports[ name ];
 	if ( reexportDeclaration ) {
@@ -8185,8 +8204,8 @@ Module.prototype.traceExport = function traceExport ( name ) {
 	if ( name === 'default' ) return;
 
 	for ( var i = 0; i < this.exportAllModules.length; i += 1 ) {
-		var module = this$1.exportAllModules[i];
-		var declaration$2 = module.traceExport( name );
+		var module$1 = this$1.exportAllModules[i];
+		var declaration$2 = module$1.traceExport( name );
 
 		if ( declaration$2 ) return declaration$2;
 	}
@@ -9039,6 +9058,9 @@ Link.prototype.traceMappings = function traceMappings () {
 
 		line.forEach( function (segment) {
 			var source = this$1.sources[ segment[1] ];
+
+			if ( !source ) return;
+
 			var traced = source.traceSegment( segment[2], segment[3], this$1.names[ segment[4] ] );
 
 			if ( traced ) {
@@ -9538,7 +9560,9 @@ Bundle$$1.prototype.fetchModule = function fetchModule ( id, importer ) {
 
 			return this$1.fetchAllDependencies( module ).then( function () {
 				keys( module.exports ).forEach( function (name) {
-					module.exportsAll[name] = module.id;
+					if ( name !== 'default' ) {
+						module.exportsAll[name] = module.id;
+					}
 				});
 				module.exportAllSources.forEach( function (source) {
 					var id = module.resolvedIds[ source ];
@@ -9549,10 +9573,11 @@ Bundle$$1.prototype.fetchModule = function fetchModule ( id, importer ) {
 						if ( name in module.exportsAll ) {
 							this$1.warn({
 								code: 'NAMESPACE_CONFLICT',
-								message: ("Conflicting namespaces: " + (relativeId( module.id )) + " re-exports '" + name + "' from both " + (relativeId( module.exportsAll[ name ] )) + " (will be ignored) and " + (relativeId( exportAllModule.exportsAll[ name ] )))
+								message: ("Conflicting namespaces: " + (relativeId( module.id )) + " re-exports '" + name + "' from both " + (relativeId( module.exportsAll[ name ] )) + " and " + (relativeId( exportAllModule.exportsAll[ name ] )) + " (will be ignored)")
 							});
+						} else {
+							  module.exportsAll[ name ] = exportAllModule.exportsAll[ name ];
 						}
-						module.exportsAll[ name ] = exportAllModule.exportsAll[ name ];
 					});
 				});
 				return module;
@@ -9689,7 +9714,7 @@ Bundle$$1.prototype.render = function render ( options ) {
 		.filter( Boolean )
 		.join( '\n\n' );
 
-	if ( intro ) intro += '\n\n';
+		if ( intro ) intro += '\n\n';
 
 	var outro = [ options.outro ]
 		.concat(
@@ -9700,12 +9725,12 @@ Bundle$$1.prototype.render = function render ( options ) {
 
 	if ( outro ) outro = "\n\n" + outro;
 
-	var indentString = getIndentString( magicString, options );
+		var indentString = getIndentString( magicString, options );
 
-		var finalise = finalisers[ options.format ];
+	var finalise = finalisers[ options.format ];
 	if ( !finalise ) {
-			error({
-				code: 'INVALID_OPTION',
+		error({
+			code: 'INVALID_OPTION',
 			message: ("You must specify an output type - valid options are " + (keys( finalisers ).join( ', ' )))
 		});
 	}
@@ -9816,7 +9841,7 @@ Bundle$$1.prototype.sort = function sort () {
 				var b = ordered[i];
 
 				// TODO reinstate this! it no longer works
-				if ( stronglyDependsOn[ a.id ][ b.id ] ) {
+					if ( stronglyDependsOn[ a.id ][ b.id ] ) {
 					// somewhere, there is a module that imports b before a. Because
 					// b imports a, a is placed before b. We need to find the module
 					// in question, so we can provide a useful error message
@@ -9837,7 +9862,7 @@ Bundle$$1.prototype.sort = function sort () {
 
 					findParent( this$1.entryModule );
 
-					this$1.onwarn(
+						this$1.onwarn(
 						("Module " + (a.id) + " may be unable to evaluate without " + (b.id) + ", but is included first due to a cyclical dependency. Consider swapping the import statements in " + parent + " to ensure correct ordering")
 					);
 				}
@@ -9864,7 +9889,7 @@ Bundle$$1.prototype.warn = function warn ( warning ) {
 	this.onwarn( warning );
 };
 
-var VERSION = '0.41.2';
+var VERSION = '0.41.6';
 
 var ALLOWED_KEYS = [
 	'acorn',