├── .babelrc
├── .gitignore
├── integration
    ├── run.js
    └── styles
    │   ├── bundle.js
    │   ├── config.js
    │   ├── index.html
    │   ├── index.js
    │   └── styles.css
├── karma.conf.js
├── lib
    ├── basic
    │   └── index.js
    ├── config
    │   ├── configure.js
    │   ├── loader.js
    │   └── utils.js
    ├── configure.js
    ├── index.js
    ├── loader.js
    └── utils.js
├── package.json
├── src
    ├── assets
    │   └── index.js
    ├── babel
    │   └── index.js
    ├── basic
    │   └── index.js
    ├── config
    │   ├── clone.js
    │   ├── configure.js
    │   ├── inject
    │   │   ├── env.js
    │   │   ├── index.js
    │   │   ├── loader.js
    │   │   ├── plugin.js
    │   │   └── resolve.js
    │   ├── loader.js
    │   ├── merge.js
    │   ├── utils.js
    │   └── validate.js
    ├── es6
    │   └── index.js
    ├── helpers.js
    ├── html
    │   └── index.js
    ├── index.js
    ├── react
    │   └── index.js
    └── styles
    │   └── index.js
├── test-entry.js
├── test-helpers.js
└── test
    ├── assets
        ├── fixtures
        │   ├── config.js
        │   ├── entry.js
        │   ├── fonts
        │   │   ├── rw-widgets.eot
        │   │   ├── rw-widgets.svg
        │   │   ├── rw-widgets.ttf
        │   │   └── rw-widgets.woff
        │   └── img
        │   │   ├── loader-big.gif
        │   │   └── loader.gif
        └── unit.js
    ├── babel
        ├── fixtures
        │   ├── config.js
        │   ├── entry.js
        │   └── foo.es6
        └── unit.js
    ├── basic
        ├── fixtures
        │   ├── config.js
        │   ├── data.json
        │   └── entry.js
        └── unit.js
    ├── configure.js
    ├── loader.js
    ├── react
        ├── fixtures
        │   ├── Component.jsx
        │   ├── config.js
        │   └── entry.js
        └── unit.js
    ├── styles
        ├── fixtures
        │   ├── config.js
        │   ├── entry.js
        │   └── styles.css
        └── unit.js
    └── validations.js


/.babelrc:
--------------------------------------------------------------------------------
1 | {
2 |   stage: 1,
3 |   plugins: [
4 |     "object-assign"
5 |   ]
6 | }
7 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | *.es6.js
3 | 


--------------------------------------------------------------------------------
/integration/run.js:
--------------------------------------------------------------------------------
 1 | require('babel/register');
 2 | 
 3 | var path = require('path')
 4 | var argv = require('yargs').argv;
 5 | var open = require('open');
 6 | var Mocha = require('mocha')
 7 | var webpack = require('webpack');
 8 | 
 9 | var test = argv._[0];
10 | 
11 | if (!test)
12 |   throw new Error('must include a test')
13 | 
14 | var config = require(path.join(__dirname, test, 'config.js'))
15 | 
16 | 
17 | console.log(config)
18 | var compiler = webpack(config)
19 | 
20 | if (argv.watch)
21 |   compiler.watch({}, report)
22 | else
23 |   compiler.run(function(err, stats) {
24 |     report(err, stats)
25 |   })
26 | 
27 | var first = true;
28 | 
29 | function runServerTests(stats) {
30 |   var test = require(path.join(__dirname, test, 'config.js'))
31 |   var mocha = new Mocha({
32 |     reporter: 'Spec',
33 |     globals:
34 |   });
35 | }
36 | 
37 | function report(err, stats) {
38 |   if (argv.open && first)
39 |     open(path.join(__dirname, test, 'output/index.html'), 'chrome');
40 | 
41 |   first = false
42 |   if (err) {
43 |     console.error(err.stack || err)
44 |     if (err.details) console.error(err.details)
45 |     return process.on("exit", function () { process.exit(1) })
46 |   }
47 |   process.stdout.write(stats.toString() + '\n')
48 | }
49 | 
50 | var errors = (stats.compilation.errors || []).join('\n');
51 | var warnings = (stats.compilation.warnings || []).join('\n');
52 | 


--------------------------------------------------------------------------------
/integration/styles/bundle.js:
--------------------------------------------------------------------------------
  1 | /******/ (function(modules) { // webpackBootstrap
  2 | /******/ 	// The module cache
  3 | /******/ 	var installedModules = {};
  4 | 
  5 | /******/ 	// The require function
  6 | /******/ 	function __webpack_require__(moduleId) {
  7 | 
  8 | /******/ 		// Check if module is in cache
  9 | /******/ 		if(installedModules[moduleId])
 10 | /******/ 			return installedModules[moduleId].exports;
 11 | 
 12 | /******/ 		// Create a new module (and put it into the cache)
 13 | /******/ 		var module = installedModules[moduleId] = {
 14 | /******/ 			exports: {},
 15 | /******/ 			id: moduleId,
 16 | /******/ 			loaded: false
 17 | /******/ 		};
 18 | 
 19 | /******/ 		// Execute the module function
 20 | /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
 21 | 
 22 | /******/ 		// Flag the module as loaded
 23 | /******/ 		module.loaded = true;
 24 | 
 25 | /******/ 		// Return the exports of the module
 26 | /******/ 		return module.exports;
 27 | /******/ 	}
 28 | 
 29 | 
 30 | /******/ 	// expose the modules object (__webpack_modules__)
 31 | /******/ 	__webpack_require__.m = modules;
 32 | 
 33 | /******/ 	// expose the module cache
 34 | /******/ 	__webpack_require__.c = installedModules;
 35 | 
 36 | /******/ 	// __webpack_public_path__
 37 | /******/ 	__webpack_require__.p = "";
 38 | 
 39 | /******/ 	// Load entry module and return exports
 40 | /******/ 	return __webpack_require__(0);
 41 | /******/ })
 42 | /************************************************************************/
 43 | /******/ ([
 44 | /* 0 */
 45 | /***/ function(module, exports, __webpack_require__) {
 46 | 
 47 | 	
 48 | 	__webpack_require__(1)
 49 | 
 50 | 
 51 | /***/ },
 52 | /* 1 */
 53 | /***/ function(module, exports, __webpack_require__) {
 54 | 
 55 | 	// style-loader: Adds some css to the DOM by adding a <style> tag
 56 | 
 57 | 	// load the styles
 58 | 	var content = __webpack_require__(2);
 59 | 	if(typeof content === 'string') content = [[module.id, content, '']];
 60 | 	// add the styles to the DOM
 61 | 	var update = __webpack_require__(4)(content, {});
 62 | 	if(content.locals) module.exports = content.locals;
 63 | 	// Hot Module Replacement
 64 | 	if(false) {
 65 | 		// When the styles change, update the <style> tags
 66 | 		if(!content.locals) {
 67 | 			module.hot.accept("!!./../node_modules/css-loader/index.js!./styles.css", function() {
 68 | 				var newContent = require("!!./../node_modules/css-loader/index.js!./styles.css");
 69 | 				if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
 70 | 				update(newContent);
 71 | 			});
 72 | 		}
 73 | 		// When the module is disposed, remove the <style> tags
 74 | 		module.hot.dispose(function() { update(); });
 75 | 	}
 76 | 
 77 | /***/ },
 78 | /* 2 */
 79 | /***/ function(module, exports, __webpack_require__) {
 80 | 
 81 | 	exports = module.exports = __webpack_require__(3)();
 82 | 	// imports
 83 | 
 84 | 
 85 | 	// module
 86 | 	exports.push([module.id, "\r\nbody {\r\n  font-size: 24px;\r\n}\r\n\r\n.box {\r\n  padding: 20px;\r\n  border: 1px blue solid;\r\n}\r\n\r\n.red {\r\n  color: red;\r\n}\r\n", ""]);
 87 | 
 88 | 	// exports
 89 | 
 90 | 
 91 | /***/ },
 92 | /* 3 */
 93 | /***/ function(module, exports) {
 94 | 
 95 | 	/*
 96 | 		MIT License http://www.opensource.org/licenses/mit-license.php
 97 | 		Author Tobias Koppers @sokra
 98 | 	*/
 99 | 	// css base code, injected by the css-loader
100 | 	module.exports = function() {
101 | 		var list = [];
102 | 
103 | 		// return the list of modules as css string
104 | 		list.toString = function toString() {
105 | 			var result = [];
106 | 			for(var i = 0; i < this.length; i++) {
107 | 				var item = this[i];
108 | 				if(item[2]) {
109 | 					result.push("@media " + item[2] + "{" + item[1] + "}");
110 | 				} else {
111 | 					result.push(item[1]);
112 | 				}
113 | 			}
114 | 			return result.join("");
115 | 		};
116 | 
117 | 		// import a list of modules into the list
118 | 		list.i = function(modules, mediaQuery) {
119 | 			if(typeof modules === "string")
120 | 				modules = [[null, modules, ""]];
121 | 			var alreadyImportedModules = {};
122 | 			for(var i = 0; i < this.length; i++) {
123 | 				var id = this[i][0];
124 | 				if(typeof id === "number")
125 | 					alreadyImportedModules[id] = true;
126 | 			}
127 | 			for(i = 0; i < modules.length; i++) {
128 | 				var item = modules[i];
129 | 				// skip already imported module
130 | 				// this implementation is not 100% perfect for weird media query combinations
131 | 				//  when a module is imported multiple times with different media queries.
132 | 				//  I hope this will never occur (Hey this way we have smaller bundles)
133 | 				if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
134 | 					if(mediaQuery && !item[2]) {
135 | 						item[2] = mediaQuery;
136 | 					} else if(mediaQuery) {
137 | 						item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
138 | 					}
139 | 					list.push(item);
140 | 				}
141 | 			}
142 | 		};
143 | 		return list;
144 | 	};
145 | 
146 | 
147 | /***/ },
148 | /* 4 */
149 | /***/ function(module, exports, __webpack_require__) {
150 | 
151 | 	/*
152 | 		MIT License http://www.opensource.org/licenses/mit-license.php
153 | 		Author Tobias Koppers @sokra
154 | 	*/
155 | 	var stylesInDom = {},
156 | 		memoize = function(fn) {
157 | 			var memo;
158 | 			return function () {
159 | 				if (typeof memo === "undefined") memo = fn.apply(this, arguments);
160 | 				return memo;
161 | 			};
162 | 		},
163 | 		isOldIE = memoize(function() {
164 | 			return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
165 | 		}),
166 | 		getHeadElement = memoize(function () {
167 | 			return document.head || document.getElementsByTagName("head")[0];
168 | 		}),
169 | 		singletonElement = null,
170 | 		singletonCounter = 0,
171 | 		styleElementsInsertedAtTop = [];
172 | 
173 | 	module.exports = function(list, options) {
174 | 		if(false) {
175 | 			if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
176 | 		}
177 | 
178 | 		options = options || {};
179 | 		// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
180 | 		// tags it will allow on a page
181 | 		if (typeof options.singleton === "undefined") options.singleton = isOldIE();
182 | 
183 | 		// By default, add <style> tags to the bottom of <head>.
184 | 		if (typeof options.insertAt === "undefined") options.insertAt = "bottom";
185 | 
186 | 		var styles = listToStyles(list);
187 | 		addStylesToDom(styles, options);
188 | 
189 | 		return function update(newList) {
190 | 			var mayRemove = [];
191 | 			for(var i = 0; i < styles.length; i++) {
192 | 				var item = styles[i];
193 | 				var domStyle = stylesInDom[item.id];
194 | 				domStyle.refs--;
195 | 				mayRemove.push(domStyle);
196 | 			}
197 | 			if(newList) {
198 | 				var newStyles = listToStyles(newList);
199 | 				addStylesToDom(newStyles, options);
200 | 			}
201 | 			for(var i = 0; i < mayRemove.length; i++) {
202 | 				var domStyle = mayRemove[i];
203 | 				if(domStyle.refs === 0) {
204 | 					for(var j = 0; j < domStyle.parts.length; j++)
205 | 						domStyle.parts[j]();
206 | 					delete stylesInDom[domStyle.id];
207 | 				}
208 | 			}
209 | 		};
210 | 	}
211 | 
212 | 	function addStylesToDom(styles, options) {
213 | 		for(var i = 0; i < styles.length; i++) {
214 | 			var item = styles[i];
215 | 			var domStyle = stylesInDom[item.id];
216 | 			if(domStyle) {
217 | 				domStyle.refs++;
218 | 				for(var j = 0; j < domStyle.parts.length; j++) {
219 | 					domStyle.parts[j](item.parts[j]);
220 | 				}
221 | 				for(; j < item.parts.length; j++) {
222 | 					domStyle.parts.push(addStyle(item.parts[j], options));
223 | 				}
224 | 			} else {
225 | 				var parts = [];
226 | 				for(var j = 0; j < item.parts.length; j++) {
227 | 					parts.push(addStyle(item.parts[j], options));
228 | 				}
229 | 				stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
230 | 			}
231 | 		}
232 | 	}
233 | 
234 | 	function listToStyles(list) {
235 | 		var styles = [];
236 | 		var newStyles = {};
237 | 		for(var i = 0; i < list.length; i++) {
238 | 			var item = list[i];
239 | 			var id = item[0];
240 | 			var css = item[1];
241 | 			var media = item[2];
242 | 			var sourceMap = item[3];
243 | 			var part = {css: css, media: media, sourceMap: sourceMap};
244 | 			if(!newStyles[id])
245 | 				styles.push(newStyles[id] = {id: id, parts: [part]});
246 | 			else
247 | 				newStyles[id].parts.push(part);
248 | 		}
249 | 		return styles;
250 | 	}
251 | 
252 | 	function insertStyleElement(options, styleElement) {
253 | 		var head = getHeadElement();
254 | 		var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
255 | 		if (options.insertAt === "top") {
256 | 			if(!lastStyleElementInsertedAtTop) {
257 | 				head.insertBefore(styleElement, head.firstChild);
258 | 			} else if(lastStyleElementInsertedAtTop.nextSibling) {
259 | 				head.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
260 | 			} else {
261 | 				head.appendChild(styleElement);
262 | 			}
263 | 			styleElementsInsertedAtTop.push(styleElement);
264 | 		} else if (options.insertAt === "bottom") {
265 | 			head.appendChild(styleElement);
266 | 		} else {
267 | 			throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
268 | 		}
269 | 	}
270 | 
271 | 	function removeStyleElement(styleElement) {
272 | 		styleElement.parentNode.removeChild(styleElement);
273 | 		var idx = styleElementsInsertedAtTop.indexOf(styleElement);
274 | 		if(idx >= 0) {
275 | 			styleElementsInsertedAtTop.splice(idx, 1);
276 | 		}
277 | 	}
278 | 
279 | 	function createStyleElement(options) {
280 | 		var styleElement = document.createElement("style");
281 | 		styleElement.type = "text/css";
282 | 		insertStyleElement(options, styleElement);
283 | 		return styleElement;
284 | 	}
285 | 
286 | 	function createLinkElement(options) {
287 | 		var linkElement = document.createElement("link");
288 | 		linkElement.rel = "stylesheet";
289 | 		insertStyleElement(options, linkElement);
290 | 		return linkElement;
291 | 	}
292 | 
293 | 	function addStyle(obj, options) {
294 | 		var styleElement, update, remove;
295 | 
296 | 		if (options.singleton) {
297 | 			var styleIndex = singletonCounter++;
298 | 			styleElement = singletonElement || (singletonElement = createStyleElement(options));
299 | 			update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
300 | 			remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
301 | 		} else if(obj.sourceMap &&
302 | 			typeof URL === "function" &&
303 | 			typeof URL.createObjectURL === "function" &&
304 | 			typeof URL.revokeObjectURL === "function" &&
305 | 			typeof Blob === "function" &&
306 | 			typeof btoa === "function") {
307 | 			styleElement = createLinkElement(options);
308 | 			update = updateLink.bind(null, styleElement);
309 | 			remove = function() {
310 | 				removeStyleElement(styleElement);
311 | 				if(styleElement.href)
312 | 					URL.revokeObjectURL(styleElement.href);
313 | 			};
314 | 		} else {
315 | 			styleElement = createStyleElement(options);
316 | 			update = applyToTag.bind(null, styleElement);
317 | 			remove = function() {
318 | 				removeStyleElement(styleElement);
319 | 			};
320 | 		}
321 | 
322 | 		update(obj);
323 | 
324 | 		return function updateStyle(newObj) {
325 | 			if(newObj) {
326 | 				if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
327 | 					return;
328 | 				update(obj = newObj);
329 | 			} else {
330 | 				remove();
331 | 			}
332 | 		};
333 | 	}
334 | 
335 | 	var replaceText = (function () {
336 | 		var textStore = [];
337 | 
338 | 		return function (index, replacement) {
339 | 			textStore[index] = replacement;
340 | 			return textStore.filter(Boolean).join('\n');
341 | 		};
342 | 	})();
343 | 
344 | 	function applyToSingletonTag(styleElement, index, remove, obj) {
345 | 		var css = remove ? "" : obj.css;
346 | 
347 | 		if (styleElement.styleSheet) {
348 | 			styleElement.styleSheet.cssText = replaceText(index, css);
349 | 		} else {
350 | 			var cssNode = document.createTextNode(css);
351 | 			var childNodes = styleElement.childNodes;
352 | 			if (childNodes[index]) styleElement.removeChild(childNodes[index]);
353 | 			if (childNodes.length) {
354 | 				styleElement.insertBefore(cssNode, childNodes[index]);
355 | 			} else {
356 | 				styleElement.appendChild(cssNode);
357 | 			}
358 | 		}
359 | 	}
360 | 
361 | 	function applyToTag(styleElement, obj) {
362 | 		var css = obj.css;
363 | 		var media = obj.media;
364 | 		var sourceMap = obj.sourceMap;
365 | 
366 | 		if(media) {
367 | 			styleElement.setAttribute("media", media)
368 | 		}
369 | 
370 | 		if(styleElement.styleSheet) {
371 | 			styleElement.styleSheet.cssText = css;
372 | 		} else {
373 | 			while(styleElement.firstChild) {
374 | 				styleElement.removeChild(styleElement.firstChild);
375 | 			}
376 | 			styleElement.appendChild(document.createTextNode(css));
377 | 		}
378 | 	}
379 | 
380 | 	function updateLink(linkElement, obj) {
381 | 		var css = obj.css;
382 | 		var media = obj.media;
383 | 		var sourceMap = obj.sourceMap;
384 | 
385 | 		if(sourceMap) {
386 | 			// http://stackoverflow.com/a/26603875
387 | 			css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
388 | 		}
389 | 
390 | 		var blob = new Blob([css], { type: "text/css" });
391 | 
392 | 		var oldSrc = linkElement.href;
393 | 
394 | 		linkElement.href = URL.createObjectURL(blob);
395 | 
396 | 		if(oldSrc)
397 | 			URL.revokeObjectURL(oldSrc);
398 | 	}
399 | 
400 | 
401 | /***/ }
402 | /******/ ]);


--------------------------------------------------------------------------------
/integration/styles/config.js:
--------------------------------------------------------------------------------
1 | var configure = require('webpack-config-utils')
2 | var styles = require('../')
3 | 
4 | module.exports = configure()
5 |   .use(styles)
6 |   .entry(__dirname + '/index.js')
7 |   .output(__dirname + '/bundle.js')
8 |   .resolve()
9 | 


--------------------------------------------------------------------------------
/integration/styles/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html xmlns="http://www.w3.org/1999/xhtml">
 3 |   <head>
 4 |       <meta charset="utf-8" />
 5 |   </head>
 6 |   <body>
 7 |     <div class='box'>
 8 |       <p class="red">
 9 |         hello there styles!
10 |       </p>
11 |     </div>
12 |   </body>
13 |   <script src="./bundle.js" type="text/javascript"></script>
14 | </html>
15 | 


--------------------------------------------------------------------------------
/integration/styles/index.js:
--------------------------------------------------------------------------------
1 | 
2 | require('./styles.css')
3 | 


--------------------------------------------------------------------------------
/integration/styles/styles.css:
--------------------------------------------------------------------------------
 1 | 
 2 | body {
 3 |   font-size: 24px;
 4 | }
 5 | 
 6 | .box {
 7 |   padding: 20px;
 8 |   border: 1px blue solid;
 9 | }
10 | 
11 | .red {
12 |   color: red;
13 | }
14 | 


--------------------------------------------------------------------------------
/karma.conf.js:
--------------------------------------------------------------------------------
 1 | require('babel/register');
 2 | 
 3 | 
 4 | var reporters = ;
 5 | 
 6 | module.exports = function (config) {
 7 |   config.set({
 8 | 
 9 |     basePath: '',
10 | 
11 |     frameworks: [
12 |       'mocha',
13 |       'sinon-chai'
14 |     ],
15 | 
16 |     files: [
17 |       'test/index.js'
18 |     ],
19 | 
20 |     preprocessors: {
21 |       'test/index.js': ['webpack', 'sourcemap']
22 |     },
23 | 
24 |     webpackMiddleware: {
25 |       noInfo: true
26 |     },
27 | 
28 |     reporters: ['mocha'],
29 | 
30 |     port: 9876,
31 |     colors: true,
32 |     logLevel: 'INFO',
33 |     browsers: [ 'Chrome' ],
34 |   });
35 | };
36 | 


--------------------------------------------------------------------------------
/lib/basic/index.js:
--------------------------------------------------------------------------------
1 | "use strict";


--------------------------------------------------------------------------------
/lib/config/configure.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | Object.defineProperty(exports, '__esModule', {
  4 |   value: true
  5 | });
  6 | 
  7 | var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
  8 | 
  9 | exports['default'] = create;
 10 | 
 11 | function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
 12 | 
 13 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 14 | 
 15 | function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 16 | 
 17 | var _path = require('path');
 18 | 
 19 | var _path2 = _interopRequireDefault(_path);
 20 | 
 21 | var _assert = require('assert');
 22 | 
 23 | var _assert2 = _interopRequireDefault(_assert);
 24 | 
 25 | var _webpack = require('webpack');
 26 | 
 27 | var _webpack2 = _interopRequireDefault(_webpack);
 28 | 
 29 | var _lodashStringTrimRight = require('lodash/string/trimRight');
 30 | 
 31 | var _lodashStringTrimRight2 = _interopRequireDefault(_lodashStringTrimRight);
 32 | 
 33 | var _utils = require('./utils');
 34 | 
 35 | var utils = _interopRequireWildcard(_utils);
 36 | 
 37 | var _loader2 = require('./loader');
 38 | 
 39 | var _loader3 = _interopRequireDefault(_loader2);
 40 | 
 41 | function create(defaults) {
 42 |   var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
 43 | 
 44 |   var config = _extends(Object.create(fluent), {
 45 |     _config: utils.ensureConfig(defaults || {}),
 46 |     options: options,
 47 |     _loaders: {},
 48 |     _plugins: {}
 49 |   });
 50 | 
 51 |   Object.defineProperty(config, 'valueOf', {
 52 |     value: fluent.resolve
 53 |   });
 54 | 
 55 |   return config;
 56 | }
 57 | 
 58 | var fluent = {
 59 | 
 60 |   entry: function entry(name, _entry) {
 61 |     if (arguments.length === 2) _entry = _defineProperty({}, name, _entry);else _entry = name;
 62 | 
 63 |     utils.addEntry(this._config, _entry);
 64 | 
 65 |     if (this._isHot) utils.addHotEntries(this._config.entry);
 66 | 
 67 |     return this;
 68 |   },
 69 | 
 70 |   raw: function raw(fn) {
 71 |     typeof fn === 'function' ? fn(this._config) : _extends(this._config, fn);
 72 |     return this;
 73 |   },
 74 | 
 75 |   output: function output(filePath, publicPath) {
 76 |     filePath = _path2['default'].resolve(filePath);
 77 | 
 78 |     this._config.output = {
 79 |       filename: _path2['default'].basename(filePath),
 80 |       path: _path2['default'].dirname(filePath)
 81 |     };
 82 | 
 83 |     if (publicPath) this._config.output.publicPath = publicPath;
 84 | 
 85 |     return this;
 86 |   },
 87 | 
 88 |   use: function use() {
 89 |     var _this = this;
 90 | 
 91 |     for (var _len = arguments.length, fns = Array(_len), _key = 0; _key < _len; _key++) {
 92 |       fns[_key] = arguments[_key];
 93 |     }
 94 | 
 95 |     fns.forEach(function (fn) {
 96 |       return fn && fn(_this);
 97 |     });
 98 |     return this;
 99 |   },
100 | 
101 |   isHot: function isHot() {
102 |     return !!this._isHot;
103 |   },
104 | 
105 |   isProduction: function isProduction() {
106 |     return process.env.NODE_ENV === 'production';
107 |   },
108 | 
109 |   hot: function hot() {
110 |     var reload = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];
111 | 
112 |     var entry = this._config.entry;
113 | 
114 |     if (reload && !this._isHot) {
115 |       var plugin = new _webpack2['default'].HotModuleReplacementPlugin();
116 | 
117 |       this._isHot = true;
118 |       this.plugin('hmr', plugin);
119 | 
120 |       if (entry) utils.addHotEntries(entry);
121 |     } else if (!reload && this._isHot) {
122 |       this._isHot = false;
123 |       if (!entry) return this;
124 |       utils.removeHotEntries(entry);
125 |       this.removePlugin('hmr');
126 |     }
127 | 
128 |     return this;
129 |   },
130 | 
131 |   loader: function loader(name, _loader, _replace) {
132 |     var current = this._loaders[name];
133 | 
134 |     if (!_loader || _loader === true) {
135 |       ext = (0, _lodashStringTrimRight2['default'])(name, '-loader');
136 |       _loader = (0, _loader3['default'])(name)['for'](ext).resolve();
137 |     }
138 | 
139 |     (0, _assert2['default'])(!current || _replace === true, 'There is already a loader or set of loaders by this name: "' + name + '". ' + 'use `replaceLoader()` to override an existing loader');
140 | 
141 |     if (_loader) {
142 |       if (typeof _loader === 'function') {
143 |         _loader = _loader(_loader3['default'], current);
144 |         _loader = _loader.resolve ? _loader.resolve() : _loader;
145 |       }
146 | 
147 |       this._loaders[name] = utils.addLoader(this._config, _loader, current);
148 |     }
149 | 
150 |     return this;
151 |   },
152 | 
153 |   replaceLoader: function replaceLoader(name, loader) {
154 |     return this.loader(name, loader, true);
155 |   },
156 | 
157 |   removeLoader: function removeLoader(name) {
158 |     var loaders = this._loaders[name];
159 |     delete this._loaders[name];
160 |     remove(this._config.module.loaders, loaders);
161 |     return this;
162 |   },
163 | 
164 |   plugin: function plugin(name, _plugin) {
165 |     if (_plugin) this._plugins[name] = utils.addPlugin(this._config, _plugin);
166 |     return this;
167 |   },
168 | 
169 |   removePlugin: function removePlugin(name) {
170 |     var plugins = this._plugins[name];
171 |     delete this._plugins[name];
172 | 
173 |     remove(this._config.plugins, plugins);
174 |     return this;
175 |   },
176 | 
177 |   resolve: function resolve() {
178 |     return this._config;
179 |   }
180 | };
181 | 
182 | function remove(arr, items) {
183 |   if (!items) return;
184 | 
185 |   [].concat(items).forEach(function (item) {
186 |     var idx = arr.indexOf(item);
187 |     if (idx === -1) arr.splice(idx, 1);
188 |   });
189 | }
190 | module.exports = exports['default'];


--------------------------------------------------------------------------------
/lib/config/loader.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | Object.defineProperty(exports, '__esModule', {
  4 |   value: true
  5 | });
  6 | 
  7 | var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
  8 | 
  9 | exports['default'] = buildLoader;
 10 | 
 11 | function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
 12 | 
 13 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 14 | 
 15 | var _lodashStringTrimLeft = require('lodash/string/trimLeft');
 16 | 
 17 | var _lodashStringTrimLeft2 = _interopRequireDefault(_lodashStringTrimLeft);
 18 | 
 19 | var _lodashArrayFindIndex = require('lodash/array/findIndex');
 20 | 
 21 | var _lodashArrayFindIndex2 = _interopRequireDefault(_lodashArrayFindIndex);
 22 | 
 23 | var _assert = require('assert');
 24 | 
 25 | var _assert2 = _interopRequireDefault(_assert);
 26 | 
 27 | var _escapeRegexp = require('escape-regexp');
 28 | 
 29 | var _escapeRegexp2 = _interopRequireDefault(_escapeRegexp);
 30 | 
 31 | var _utils = require('./utils');
 32 | 
 33 | var utils = _interopRequireWildcard(_utils);
 34 | 
 35 | var canChain = function canChain(l) {
 36 |   return typeof l === 'string' || l && !l._query;
 37 | };
 38 | var toSingle = function toSingle(l) {
 39 |   return {
 40 |     _query: l._query,
 41 |     _loaders: [l.loader || l]
 42 |   };
 43 | };
 44 | 
 45 | function validateStringLoader(str) {
 46 |   (0, _assert2['default'])(str.indexOf('!') === -1, 'Loader modules should be specified individually without the "!"; ' + 'instead pass each loader name as a seperate argument: \n\n' + 'change: `("' + str + '")` to: `(' + str.split('!').map(function (s) {
 47 |     return '"' + s + '"';
 48 |   }).join(', ') + ')` ');
 49 | 
 50 |   return str;
 51 | }
 52 | 
 53 | function regexEqual(x, y) {
 54 |   if (typeof x === 'string' && typeof y === 'string') return x === y;else if (x instanceof RegExp && !(y instanceof RegExp)) return x.source === y;else if (!(x instanceof RegExp) && y instanceof RegExp) return x === y.source;
 55 | 
 56 |   return x instanceof RegExp && y instanceof RegExp && x.source === y.source && x.global === y.global && x.ignoreCase === y.ignoreCase && x.multiline === y.multiline;
 57 | }
 58 | 
 59 | function lilBuilder(loader) {
 60 |   var _query = undefined;
 61 | 
 62 |   validateStringLoader(loader);
 63 | 
 64 |   if (loader.indexOf('?') !== -1) {
 65 |     var parts = loader.split('?');
 66 |     loader = parts.shift();
 67 |     _query = parts.join('?');
 68 |   }
 69 | 
 70 |   return _extends(Object.create({
 71 |     query: loaderBuilder.query
 72 |   }), { loader: loader, _query: _query });
 73 | }
 74 | 
 75 | var loaderBuilder = {
 76 |   using: function using() {
 77 |     for (var _len = arguments.length, loaders = Array(_len), _key = 0; _key < _len; _key++) {
 78 |       loaders[_key] = arguments[_key];
 79 |     }
 80 | 
 81 |     this._loaders = this._loaders.concat(loaders.map(function (loader) {
 82 | 
 83 |       if (typeof loader === 'function') {
 84 |         return loader(lilBuilder);
 85 |       }
 86 | 
 87 |       loader = lilBuilder(loader);
 88 | 
 89 |       if (canChain(loader)) loader = loader.loader;
 90 | 
 91 |       return loader;
 92 |     }));
 93 |     return this;
 94 |   },
 95 | 
 96 |   query: function query(_query2) {
 97 |     this._query = utils.tryParseQuery(_query2);
 98 |     return this;
 99 |   },
100 | 
101 |   include: function include() {
102 |     var _this = this;
103 | 
104 |     for (var _len2 = arguments.length, includes = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
105 |       includes[_key2] = arguments[_key2];
106 |     }
107 | 
108 |     includes.forEach(function (include) {
109 |       var idx = (0, _lodashArrayFindIndex2['default'])(_this._excludes, function (exclude) {
110 |         return regexEqual(include, exclude);
111 |       });
112 | 
113 |       if (idx !== -1) _this._excludes.splice(idx, 1);
114 |     });
115 | 
116 |     this._includes = this._includes.concat(includes);
117 | 
118 |     return this;
119 |   },
120 | 
121 |   exclude: function exclude() {
122 |     var _this2 = this;
123 | 
124 |     for (var _len3 = arguments.length, excludes = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
125 |       excludes[_key3] = arguments[_key3];
126 |     }
127 | 
128 |     excludes.forEach(function (exclude) {
129 |       var idx = (0, _lodashArrayFindIndex2['default'])(_this2._includes, function (include) {
130 |         return regexEqual(include, exclude);
131 |       });
132 | 
133 |       if (idx !== -1) _this2._includes.splice(idx, 1);
134 |     });
135 | 
136 |     this._excludes = this._excludes.concat(excludes);
137 | 
138 |     return this;
139 |   },
140 | 
141 |   ext: function ext() {
142 |     for (var _len4 = arguments.length, exts = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
143 |       exts[_key4] = arguments[_key4];
144 |     }
145 | 
146 |     exts = exts.map(function (ext) {
147 |       _assert2['default'].ok(typeof ext === 'string', 'extension names must be strings');
148 |       return (0, _lodashStringTrimLeft2['default'])(ext, '.');
149 |     });
150 | 
151 |     this._exts = this._exts.concat(exts);
152 |     return this;
153 |   },
154 | 
155 |   resolve: function resolve() {
156 |     var _this3 = this;
157 | 
158 |     var result = {};
159 |     var loaders = this._loaders;
160 | 
161 |     _assert2['default'].ok(loaders.length, 'No loader module provided! Provide a loader with `using()` to point to a local ' + 'loader module');
162 | 
163 |     if (loaders.length > 1 && !loaders.every(canChain)) {
164 |       return loaders.map(function (loader) {
165 |         return _extends(buildLoader(), _this3, toSingle(loader)).resolve();
166 |       });
167 |     }
168 | 
169 |     var innerQuery = loaders[0]._query;
170 |     if (innerQuery) this.query(innerQuery);
171 | 
172 |     loaders = loaders.map(function (l) {
173 |       return typeof l === 'string' ? l : l.loader;
174 |     });
175 | 
176 |     if (loaders.length === 1) result.loader = loaders[0];else result.loaders = loaders;
177 | 
178 |     _assert2['default'].ok(this._exts.length || this._tests.length, 'All loaders must match some file type with ext(), or contain a test()');
179 | 
180 |     result.test = new RegExp('\\.(' + this._exts.map(_escapeRegexp2['default']).join('|') + ')$', 'i');
181 | 
182 |     if (this._includes.length) result.include = this._includes;
183 | 
184 |     if (this._excludes.length) result.exclude = this._excludes;
185 | 
186 |     if (this._query) result.query = this._query;
187 | 
188 |     return result;
189 |   }
190 | };
191 | 
192 | loaderBuilder['for'] = loaderBuilder.ext;
193 | 
194 | function buildLoader() {
195 |   var builder = _extends(Object.create(loaderBuilder), {
196 |     _loaders: [],
197 |     _tests: [],
198 |     _exts: [],
199 |     _includes: [],
200 |     _excludes: [/node_modules/]
201 |   });
202 | 
203 |   for (var _len5 = arguments.length, loaders = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
204 |     loaders[_key5] = arguments[_key5];
205 |   }
206 | 
207 |   if (loaders.length) builder.using.apply(builder, loaders);
208 | 
209 |   return builder;
210 | }
211 | 
212 | module.exports = exports['default'];


--------------------------------------------------------------------------------
/lib/config/utils.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | Object.defineProperty(exports, '__esModule', {
  4 |   value: true
  5 | });
  6 | exports.ensureConfig = ensureConfig;
  7 | exports.addEntry = addEntry;
  8 | exports.resolveLoader = resolveLoader;
  9 | exports.addLoader = addLoader;
 10 | exports.addPlugin = addPlugin;
 11 | exports.tryParseQuery = tryParseQuery;
 12 | exports.addHotEntries = addHotEntries;
 13 | exports.removeHotEntries = removeHotEntries;
 14 | 
 15 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 16 | 
 17 | function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
 18 | 
 19 | function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 20 | 
 21 | var _assert = require('assert');
 22 | 
 23 | var _assert2 = _interopRequireDefault(_assert);
 24 | 
 25 | var _ip = require('ip');
 26 | 
 27 | var _ip2 = _interopRequireDefault(_ip);
 28 | 
 29 | var _path = require('path');
 30 | 
 31 | var _path2 = _interopRequireDefault(_path);
 32 | 
 33 | var _jsonic = require('jsonic');
 34 | 
 35 | var _jsonic2 = _interopRequireDefault(_jsonic);
 36 | 
 37 | var _lodashObjectHas = require('lodash/object/has');
 38 | 
 39 | var _lodashObjectHas2 = _interopRequireDefault(_lodashObjectHas);
 40 | 
 41 | var _lodashObjectSet = require('lodash/object/set');
 42 | 
 43 | var _lodashObjectSet2 = _interopRequireDefault(_lodashObjectSet);
 44 | 
 45 | var _lodashObjectGet = require('lodash/object/get');
 46 | 
 47 | var _lodashObjectGet2 = _interopRequireDefault(_lodashObjectGet);
 48 | 
 49 | var _lodashObjectAssign = require('lodash/object/assign');
 50 | 
 51 | var _lodashObjectAssign2 = _interopRequireDefault(_lodashObjectAssign);
 52 | 
 53 | var _lodashObjectDefaultsDeep = require('lodash/object/defaultsDeep');
 54 | 
 55 | var _lodashObjectDefaultsDeep2 = _interopRequireDefault(_lodashObjectDefaultsDeep);
 56 | 
 57 | var webpackDevServerAddress = 'http://' + _ip2['default'].address() + ':' + (process.env.PORT || 8080);
 58 | 
 59 | var HOT_ENTRY = 'webpack/hot/dev-server';
 60 | var DEV_ENTRY = 'webpack-dev-server/client?' + webpackDevServerAddress;
 61 | 
 62 | function ensureConfig(config) {
 63 |   if (!config) throw new Error("You didn't provide a config object to the config preset");
 64 | 
 65 |   return (0, _lodashObjectDefaultsDeep2['default'])(config, {
 66 |     resolve: {
 67 |       extensions: ['', 'js'],
 68 |       alias: {}
 69 |     },
 70 |     module: {
 71 |       loaders: []
 72 |     },
 73 | 
 74 |     plugins: []
 75 |   });
 76 | }
 77 | 
 78 | function addEntry(config, entry) {
 79 |   if ((0, _lodashObjectHas2['default'])(config, 'entry')) {
 80 |     if (!config.entry || config.entry === 'string') config.entry = config.entry != null ? { '': config.entry } : {};
 81 |   } else config.entry = {};
 82 | 
 83 |   if (typeof entry === 'string') {
 84 |     var _name = _path2['default'].basename(entry, _path2['default'].extname(entry));
 85 |     if (_name.indexOf('index') !== -1) _name = _path2['default'].basename(_path2['default'].dirname(_path2['default'].resolve(entry)));
 86 | 
 87 |     entry = _defineProperty({}, _name, entry);
 88 |   }
 89 | 
 90 |   (0, _lodashObjectAssign2['default'])(config.entry, entry);
 91 |   return config;
 92 | }
 93 | 
 94 | function resolveLoader(name) {
 95 |   var loader = name,
 96 |       parts = name.split('!');
 97 | 
 98 |   if (parts.length > 1) return parts.map(resolveLoader).join('!');
 99 | 
100 |   if (loader.indexOf('loader') === -1) loader += '-loader';
101 | 
102 |   try {
103 |     loader = require.resolve(loader);
104 |   } catch (err) {
105 |     loader = require.resolve(name);
106 |   }
107 | 
108 |   return loader;
109 | }
110 | 
111 | function addLoader(config, newLoaders, replaces) {
112 |   if (newLoaders === undefined) newLoaders = [];
113 | 
114 |   ensureConfig(config);
115 | 
116 |   replaces = replaces || [].concat(replaces);
117 | 
118 |   var loaders = (0, _lodashObjectGet2['default'])(config, 'module.loaders'),
119 |       idx = loaders.indexOf(replaces[0]);
120 | 
121 |   newLoaders = [].concat(newLoaders);
122 | 
123 |   newLoaders.forEach(function (loader) {
124 |     _assert2['default'].ok((0, _lodashObjectHas2['default'])(loader, 'loader') || (0, _lodashObjectHas2['default'])(loader, 'loaders'), 'Loaders must contain a `loader` or `loaders` property.');
125 | 
126 |     _assert2['default'].ok(loader.test instanceof RegExp, 'Loaders must contain a `test` regex property.');
127 | 
128 |     if (loader.loader) loader.loader = resolveLoader(loader.loader);else loader.loaders = loader.loaders.map(resolveLoader);
129 |   });
130 | 
131 |   if (idx !== -1) loaders.splice(idx, replaces.length);else idx = loaders.length;
132 | 
133 |   loaders.splice.apply(loaders, [idx, 0].concat(_toConsumableArray(newLoaders)));
134 | 
135 |   return newLoaders.length === 0 ? newLoaders[0] : newLoaders;
136 | }
137 | 
138 | function addPlugin(config, plugin) {
139 |   ensureConfig(config);
140 |   (0, _lodashObjectGet2['default'])(config, 'plugins').push(plugin);
141 |   return plugin;
142 | }
143 | 
144 | function tryParseQuery(query) {
145 |   try {
146 |     query = (0, _jsonic2['default'])(query);
147 |   } catch (_) {}
148 | 
149 |   return query;
150 | }
151 | 
152 | function addHotEntries(entry) {
153 |   Object.keys(entry).forEach(function (name) {
154 |     var current = [].concat(entry[name]);
155 |     if (current.indexOf(HOT_ENTRY) === -1 && current.indexOf(DEV_ENTRY) === -1) entry[name] = [HOT_ENTRY, DEV_ENTRY].concat(_toConsumableArray(current));
156 |   });
157 | }
158 | 
159 | function removeHotEntries(entry) {
160 |   Object.keys(entry).forEach(function (name) {
161 |     var current = [].concat(entry[name]),
162 |         hotIdx = current.indexOf(HOT_ENTRY);
163 | 
164 |     if (hotIdx !== -1) current.splice(hotIdx, 1);
165 | 
166 |     var devIdx = current.indexOf(DEV_ENTRY);
167 |     if (devIdx !== -1) current.splice(devIdx, 1);
168 | 
169 |     entry[name] = current.length === 1 ? current[0] : current;
170 |   });
171 | }


--------------------------------------------------------------------------------
/lib/configure.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | Object.defineProperty(exports, '__esModule', {
  4 |   value: true
  5 | });
  6 | 
  7 | var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
  8 | 
  9 | exports['default'] = create;
 10 | 
 11 | function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
 12 | 
 13 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 14 | 
 15 | var _path = require('path');
 16 | 
 17 | var _path2 = _interopRequireDefault(_path);
 18 | 
 19 | var _assert = require('assert');
 20 | 
 21 | var _assert2 = _interopRequireDefault(_assert);
 22 | 
 23 | var _webpack = require('webpack');
 24 | 
 25 | var _webpack2 = _interopRequireDefault(_webpack);
 26 | 
 27 | var _utils = require('./utils');
 28 | 
 29 | var utils = _interopRequireWildcard(_utils);
 30 | 
 31 | var _loader2 = require('./loader');
 32 | 
 33 | var _loader3 = _interopRequireDefault(_loader2);
 34 | 
 35 | function create(defaults) {
 36 |   var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
 37 | 
 38 |   var config = _extends(Object.create(fluent), {
 39 |     _config: utils.ensureConfig(defaults || {}),
 40 |     options: options,
 41 |     _loaders: {},
 42 |     _plugins: {}
 43 |   });
 44 | 
 45 |   Object.defineProperty(config, 'valueOf', {
 46 |     value: fluent.resolve
 47 |   });
 48 | 
 49 |   return config;
 50 | }
 51 | 
 52 | var fluent = {
 53 | 
 54 |   entry: function entry(_entry) {
 55 |     utils.addEntry(this._config, _entry);
 56 | 
 57 |     if (this._isHot) utils.addHotEntries(this._config.entry);
 58 | 
 59 |     return this;
 60 |   },
 61 | 
 62 |   raw: function raw(fn) {
 63 |     typeof fn === 'function' ? fn(this._config) : _extends(this._config, fn);
 64 |     return this;
 65 |   },
 66 | 
 67 |   output: function output(filePath, publicPath) {
 68 |     filePath = _path2['default'].resolve(filePath);
 69 | 
 70 |     this._config.output = {
 71 |       filename: _path2['default'].basename(filePath),
 72 |       path: _path2['default'].dirname(filePath)
 73 |     };
 74 | 
 75 |     if (publicPath) this._config.output.publicPath = publicPath;
 76 | 
 77 |     return this;
 78 |   },
 79 | 
 80 |   use: function use() {
 81 |     var _this = this;
 82 | 
 83 |     for (var _len = arguments.length, fns = Array(_len), _key = 0; _key < _len; _key++) {
 84 |       fns[_key] = arguments[_key];
 85 |     }
 86 | 
 87 |     fns.forEach(function (fn) {
 88 |       return fn && fn(_this);
 89 |     });
 90 |     return this;
 91 |   },
 92 | 
 93 |   isHot: function isHot() {
 94 |     return !!this._isHot;
 95 |   },
 96 | 
 97 |   isProduction: function isProduction() {
 98 |     return process.env.NODE_ENV === 'production';
 99 |   },
100 | 
101 |   hot: function hot() {
102 |     var reload = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];
103 | 
104 |     var entry = this._config.entry;
105 | 
106 |     if (reload && !this._isHot) {
107 |       var plugin = new _webpack2['default'].HotModuleReplacementPlugin();
108 | 
109 |       this._isHot = true;
110 |       this.plugin('hmr', plugin);
111 | 
112 |       if (entry) utils.addHotEntries(entry);
113 |     } else if (!reload && this._isHot) {
114 |       this._isHot = false;
115 |       if (!entry) return this;
116 |       utils.removeHotEntries(entry);
117 |       this.removePlugin('hmr');
118 |     }
119 | 
120 |     return this;
121 |   },
122 | 
123 |   loader: function loader(name, _loader, _replace) {
124 |     var current = this._loaders[name];
125 | 
126 |     (0, _assert2['default'])(!current || _replace === true, 'There is already a loader or set of loaders by this name: "' + name + '". ' + 'use `replaceLoader()` to override an existing loader');
127 | 
128 |     if (_loader) {
129 |       if (typeof _loader === 'function') {
130 |         _loader = _loader(_loader3['default'], current);
131 |         _loader = _loader.resolve ? _loader.resolve() : _loader;
132 |       }
133 | 
134 |       this._loaders[name] = utils.addLoader(this._config, _loader, current);
135 |     }
136 | 
137 |     return this;
138 |   },
139 | 
140 |   replaceLoader: function replaceLoader(name, loader) {
141 |     return this.loader(name, loader, true);
142 |   },
143 | 
144 |   removeLoader: function removeLoader(name) {
145 |     var loaders = this._loaders[name];
146 |     delete this._loaders[name];
147 |     remove(this._config.module.loaders, loaders);
148 |     return this;
149 |   },
150 | 
151 |   plugin: function plugin(name, _plugin) {
152 |     if (_plugin) this._plugins[name] = utils.addPlugin(this._config, _plugin);
153 |     return this;
154 |   },
155 | 
156 |   removePlugin: function removePlugin(name) {
157 |     var plugins = this._plugins[name];
158 |     delete this._plugins[name];
159 | 
160 |     remove(this._config.plugins, plugins);
161 |     return this;
162 |   },
163 | 
164 |   resolve: function resolve() {
165 |     return this._config;
166 |   }
167 | };
168 | 
169 | function remove(arr, items) {
170 |   if (!items) return;
171 | 
172 |   [].concat(items).forEach(function (item) {
173 |     var idx = arr.indexOf(item);
174 |     if (idx === -1) arr.splice(idx, 1);
175 |   });
176 | }
177 | module.exports = exports['default'];


--------------------------------------------------------------------------------
/lib/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | Object.defineProperty(exports, '__esModule', {
 4 |   value: true
 5 | });
 6 | 
 7 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 8 | 
 9 | var _configConfigure = require('./config/configure');
10 | 
11 | var _configConfigure2 = _interopRequireDefault(_configConfigure);
12 | 
13 | exports['default'] = _configConfigure2['default'];
14 | module.exports = exports['default'];


--------------------------------------------------------------------------------
/lib/loader.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | Object.defineProperty(exports, '__esModule', {
  4 |   value: true
  5 | });
  6 | 
  7 | var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
  8 | 
  9 | exports['default'] = buildLoader;
 10 | 
 11 | function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
 12 | 
 13 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 14 | 
 15 | var _lodashStringTrimLeft = require('lodash/string/trimLeft');
 16 | 
 17 | var _lodashStringTrimLeft2 = _interopRequireDefault(_lodashStringTrimLeft);
 18 | 
 19 | var _lodashArrayFindIndex = require('lodash/array/findIndex');
 20 | 
 21 | var _lodashArrayFindIndex2 = _interopRequireDefault(_lodashArrayFindIndex);
 22 | 
 23 | var _assert = require('assert');
 24 | 
 25 | var _assert2 = _interopRequireDefault(_assert);
 26 | 
 27 | var _escapeRegexp = require('escape-regexp');
 28 | 
 29 | var _escapeRegexp2 = _interopRequireDefault(_escapeRegexp);
 30 | 
 31 | var _utils = require('./utils');
 32 | 
 33 | var utils = _interopRequireWildcard(_utils);
 34 | 
 35 | var canChain = function canChain(l) {
 36 |   return typeof l === 'string' || l && !l._query;
 37 | };
 38 | var toSingle = function toSingle(l) {
 39 |   return {
 40 |     _query: l._query,
 41 |     _loaders: [l.loader || l]
 42 |   };
 43 | };
 44 | 
 45 | function validateStringLoader(str) {
 46 |   (0, _assert2['default'])(str.indexOf('!') === -1, 'Loader modules should be specified individually without the "!"; ' + 'instead pass each loader name as a seperate argument: \n\n' + 'change: `("' + str + '")` to: `(' + str.split('!').map(function (s) {
 47 |     return '"' + s + '"';
 48 |   }).join(', ') + ')` ');
 49 | 
 50 |   return str;
 51 | }
 52 | 
 53 | function regexEqual(x, y) {
 54 |   return x instanceof RegExp && y instanceof RegExp && x.source === y.source && x.global === y.global && x.ignoreCase === y.ignoreCase && x.multiline === y.multiline;
 55 | }
 56 | 
 57 | function lilBuilder(loader) {
 58 |   var _query = undefined;
 59 | 
 60 |   validateStringLoader(loader);
 61 | 
 62 |   if (loader.indexOf('?') !== -1) {
 63 |     var parts = loader.split('?');
 64 |     loader = parts.shift();
 65 |     _query = parts.join('?');
 66 |   }
 67 | 
 68 |   return _extends(Object.create({
 69 |     query: loaderBuilder.query
 70 |   }), { loader: loader, _query: _query });
 71 | }
 72 | 
 73 | var loaderBuilder = {
 74 |   using: function using() {
 75 |     for (var _len = arguments.length, loaders = Array(_len), _key = 0; _key < _len; _key++) {
 76 |       loaders[_key] = arguments[_key];
 77 |     }
 78 | 
 79 |     this._loaders = this._loaders.concat(loaders.map(function (loader) {
 80 | 
 81 |       if (typeof loader === 'function') {
 82 |         return loader(lilBuilder);
 83 |       }
 84 | 
 85 |       loader = lilBuilder(loader);
 86 | 
 87 |       if (canChain(loader)) loader = loader.loader;
 88 | 
 89 |       return loader;
 90 |     }));
 91 |     return this;
 92 |   },
 93 | 
 94 |   query: function query(_query2) {
 95 |     this._query = utils.tryParseQuery(_query2);
 96 |     return this;
 97 |   },
 98 | 
 99 |   include: function include() {
100 |     var _this = this;
101 | 
102 |     for (var _len2 = arguments.length, includes = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
103 |       includes[_key2] = arguments[_key2];
104 |     }
105 | 
106 |     includes.forEach(function (include) {
107 |       var idx = (0, _lodashArrayFindIndex2['default'])(_this._excludes, function (exclude) {
108 |         return String(include) === String(exclude) || regexEqual(include, exclude);
109 |       });
110 | 
111 |       if (idx !== -1) _this._excludes.splice(idx, 1);
112 |     });
113 | 
114 |     this._includes = this._includes.concat(includes);
115 | 
116 |     return this;
117 |   },
118 | 
119 |   exclude: function exclude() {
120 |     var _this2 = this;
121 | 
122 |     for (var _len3 = arguments.length, excludes = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
123 |       excludes[_key3] = arguments[_key3];
124 |     }
125 | 
126 |     excludes.forEach(function (exclude) {
127 |       var idx = (0, _lodashArrayFindIndex2['default'])(_this2._includes, function (include) {
128 |         return String(include) === String(exclude) || regexEqual(include, exclude);
129 |       });
130 | 
131 |       if (idx !== -1) _this2._includes.splice(idx, 1);
132 |     });
133 | 
134 |     this._excludes = this._excludes.concat(excludes);
135 | 
136 |     return this;
137 |   },
138 | 
139 |   ext: function ext() {
140 |     for (var _len4 = arguments.length, exts = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
141 |       exts[_key4] = arguments[_key4];
142 |     }
143 | 
144 |     exts = exts.map(function (ext) {
145 |       _assert2['default'].ok(typeof ext === 'string', 'extension names must be strings');
146 |       return (0, _lodashStringTrimLeft2['default'])(ext, '.');
147 |     });
148 | 
149 |     this._exts = this._exts.concat(exts);
150 |     return this;
151 |   },
152 | 
153 |   resolve: function resolve() {
154 |     var _this3 = this;
155 | 
156 |     var result = {};
157 |     var loaders = this._loaders;
158 | 
159 |     _assert2['default'].ok(loaders.length, 'No loader module provided! Provide a loader with `using()` to point to a local ' + 'loader module');
160 | 
161 |     if (loaders.length > 1 && !loaders.every(canChain)) {
162 |       return loaders.map(function (loader) {
163 |         return _extends(buildLoader(), _this3, toSingle(loader)).resolve();
164 |       });
165 |     }
166 | 
167 |     var innerQuery = loaders[0]._query;
168 |     if (innerQuery) this.query(innerQuery);
169 | 
170 |     loaders = loaders.map(function (l) {
171 |       return typeof l === 'string' ? l : l.loader;
172 |     });
173 | 
174 |     if (loaders.length === 1) result.loader = loaders[0];else result.loaders = loaders;
175 | 
176 |     _assert2['default'].ok(this._exts.length || this._tests.length, 'All loaders must match some file type with ext(), or contain a test()');
177 | 
178 |     result.test = new RegExp('\\.(' + this._exts.map(_escapeRegexp2['default']).join('|') + ')', 'i');
179 | 
180 |     if (this._includes.length) result.include = this._includes;
181 | 
182 |     if (this._excludes.length) result.exclude = this._excludes;
183 | 
184 |     if (this._query) result.query = this._query;
185 | 
186 |     return result;
187 |   }
188 | };
189 | 
190 | function buildLoader() {
191 |   var builder = _extends(Object.create(loaderBuilder), {
192 |     _loaders: [],
193 |     _tests: [],
194 |     _exts: [],
195 |     _includes: [],
196 |     _excludes: [/node_modules/]
197 |   });
198 | 
199 |   for (var _len5 = arguments.length, loaders = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
200 |     loaders[_key5] = arguments[_key5];
201 |   }
202 | 
203 |   if (loaders.length) builder.using.apply(builder, loaders);
204 | 
205 |   return builder;
206 | }
207 | 
208 | module.exports = exports['default'];


--------------------------------------------------------------------------------
/lib/utils.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | Object.defineProperty(exports, '__esModule', {
  4 |   value: true
  5 | });
  6 | exports.ensureConfig = ensureConfig;
  7 | exports.addEntry = addEntry;
  8 | exports.resolveLoader = resolveLoader;
  9 | exports.addLoader = addLoader;
 10 | exports.addPlugin = addPlugin;
 11 | exports.tryParseQuery = tryParseQuery;
 12 | exports.addHotEntries = addHotEntries;
 13 | exports.removeHotEntries = removeHotEntries;
 14 | 
 15 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 16 | 
 17 | function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
 18 | 
 19 | function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 20 | 
 21 | var _assert = require('assert');
 22 | 
 23 | var _assert2 = _interopRequireDefault(_assert);
 24 | 
 25 | var _ip = require('ip');
 26 | 
 27 | var _ip2 = _interopRequireDefault(_ip);
 28 | 
 29 | var _path = require('path');
 30 | 
 31 | var _path2 = _interopRequireDefault(_path);
 32 | 
 33 | var _jsonic = require('jsonic');
 34 | 
 35 | var _jsonic2 = _interopRequireDefault(_jsonic);
 36 | 
 37 | var _lodashObjectHas = require('lodash/object/has');
 38 | 
 39 | var _lodashObjectHas2 = _interopRequireDefault(_lodashObjectHas);
 40 | 
 41 | var _lodashObjectSet = require('lodash/object/set');
 42 | 
 43 | var _lodashObjectSet2 = _interopRequireDefault(_lodashObjectSet);
 44 | 
 45 | var _lodashObjectGet = require('lodash/object/get');
 46 | 
 47 | var _lodashObjectGet2 = _interopRequireDefault(_lodashObjectGet);
 48 | 
 49 | var _lodashObjectAssign = require('lodash/object/assign');
 50 | 
 51 | var _lodashObjectAssign2 = _interopRequireDefault(_lodashObjectAssign);
 52 | 
 53 | var _lodashObjectDefaultsDeep = require('lodash/object/defaultsDeep');
 54 | 
 55 | var _lodashObjectDefaultsDeep2 = _interopRequireDefault(_lodashObjectDefaultsDeep);
 56 | 
 57 | var webpackDevServerAddress = 'http://' + _ip2['default'].address() + ':' + (process.env.PORT || 8080);
 58 | 
 59 | var HOT_ENTRY = 'webpack/hot/dev-server';
 60 | var DEV_ENTRY = 'webpack-dev-server/client?' + webpackDevServerAddress;
 61 | 
 62 | function ensureConfig(config) {
 63 |   if (!config) throw new Error("You didn't provide a config object to the config preset");
 64 | 
 65 |   return (0, _lodashObjectDefaultsDeep2['default'])(config, {
 66 |     resolve: {
 67 |       extensions: ['', 'js'],
 68 |       alias: {}
 69 |     },
 70 |     module: {
 71 |       loaders: []
 72 |     },
 73 | 
 74 |     plugins: []
 75 |   });
 76 | }
 77 | 
 78 | function addEntry(config, entry) {
 79 |   if ((0, _lodashObjectHas2['default'])(config, 'entry')) {
 80 |     if (!config.entry || config.entry === 'string') config.entry = config.entry != null ? { '': config.entry } : {};
 81 |   } else config.entry = {};
 82 | 
 83 |   if (typeof entry === 'string') {
 84 |     var _name = _path2['default'].basename(entry, _path2['default'].extname(entry));
 85 |     if (_name.indexOf('index') !== -1) _name = _path2['default'].basename(_path2['default'].dirname(_path2['default'].resolve(entry)));
 86 | 
 87 |     entry = _defineProperty({}, _name, entry);
 88 |   }
 89 | 
 90 |   (0, _lodashObjectAssign2['default'])(config.entry, entry);
 91 |   return config;
 92 | }
 93 | 
 94 | function resolveLoader(name) {
 95 |   var loader = name,
 96 |       parts = name.split('!');
 97 | 
 98 |   if (parts.length > 1) return parts.map(resolveLoader).join('!');
 99 | 
100 |   if (loader.indexOf('loader') === -1) loader += '-loader';
101 | 
102 |   try {
103 |     loader = require.resolve(loader);
104 |   } catch (err) {
105 |     loader = require.resolve(name);
106 |   }
107 | 
108 |   return loader;
109 | }
110 | 
111 | function addLoader(config, newLoaders, replaces) {
112 |   if (newLoaders === undefined) newLoaders = [];
113 | 
114 |   ensureConfig(config);
115 | 
116 |   replaces = replaces || [].concat(replaces);
117 | 
118 |   var loaders = (0, _lodashObjectGet2['default'])(config, 'module.loaders'),
119 |       idx = loaders.indexOf(replaces[0]);
120 | 
121 |   newLoaders = [].concat(newLoaders);
122 | 
123 |   newLoaders.forEach(function (loader) {
124 |     _assert2['default'].ok((0, _lodashObjectHas2['default'])(loader, 'loader') || (0, _lodashObjectHas2['default'])(loader, 'loaders'), 'Loaders must contain a `loader` or `loaders` property.');
125 | 
126 |     _assert2['default'].ok(loader.test instanceof RegExp, 'Loaders must contain a `test` regex property.');
127 | 
128 |     if (loader.loader) loader.loader = resolveLoader(loader.loader);else loader.loaders = loader.loaders.map(resolveLoader);
129 |   });
130 | 
131 |   if (idx !== -1) loaders.splice(idx, replaces.length);else idx = loaders.length;
132 | 
133 |   loaders.splice.apply(loaders, [idx, 0].concat(_toConsumableArray(newLoaders)));
134 | 
135 |   return newLoaders.length === 0 ? newLoaders[0] : newLoaders;
136 | }
137 | 
138 | function addPlugin(config, plugin) {
139 |   ensureConfig(config);
140 |   (0, _lodashObjectGet2['default'])(config, 'plugins').push(plugin);
141 |   return plugin;
142 | }
143 | 
144 | function tryParseQuery(query) {
145 |   try {
146 |     query = (0, _jsonic2['default'])(query);
147 |   } catch (_) {}
148 | 
149 |   return query;
150 | }
151 | 
152 | function addHotEntries(entry) {
153 |   Object.keys(entry).forEach(function (name) {
154 |     var current = [].concat(entry[name]);
155 |     if (current.indexOf(HOT_ENTRY) === -1 && current.indexOf(DEV_ENTRY) === -1) entry[name] = [HOT_ENTRY, DEV_ENTRY].concat(_toConsumableArray(current));
156 |   });
157 | }
158 | 
159 | function removeHotEntries(entry) {
160 |   Object.keys(entry).forEach(function (name) {
161 |     var current = [].concat(entry[name]),
162 |         hotIdx = current.indexOf(HOT_ENTRY);
163 | 
164 |     if (hotIdx !== -1) current.splice(hotIdx, 1);
165 | 
166 |     var devIdx = current.indexOf(DEV_ENTRY);
167 |     if (devIdx !== -1) current.splice(devIdx, 1);
168 | 
169 |     entry[name] = current.length === 1 ? current[0] : current;
170 |   });
171 | }


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "webpack-config-utils",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": "lib/index.js",
 6 |   "scripts": {
 7 |     "test": "mocha test/*.js -R spec --compilers js:babel/register",
 8 |     "test-presets": "mocha test/**/unit.js -R spec --compilers js:babel/register",
 9 |     "tdd": "npm run test -- --watch",
10 |     "tdd-presets": "npm run test-presets -- --watch",
11 |     "preset": "node ./integration/run.js",
12 |     "preset-visual": "npm run preset -- --open",
13 |     "build": "babel src --out-dir lib --stage=1",
14 |     "prepublish": "npm run build"
15 |   },
16 |   "repository": {
17 |     "type": "git",
18 |     "url": "git+https://github.com/jquense/webpack-config-utils.git"
19 |   },
20 |   "files": [
21 |     "lib",
22 |     "README.md"
23 |   ],
24 |   "keywords": [
25 |     "webpack",
26 |     "config",
27 |     "utils"
28 |   ],
29 |   "author": "jquense",
30 |   "license": "MIT",
31 |   "bugs": {
32 |     "url": "https://github.com/jquense/webpack-config-utils/issues"
33 |   },
34 |   "homepage": "https://github.com/jquense/webpack-config-utils#readme",
35 |   "peerDependencies": {
36 |     "webpack": "^1.9.11"
37 |   },
38 |   "dependencies": {
39 |     "babel": "^5.8.34",
40 |     "babel-plugin-dev-expression": "^0.1.0",
41 |     "babel-plugin-object-assign": "^1.2.1",
42 |     "chai": "^3.4.1",
43 |     "css-loader": "^0.23.1",
44 |     "escape-regexp": "0.0.1",
45 |     "extract-text-webpack-plugin": "^0.9.1",
46 |     "file-loader": "^0.8.5",
47 |     "html-webpack-plugin": "^1.7.0",
48 |     "image-webpack-loader": "^1.6.2",
49 |     "ip": "^1.1.0",
50 |     "json-loader": "^0.5.4",
51 |     "jsonic": "^0.2.2",
52 |     "less-loader": "^2.2.2",
53 |     "lodash": "^3.10.1",
54 |     "mocha": "^2.3.4",
55 |     "node-libs-browser": "^0.5.3",
56 |     "raw-loader": "^0.5.1",
57 |     "react-hot-loader": "^1.3.0",
58 |     "sass-loader": "^3.1.2",
59 |     "style-loader": "^0.13.0",
60 |     "url-loader": "^0.5.7",
61 |     "webpack": "^1.12.9"
62 |   },
63 |   "devDependencies": {
64 |     "babel-loader": "^5.4.0",
65 |     "css-loader": "^0.23.1",
66 |     "karma": "^0.13.17",
67 |     "karma-chrome-launcher": "^0.2.2",
68 |     "karma-mocha": "^0.2.1",
69 |     "karma-sinon-chai": "^1.1.0",
70 |     "memory-fs": "^0.3.0",
71 |     "open": "0.0.5",
72 |     "style-loader": "^0.13.0",
73 |     "yargs": "^3.31.0"
74 |   }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/assets/index.js:
--------------------------------------------------------------------------------
 1 | import path from 'path';
 2 | import webpack from 'webpack';
 3 | 
 4 | export default function({ path, image: imageOptions }) {
 5 | 
 6 |   if (arguments[0]._config)
 7 |     return assetConfig(...arguments)
 8 | 
 9 |   return assetConfig
10 | 
11 |   function assetConfig(config) {
12 |     let name = 'asset-[name].[ext]'
13 |       , fonts = 'fonts/' + name
14 |       , images = 'images/' + name;
15 | 
16 |     if (path) {
17 |       fonts = path.join(path, fonts)
18 |       images = path.join(path, images)
19 |     }
20 | 
21 |     config
22 |       .loader('web-fonts', loader => loader('url')
23 |         .test(/\.woff(2)?(\?v=[0-9]\.[0-9]\.[0-9])?$/)
24 |         .options({
25 |           limit: 10000,
26 |           mimetype: 'application/font-woff',
27 |           name: fonts
28 |         })
29 |       )
30 |       .loader('file-fonts', loader => loader('file')
31 |         .test(/\.(ttf|eot|svg)(\?v=[0-9]\.[0-9]\.[0-9])?$/)
32 |         .options({ name: fonts })
33 |       )
34 |       .loader('images', loader => loader('file')
35 |         .for('jpe', 'jpeg', 'png', 'gif')
36 |         .options({ name: images })
37 |         .inProduction(loader => loader
38 |           .push(sub => sub('image-webpack')
39 |             .options({
40 |               progressive: true,
41 |               optimizationLevel: 5,
42 |               ...imageOptions
43 |             })
44 |           )
45 |         )
46 |       )
47 |   }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/babel/index.js:
--------------------------------------------------------------------------------
 1 | 
 2 | export default function babel(config) {
 3 |   let exts = ['js', 'babel', 'babel.js', 'es6']
 4 |   config
 5 |     .extensions(...exts)
 6 |     .replaceLoader('babel', loader => loader()
 7 |       .ext(...exts)
 8 |     )
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/basic/index.js:
--------------------------------------------------------------------------------
 1 | import webpack from 'webpack';
 2 | 
 3 | export default function(config) {
 4 |   return config
 5 |     .extension('json')
 6 |     .modules('bower_components')
 7 |     .sourcemap('cheap-module-eval-source-map')
 8 |     .replaceLoader('json')
 9 |     .replaceLoader('raw')
10 |     .replacePlugin('occurence', new webpack.optimize.OccurenceOrderPlugin())
11 |     .replacePlugin('common', new webpack.optimize.CommonsChunkPlugin('common.bundle.js'))
12 |     .inTest(config => config
13 |       .sourcemap('inline-source-map')
14 |     )
15 |     .inProduction(config => config
16 |       .sourcemap('source-map')
17 |       .replacePlugin('dedupe', new webpack.optimize.DedupePlugin())
18 |       .plugin('uglify', new webpack.optimize.UglifyJsPlugin({
19 |         output : { comments: false },
20 |         compress : {
21 |           unused: true,
22 |           dead_code: true,
23 |           warnings: false,
24 |         }
25 |       }))
26 |     )
27 | }
28 | 


--------------------------------------------------------------------------------
/src/config/clone.js:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2011-2014, Walmart and other contributors.
 2 | // Copyright (c) 2011, Yahoo Inc.
 3 | // All rights reserved. https://github.com/hapijs/hoek/blob/master/LICENSE
 4 | 
 5 | 
 6 | module.exports = function clone(obj, seen) {
 7 |   var isFirst = !seen
 8 | 
 9 |   if (typeof obj !== 'object' || obj === null)
10 |     return obj;
11 | 
12 |   seen = seen || { orig: [], copy: [] };
13 | 
14 |   var lookup = seen.orig.indexOf(obj);
15 | 
16 |   if (lookup !== -1)
17 |     return seen.copy[lookup];
18 | 
19 |   var newObj;
20 |   var cloneDeep = false;
21 | 
22 |   if (!Array.isArray(obj)) {
23 |     if (obj instanceof Date) {
24 |       newObj = new Date(obj.getTime());
25 |     }
26 |     else if (obj instanceof RegExp) {
27 |       newObj = new RegExp(obj);
28 |     }
29 |     else {
30 |       var proto = Object.getPrototypeOf(obj);
31 | 
32 |       if (!proto && proto !== null) {
33 |         newObj = obj;
34 |       }
35 |       else {
36 |         newObj = Object.create(proto);
37 |         cloneDeep = true;
38 |       }
39 |     }
40 |   }
41 |   else {
42 |     newObj = [];
43 |     cloneDeep = true;
44 |   }
45 | 
46 |   seen.orig.push(obj);
47 |   seen.copy.push(newObj);
48 | 
49 |   if (cloneDeep) {
50 |     var keys = Object.getOwnPropertyNames(obj);
51 | 
52 |     for (var i = 0, il = keys.length; i < il; ++i) {
53 |       var key = keys[i];
54 | 
55 |       var descriptor = Object.getOwnPropertyDescriptor(obj, key);
56 | 
57 |       if (descriptor.get || descriptor.set) {
58 |         Object.defineProperty(newObj, key, descriptor);
59 |       }
60 |       else {
61 |         Object.defineProperty(newObj, key, {
62 |           ...descriptor,
63 |           value: clone(obj[key], seen)
64 |         });
65 |       }
66 |     }
67 |   }
68 | 
69 |   return newObj;
70 | }
71 | 


--------------------------------------------------------------------------------
/src/config/configure.js:
--------------------------------------------------------------------------------
  1 | import path from 'path';
  2 | import assert from 'assert';
  3 | import webpack from 'webpack';
  4 | import { EventEmitter } from 'events';
  5 | import set from 'lodash/object/set';
  6 | import merge from 'lodash/object/merge';
  7 | import union from 'lodash/array/union';
  8 | import transform from 'lodash/object/transform';
  9 | 
 10 | import * as inject from './inject';
 11 | import * as utils from './utils';
 12 | import validate from './validate';
 13 | 
 14 | import clone from './clone';
 15 | 
 16 | const ARRAY_DEDUPE_KEYS = [];
 17 | 
 18 | export default function create(defaults, options = {}) {
 19 |   let initConfig;
 20 | 
 21 |   if (defaults && defaults.__isConfig === true) {
 22 |     initConfig = defaults.clone()
 23 |   } else {
 24 |     initConfig = {
 25 |       _config: utils.ensureConfig(defaults || {}),
 26 |       options,
 27 |       _onResolve: [],
 28 |       _loaders: {},
 29 |       _preLoaders: {},
 30 |       _postLoaders: {},
 31 |       _plugins: {},
 32 |       _defines: {},
 33 |       _envs: {},
 34 |     }
 35 |   }
 36 | 
 37 |   let config = Object.assign(Object.create(fluent), initConfig)
 38 | 
 39 |   Object.defineProperties(config, {
 40 |     valueOf: { value: fluent.resolve },
 41 |     __isConfig: { value: true }
 42 |   })
 43 | 
 44 |   return config
 45 | }
 46 | 
 47 | function concat(a, b, key) {
 48 |   if (Array.isArray(a)) {
 49 |     if (fluent.ARRAY_DEDUPE_KEYS.indexOf(key) !== -1)
 50 |       return union(a, b)
 51 |     else
 52 |       return a.concat(b)
 53 |   }
 54 | }
 55 | 
 56 | 
 57 | let fluent = Object.assign(new EventEmitter(), {
 58 |   ARRAY_DEDUPE_KEYS,
 59 | 
 60 |   clone() {
 61 |     return clone(this)
 62 |   },
 63 | 
 64 |   sourcemap(type = 'source-map') {
 65 |     this._config.devtool = type;
 66 |     return this
 67 |   },
 68 | 
 69 |   entry(name, entry) {
 70 |     if (arguments.length === 2)
 71 |       entry = { [name]: entry }
 72 |     else
 73 |       entry = name
 74 | 
 75 |     utils.addEntry(this._config, entry)
 76 | 
 77 |     if (this._isHot)
 78 |       utils.addHotEntries(this._config.entry)
 79 | 
 80 |     this.emit('entry')
 81 |     return this
 82 |   },
 83 | 
 84 |   output(filePath, publicPath) {
 85 |     filePath = path.resolve(filePath);
 86 | 
 87 |     this._config.output = {
 88 |       filename: path.basename(filePath),
 89 |       path: path.dirname(filePath)
 90 |     }
 91 | 
 92 |     if (publicPath)
 93 |       this._config.output.publicPath = publicPath;
 94 | 
 95 |     this.emit('output')
 96 |     return this
 97 |   },
 98 | 
 99 |   use(...fns) {
100 |     fns.forEach(fn => fn && fn(this))
101 |     return this
102 |   },
103 | 
104 |   raw(fn) {
105 |     typeof fn === 'function'
106 |       ? fn(this._config)
107 |       : merge(this._config, fn, concat)
108 |     return this
109 |   },
110 | 
111 |   isHot(fn) {
112 |     if (this._isHot) fn(this)
113 |     return this
114 |   },
115 | 
116 |   hot(reload = true) {
117 |     return this
118 |       .notInProduction(() => {
119 |         let entry = this._config.entry;
120 | 
121 |         if (reload && !this._isHot) {
122 |           let plugin = new webpack.HotModuleReplacementPlugin();
123 | 
124 |           this._isHot = true
125 |           this.replacePlugin('$$hmr', plugin)
126 | 
127 |           if (entry)
128 |             utils.addHotEntries(entry)
129 | 
130 |           this.emit('hot', this._isHot)
131 |         }
132 |         else if (!reload && this._isHot) {
133 |           this._isHot = false
134 |           this.removePlugin('$$hmr')
135 | 
136 |           if (entry) {
137 |             utils.removeHotEntries(entry)
138 |           }
139 | 
140 |           this.emit('hot', this._isHot)
141 |         }
142 |       })
143 |   },
144 | 
145 |   define(pathOrObject, value) {
146 |     let defines = this._defines;
147 |     let stringify = obj => deepTransform(obj, val => JSON.stringify(val))
148 | 
149 |     if (typeof pathOrObject === 'string') {
150 |       value = JSON.stringify(value)
151 |       set(defines, pathOrObject, value)
152 |     }
153 |     else {
154 |       merge(defines, stringify(pathOrObject))
155 |     }
156 | 
157 |     this.replacePlugin('$$define', new webpack.DefinePlugin(defines))
158 |     return this
159 |   },
160 | 
161 |   resolve() {
162 |     validate(this._config)
163 |     this.emit('resolve')
164 | 
165 |     // validate again since the onResolve hooks
166 |     // may have changed something
167 |     validate(this._config)
168 |     return this._config
169 |   }
170 | })
171 | 
172 | 
173 | inject.loader(fluent)
174 | inject.plugin(fluent)
175 | inject.resolve(fluent)
176 | inject.env(fluent)
177 | 
178 | function deepTransform(obj, fn) {
179 |   return transform(obj, (result, val, key) => {
180 |     if (val != null) {
181 |       if (typeof val === 'object' && !(val instanceof RegExp)) {
182 |         val = deepTransform(val, fn)
183 |       }
184 |       else {
185 |         val = fn(val, key)
186 |       }
187 |     }
188 |     result[key] = val
189 |   },
190 |   Array.isArray(obj) ? [] : {})
191 | }
192 | 


--------------------------------------------------------------------------------
/src/config/inject/env.js:
--------------------------------------------------------------------------------
 1 | import pick from 'lodash/object/pick';
 2 | import capitalize from 'lodash/string/capitalize'
 3 | 
 4 | const BUILT_IN = ['production', 'test', 'development'];
 5 | 
 6 | export default function (obj) {
 7 | 
 8 |   function isEnv(ctx, env) {
 9 |     let envs = ctx._envs = ctx._envs || (ctx._envs = {})
10 |     let names = envs[env]
11 | 
12 |     return [env].concat(names)
13 |       .some(env => process.env.NODE_ENV === env)
14 |   }
15 | 
16 |   function setAliases(ctx, name, aliases) {
17 |     let envs = ctx._envs = ctx._envs || (ctx._envs = {})
18 | 
19 |     if (arguments.length === 1)
20 |       return assign(envs, pick(name, BUILT_IN))
21 | 
22 |     envs[name] = [].concat(aliases)
23 |   }
24 | 
25 |   Object.assign(obj, {
26 | 
27 |     env(builtin, name) {
28 |       if (typeof name === 'function')
29 |         return this.inEnv(builtin, name)
30 | 
31 |       setAliases(this, builtin, name)
32 |       return this
33 |     },
34 | 
35 |     inEnv(envName, fn) {
36 |       if (isEnv(this, envName)) fn(this)
37 |       return this
38 |     },
39 | 
40 |     notInEnv(envName, fn) {
41 |       if (!isEnv(this, envName)) fn(this)
42 |       return this
43 |     },
44 |   })
45 | 
46 |   BUILT_IN.forEach(env => {
47 |     Object.assign(obj, {
48 |       ['in' + capitalize(env)](fn) {
49 |         return this.inEnv(env, fn)
50 |       },
51 |       ['notIn' + capitalize(env)](fn) {
52 |         return this.notInEnv(env, fn)
53 |       }
54 |     })
55 |   })
56 | }
57 | 


--------------------------------------------------------------------------------
/src/config/inject/index.js:
--------------------------------------------------------------------------------
1 | 
2 | export { default as loader } from './loader';
3 | export { default as plugin } from './plugin';
4 | export { default as resolve } from './resolve';
5 | export { default as env } from './env';
6 | 


--------------------------------------------------------------------------------
/src/config/inject/loader.js:
--------------------------------------------------------------------------------
  1 | import assert from 'assert';
  2 | 
  3 | import get from 'lodash/object/get';
  4 | import capitalize from 'lodash/string/capitalize'
  5 | import trimRight from 'lodash/string/trimRight';
  6 | 
  7 | import * as utils from '../utils';
  8 | import loaderBuilder from '../loader';
  9 | 
 10 | const REPLACE = 'replace';
 11 | const ADJUST = 'adjust';
 12 | 
 13 | export default function injectLoaders(obj) {
 14 | 
 15 |   ['', 'pre', 'post'].forEach(type => {
 16 |     let suffix = type ? (type + 'Loader') : 'loader';
 17 |     let name = prefix => (prefix || '') + (prefix ? capitalize(suffix): suffix)
 18 | 
 19 |     let add = name()
 20 |       , adjust = name('adjust')
 21 |       , replace = name('replace')
 22 |       , remove = name('remove')
 23 |       , field = '_' + add + 's'
 24 | 
 25 |     let ensureField = ctx => ctx[field] || (ctx[field] = {})
 26 | 
 27 |     obj.ARRAY_DEDUPE_KEYS.push(add + 's')
 28 | 
 29 |     Object.assign(obj, {
 30 | 
 31 |       [add](name, loader, _action) {
 32 |         let builder
 33 |           , current = ensureField(this)[name];
 34 | 
 35 |         assert(!(current && !_action),
 36 |             'There is already a ' + add + ' or set of ' + add + 's by this name: "' + name + '". '
 37 |           + 'use `' + replace + '()` to override an existing loader or `' + adjust + '()` or edit this one.'
 38 |         );
 39 | 
 40 |         if (!loader || loader === true) {
 41 |           loader = loaderBuilder(name).for(trimRight(name, '-loader'))
 42 |         }
 43 | 
 44 |         if (loader) {
 45 |           let currentLoader = current && current.loader;
 46 | 
 47 |           current = current && (current.builder || current.loader);
 48 | 
 49 |           if (typeof loader === 'function') {
 50 | 
 51 |             builder = _action === ADJUST
 52 |               ? loader(current)
 53 |               : loader(loaderBuilder, current);
 54 |           }
 55 |           else if (loader.resolve) {
 56 |             builder = loader
 57 |           }
 58 | 
 59 | 
 60 |           if (builder && builder.resolve) {
 61 |             if (!builder._loaders.length)
 62 |               builder.set(name)
 63 | 
 64 |             loader = builder.resolve()
 65 |           }
 66 | 
 67 |           loader = utils.addLoader(
 68 |               get(this, '_config.module.loaders')
 69 |             , loader
 70 |             , currentLoader
 71 |           )
 72 | 
 73 |           ensureField(this)[name] = {
 74 |             builder,
 75 |             loader
 76 |           }
 77 |         }
 78 | 
 79 |         return this
 80 |       },
 81 | 
 82 |       [replace](name, loader) {
 83 |         return this[add](name, loader, REPLACE)
 84 |       },
 85 | 
 86 |       [adjust](name, loader) {
 87 |         return this[add](name, loader, ADJUST)
 88 |       },
 89 | 
 90 |       [remove](name) {
 91 |         let loaders = ensureField(this)[name]
 92 |         delete loaders[name];
 93 |         remove(this._config.module.loaders, loaders.loader)
 94 |         return this
 95 |       },
 96 |     })
 97 |   })
 98 | 
 99 |   return obj
100 | }
101 | 
102 | 
103 | function remove(arr, items) {
104 |   if (!items) return
105 | 
106 |   [].concat(items).forEach(item => {
107 |     let idx = arr.indexOf(item)
108 |     if (idx === -1) arr.splice(idx, 1)
109 |   })
110 | }
111 | 


--------------------------------------------------------------------------------
/src/config/inject/plugin.js:
--------------------------------------------------------------------------------
 1 | import assert from 'assert';
 2 | import * as utils from '../utils';
 3 | import get from 'lodash/object/get';
 4 | 
 5 | export default function injectPlugin(obj) {
 6 | 
 7 |   return Object.assign(obj, {
 8 | 
 9 |     plugin(name, plugin, _replace) {
10 |       let current = this._plugins[name];
11 | 
12 |       assert(!(current && _replace === false),
13 |           'There is already a plugin or set of plugins by this name: "' + name + '". '
14 |         + 'use `replacePlugin()` to override an existing plugin'
15 |       );
16 | 
17 |       this._plugins[name] = utils.addPlugin(
18 |         get(this, '_config.plugins'), plugin)
19 | 
20 |       return this
21 |     },
22 | 
23 |     replacePlugin(name, plugin) {
24 |       this.plugin(name, plugin, true)
25 |       return this
26 |     },
27 | 
28 |     removePlugin(name) {
29 |       let plugins = this._plugins[name]
30 |       delete this._plugins[name];
31 | 
32 |       remove(this._config.plugins, plugins)
33 |       return this
34 |     },
35 |   })
36 | }
37 | 
38 | function remove(arr, items) {
39 |   if (!items) return
40 | 
41 |   [].concat(items).forEach(item => {
42 |     let idx = arr.indexOf(item)
43 |     if (idx === -1) arr.splice(idx, 1)
44 |   })
45 | }
46 | 


--------------------------------------------------------------------------------
/src/config/inject/resolve.js:
--------------------------------------------------------------------------------
 1 | import path from 'path';
 2 | import get from 'lodash/object/get';
 3 | import set from 'lodash/object/set';
 4 | import trimLeft from 'lodash/string/trimLeft';
 5 | 
 6 | const DEFAULT_MODULE_DIRECTORIES = ["web_modules", "node_modules"]
 7 | 
 8 | export default function resolve(obj) {
 9 | 
10 |   obj.ARRAY_DEDUPE_KEYS.push('root', 'extensions', 'modulesDirectories')
11 | 
12 |   Object.assign(obj, {
13 | 
14 |     extension(...exts) {
15 |       return this.raw({
16 |         resolve: {
17 |           extensions: exts.map(ext => ('.' + trimLeft(ext, '.')))
18 |         }
19 |       })
20 |     },
21 | 
22 |     root(...dirs) {
23 |       dirs = dirs.map(dir =>
24 |         path.isAbsolute(dir) ? dir : path.resolve(process.cwd(), dir))
25 | 
26 |       return this.raw({
27 |         resolve: {
28 |           root: dirs
29 |         }
30 |       })
31 |     },
32 | 
33 |     alias(alias, module) {
34 |       return this.raw({
35 |         resolve: {
36 |           alias: {
37 |             [alias]: module
38 |           }
39 |         }
40 |       })
41 |     },
42 | 
43 |     modules(...modules) {
44 |       return this.raw({
45 |         resolve: {
46 |           modulesDirectories: DEFAULT_MODULE_DIRECTORIES.concat(modules)
47 |         }
48 |       })
49 |     }
50 |   })
51 | 
52 | 
53 |   obj.extensions = obj.extension
54 | }
55 | 


--------------------------------------------------------------------------------
/src/config/loader.js:
--------------------------------------------------------------------------------
  1 | import trimLeft from 'lodash/string/trimLeft'
  2 | import findIndex from 'lodash/array/findIndex'
  3 | import assert from 'assert';
  4 | import escape from 'escape-regexp';
  5 | import * as utils from './utils';
  6 | import injectEnv from './inject/env';
  7 | 
  8 | let getLoader = loader => loader.loader || loader;
  9 | 
 10 | let canChain = l => typeof l === 'string' || (l && !l._query)
 11 | let toSingle = l => ({
 12 |   _query: l._query,
 13 |   _loaders: [ l.loader || l ]
 14 | })
 15 | 
 16 | 
 17 | export default function buildLoader(...loaders) {
 18 |   let builder = Object.assign(Object.create(loaderBuilder), {
 19 |     _loaders: [],
 20 |     _tests: [],
 21 |     _exts: [],
 22 |     _envs: [],
 23 |     _includes: [],
 24 |     _excludes: [/node_modules/]
 25 |   })
 26 | 
 27 |   if (loaders.length)
 28 |     builder.set(...loaders)
 29 | 
 30 |   return builder;
 31 | }
 32 | 
 33 | function lilBuilder(loader) {
 34 |   let _query;
 35 | 
 36 |   validateStringLoader(loader)
 37 | 
 38 |   if (loader.indexOf('?') !== -1) {
 39 |     let parts = loader.split('?')
 40 |     loader = parts.shift()
 41 |     _query = parts.join('?')
 42 |   }
 43 | 
 44 |   return Object.assign(Object.create({
 45 |     query: loaderBuilder.query,
 46 |     options: loaderBuilder.query,
 47 |   }), { loader, _query })
 48 | }
 49 | 
 50 | 
 51 | let loaderBuilder = {
 52 |   set(...loaders) {
 53 |     this._loaders = buildLoaders(loaders)
 54 |     return this
 55 |   },
 56 | 
 57 |   remove(...loaders) {
 58 |     this._loaders = this._loaders
 59 |       .filter(l => loaders.indexOf(l.loader || l) === -1)
 60 |     return this
 61 |   },
 62 | 
 63 |   unshift(...loaders) {
 64 |     if (this._loaders.length === 1) {
 65 |       let name = getLoader(this._loaders[0])
 66 |       this._loaders[0] = lilBuilder(name).query(this._query)
 67 |     }
 68 |     this._loaders = buildLoaders(loaders).concat(this._loaders)
 69 |     return this
 70 |   },
 71 | 
 72 |   push(...loaders) {
 73 |     if (this._loaders.length === 1) {
 74 |       this._loaders[0] = lilBuilder(this._loaders[0]).query(this._query)
 75 |     }
 76 | 
 77 |     this._loaders = this._loaders.concat(buildLoaders(loaders))
 78 |     return this
 79 |   },
 80 | 
 81 |   when(regex) {
 82 |     this._tests.push(regex)
 83 |   },
 84 | 
 85 |   query(query) {
 86 |     this._query = utils.tryParseQuery(query)
 87 |     return this
 88 |   },
 89 | 
 90 |   include(...includes) {
 91 |     includes.forEach(include => {
 92 |       let idx = findIndex(this._excludes,
 93 |         exclude => regexEqual(include, exclude)
 94 |       )
 95 | 
 96 |       if (idx !== -1)
 97 |         this._excludes.splice(idx, 1)
 98 |     })
 99 | 
100 |     this._includes = this._includes.concat(includes)
101 | 
102 |     return this
103 |   },
104 | 
105 |   exclude(...excludes) {
106 |     excludes.forEach(exclude => {
107 |       let idx = findIndex(this._includes,
108 |         include => regexEqual(include, exclude)
109 |       )
110 | 
111 |       if (idx !== -1)
112 |         this._includes.splice(idx, 1)
113 |     })
114 | 
115 |     this._excludes = this._excludes.concat(excludes)
116 | 
117 |     return this
118 |   },
119 | 
120 |   test(...tests) {
121 |     this._tests = this._tests.concat(tests);
122 |     return this
123 |   },
124 | 
125 |   ext(...exts) {
126 |     exts = exts.map(ext => {
127 |       assert.ok(typeof ext === 'string', 'extension names must be strings')
128 |       return trimLeft(ext, '.')
129 |     })
130 | 
131 |     this._exts = this._exts.concat(exts)
132 |     return this
133 |   },
134 | 
135 |   removeExt(...exts) {
136 |     exts = exts.map(ext => trimLeft(ext, '.'))
137 |     this._exts = this._exts.filter(ext => exts.indexOf(ext) === -1)
138 |     return this
139 |   },
140 | 
141 |   toInline(stringify = true) {
142 |     let loaders = this._loaders;
143 |     return loaders.map(loader => {
144 |       let name = loader.loader || loader
145 |         , query = loader.query;
146 | 
147 |       if (query)
148 |         query = '?' + (stringify && typeof query !== 'string')
149 |           ? JSON.stringify(query) : utils.stringifyQuery(query)
150 | 
151 |       return name + (query || '')
152 |     })
153 |     .join('!')
154 |   },
155 | 
156 |   resolve() {
157 |     let result = {}
158 |     let loaders = this._loaders;
159 | 
160 |     assert.ok(loaders.length,
161 |       'No loader module provided! Provide a loader with `using()` to point to a local ' +
162 |       'loader module');
163 | 
164 |     if (loaders.length > 1 && !loaders.every(canChain)) {
165 |       return loaders.map(loader => Object.assign(
166 |         buildLoader(), this, toSingle(loader)).resolve()
167 |       )
168 |     }
169 | 
170 |     let innerQuery = loaders[0]._query
171 |     if (innerQuery)
172 |       this.query(innerQuery)
173 | 
174 |     loaders = loaders.map(getLoader)
175 | 
176 |     if (loaders.length === 1)
177 |       result.loader = loaders[0]
178 |     else
179 |       result.loaders = loaders
180 | 
181 |     assert.ok(this._exts.length || this._tests.length,
182 |       'All loaders must match some file type with ext(), or contain a test()');
183 | 
184 |     result.test = this._tests.concat()
185 | 
186 |     if (this._exts.length)
187 |       result.test.push(
188 |         new RegExp('\\.(' + this._exts.map(escape).join('|') + ')$', 'i')
189 |       )
190 | 
191 |     if (this._includes.length)
192 |       result.include = this._includes
193 | 
194 |     if (this._excludes.length)
195 |       result.exclude = this._excludes
196 | 
197 |     if (this._query)
198 |       result.query = this._query
199 | 
200 |     result.test = unwrap(result.test)
201 | 
202 |     return result
203 |   }
204 | }
205 | 
206 | loaderBuilder.options = loaderBuilder.query;
207 | loaderBuilder.for = loaderBuilder.ext;
208 | loaderBuilder.notFor = loaderBuilder.removeExt;
209 | loaderBuilder.use = loaderBuilder.set;
210 | 
211 | injectEnv(loaderBuilder)
212 | 
213 | 
214 | function validateStringLoader(str) {
215 |   assert(str.indexOf('!') === -1,
216 |     'Loader modules should be specified individually without the "!"; ' +
217 |     'instead pass each loader name as a seperate argument: \n\n' +
218 |     'change: `("' + str + '")` to: `(' + str.split('!').map(s => '"'+ s + '"').join(', ') + ')` ')
219 | 
220 |   return str
221 | }
222 | 
223 | function regexEqual(x, y) {
224 |   if (typeof x === 'string' && typeof y === 'string')
225 |     return x === y
226 | 
227 |   else if ((x instanceof RegExp) && !(y instanceof RegExp))
228 |     return x.source === y
229 | 
230 |   else if (!(x instanceof RegExp) && (y instanceof RegExp))
231 |     return x === y.source
232 | 
233 |   return (x instanceof RegExp) && (y instanceof RegExp) &&
234 |          (x.source === y.source) && (x.global === y.global) &&
235 |          (x.ignoreCase === y.ignoreCase) && (x.multiline === y.multiline);
236 | }
237 | 
238 | function buildLoaders(loaders) {
239 |   loaders = loaders.reduce((arr, l) =>
240 |       arr.concat(typeof l === 'string' ? l.split('!'): l)
241 |     , [])
242 | 
243 |   return loaders.map(loader => {
244 |     if (typeof loader === 'function')
245 |       return loader(lilBuilder)
246 | 
247 |     loader = lilBuilder(loader)
248 | 
249 |     if (canChain(loader))
250 |       loader = loader.loader
251 | 
252 |     return loader
253 |   })
254 | }
255 | 
256 | function unwrap(arr) {
257 |   return arr.length === 1 ? arr[0] : arr
258 | }
259 | 


--------------------------------------------------------------------------------
/src/config/merge.js:
--------------------------------------------------------------------------------
 1 | import each from 'lodash/collection/each'
 2 | 
 3 | function mergeLoaders(target, source) {
 4 |   let tLoaders = target._loaders
 5 |     , sLoaders = source._loaders;
 6 | 
 7 | 
 8 | }
 9 | 
10 | function mergeTwo(target, source) {
11 | 
12 | }
13 | 
14 | export default function mergeConfig(...configs) {
15 |   configs.reduce((target, source) => {
16 |     target._loaders = Object.assign(target._loaders, source._loaders)
17 |     target._plugins = Object.assign(target._plugins, source._plugins)
18 |   })
19 | }
20 | 


--------------------------------------------------------------------------------
/src/config/utils.js:
--------------------------------------------------------------------------------
  1 | import assert from 'assert';
  2 | import ip from 'ip';
  3 | import path from 'path';
  4 | import jsonic from 'jsonic';
  5 | import has from 'lodash/object/has';
  6 | import set from 'lodash/object/set';
  7 | import get from 'lodash/object/get';
  8 | import assign from 'lodash/object/assign';
  9 | import defaultsDeep from 'lodash/object/defaultsDeep';
 10 | 
 11 | const webpackDevServerAddress = `http://${ip.address()}:${process.env.PORT || 8080}`
 12 | 
 13 | const HOT_ENTRY = 'webpack/hot/dev-server';
 14 | const DEV_ENTRY = 'webpack-dev-server/client?' + webpackDevServerAddress;
 15 | 
 16 | 
 17 | export function ensureConfig(config) {
 18 |   if (!config)
 19 |     throw new Error("You didn't provide a config object to the config preset")
 20 | 
 21 |   return defaultsDeep(config, {
 22 |     resolve: {
 23 |       extensions: ['', '.js'],
 24 |       alias: {},
 25 |       root: []
 26 |     },
 27 |     module: {
 28 |       loaders: [],
 29 |       postLoaders: [],
 30 |       preLoaders: []
 31 |     },
 32 | 
 33 |     plugins: []
 34 |   })
 35 | }
 36 | 
 37 | export function addEntry(config, entry) {
 38 |   if (has(config, 'entry')) {
 39 |     if (!config.entry || config.entry === 'string')
 40 |       config.entry = config.entry != null ? { '': config.entry } : {}
 41 |   }
 42 |   else
 43 |     config.entry = {}
 44 | 
 45 |   if (typeof entry === 'string') {
 46 |     let name = path.basename(entry, path.extname(entry))
 47 |     if (name.indexOf('index') !== -1)
 48 |       name = path.basename(path.dirname(path.resolve(entry)))
 49 | 
 50 |     entry = { [name]: entry }
 51 |   }
 52 | 
 53 |   assign(config.entry, entry)
 54 |   return config
 55 | }
 56 | 
 57 | export function resolveLoader(name) {
 58 |   let loader = name
 59 |     , parts = name.split('!')
 60 | 
 61 |   if (parts.length > 1)
 62 |     return parts.map(resolveLoader).join('!')
 63 | 
 64 |   if (loader.indexOf('loader') === -1)
 65 |     loader += '-loader'
 66 | 
 67 |   try {
 68 |     loader = require.resolve(loader)
 69 |   } catch (err) {
 70 |     loader = require.resolve(name)
 71 |   }
 72 | 
 73 |   return loader
 74 | }
 75 | 
 76 | export function addLoader(loaders, newLoaders = [], replaces) {
 77 |   replaces = [].concat(replaces);
 78 | 
 79 |   let idx = loaders.indexOf(replaces[0])
 80 | 
 81 |   newLoaders = [].concat(newLoaders)
 82 | 
 83 |   newLoaders.forEach(loader => {
 84 |     assert.ok(has(loader, 'loader') || has(loader, 'loaders')
 85 |       , 'Loaders must contain a `loader` or `loaders` property.')
 86 | 
 87 |     assert.ok(loader.test instanceof RegExp
 88 |       , 'Loaders must contain a `test` regex property.')
 89 | 
 90 |     if (loader.loader)
 91 |       loader.loader = resolveLoader(loader.loader)
 92 |     else
 93 |       loader.loaders = loader.loaders.map(resolveLoader)
 94 |   })
 95 | 
 96 |   if (idx !== -1)
 97 |     loaders.splice(idx, replaces.length)
 98 |   else
 99 |     idx = loaders.length
100 | 
101 |   loaders.splice(idx, 0, ...newLoaders)
102 | 
103 |   return newLoaders.length <= 1 ? newLoaders[0] : newLoaders
104 | }
105 | 
106 | export function removeLoader(loaders, remove = []) {
107 |   let idx = loaders.indexOf(replaces[0]);
108 | 
109 |   [].concat(remove)
110 |     .forEach(loader => {
111 |       let idx = loaders.indexOf(loader)
112 | 
113 |       if (idx !== -1)
114 |         loaders.splice(idx, 1)
115 |     })
116 | }
117 | 
118 | 
119 | export function addPlugin(plugins, newPlugins, replaces) {
120 |   replaces = [].concat(replaces);
121 | 
122 |   let idx = plugins.indexOf(replaces[0])
123 | 
124 |   newPlugins = [].concat(newPlugins);
125 | 
126 |   if (idx !== -1)
127 |     plugins.splice(idx, replaces.length)
128 |   else
129 |     idx = plugins.length
130 | 
131 |   plugins.splice(idx, 0, ...newPlugins)
132 | 
133 |   return newPlugins.length <= 1 ? newPlugins[0] : newPlugins
134 | }
135 | 
136 | export function tryParseQuery(query) {
137 |   try {
138 |     query = jsonic(query)
139 |   } catch (_) {}
140 | 
141 |   return query
142 | }
143 | 
144 | export function stringifyQuery(query) {
145 |   if (typeof query === 'string') return query
146 | 
147 |   return Object.keys(query).reduce((str, key) => {
148 |     return str + (str ? '&' : '') + key + '=' + query[key]
149 |   }, '')
150 | }
151 | 
152 | export function addHotEntries(entry) {
153 |   Object.keys(entry).forEach(name => {
154 |     let current = [].concat(entry[name]);
155 |     if (current.indexOf(HOT_ENTRY) === -1 && current.indexOf(DEV_ENTRY) === -1)
156 |       entry[name] = [
157 |         HOT_ENTRY,
158 |         DEV_ENTRY,
159 |         ...current
160 |       ]
161 |   })
162 | }
163 | 
164 | let isObject = ob => typeof obj === 'object' && obj !== null && !Array.isArray(object)
165 | 
166 | export function removeHotEntries(entry) {
167 |   Object.keys(entry).forEach(name => {
168 |     let current = [].concat(entry[name])
169 |       , hotIdx = current.indexOf(HOT_ENTRY);
170 | 
171 |     if (hotIdx !== -1) current.splice(hotIdx, 1)
172 | 
173 |     let devIdx = current.indexOf(DEV_ENTRY)
174 |     if (devIdx !== -1) current.splice(devIdx, 1)
175 | 
176 |     entry[name] = current.length === 1 ? current[0] : current
177 |   })
178 | }
179 | 


--------------------------------------------------------------------------------
/src/config/validate.js:
--------------------------------------------------------------------------------
 1 | import assert from 'assert';
 2 | import path from 'path';
 3 | import includes from 'lodash/collection/includes';
 4 | 
 5 | function report(condition, problem, solution, link) {
 6 |   assert.ok(!condition, problem + '\n\ntry: \n\n' + solution + (!link ? '' : '\n\nreference: ' + link))
 7 | }
 8 | 
 9 | function validateOutput(config) {
10 |   let entry = config.entry
11 |     , output = config.output;
12 | 
13 |   if (!output) return;
14 |   
15 |   let filename = output.filename
16 |     , ext = path.extname(filename);
17 | 
18 |   report(
19 |     !(includes(filename, '[name]') || includes(filename, '[chunkhash]')) &&
20 |     (!Array.isArray(entry) && typeof entry !== 'string') &&
21 |     Object.keys(entry).length > 1,
22 |     `You have specified multiple entry points, but used a hardcoded output filname ("${filename}"). ` +
23 |     `This will result in each entry file having the same file name and accidently replace the previous one. `,
24 | 
25 |     `Use a substition ("[name]", "[chunkhash]") in your file name to make each unique, such as: ` +
26 |     `"${path.basename(filename, ext)}.[name]${ext ? ext : ''}" instead.`,
27 | 
28 |     'https://webpack.github.io/docs/configuration.html#output-filename'
29 |   )
30 | }
31 | 
32 | export default function validate(config) {
33 |   validateOutput(config)
34 | }
35 | 


--------------------------------------------------------------------------------
/src/es6/index.js:
--------------------------------------------------------------------------------
1 | 
2 | export default function es6(config) {
3 |   config
4 |     .extensions('babel', 'babel.js', 'es6')
5 |     .replaceLoader('babel', loader => loader()
6 |       .ext('js', 'babel', 'es6')
7 |     )
8 | }
9 | 


--------------------------------------------------------------------------------
/src/helpers.js:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | export function createPreset(fn){
 4 |   return function preset(options) {
 5 |     if (!options || options._config)
 6 |       return fn.call({ options: {} }, options)
 7 | 
 8 |     return fn.bind({ options })
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/html/index.js:
--------------------------------------------------------------------------------
1 | import HtmlWebpackPlugin from 'html-webpack-plugin';
2 | import { createPreset } from './helpers';
3 | 
4 | export default createPreset(function htmlConfig(config) {
5 |   config.plugin('html', new HtmlWebpackPlugin(this.options))
6 | }
7 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
1 | import configure from './config/configure';
2 | 
3 | export default configure
4 | 


--------------------------------------------------------------------------------
/src/react/index.js:
--------------------------------------------------------------------------------
 1 | import webpack from 'webpack';
 2 | import babel from '../babel';
 3 | 
 4 | export default function reactConfig(config) {
 5 |   config
 6 |     .use(babel)
 7 |     .extension('jsx')
 8 |     .adjustLoader('babel', loader => loader
 9 |       .for('jsx')
10 |     )
11 |     .inProduction( config => config
12 |       .define('process.env.NODE_ENV', 'production')
13 |       .raw({
14 |         babel: {
15 |           stage: 1,
16 |           plugins: [
17 |             require('babel-plugin-dev-expression')
18 |           ]
19 |         }
20 |       })
21 |     )
22 |     .on('hot', isHot => {
23 |       if (isHot) config
24 |         .plugin('no-errors', new webpack.NoErrorsPlugin())
25 |         .adjustLoader('babel', loader => loader
26 |           .unshift('react-hot'))
27 |       else config
28 |         .removePlugin('no-errors', new webpack.NoErrorsPlugin())
29 |         .adjustLoader('babel', loader => loader
30 |           .remove('react-hot'))
31 |     })
32 | }
33 | 


--------------------------------------------------------------------------------
/src/styles/index.js:
--------------------------------------------------------------------------------
 1 | import ExtractTextPlugin from 'extract-text-webpack-plugin';
 2 | import assets from '../assets';
 3 | 
 4 | function basic(config) {
 5 |   config
 6 |     .use(assets)
 7 |     .loader('styles', loader => loader('style', 'css')
 8 |       .ext('css')
 9 |     )
10 | }
11 | 
12 | let presets = basic
13 | 
14 | presets.basic = basic
15 | 
16 | presets.less = function(config) {
17 |   config
18 |     .use(basic)
19 |     .adjustLoader('styles', loader => loader
20 |       .push('less')
21 |       .ext('less')
22 |     )
23 | }
24 | 
25 | presets.sass = function(config) {
26 |   config
27 |     .use(basic)
28 |     .adjustLoader('styles', loader => loader
29 |       .push('sass')
30 |       .ext('sass', 'scss')
31 |     )
32 | }
33 | 
34 | 
35 | Object.keys(presets)
36 |   .forEach(key => createExtractVariant(presets[key]))
37 | 
38 | module.exports = presets
39 | 
40 | function createExtractVariant(preset) {
41 |   preset.extract = function(config) {
42 |     var extract = new ExtractTextPlugin('[name]-styles.css', { allChunks: true });
43 | 
44 |     config
45 |       .use(preset)
46 |       .plugin('extract-styles', extract)
47 |       .adjustLoader('styles', loader => {
48 |         let parts = loader.toInline().split('!')
49 |         return loader.set(ExtractTextPlugin.extract(parts.shift(), parts))
50 |       })
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/test-entry.js:
--------------------------------------------------------------------------------
 1 | var chai = require('chai')
 2 | 
 3 | chai.use(require('chai-as-promised'))
 4 | chai.use(require('sinon-chai'))
 5 | 
 6 | chai.should();
 7 | 
 8 | var presetContext = require.context('./src', true, /\/__tests__\/.+(\.js|\.jsx)/)
 9 | var testsContext = require.context('./test', true, /\.(js|jsx)$/);
10 | 
11 | if (process.env.WEBPACK === 'presets')
12 |   presetContext.keys().forEach(scriptsContext)
13 | else
14 |   testsContext.keys().forEach(testsContext)
15 | 


--------------------------------------------------------------------------------
/test-helpers.js:
--------------------------------------------------------------------------------
 1 | var webpack = require('webpack');
 2 | var MemoryFileSystem = require("memory-fs");
 3 | import path from 'path';
 4 | import { expect } from 'chai'
 5 | import configure from './src';
 6 | import contains from 'lodash/collection/contains';
 7 | 
 8 | let resolve = c => c && typeof c.resolve === 'function' ? c.resolve() : c;
 9 | 
10 | export function hasLoader(config, loader) {
11 |   config = resolve(config)
12 |   if (typeof loader !== 'string') return false
13 |   return config.module.loaders.some(l =>
14 |     [].concat(l.loader || l.loaders)
15 |       .some(name => contains(name, loader))
16 |   )
17 | }
18 | 
19 | export function hasPlugin(config, plugin) {
20 |   config = resolve(config)
21 |   if (typeof plugin !== 'function') return false
22 |   return config.plugins.some(p =>
23 |     p.constructor === plugin
24 |   )
25 | }
26 | 
27 | export function compare(builder, config) {
28 |   expect(builder.resolve()).to.eql(
29 |     configure(config || {}).resolve()
30 |   )
31 | }
32 | 
33 | export function run(config, assert) {
34 |   return new Promise((resolve, reject) => {
35 |     let compiler = webpack(config)
36 |     let fs = compiler.outputFileSystem = new MemoryFileSystem();
37 | 
38 |     compiler.run(function (err, stats) {
39 |       if (err) return reject(err)
40 |       let errors = stats.compilation.errors || [];
41 |       if (assert) expect(errors.length).to.equal(0, errors.join('\n'))
42 | 
43 |       resolve({
44 |         fs,
45 |         output: getOutputFiles(fs, config.output.path),
46 |         stats,
47 |         errors,
48 |         warnings: stats.compilation.warnings || []
49 |       })
50 |     })
51 |   })
52 | }
53 | 
54 | function getOutputFiles(fs, dir) {
55 |   let files = []
56 |   dir = path.normalize(dir)
57 |   getFiles(dir)
58 | 
59 |   return files.map(f => path.normalize(f).replace(dir + path.sep, ''))
60 | 
61 |   function getFiles(dir) {
62 |     fs.readdirSync(dir).forEach(filename => {
63 |       let file = path.join(dir, filename)
64 |       if (fs.statSync(file).isDirectory())
65 |         getFiles(file)
66 |       else
67 |         files.push(file)
68 |     })
69 |   }
70 | }
71 | 
72 | export function env(name, fn) {
73 |   let current = process.env.NODE_ENV;
74 | 
75 |   process.env.NODE_ENV = name;
76 |   let result = fn()
77 |   process.env.NODE_ENV = current;
78 |   return result;
79 | }
80 | 


--------------------------------------------------------------------------------
/test/assets/fixtures/config.js:
--------------------------------------------------------------------------------
 1 | import HtmlWebpackPlugin from 'html-webpack-plugin';
 2 | import configure from '../../../src'
 3 | import assets from '../../../src/assets'
 4 | 
 5 | export default configure()
 6 |   .use(assets)
 7 |   .entry(__dirname + '/entry.js')
 8 |   .output(__dirname + '/../output/bundle.js')
 9 |   .plugin('html', new HtmlWebpackPlugin())
10 |   .resolve()
11 | 


--------------------------------------------------------------------------------
/test/assets/fixtures/entry.js:
--------------------------------------------------------------------------------
1 | 
2 | require('./fonts/rw-widgets.eot')
3 | require('./fonts/rw-widgets.svg')
4 | require('./fonts/rw-widgets.ttf')
5 | require('./fonts/rw-widgets.woff')
6 | 
7 | require('./img/loader-big.gif')
8 | require('./img/loader.gif')
9 | 


--------------------------------------------------------------------------------
/test/assets/fixtures/fonts/rw-widgets.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jquense/webpack-config-utils/81c6a782efe6d12349985d1d8f5044c9dbf3f769/test/assets/fixtures/fonts/rw-widgets.eot


--------------------------------------------------------------------------------
/test/assets/fixtures/fonts/rw-widgets.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" standalone="no"?>
 2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 3 | <svg xmlns="http://www.w3.org/2000/svg">
 4 | <metadata>Copyright (C) 2015 by original authors @ fontello.com</metadata>
 5 | <defs>
 6 | <font id="rw-widgets" horiz-adv-x="1000" >
 7 | <font-face font-family="rw-widgets" font-weight="400" font-stretch="normal" units-per-em="1000" ascent="850" descent="-150" />
 8 | <missing-glyph horiz-adv-x="1000" />
 9 | <glyph glyph-name="up-dir" unicode="&#xe800;" d="m571 171q0-14-10-25t-25-10h-500q-15 0-25 10t-11 25 11 26l250 250q10 10 25 10t25-10l250-250q10-11 10-26z" horiz-adv-x="571.4" />
10 | <glyph glyph-name="left-dir" unicode="&#xe801;" d="m357 600v-500q0-14-10-25t-26-11-25 11l-250 250q-10 11-10 25t10 25l250 250q11 11 25 11t26-11 10-25z" horiz-adv-x="357.1" />
11 | <glyph glyph-name="right-dir" unicode="&#xe802;" d="m321 350q0-14-10-25l-250-250q-11-11-25-11t-25 11-11 25v500q0 15 11 25t25 11 25-11l250-250q10-10 10-25z" horiz-adv-x="357.1" />
12 | <glyph glyph-name="down-dir" unicode="&#xe803;" d="m571 457q0-14-10-25l-250-250q-11-11-25-11t-25 11l-250 250q-11 11-11 25t11 25 25 11h500q14 0 25-11t10-25z" horiz-adv-x="571.4" />
13 | <glyph glyph-name="calendar" unicode="&#xe804;" d="m71-79h161v161h-161v-161z m197 0h178v161h-178v-161z m-197 197h161v178h-161v-178z m197 0h178v178h-178v-178z m-197 214h161v161h-161v-161z m411-411h179v161h-179v-161z m-214 411h178v161h-178v-161z m428-411h161v161h-161v-161z m-214 197h179v178h-179v-178z m-196 482v161q0 7-6 12t-12 6h-36q-7 0-12-6t-6-12v-161q0-7 6-13t12-5h36q7 0 12 5t6 13z m410-482h161v178h-161v-178z m-214 214h179v161h-179v-161z m214 0h161v161h-161v-161z m18 268v161q0 7-5 12t-13 6h-35q-8 0-13-6t-5-12v-161q0-7 5-13t13-5h35q8 0 13 5t5 13z m215 36v-715q0-29-22-50t-50-21h-786q-29 0-50 21t-21 50v715q0 29 21 50t50 21h72v54q0 36 26 63t63 26h36q37 0 63-26t26-63v-54h214v54q0 36 27 63t63 26h35q37 0 63-26t27-63v-54h71q29 0 50-21t22-50z" horiz-adv-x="928.6" />
14 | <glyph glyph-name="clock" unicode="&#xe805;" d="m500 546v-250q0-7-5-12t-13-5h-178q-8 0-13 5t-5 12v36q0 8 5 13t13 5h125v196q0 8 5 13t12 5h36q8 0 13-5t5-13z m232-196q0 83-41 152t-110 111-152 41-153-41-110-111-41-152 41-152 110-111 153-41 152 41 110 111 41 152z m125 0q0-117-57-215t-156-156-215-58-216 58-155 156-58 215 58 215 155 156 216 58 215-58 156-156 57-215z" horiz-adv-x="857.1" />
15 | <glyph glyph-name="search" unicode="&#xe806;" d="m643 386q0 103-74 176t-176 74-177-74-73-176 73-177 177-73 176 73 74 177z m286-465q0-29-22-50t-50-21q-30 0-50 21l-191 191q-100-69-223-69-80 0-153 31t-125 84-84 125-31 153 31 152 84 126 125 84 153 31 152-31 126-84 84-126 31-152q0-123-69-223l191-191q21-21 21-51z" horiz-adv-x="928.6" />
16 | </font>
17 | </defs>
18 | </svg>


--------------------------------------------------------------------------------
/test/assets/fixtures/fonts/rw-widgets.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jquense/webpack-config-utils/81c6a782efe6d12349985d1d8f5044c9dbf3f769/test/assets/fixtures/fonts/rw-widgets.ttf


--------------------------------------------------------------------------------
/test/assets/fixtures/fonts/rw-widgets.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jquense/webpack-config-utils/81c6a782efe6d12349985d1d8f5044c9dbf3f769/test/assets/fixtures/fonts/rw-widgets.woff


--------------------------------------------------------------------------------
/test/assets/fixtures/img/loader-big.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jquense/webpack-config-utils/81c6a782efe6d12349985d1d8f5044c9dbf3f769/test/assets/fixtures/img/loader-big.gif


--------------------------------------------------------------------------------
/test/assets/fixtures/img/loader.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jquense/webpack-config-utils/81c6a782efe6d12349985d1d8f5044c9dbf3f769/test/assets/fixtures/img/loader.gif


--------------------------------------------------------------------------------
/test/assets/unit.js:
--------------------------------------------------------------------------------
 1 | import webpack from 'webpack';
 2 | import path from 'path';
 3 | import configure from '../../src'
 4 | import assets from '../../src/assets'
 5 | import * as testUtils from '../../test-helpers'
 6 | import chai from 'chai'
 7 | 
 8 | let expect = chai.expect;
 9 | chai.should()
10 | 
11 | describe('asset preset', function() {
12 |   this.timeout(10000)
13 | 
14 |   beforeEach(() => {
15 |     process.env.NODE_ENV = null
16 |   })
17 | 
18 |   it('should be usable', () => {
19 |     configure()
20 |       .use(assets)
21 |       .resolve()
22 |   })
23 | 
24 |   it('should optimize images in production', () => {
25 | 
26 |     return testUtils.env('production', () => {
27 |       let config = require('./fixtures/config')
28 | 
29 |       testUtils.hasLoader(config, 'image-webpack-loader')
30 |         .should.equal(true)
31 | 
32 |       return testUtils
33 |         .run(config, true)
34 |         .then(({ output, fs }) => {
35 |           let contents = fs.readFileSync(__dirname + '/output/bundle.js').toString('utf8')
36 | 
37 |           output.should
38 |             .contain(path.join('bundle.js'))
39 |           .and
40 |             .contain(path.join('fonts/asset-rw-widgets.eot'))
41 |             .contain(path.join('fonts/asset-rw-widgets.svg'))
42 |             .contain(path.join('fonts/asset-rw-widgets.ttf'))
43 |           .and
44 |             .contain(path.join('images/asset-loader.gif'))
45 |             .contain(path.join('images/asset-loader-big.gif'))
46 |         })
47 |     })
48 |   })
49 | 
50 |   it('should create output files', () => {
51 |     let config = require('./fixtures/config')
52 | 
53 |     return testUtils
54 |       .run(config, true)
55 |       .then(({ output }) => {
56 |         output.should
57 |           .contain(path.join('bundle.js'))
58 |         .and
59 |           .contain(path.join('fonts/asset-rw-widgets.eot'))
60 |           .contain(path.join('fonts/asset-rw-widgets.svg'))
61 |           .contain(path.join('fonts/asset-rw-widgets.ttf'))
62 |         .and
63 |           .contain(path.join('images/asset-loader.gif'))
64 |           .contain(path.join('images/asset-loader-big.gif'))
65 |       })
66 |   })
67 | 
68 |   it('should inline woff', () => {
69 |     let config = require('./fixtures/config')
70 | 
71 |     return testUtils
72 |       .run(config, true)
73 |       .then(({ fs }) => {
74 |         let contents = fs.readFileSync(__dirname + '/output/bundle.js').toString('utf8')
75 |         contents.should.contain('module.exports = "data:application/font-woff;base64')
76 |       })
77 |   })
78 | 
79 | })
80 | 


--------------------------------------------------------------------------------
/test/babel/fixtures/config.js:
--------------------------------------------------------------------------------
 1 | import HtmlWebpackPlugin from 'html-webpack-plugin';
 2 | import configure from '../../../src'
 3 | import babel from '../../../src/babel'
 4 | 
 5 | export default configure()
 6 |   .use(babel)
 7 |   .entry(__dirname + '/entry.js')
 8 |   .output(__dirname + '/../output/bundle.js')
 9 |   .plugin('html', new HtmlWebpackPlugin())
10 |   .resolve()
11 | 


--------------------------------------------------------------------------------
/test/babel/fixtures/entry.js:
--------------------------------------------------------------------------------
1 | import './foo'
2 | 
3 | let b = 6
4 | const foo = 'bar'
5 | 
6 | let obj = { b, foo }
7 | 


--------------------------------------------------------------------------------
/test/babel/fixtures/foo.es6:
--------------------------------------------------------------------------------
1 | 
2 | let bar = `hello!`
3 | 


--------------------------------------------------------------------------------
/test/babel/unit.js:
--------------------------------------------------------------------------------
 1 | import webpack from 'webpack';
 2 | import configure from '../../src'
 3 | import babel from '../../src/babel'
 4 | import * as testUtils from '../../test-helpers'
 5 | 
 6 | import chai from 'chai'
 7 | 
 8 | let expect = chai.expect;
 9 | chai.should()
10 | 
11 | describe('babel preset', function() {
12 |   beforeEach(() => {
13 |     process.env.NODE_ENV = null
14 |   })
15 | 
16 |   it('should be usable', () => {
17 |     configure()
18 |       .use(babel)
19 |       .resolve()
20 |   })
21 | 
22 |   it('should transpile code', () => {
23 |     let config = require('./fixtures/config')
24 | 
25 |     return testUtils
26 |       .run(config, true)
27 |       .then(({ fs }) => {
28 |         let contents = fs.readFileSync(__dirname + '/output/bundle.js').toString('utf8')
29 |         contents.should
30 |           .contain("var foo = 'bar';")
31 |           .contain("var b = 6;")
32 |       })
33 |   })
34 | })
35 | 


--------------------------------------------------------------------------------
/test/basic/fixtures/config.js:
--------------------------------------------------------------------------------
 1 | import HtmlWebpackPlugin from 'html-webpack-plugin';
 2 | import configure from '../../../src'
 3 | import basic from '../../../src/basic'
 4 | 
 5 | export default configure()
 6 |   .use(basic)
 7 |   .entry(__dirname + '/entry.js')
 8 |   .output(__dirname + '/../output/bundle.js')
 9 |   .plugin('html', new HtmlWebpackPlugin())
10 |   .resolve()
11 | 


--------------------------------------------------------------------------------
/test/basic/fixtures/data.json:
--------------------------------------------------------------------------------
1 | {
2 |   "hello": true
3 | }
4 | 


--------------------------------------------------------------------------------
/test/basic/fixtures/entry.js:
--------------------------------------------------------------------------------
1 | // json loader
2 | var data = require('./data')
3 | 
4 | var pre = document.createElement('pre')
5 | 
6 | pre.innerText = JSON.stringify(data, null, 2)
7 | 
8 | document.body.appendChild(pre)
9 | 


--------------------------------------------------------------------------------
/test/basic/unit.js:
--------------------------------------------------------------------------------
  1 | import webpack from 'webpack';
  2 | import configure from '../../src'
  3 | import basic from '../../src/basic'
  4 | import * as testUtils from '../../test-helpers'
  5 | import chai from 'chai'
  6 | 
  7 | let expect = chai.expect;
  8 | chai.should()
  9 | 
 10 | describe('basic preset', function() {
 11 | 
 12 |   beforeEach(() => {
 13 |     process.env.NODE_ENV = null
 14 |   })
 15 | 
 16 |   it('should be usable', () => {
 17 |     configure()
 18 |       .use(basic)
 19 |       .resolve()
 20 |   })
 21 | 
 22 |   it('should add extensions', ()=> {
 23 |     let config = configure().use(basic).resolve();
 24 | 
 25 |     config.resolve.extensions
 26 |       .should.contain('.json')
 27 |   })
 28 | 
 29 |   it('should add bower components', ()=> {
 30 |     let config = configure().use(basic).use(basic).resolve();
 31 | 
 32 |     config.resolve.modulesDirectories
 33 |       .should.eql(['web_modules', 'node_modules', 'bower_components'])
 34 |   })
 35 | 
 36 |   it('should be have dedupe plugin', () => {
 37 |     testUtils.hasPlugin(
 38 |       configure().use(basic),
 39 |       webpack.optimize.DedupePlugin
 40 |     ).should.equal(false)
 41 | 
 42 |     testUtils.env('production', ()=> {
 43 |       testUtils.hasPlugin(
 44 |         configure().use(basic),
 45 |         webpack.optimize.DedupePlugin
 46 |       ).should.equal(true)
 47 |     })
 48 |   })
 49 | 
 50 |   it('should be have OccurenceOrderPlugin', () => {
 51 |     testUtils.hasPlugin(
 52 |       configure().use(basic),
 53 |       webpack.optimize.OccurenceOrderPlugin
 54 |     ).should.equal(true)
 55 |   })
 56 | 
 57 |   it('should be have CommonsChunkPlugin', () => {
 58 |     testUtils.hasPlugin(
 59 |       configure().use(basic),
 60 |       webpack.optimize.CommonsChunkPlugin
 61 |     ).should.equal(true)
 62 |   })
 63 | 
 64 |   it('should be have Uglify plugin in prod', () => {
 65 |     testUtils.hasPlugin(
 66 |       configure().use(basic),
 67 |       webpack.optimize.UglifyJsPlugin
 68 |     ).should.equal(false)
 69 | 
 70 |     testUtils.env('production', ()=> {
 71 |       testUtils.hasPlugin(
 72 |         configure().use(basic),
 73 |         webpack.optimize.UglifyJsPlugin
 74 |       ).should.equal(true)
 75 |     })
 76 |   })
 77 | 
 78 |   it('should be have appropriate source map setting', () => {
 79 | 
 80 |     configure().use(basic).resolve().devtool
 81 |       .should.equal('cheap-module-eval-source-map')
 82 | 
 83 |     testUtils.env('test', ()=> {
 84 |       configure().use(basic).resolve().devtool
 85 |         .should.equal('inline-source-map')
 86 |     })
 87 | 
 88 |     testUtils.env('production', ()=> {
 89 |       configure().use(basic).resolve().devtool
 90 |         .should.equal('source-map')
 91 |     })
 92 |   })
 93 | 
 94 |   it('create output files', () => {
 95 |     let config = require('./fixtures/config')
 96 | 
 97 |     return testUtils
 98 |       .run(config, true)
 99 |       .then(({ output }) => {
100 |         output.should
101 |           .contain('bundle.js')
102 |           .contain('common.bundle.js')
103 |       })
104 |   })
105 | 
106 | })
107 | 


--------------------------------------------------------------------------------
/test/configure.js:
--------------------------------------------------------------------------------
  1 | import chai from 'chai'
  2 | import path from 'path'
  3 | import capitalize from 'lodash/string/capitalize'
  4 | import configure from '../src/config/configure.js'
  5 | import { compare } from '../test-helpers';
  6 | 
  7 | let expect = chai.expect;
  8 | 
  9 | chai.should()
 10 | 
 11 | 
 12 | 
 13 | describe('creating configs', () => {
 14 | 
 15 |   it('should add an entry', () => {
 16 | 
 17 |     compare(
 18 |       configure()
 19 |         .entry(__dirname + '/index.es6.js')
 20 |         .entry('vendor', ['lodash', 'react'])
 21 | 
 22 |       , {
 23 |         entry: {
 24 |           test: __dirname + '/index.es6.js',
 25 |           vendor: ['lodash', 'react'],
 26 |         }
 27 |       }
 28 |     )
 29 |   }),
 30 | 
 31 |   it('should clone config', () => {
 32 |     let configA = configure().loader('json')
 33 |       , configB = configA.clone()
 34 | 
 35 |     expect(configA).to.not.equal(configB)
 36 | 
 37 |     expect(configA).to.eql(configB)
 38 |     expect(configA._loaders).to.not.equal(configB._loaders)
 39 |   })
 40 | 
 41 |   describe('loaders', () => {
 42 |     ['loader', 'preLoader', 'postLoader'].forEach(type => {
 43 | 
 44 |       let add = type
 45 |         , remove = 'remove' + capitalize(type)
 46 |         , replace = 'replace' + capitalize(type)
 47 | 
 48 |       it('should add a ' + type + ' by name', () => {
 49 | 
 50 |         compare(
 51 |           configure()[add]('json')
 52 |           , {
 53 |             module: {
 54 |               loaders: [
 55 |                 {
 56 |                   loader: require.resolve('json-loader'),
 57 |                   test: /\.(json)$/i,
 58 |                   exclude: [/node_modules/]
 59 |                 },
 60 |               ]
 61 |             }
 62 |           }
 63 |         )
 64 |       })
 65 | 
 66 | 
 67 |       it('should add a ' + type + ' via an object', () => {
 68 | 
 69 |         compare(
 70 |           configure()
 71 |             [add]('js', { loader: 'babel', test: /\.(js)/ })
 72 |             [add]('styles', { loader: 'css', test: /\.(css)/ })
 73 |           , {
 74 |             module: {
 75 |               loaders: [
 76 |                 { loader: require.resolve('babel-loader'), test: /\.(js)/ },
 77 |                 { loader: require.resolve('css-loader'), test: /\.(css)/ }
 78 |               ]
 79 |             }
 80 |           }
 81 |         )
 82 |       })
 83 | 
 84 |       it('should add a ' + type + ' via a builder', () => {
 85 | 
 86 |         compare(
 87 |           configure()
 88 |             [add]('js', builder =>
 89 |               builder('babel').ext('js'))
 90 | 
 91 |           , {
 92 |             module: {
 93 |               loaders: [
 94 |                 {
 95 |                   loader: require.resolve('babel-loader'),
 96 |                   test: /\.(js)$/i,
 97 |                   exclude: [/node_modules/]
 98 |                 }
 99 |               ]
100 |             }
101 |           }
102 |         )
103 |       })
104 | 
105 |       it('should add multiple ' + type + 's via an array', () => {
106 | 
107 |         compare(
108 |           configure()
109 |             [add]('styles', [
110 |               { loader: 'style', test: /\.(css)/ },
111 |               { loader: 'css', test: /\.(css)/ }
112 |             ])
113 |             [add]('js', { loader: 'babel', test: /\.(js)/ })
114 |           , {
115 |             module: {
116 |               loaders: [
117 |                 { loader: require.resolve('style-loader'), test: /\.(css)/ },
118 |                 { loader: require.resolve('css-loader'), test: /\.(css)/ },
119 |                 { loader: require.resolve('babel-loader'), test: /\.(js)/ }
120 |               ]
121 |             }
122 |           }
123 |         )
124 |       })
125 | 
126 |       it('should add multiple ' + type + 's via a builder', () => {
127 | 
128 |         compare(
129 |           configure()
130 |             [add]('js', builder =>
131 |               builder(
132 |                 'css', l => l('babel').query({ stage: 0 })
133 |               )
134 |               .ext('js'))
135 | 
136 |           , {
137 |             module: {
138 |               loaders: [
139 |                 {
140 |                   loader: require.resolve('css-loader'),
141 |                   test: /\.(js)$/i,
142 |                   exclude: [/node_modules/]
143 |                 },
144 |                 {
145 |                   loader: require.resolve('babel-loader'),
146 |                   query: { stage: 0 },
147 |                   test: /\.(js)$/i,
148 |                   exclude: [/node_modules/]
149 |                 }
150 |               ]
151 |             }
152 |           }
153 |         )
154 |       })
155 | 
156 |       it('should throw with an existing a ' + type, () => {
157 |         expect(() => configure()
158 |           [add]('styles', { loader: 'babel', test: /\.(js)/ })
159 |           [add]('styles', { loader: 'css', test: /\.(css)/ })
160 |           .resolve()
161 |         )
162 |         .to.throw(/There is already a (post|pre)?loader or set of (post|pre)?loaders by this name/i)
163 |       })
164 | 
165 |       it('should replace a ' + type, () => {
166 | 
167 |         compare(
168 |           configure()
169 |             [add]('styles', { loader: 'css', test: /\.(css)/ })
170 |             [add]('js', { loader: 'babel', test: /\.(js)/ })
171 |             [replace]('styles', { loader: 'style!css', test: /\.(css)/ })
172 |           , {
173 |             module: {
174 |               loaders: [
175 |                 {
176 |                   loader: ['style-loader','css-loader'].map(require.resolve).join('!'),
177 |                   test: /\.(css)/
178 |                 },
179 |                 { loader: require.resolve('babel-loader'), test: /\.(js)/ }
180 |               ]
181 |             }
182 |           }
183 |         )
184 |       })
185 | 
186 |       it('should replace a set of ' + type + 's', () => {
187 | 
188 |         compare(
189 |           configure()
190 |             [add]('styles', [
191 |               { loader: 'style', test: /\.(css)/ },
192 |               { loader: 'css', test: /\.(css)/ }
193 |             ])
194 |             [add]('js', { loader: 'babel', test: /\.(js)/ })
195 |             [replace]('styles', { loader: 'style!css', test: /\.(css)/ })
196 |           , {
197 |             module: {
198 |               loaders: [
199 |                 {
200 |                   loader: ['style-loader','css-loader'].map(require.resolve).join('!'),
201 |                   test: /\.(css)/
202 |                 },
203 |                 { loader: require.resolve('babel-loader'), test: /\.(js)/ }
204 |               ]
205 |             }
206 |           }
207 |         )
208 |       })
209 | 
210 |     })
211 |   })
212 | 
213 |   describe('environments', ()=> {
214 |     let env;
215 | 
216 |     beforeEach(()=> env = process.env.NODE_ENV)
217 |     afterEach(() => process.env.NODE_ENV = env)
218 | 
219 |     it('should apply when in the environment', ()=> {
220 |       let called = 0;
221 |       process.env.NODE_ENV = 'myenv'
222 | 
223 |       configure().inEnv('myenv', ()=> called++)
224 |       configure().notInEnv('myenv', ()=> called++)
225 | 
226 |       expect(called).to.equal(1)
227 |     })
228 | 
229 |     it('should allow aliasing built-in envs', ()=> {
230 |       let called = 0;
231 | 
232 |       process.env.NODE_ENV = 'staging'
233 | 
234 |       configure()
235 |         .env('production', 'staging')
236 |         .inEnv('production', ()=> called++)
237 |         .notInEnv('production', ()=> called++)
238 | 
239 |       process.env.NODE_ENV = 'dev-staging'
240 | 
241 |       configure()
242 |         .env('production', ['staging', 'dev-staging'])
243 |         .inEnv('production', ()=> called++)
244 |         .notInEnv('production', ()=> called++)
245 | 
246 |       expect(called).to.equal(2)
247 |     })
248 | 
249 |     it('should have built in convenience methods', ()=> {
250 |       ['Production', 'Test', 'Development'].forEach(env => {
251 |         configure()['in' + env].should.be.a('function')
252 |         configure()['notIn' + env].should.be.a('function')
253 |       })
254 |     })
255 |   })
256 | 
257 |   it('should add extensions', () => {
258 |     compare(
259 |       configure()
260 |         .extension('.jsx', 'es6', 'js')
261 |     , {
262 |       resolve: {
263 |         extensions: ['', '.js', '.jsx', '.es6']
264 |       }
265 |     })
266 |   })
267 | 
268 |   it('should define roots', () => {
269 |     compare(
270 |       configure()
271 |         .root('./config', './config', path.resolve(__dirname, '../basic'))
272 |     , {
273 |       resolve: {
274 |         root: [
275 |           path.resolve('./config'),
276 |           path.resolve('./basic')
277 |         ]
278 |       }
279 |     })
280 |   })
281 | 
282 |   it('should define aliases', () => {
283 |     compare(
284 |       configure()
285 |         .alias('bl', 'css-loader')
286 |         .alias('bl', 'babel-loader')
287 |     , {
288 |       resolve: {
289 |         alias: {
290 |           bl: 'babel-loader'
291 |         }
292 |       }
293 |     })
294 |   })
295 | 
296 |   it('should add defines', () => {
297 | 
298 |     configure()
299 |       .define('process.env.MY_ENV', true)
300 |       .define({
301 |         process: {
302 |           env: {
303 |             NODE_ENV: 'production'
304 |           }
305 |         }
306 |       })
307 |       ._defines.should.eql({
308 |         process: {
309 |           env: {
310 |             MY_ENV: 'true',
311 |             NODE_ENV: '"production"'
312 |           }
313 |         }
314 |       })
315 |   })
316 | })
317 | 


--------------------------------------------------------------------------------
/test/loader.js:
--------------------------------------------------------------------------------
  1 | import chai from 'chai'
  2 | import loader from '../src/config/loader.js'
  3 | 
  4 | let expect = chai.expect;
  5 | 
  6 | chai.should()
  7 | 
  8 | describe('loader builder', () => {
  9 |   it('should create a simple loader', () => {
 10 | 
 11 |     expect(
 12 |       loader('babel')
 13 |         .ext('js', 'jsx')
 14 |         .resolve()
 15 |     ).to.eql(
 16 |       {
 17 |           loader: 'babel',
 18 |           test: /\.(js|jsx)$/i,
 19 |           exclude: [/node_modules/]
 20 |       }
 21 |     )
 22 |   })
 23 | 
 24 |   it('should create a single chained loader with strings', () => {
 25 | 
 26 |     expect(
 27 |       loader('react-hot', 'babel')
 28 |         .ext('js', 'jsx')
 29 |         .resolve()
 30 |     ).to.eql(
 31 |       {
 32 |           loaders: ['react-hot', 'babel'],
 33 |           test: /\.(js|jsx)$/i,
 34 |           exclude: [/node_modules/]
 35 |       }
 36 |     )
 37 |   })
 38 | 
 39 |   it('should create a single chained loader with strings', () => {
 40 | 
 41 |     expect(
 42 |       loader('react-hot', l => l('babel'))
 43 |         .ext('js', 'jsx')
 44 |         .resolve()
 45 |     ).to.eql(
 46 |       {
 47 |           loaders: ['react-hot', 'babel'],
 48 |           test: /\.(js|jsx)$/i,
 49 |           exclude: [/node_modules/]
 50 |       }
 51 |     )
 52 |   })
 53 |   it('should create a single chained loader single fn loader', () => {
 54 | 
 55 |     expect(
 56 |       loader(l => l('babel').query({ stage: 0 }))
 57 |         .for('js', 'jsx')
 58 |         .resolve()
 59 |     ).to.eql(
 60 |       {
 61 |           loader: 'babel',
 62 |           query: { stage: 0 },
 63 |           test: /\.(js|jsx)$/i,
 64 |           exclude: [/node_modules/]
 65 |       }
 66 |     )
 67 |   })
 68 | 
 69 |   it('should create multiple equivalent loaders when needed', () => {
 70 |     expect(
 71 |       loader('react-hot', l => l('babel').query({ stage: 0 }))
 72 |         .ext('js', 'jsx')
 73 |         .resolve()
 74 |     ).to.eql([
 75 |       { loader: 'react-hot', test: /\.(js|jsx)$/i, exclude: [/node_modules/] },
 76 |       { loader: 'babel', test: /\.(js|jsx)$/i, exclude: [/node_modules/], query: { stage: 0 } },
 77 |     ])
 78 |   })
 79 | 
 80 |   it('should parse out query', () => {
 81 |     expect(loader('babel?stage=0').ext('js').resolve())
 82 |       .to.eql({
 83 |         loader: 'babel',
 84 |         test: /\.(js)$/i,
 85 |         exclude: [/node_modules/],
 86 |         query: 'stage=0'
 87 |       })
 88 | 
 89 |     expect(loader(l => l('babel?{stage: 0}')).for('js').resolve())
 90 |       .to.eql({
 91 |         loader: 'babel',
 92 |         test: /\.(js)$/i,
 93 |         exclude: [/node_modules/],
 94 |         query: { stage: 0 }
 95 |       })
 96 |   })
 97 | 
 98 |   it('should throw when trying to chain with !', () => {
 99 |     expect(() => loader('react-hot!babel').resolve())
100 |       .to.throw(/change: `\("react-hot!babel"\)` to: `\("react-hot", "babel"\)`/)
101 |   })
102 | 
103 |   it('should throw when missing loaders', () => {
104 |     expect(() => loader().resolve())
105 |       .to.throw(/No loader module provided!/)
106 |   })
107 | 
108 |   it('should throw when missing tests', () => {
109 |     expect(() => loader('babel').resolve())
110 |       .to.throw(/All loaders must match some file type/)
111 |   })
112 | 
113 |   it('should remove exclude when included', () => {
114 |     expect(
115 |       loader('babel').ext('js')
116 |         .include("node_modules")
117 |         .resolve()
118 |     ).to.eql({
119 |         loader: 'babel',
120 |         test: /\.(js)$/i,
121 |         include: ["node_modules"]
122 |     })
123 |   })
124 | 
125 |   it('should remove include when excluded', () => {
126 |     let ldr = loader('babel')
127 |       .ext('js')
128 |       .include(/foo/)
129 | 
130 |     expect(ldr.resolve()).to.eql({
131 |         loader: 'babel',
132 |         test: /\.(js)$/i,
133 |         exclude: [/node_modules/],
134 |         include: [/foo/]
135 |     })
136 | 
137 |     expect(ldr.exclude(/foo/).resolve()).to.eql({
138 |         loader: 'babel',
139 |         test: /\.(js)$/i,
140 |         exclude: [/node_modules/, /foo/]
141 |     })
142 |   })
143 | 
144 | })
145 | 


--------------------------------------------------------------------------------
/test/react/fixtures/Component.jsx:
--------------------------------------------------------------------------------
1 | 
2 | export default props => <strong>{props.name}</strong>
3 | 


--------------------------------------------------------------------------------
/test/react/fixtures/config.js:
--------------------------------------------------------------------------------
 1 | import HtmlWebpackPlugin from 'html-webpack-plugin';
 2 | import configure from '../../../src'
 3 | import react from '../../../src/react'
 4 | 
 5 | export default configure()
 6 |   .use(react)
 7 |   .entry(__dirname + '/entry.js')
 8 |   .output(__dirname + '/../output/bundle.js')
 9 |   .plugin('html', new HtmlWebpackPlugin())
10 |   .resolve()
11 | 


--------------------------------------------------------------------------------
/test/react/fixtures/entry.js:
--------------------------------------------------------------------------------
1 | import Greeting from './Component';
2 | 
3 | let App = React.createClass({
4 |   render() {
5 |     return <div>hello there <Greeting name={this.props.name}/></div>
6 |   }
7 | })
8 | 


--------------------------------------------------------------------------------
/test/react/unit.js:
--------------------------------------------------------------------------------
 1 | import webpack from 'webpack';
 2 | import configure from '../../src'
 3 | import react from '../../src/react'
 4 | import * as testUtils from '../../test-helpers'
 5 | 
 6 | import chai from 'chai'
 7 | 
 8 | let expect = chai.expect;
 9 | chai.should()
10 | 
11 | describe('react preset', function() {
12 |   beforeEach(() => {
13 |     process.env.NODE_ENV = null
14 |   })
15 | 
16 |   it('should be usable', () => {
17 |     configure()
18 |       .use(react)
19 |       .resolve()
20 |   })
21 | 
22 |   it('should add react-hot-loader in hot mode', () => {
23 |     let config = configure().use(react)
24 | 
25 |     testUtils.hasLoader(config, 'react-hot-loader')
26 |       .should.equal(false)
27 | 
28 |     testUtils.hasLoader(config.hot(), 'react-hot-loader')
29 |       .should.equal(true)
30 | 
31 |     testUtils.hasLoader(config.hot().hot().hot(false).hot().hot(false), 'react-hot-loader')
32 |       .should.equal(false)
33 |   })
34 | 
35 |   it('should transpile code', () => {
36 |     let config = require('./fixtures/config')
37 | 
38 |     return testUtils
39 |       .run(config, true)
40 |       .then(({ fs }) => {
41 |         let contents = fs.readFileSync(__dirname + '/output/bundle.js').toString('utf8')
42 |         contents.should
43 |           .contain("React.createElement(")
44 |       })
45 |   })
46 | })
47 | 


--------------------------------------------------------------------------------
/test/styles/fixtures/config.js:
--------------------------------------------------------------------------------
 1 | import HtmlWebpackPlugin from 'html-webpack-plugin';
 2 | import configure from '../../../src'
 3 | import styles from '../../../src/styles'
 4 | 
 5 | export default configure()
 6 |   .use(styles)
 7 |   .entry(__dirname + '/entry.js')
 8 |   .output(__dirname + '/../output/bundle.js')
 9 |   .plugin('html', new HtmlWebpackPlugin())
10 |   .resolve()
11 | 


--------------------------------------------------------------------------------
/test/styles/fixtures/entry.js:
--------------------------------------------------------------------------------
 1 | require('./styles.css')
 2 | 
 3 | document.body.innerHTML = `
 4 |   <div class='box'>
 5 |     <p class="red">
 6 |       hello there styles!
 7 |     </p>
 8 |   </div>
 9 | `
10 | 


--------------------------------------------------------------------------------
/test/styles/fixtures/styles.css:
--------------------------------------------------------------------------------
 1 | 
 2 | body {
 3 |   font-size: 24px;
 4 | }
 5 | 
 6 | .box {
 7 |   padding: 20px;
 8 |   border: 1px blue solid;
 9 | }
10 | 
11 | .red {
12 |   color: red;
13 | }
14 | 


--------------------------------------------------------------------------------
/test/styles/unit.js:
--------------------------------------------------------------------------------
  1 | import webpack from 'webpack';
  2 | import configure from '../../src'
  3 | import styles from '../../src/styles'
  4 | import * as testUtils from '../../test-helpers'
  5 | import chai from 'chai'
  6 | 
  7 | let expect = chai.expect;
  8 | chai.should()
  9 | 
 10 | describe('styles preset', function() {
 11 | 
 12 |   beforeEach(() => {
 13 |     process.env.NODE_ENV = null
 14 |   })
 15 | 
 16 |   describe('basic', () => {
 17 |     let preset = styles;
 18 | 
 19 |     it('should be usable', () => {
 20 |       configure()
 21 |         .use(preset)
 22 |         .resolve()
 23 | 
 24 |       configure()
 25 |         .use(preset.extract)
 26 |         .resolve()
 27 |     })
 28 | 
 29 |     it('should be have correct loaders', () => {
 30 |       let config = configure().use(preset).resolve()
 31 | 
 32 |       testUtils.hasLoader(config, 'style-loader')
 33 |         .should.equal(true)
 34 |       testUtils.hasLoader(config, 'css-loader')
 35 |         .should.equal(true)
 36 |     })
 37 | 
 38 |     it('should be have correct loaders (extract)', () => {
 39 |       let config = configure().use(preset.extract).resolve()
 40 | 
 41 |       testUtils.hasLoader(config, 'extract-text-webpack')
 42 |         .should.equal(true)
 43 | 
 44 |       testUtils.hasLoader(config, 'css-loader')
 45 |         .should.equal(true)
 46 |     })
 47 |   })
 48 | 
 49 |   describe('less', () => {
 50 |     let preset = styles.less;
 51 | 
 52 |     it('should be usable', () => {
 53 |       configure()
 54 |         .use(preset)
 55 |         .resolve()
 56 | 
 57 |       configure()
 58 |         .use(preset.extract)
 59 |         .resolve()
 60 |     })
 61 | 
 62 |     it('should be have correct loaders', () => {
 63 |       let config = configure().use(preset).resolve()
 64 | 
 65 |       testUtils.hasLoader(config, 'style-loader')
 66 |         .should.equal(true)
 67 |       testUtils.hasLoader(config, 'css-loader')
 68 |         .should.equal(true)
 69 |       testUtils.hasLoader(config, 'less-loader')
 70 |         .should.equal(true)
 71 |     })
 72 | 
 73 |     it('should be have correct loaders (extract)', () => {
 74 |       let config = configure().use(preset.extract).resolve()
 75 | 
 76 |       testUtils.hasLoader(config, 'extract-text-webpack')
 77 |         .should.equal(true)
 78 |       testUtils.hasLoader(config, 'css-loader')
 79 |         .should.equal(true)
 80 |       testUtils.hasLoader(config, 'less-loader')
 81 |         .should.equal(true)
 82 |     })
 83 |   })
 84 | 
 85 |   describe('sass', () => {
 86 |     let preset = styles.sass;
 87 | 
 88 |     it('should be usable', () => {
 89 |       configure()
 90 |         .use(preset)
 91 |         .resolve()
 92 | 
 93 |       configure()
 94 |         .use(preset.extract)
 95 |         .resolve()
 96 |     })
 97 | 
 98 |     it('should be have correct loaders', () => {
 99 |       let config = configure().use(preset).resolve()
100 | 
101 |       testUtils.hasLoader(config, 'style-loader')
102 |         .should.equal(true)
103 |       testUtils.hasLoader(config, 'css-loader')
104 |         .should.equal(true)
105 |       testUtils.hasLoader(config, 'sass-loader')
106 |         .should.equal(true)
107 |     })
108 | 
109 |     it('should be have correct loaders (extract)', () => {
110 |       let config = configure().use(preset.extract).resolve()
111 | 
112 |       testUtils.hasLoader(config, 'extract-text-webpack')
113 |         .should.equal(true)
114 |       testUtils.hasLoader(config, 'css-loader')
115 |         .should.equal(true)
116 |       testUtils.hasLoader(config, 'sass-loader')
117 |         .should.equal(true)
118 |     })
119 |   })
120 | })
121 | 


--------------------------------------------------------------------------------
/test/validations.js:
--------------------------------------------------------------------------------
 1 | import chai from 'chai'
 2 | import capitalize from 'lodash/string/capitalize'
 3 | import validate from '../src/config/validate.js'
 4 | import escape from 'escape-regexp';
 5 | 
 6 | let expect = chai.expect;
 7 | 
 8 | chai.should()
 9 | 
10 | 
11 | describe('config validations', ()=> {
12 | 
13 |   function reports(config, ...lineMatches) {
14 |     let match = lineMatches
15 |       .map(m => m.source || escape(m))
16 |       .join('[^]+')
17 | 
18 |     if (match) match = new RegExp(match, 'gmi')
19 |     expect(()=> validate(config)).to.throw(match)
20 |   }
21 | 
22 |   describe('output', ()=> {
23 |     it('should catch non-differentiated filenames with multiple entries', () => {
24 |       let config = {
25 |         entry: {
26 |           app: './app.js',
27 |           vendor: './vendor.js'
28 |         },
29 |         output: {
30 |           filename: 'bundle.js'
31 |         }
32 |       }
33 |       reports(config,
34 |         'You have specified multiple entry points',
35 |         'such as: "bundle.[name].js"'
36 |       )
37 |     })
38 |   })
39 | })
40 | 


--------------------------------------------------------------------------------