webpack 2.2.0-rc.6 → 2.2.1

package/lib/Compilation.js

@@ -29,6 +29,21 @@ function byId(a, b) {
 	return 0;
 }
 
+function iterationBlockVariable(variables, fn) {
+	for(var indexVariable = 0; indexVariable < variables.length; indexVariable++) {
+		var varDep = variables[indexVariable].dependencies;
+		for(var indexVDep = 0; indexVDep < varDep.length; indexVDep++) {
+			fn(varDep[indexVDep]);
+		}
+	}
+}
+
+function iterationOfArrayCallback(arr, fn) {
+	for(var index = 0; index < arr.length; index++) {
+		fn(arr[index]);
+	}
+}
+
 class Compilation extends Tapable {
 	constructor(compiler) {
 		super();
@@ -73,13 +88,13 @@ class Compilation extends Tapable {
 	}
 
 	addModule(module, cacheGroup) {
-		cacheGroup = cacheGroup || "m";
 		const identifier = module.identifier();
 		if(this._modules[identifier]) {
 			return false;
 		}
-		if(this.cache && this.cache[cacheGroup + identifier]) {
-			const cacheModule = this.cache[cacheGroup + identifier];
+		const cacheName = (cacheGroup || "m") + identifier;
+		if(this.cache && this.cache[cacheName]) {
+			const cacheModule = this.cache[cacheName];
 
 			let rebuild = true;
 			if(!cacheModule.error && cacheModule.cacheable && this.fileTimestamps && this.contextTimestamps) {
@@ -100,7 +115,7 @@ class Compilation extends Tapable {
 		module.unbuild();
 		this._modules[identifier] = module;
 		if(this.cache) {
-			this.cache[cacheGroup + identifier] = module;
+			this.cache[cacheName] = module;
 		}
 		this.modules.push(module);
 		return true;
@@ -124,24 +139,29 @@ class Compilation extends Tapable {
 			module.building = undefined;
 			building.forEach(cb => cb(err));
 		}
-		module.build(this.options, this, this.resolvers.normal, this.inputFileSystem, (err) => {
-			module.errors.forEach(err => {
+		module.build(this.options, this, this.resolvers.normal, this.inputFileSystem, (error) => {
+			var errors = module.errors;
+			for(var indexError = 0; indexError < errors.length; indexError++) {
+				var err = errors[indexError];
 				err.origin = origin;
 				err.dependencies = dependencies;
 				if(optional)
 					this.warnings.push(err);
 				else
 					this.errors.push(err);
-			}, this);
-			module.warnings.forEach(err => {
-				err.origin = origin;
-				err.dependencies = dependencies;
-				this.warnings.push(err);
-			}, this);
+			}
+
+			var warnings = module.warnings;
+			for(var indexWarning = 0; indexWarning < warnings.length; indexWarning++) {
+				var war = warnings[indexWarning];
+				war.origin = origin;
+				war.dependencies = dependencies;
+				this.warnings.push(war);
+			}
 			module.dependencies.sort(Dependency.compare);
-			if(err) {
-				this.applyPlugins2("failed-module", module, err);
-				return callback(err);
+			if(error) {
+				this.applyPlugins2("failed-module", module, error);
+				return callback(error);
 			}
 			this.applyPlugins1("succeed-module", module);
 			return callback();
@@ -162,13 +182,13 @@ class Compilation extends Tapable {
 
 		function addDependenciesBlock(block) {
 			if(block.dependencies) {
-				block.dependencies.forEach(addDependency);
+				iterationOfArrayCallback(block.dependencies, addDependency);
 			}
 			if(block.blocks) {
-				block.blocks.forEach(addDependenciesBlock);
+				iterationOfArrayCallback(block.blocks, addDependenciesBlock);
 			}
 			if(block.variables) {
-				block.variables.forEach(v => v.dependencies.forEach(addDependency));
+				iterationBlockVariable(block.variables, addDependency);
 			}
 		}
 		addDependenciesBlock(module);
@@ -226,6 +246,15 @@ class Compilation extends Tapable {
 						return errorAndCallback(err);
 					}
 				}
+
+				function iterationDependencies(depend) {
+					for(var index = 0; index < depend.length; index++) {
+						var dep = depend[index];
+						dep.module = dependentModule;
+						dependentModule.addReason(module, dep);
+					}
+				}
+
 				if(err) {
 					return errorOrWarningAndCallback(new ModuleNotFoundError(module, err, dependencies));
 				}
@@ -250,10 +279,7 @@ class Compilation extends Tapable {
 						dependentModule.optional = isOptional();
 					}
 
-					dependencies.forEach(dep => {
-						dep.module = dependentModule;
-						dependentModule.addReason(module, dep);
-					});
+					iterationDependencies(dependencies);
 
 					if(_this.profile) {
 						if(!module.profile) {
@@ -277,10 +303,7 @@ class Compilation extends Tapable {
 					newModule.issuer = dependentModule.issuer;
 					dependentModule = newModule;
 
-					dependencies.forEach(dep => {
-						dep.module = dependentModule;
-						dependentModule.addReason(module, dep);
-					});
+					iterationDependencies(dependencies);
 
 					if(_this.profile) {
 						const afterBuilding = +new Date();
@@ -296,10 +319,7 @@ class Compilation extends Tapable {
 
 				dependentModule.optional = isOptional();
 
-				dependencies.forEach(dep => {
-					dep.module = dependentModule;
-					dependentModule.addReason(module, dep);
-				});
+				iterationDependencies(dependencies);
 
 				_this.buildModule(dependentModule, isOptional(), module, dependencies, err => {
 					if(err) {
@@ -498,8 +518,13 @@ class Compilation extends Tapable {
 	}
 
 	finish() {
-		this.applyPlugins1("finish-modules", this.modules);
-		this.modules.forEach(m => this.reportDependencyErrorsAndWarnings(m, [m]));
+		var modules = this.modules;
+		this.applyPlugins1("finish-modules", modules);
+
+		for(var index = 0; index < modules.length; index++) {
+			var module = modules[index];
+			this.reportDependencyErrorsAndWarnings(module, [module]);
+		}
 	}
 
 	unseal() {
@@ -628,25 +653,35 @@ class Compilation extends Tapable {
 	}
 
 	reportDependencyErrorsAndWarnings(module, blocks) {
-		blocks.forEach(block => {
-			block.dependencies.forEach(d => {
+		for(var indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
+			var block = blocks[indexBlock];
+			var dependencies = block.dependencies;
+
+			for(var indexDep = 0; indexDep < dependencies.length; indexDep++) {
+				var d = dependencies[indexDep];
+
 				const warnings = d.getWarnings();
 				if(warnings) {
-					warnings.forEach(w => {
-						const warning = new ModuleDependencyWarning(module, w, d.loc);
+					for(var indexWar = 0; indexWar < warnings.length; indexWar++) {
+						var w = warnings[indexWar];
+
+						var warning = new ModuleDependencyWarning(module, w, d.loc);
 						this.warnings.push(warning);
-					});
+					}
 				}
 				const errors = d.getErrors();
 				if(errors) {
-					errors.forEach(w => {
-						const warning = new ModuleDependencyError(module, w, d.loc);
-						this.errors.push(warning);
-					});
+					for(var indexErr = 0; indexErr < errors.length; indexErr++) {
+						var e = errors[indexErr];
+
+						var error = new ModuleDependencyError(module, e, d.loc);
+						this.errors.push(error);
+					}
 				}
-			});
+			}
+
 			this.reportDependencyErrorsAndWarnings(module, block.blocks);
-		});
+		}
 	}
 
 	addChunk(name, module, loc) {
@@ -671,6 +706,14 @@ class Compilation extends Tapable {
 	assignIndex(module) {
 		const _this = this;
 
+		const queue = [() => {
+			assignIndexToModule(module);
+		}];
+
+		const iteratorAllDependencies = d => {
+			queue.push(() => assignIndexToDependency(d));
+		};
+
 		function assignIndexToModule(module) {
 			// enter module
 			if(typeof module.index !== "number") {
@@ -691,7 +734,7 @@ class Compilation extends Tapable {
 		}
 
 		function assignIndexToDependencyBlock(block) {
-			const allDependencies = [];
+			var allDependencies = [];
 
 			function iteratorDependency(d) {
 				allDependencies.push(d);
@@ -702,22 +745,26 @@ class Compilation extends Tapable {
 			}
 
 			if(block.variables) {
-				block.variables.forEach(v => v.dependencies.forEach(iteratorDependency));
+				iterationBlockVariable(block.variables, iteratorDependency);
 			}
+
 			if(block.dependencies) {
-				block.dependencies.forEach(iteratorDependency);
+				iterationOfArrayCallback(block.dependencies, iteratorDependency);
 			}
 			if(block.blocks) {
-				block.blocks.slice().reverse().forEach(iteratorBlock, this);
+				var blocks = block.blocks;
+				var indexBlock = blocks.length;
+				while(indexBlock--) {
+					iteratorBlock(blocks[indexBlock]);
+				}
 			}
 
-			allDependencies.reverse();
-			allDependencies.forEach(d => queue.push(() => assignIndexToDependency(d)));
+			var indexAll = allDependencies.length;
+			while(indexAll--) {
+				iteratorAllDependencies(allDependencies[indexAll]);
+			}
 		}
 
-		const queue = [() => {
-			assignIndexToModule(module);
-		}];
 		while(queue.length) {
 			queue.pop()();
 		}
@@ -749,13 +796,15 @@ class Compilation extends Tapable {
 			}
 
 			if(block.variables) {
-				block.variables.forEach(v => v.dependencies.forEach(iteratorDependency, this));
+				iterationBlockVariable(block.variables, iteratorDependency);
 			}
+
 			if(block.dependencies) {
-				block.dependencies.forEach(iteratorDependency);
+				iterationOfArrayCallback(block.dependencies, iteratorDependency);
 			}
+
 			if(block.blocks) {
-				block.blocks.forEach(iteratorBlock, this);
+				iterationOfArrayCallback(block.blocks, iteratorBlock);
 			}
 		}
 
@@ -768,25 +817,7 @@ class Compilation extends Tapable {
 	}
 
 	processDependenciesBlockForChunk(block, chunk) {
-		const queue = [
-			[block, chunk]
-		];
-		while(queue.length) {
-			const queueItem = queue.pop();
-			block = queueItem[0];
-			chunk = queueItem[1];
-			if(block.variables) {
-				block.variables.forEach(v => v.dependencies.forEach(iteratorDependency, this));
-			}
-			if(block.dependencies) {
-				block.dependencies.forEach(iteratorDependency, this);
-			}
-			if(block.blocks) {
-				block.blocks.forEach(iteratorBlock, this);
-			}
-		}
-
-		function iteratorBlock(b) {
+		const iteratorBlock = b => {
 			let c;
 			if(!b.chunks) {
 				c = this.addChunk(b.chunkName, b.module, b.loc);
@@ -798,9 +829,9 @@ class Compilation extends Tapable {
 			chunk.addChunk(c);
 			c.addParent(chunk);
 			queue.push([b, c]);
-		}
+		};
 
-		function iteratorDependency(d) {
+		const iteratorDependency = d => {
 			if(!d.module) {
 				return;
 			}
@@ -811,19 +842,33 @@ class Compilation extends Tapable {
 				d.module.addChunk(chunk);
 				queue.push([d.module, chunk]);
 			}
+		};
+
+		const queue = [
+			[block, chunk]
+		];
+
+		while(queue.length) {
+			var queueItem = queue.pop();
+			block = queueItem[0];
+			chunk = queueItem[1];
+
+			if(block.variables) {
+				iterationBlockVariable(block.variables, iteratorDependency);
+			}
+
+			if(block.dependencies) {
+				iterationOfArrayCallback(block.dependencies, iteratorDependency);
+			}
+
+			if(block.blocks) {
+				iterationOfArrayCallback(block.blocks, iteratorBlock);
+			}
 		}
 	}
 
 	removeChunkFromDependencies(block, chunk) {
-		block.blocks.forEach(b => {
-			b.chunks.forEach(c => {
-				chunk.removeChunk(c);
-				c.removeParent(chunk);
-				this.removeChunkFromDependencies(b, c);
-			});
-		});
-
-		function iteratorDependency(d) {
+		const iteratorDependency = d => {
 			if(!d.module) {
 				return;
 			}
@@ -832,64 +877,121 @@ class Compilation extends Tapable {
 					this.removeChunkFromDependencies(d.module, chunk);
 				}
 			}
+		};
+
+		var blocks = block.blocks;
+		for(var indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
+			var chunks = blocks[indexBlock].chunks;
+			for(var indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
+				var blockChunk = chunks[indexChunk];
+				chunk.removeChunk(blockChunk);
+				blockChunk.removeParent(chunk);
+				this.removeChunkFromDependencies(chunks, blockChunk);
+			}
+		}
+
+		if(block.dependencies) {
+			iterationOfArrayCallback(block.dependencies, iteratorDependency);
+		}
+
+		if(block.variables) {
+			iterationBlockVariable(block.variables, iteratorDependency);
 		}
-		block.dependencies.forEach(iteratorDependency, this);
-		block.variables.forEach(v => v.dependencies.forEach(iteratorDependency, this));
 	}
 
 	applyModuleIds() {
-		const unusedIds = [];
-		let nextFreeModuleId = 0;
-		const usedIds = [];
-		const usedIdMap = {};
+		var unusedIds = [];
+		var nextFreeModuleId = 0;
+		var usedIds = [];
+		// TODO consider Map when performance has improved https://gist.github.com/sokra/234c077e1299b7369461f1708519c392
+		var usedIdMap = Object.create(null);
 		if(this.usedModuleIds) {
 			Object.keys(this.usedModuleIds).forEach(key => {
 				const id = this.usedModuleIds[key];
-				if(typeof usedIdMap[id] === "undefined") {
+				if(!usedIdMap[id]) {
 					usedIds.push(id);
-					usedIdMap[id] = id;
+					usedIdMap[id] = true;
 				}
 			});
 		}
-		this.modules.forEach(module => {
-			if(module.id !== null && typeof usedIdMap[module.id] === "undefined") {
-				usedIds.push(module.id);
-				usedIdMap[module.id] = module.id;
+
+		var modules1 = this.modules;
+		for(var indexModule1 = 0; indexModule1 < modules1.length; indexModule1++) {
+			var module1 = modules1[indexModule1];
+			if(module1.id && !usedIdMap[module1.id]) {
+				usedIds.push(module1.id);
+				usedIdMap[module1.id] = true;
 			}
-		});
+		}
+
 		if(usedIds.length > 0) {
-			const usedNumberIds = usedIds.filter(id => typeof id === "number");
-			nextFreeModuleId = usedNumberIds.reduce((a, b) => Math.max(a, b), -1) + 1;
-			for(let i = 0; i < nextFreeModuleId; i++) {
-				if(usedIdMap[i] !== i)
-					unusedIds.push(i);
+			var usedIdMax = -1;
+			for(var index = 0; index < usedIds.length; index++) {
+				var usedIdKey = usedIds[index];
+
+				if(typeof usedIdKey !== "number") {
+					continue;
+				}
+
+				usedIdMax = Math.max(usedIdMax, usedIdKey);
+			}
+
+			var lengthFreeModules = nextFreeModuleId = usedIdMax + 1;
+
+			while(lengthFreeModules--) {
+				if(!usedIdMap[lengthFreeModules]) {
+					unusedIds.push(lengthFreeModules);
+				}
 			}
-			unusedIds.reverse();
 		}
-		this.modules.forEach(module => {
-			if(module.id === null) {
+
+		var modules2 = this.modules;
+		for(var indexModule2 = 0; indexModule2 < modules2.length; indexModule2++) {
+			var module2 = modules2[indexModule2];
+			if(module2.id === null) {
 				if(unusedIds.length > 0)
-					module.id = unusedIds.pop();
+					module2.id = unusedIds.pop();
 				else
-					module.id = nextFreeModuleId++;
+					module2.id = nextFreeModuleId++;
 			}
-		});
+		}
 	}
 
 	applyChunkIds() {
 		const unusedIds = [];
 		let nextFreeChunkId = 0;
+
+		function getNextFreeChunkId(usedChunkIds) {
+			var keyChunks = Object.keys(usedChunkIds);
+			var result = -1;
+
+			for(var index = 0; index < keyChunks.length; index++) {
+				var usedIdKey = keyChunks[index];
+				var usedIdValue = usedChunkIds[usedIdKey];
+
+				if(typeof usedIdValue !== "number") {
+					continue;
+				}
+
+				result = Math.max(result, usedIdValue);
+			}
+
+			return result;
+		}
+
 		if(this.usedChunkIds) {
-			const usedIds = Object.keys(this.usedChunkIds).map(key => this.usedChunkIds[key]).sort();
-			const usedNumberIds = usedIds.filter(id => typeof id === "number");
-			nextFreeChunkId = usedNumberIds.reduce((a, b) => Math.max(a, b), -1) + 1;
-			for(let i = 0; i < nextFreeChunkId; i++) {
-				if(this.usedChunkIds[i] !== i)
-					unusedIds.push(i);
+			nextFreeChunkId = getNextFreeChunkId(this.usedChunkIds) + 1;
+			var index = nextFreeChunkId;
+			while(index--) {
+				if(this.usedChunkIds[index] !== index) {
+					unusedIds.push(index);
+				}
 			}
-			unusedIds.reverse();
 		}
-		this.chunks.forEach(chunk => {
+
+		var chunks = this.chunks;
+		for(var indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
+			var chunk = chunks[indexChunk];
 			if(chunk.id === null) {
 				if(unusedIds.length > 0)
 					chunk.id = unusedIds.pop();
@@ -899,19 +1001,35 @@ class Compilation extends Tapable {
 			if(!chunk.ids) {
 				chunk.ids = [chunk.id];
 			}
-		});
+		}
 	}
 
 	sortItemsWithModuleIds() {
 		this.modules.sort(byId);
-		this.modules.forEach(module => module.sortItems());
-		this.chunks.forEach(chunk => chunk.sortItems());
+
+		var modules = this.modules;
+		for(var indexModule = 0; indexModule < modules.length; indexModule++) {
+			modules[indexModule].sortItems();
+		}
+
+		var chunks = this.chunks;
+		for(var indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
+			chunks[indexChunk].sortItems();
+		}
 	}
 
 	sortItemsWithChunkIds() {
 		this.chunks.sort(byId);
-		this.modules.forEach(module => module.sortItems());
-		this.chunks.forEach(chunk => chunk.sortItems());
+
+		var modules = this.modules;
+		for(var indexModule = 0; indexModule < modules.length; indexModule++) {
+			modules[indexModule].sortItems();
+		}
+
+		var chunks = this.chunks;
+		for(var indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
+			chunks[indexChunk].sortItems();
+		}
 	}
 
 	summarizeDependencies() {
@@ -926,19 +1044,33 @@ class Compilation extends Tapable {
 		this.fileDependencies = (this.compilationDependencies || []).slice();
 		this.contextDependencies = [];
 		this.missingDependencies = [];
-		this.children.forEach(child => {
+
+		var children = this.children;
+		for(var indexChildren = 0; indexChildren < children.length; indexChildren++) {
+			var child = children[indexChildren];
+
 			this.fileDependencies = this.fileDependencies.concat(child.fileDependencies);
 			this.contextDependencies = this.contextDependencies.concat(child.contextDependencies);
 			this.missingDependencies = this.missingDependencies.concat(child.missingDependencies);
-		});
-		this.modules.forEach(module => {
+		}
+
+		var modules = this.modules;
+		for(var indexModule = 0; indexModule < modules.length; indexModule++) {
+			var module = modules[indexModule];
+
 			if(module.fileDependencies) {
-				module.fileDependencies.forEach(item => this.fileDependencies.push(item));
+				var fileDependencies = module.fileDependencies;
+				for(var indexFileDep = 0; indexFileDep < fileDependencies.length; indexFileDep++) {
+					this.fileDependencies.push(fileDependencies[indexFileDep]);
+				}
 			}
 			if(module.contextDependencies) {
-				module.contextDependencies.forEach(item => this.contextDependencies.push(item));
+				var contextDependencies = module.contextDependencies;
+				for(var indexContextDep = 0; indexContextDep < contextDependencies.length; indexContextDep++) {
+					this.contextDependencies.push(contextDependencies[indexContextDep]);
+				}
 			}
-		});
+		}
 		this.errors.forEach(error => {
 			if(Array.isArray(error.missing)) {
 				error.missing.forEach(item => this.missingDependencies.push(item));
@@ -1046,8 +1178,9 @@ class Compilation extends Tapable {
 			try {
 				const useChunkHash = !chunk.hasRuntime() || (this.mainTemplate.useChunkHash && this.mainTemplate.useChunkHash(chunk));
 				const usedHash = useChunkHash ? chunkHash : this.fullHash;
-				if(this.cache && this.cache[`c${chunk.id}`] && this.cache[`c${chunk.id}`].hash === usedHash) {
-					source = this.cache[`c${chunk.id}`].source;
+				const cacheName = "c" + chunk.id;
+				if(this.cache && this.cache[cacheName] && this.cache[cacheName].hash === usedHash) {
+					source = this.cache[cacheName].source;
 				} else {
 					if(chunk.hasRuntime()) {
 						source = this.mainTemplate.render(this.hash, chunk, this.moduleTemplate, this.dependencyTemplates);
@@ -1055,7 +1188,7 @@ class Compilation extends Tapable {
 						source = this.chunkTemplate.render(chunk, this.moduleTemplate, this.dependencyTemplates);
 					}
 					if(this.cache) {
-						this.cache[`c${chunk.id}`] = {
+						this.cache[cacheName] = {
 							hash: usedHash,
 							source: source = (source instanceof CachedSource ? source : new CachedSource(source))
 						};
@@ -1092,15 +1225,23 @@ class Compilation extends Tapable {
 
 	checkConstraints() {
 		const usedIds = {};
-		this.modules.forEach(module => {
-			if(usedIds[module.id])
-				throw new Error(`checkConstraints: duplicate module id ${module.id}`);
-		});
-		this.chunks.forEach((chunk, idx) => {
-			if(this.chunks.indexOf(chunk) !== idx)
+
+		var modules = this.modules;
+		for(var indexModule = 0; indexModule < modules.length; indexModule++) {
+			var moduleId = modules[indexModule].id;
+
+			if(usedIds[moduleId])
+				throw new Error(`checkConstraints: duplicate module id ${moduleId}`);
+		}
+
+		var chunks = this.chunks;
+		for(var indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
+			var chunk = chunks[indexChunk];
+
+			if(chunks.indexOf(chunk) !== indexChunk)
 				throw new Error(`checkConstraints: duplicate chunk in compilation ${chunk.debugId}`);
 			chunk.checkConstraints();
-		});
+		}
 	}
 }
 

package/lib/Compiler.js

@@ -320,8 +320,11 @@ Compiler.prototype.emitAssets = function(compilation, callback) {
 					return callback();
 				}
 				var content = source.source();
-				if(!Buffer.isBuffer(content))
-					content = Buffer.from(content, "utf8");
+
+				if(!Buffer.isBuffer(content)) {
+					content = new Buffer(content, "utf8"); //eslint-disable-line
+				}
+
 				source.existsAt = targetPath;
 				source.emitted = true;
 				this.outputFileSystem.writeFile(targetPath, content, callback);