First commit

hGameTest/node_modules/webpack-dev-middleware/lib/GetFilenameFromUrl.js

@@ -0,0 +1,63 @@
+var pathJoin = require("./PathJoin");
+var querystring = require("querystring");
+var urlParse = require("url").parse;
+
+function getFilenameFromUrl(publicPath, outputPath, url) {
+	var filename;
+
+	// localPrefix is the folder our bundle should be in
+	var localPrefix = urlParse(publicPath || "/", false, true);
+	var urlObject = urlParse(url);
+
+	// publicPath has the hostname that is not the same as request url's, should fail
+	if(localPrefix.hostname !== null && urlObject.hostname !== null &&
+		localPrefix.hostname !== urlObject.hostname) {
+		return false;
+	}
+
+	// publicPath is not in url, so it should fail
+	if(publicPath && localPrefix.hostname === urlObject.hostname && url.indexOf(publicPath) !== 0) {
+		return false;
+	}
+
+	// strip localPrefix from the start of url
+	if(urlObject.pathname.indexOf(localPrefix.pathname) === 0) {
+		filename = urlObject.pathname.substr(localPrefix.pathname.length);
+	}
+
+	if(!urlObject.hostname && localPrefix.hostname &&
+		url.indexOf(localPrefix.path) !== 0) {
+		return false;
+	}
+	// and if not match, use outputPath as filename
+	return querystring.unescape(filename ? pathJoin(outputPath, filename) : outputPath);
+}
+
+// support for multi-compiler configuration
+// see: https://github.com/webpack/webpack-dev-server/issues/641
+function getPaths(publicPath, compiler, url) {
+	var compilers = compiler && compiler.compilers;
+	if(Array.isArray(compilers)) {
+		var compilerPublicPath;
+		for(var i = 0; i < compilers.length; i++) {
+			compilerPublicPath = compilers[i].options
+				&& compilers[i].options.output
+				&& compilers[i].options.output.publicPath;
+			if(url.indexOf(compilerPublicPath) === 0) {
+				return {
+					publicPath: compilerPublicPath,
+					outputPath: compilers[i].outputPath
+				};
+			}
+		}
+	}
+	return {
+		publicPath: publicPath,
+		outputPath: compiler.outputPath
+	};
+}
+
+module.exports = function(publicPath, compiler, url) {
+	var paths = getPaths(publicPath, compiler, url);
+	return getFilenameFromUrl(paths.publicPath, paths.outputPath, url);
+};

hGameTest/node_modules/webpack-dev-middleware/lib/PathJoin.js

@@ -0,0 +1,5 @@
+function pathJoin(a, b) {
+	return a == "/" ? "/" + b : (a || "") + "/" + b;
+}
+
+module.exports = pathJoin;

hGameTest/node_modules/webpack-dev-middleware/lib/Shared.js

@@ -0,0 +1,240 @@
+var mime = require("mime");
+var parseRange = require("range-parser");
+var pathIsAbsolute = require("path-is-absolute");
+var MemoryFileSystem = require("memory-fs");
+var timestamp = require("time-stamp");
+
+var HASH_REGEXP = /[0-9a-f]{10,}/;
+
+module.exports = function Shared(context) {
+	var share = {
+		setOptions: function(options) {
+			if(!options) options = {};
+			if(typeof options.reportTime === "undefined") options.reportTime = false;
+			if(typeof options.watchOptions === "undefined") options.watchOptions = {};
+			if(typeof options.reporter !== "function") options.reporter = share.defaultReporter;
+			if(typeof options.log !== "function") options.log = console.log.bind(console);
+			if(typeof options.warn !== "function") options.warn = console.warn.bind(console);
+			if(typeof options.error !== "function") options.error = console.error.bind(console);
+			if(typeof options.watchDelay !== "undefined") {
+				// TODO remove this in next major version
+				options.warn("options.watchDelay is deprecated: Use 'options.watchOptions.aggregateTimeout' instead");
+				options.watchOptions.aggregateTimeout = options.watchDelay;
+			}
+			if(typeof options.watchOptions.aggregateTimeout === "undefined") options.watchOptions.aggregateTimeout = 200;
+			if(typeof options.stats === "undefined") options.stats = {};
+			if(!options.stats.context) options.stats.context = process.cwd();
+			if(options.lazy) {
+				if(typeof options.filename === "string") {
+					var str = options.filename
+						.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
+						.replace(/\\\[[a-z]+\\\]/ig, ".+");
+					options.filename = new RegExp("^[\/]{0,1}" + str + "$");
+				}
+			}
+			// defining custom MIME type
+			if(options.mimeTypes) mime.define(options.mimeTypes);
+
+			context.options = options;
+		},
+		defaultReporter: function(reporterOptions) {
+			var time = "";
+			var state = reporterOptions.state;
+			var stats = reporterOptions.stats;
+			var options = reporterOptions.options;
+
+			if(!!options.reportTime) {
+				time = "[" + timestamp("HH:mm:ss") + "] ";
+			}
+			if(state) {
+				var displayStats = (!options.quiet && options.stats !== false);
+				if(displayStats && !(stats.hasErrors() || stats.hasWarnings()) &&
+					options.noInfo)
+					displayStats = false;
+				if(displayStats) {
+					if(stats.hasErrors()) {
+						options.error(stats.toString(options.stats));
+					} else if(stats.hasWarnings()) {
+						options.warn(stats.toString(options.stats));
+					} else {
+						options.log(stats.toString(options.stats));
+					}
+				}
+				if(!options.noInfo && !options.quiet) {
+					var msg = "Compiled successfully.";
+					if(stats.hasErrors()) {
+						msg = "Failed to compile.";
+					  } else if(stats.hasWarnings()) {
+						msg = "Compiled with warnings.";
+					}
+					options.log(time + "webpack: " + msg);
+				}
+			} else {
+				options.log(time + "webpack: Compiling...");
+			}
+		},
+		handleRangeHeaders: function handleRangeHeaders(content, req, res) {
+			//assumes express API. For other servers, need to add logic to access alternative header APIs
+			res.setHeader("Accept-Ranges", "bytes");
+			if(req.headers.range) {
+				var ranges = parseRange(content.length, req.headers.range);
+
+				// unsatisfiable
+				if(-1 == ranges) {
+					res.setHeader("Content-Range", "bytes */" + content.length);
+					res.statusCode = 416;
+				}
+
+				// valid (syntactically invalid/multiple ranges are treated as a regular response)
+				if(-2 != ranges && ranges.length === 1) {
+					// Content-Range
+					res.statusCode = 206;
+					var length = content.length;
+					res.setHeader(
+						"Content-Range",
+						"bytes " + ranges[0].start + "-" + ranges[0].end + "/" + length
+					);
+
+					content = content.slice(ranges[0].start, ranges[0].end + 1);
+				}
+			}
+			return content;
+		},
+		setFs: function(compiler) {
+			if(typeof compiler.outputPath === "string" && !pathIsAbsolute.posix(compiler.outputPath) && !pathIsAbsolute.win32(compiler.outputPath)) {
+				throw new Error("`output.path` needs to be an absolute path or `/`.");
+			}
+
+			// store our files in memory
+			var fs;
+			var isMemoryFs = !compiler.compilers && compiler.outputFileSystem instanceof MemoryFileSystem;
+			if(isMemoryFs) {
+				fs = compiler.outputFileSystem;
+			} else {
+				fs = compiler.outputFileSystem = new MemoryFileSystem();
+			}
+			context.fs = fs;
+		},
+		compilerDone: function(stats) {
+			// We are now on valid state
+			context.state = true;
+			context.webpackStats = stats;
+
+			// Do the stuff in nextTick, because bundle may be invalidated
+			// if a change happened while compiling
+			process.nextTick(function() {
+				// check if still in valid state
+				if(!context.state) return;
+				// print webpack output
+				context.options.reporter({
+					state: true,
+					stats: stats,
+					options: context.options
+				});
+
+				// execute callback that are delayed
+				var cbs = context.callbacks;
+				context.callbacks = [];
+				cbs.forEach(function continueBecauseBundleAvailable(cb) {
+					cb(stats);
+				});
+			});
+
+			// In lazy mode, we may issue another rebuild
+			if(context.forceRebuild) {
+				context.forceRebuild = false;
+				share.rebuild();
+			}
+		},
+		compilerInvalid: function() {
+			if(context.state && (!context.options.noInfo && !context.options.quiet))
+				context.options.reporter({
+					state: false,
+					options: context.options
+				});
+
+			// We are now in invalid state
+			context.state = false;
+			//resolve async
+			if(arguments.length === 2 && typeof arguments[1] === "function") {
+				var callback = arguments[1];
+				callback();
+			}
+		},
+		ready: function ready(fn, req) {
+			var options = context.options;
+			if(context.state) return fn(context.webpackStats);
+			if(!options.noInfo && !options.quiet)
+				options.log("webpack: wait until bundle finished: " + (req.url || fn.name));
+			context.callbacks.push(fn);
+		},
+		startWatch: function() {
+			var options = context.options;
+			var compiler = context.compiler;
+			// start watching
+			if(!options.lazy) {
+				var watching = compiler.watch(options.watchOptions, share.handleCompilerCallback);
+				context.watching = watching;
+			} else {
+				context.state = true;
+			}
+		},
+		rebuild: function rebuild() {
+			if(context.state) {
+				context.state = false;
+				context.compiler.run(share.handleCompilerCallback);
+			} else {
+				context.forceRebuild = true;
+			}
+		},
+		handleCompilerCallback: function(err) {
+			if(err) {
+				context.options.error(err.stack || err);
+				if(err.details) context.options.error(err.details);
+			}
+		},
+		handleRequest: function(filename, processRequest, req) {
+			// in lazy mode, rebuild on bundle request
+			if(context.options.lazy && (!context.options.filename || context.options.filename.test(filename)))
+				share.rebuild();
+			if(HASH_REGEXP.test(filename)) {
+				try {
+					if(context.fs.statSync(filename).isFile()) {
+						processRequest();
+						return;
+					}
+				} catch(e) {
+				}
+			}
+			share.ready(processRequest, req);
+		},
+		waitUntilValid: function(callback) {
+			callback = callback || function() {};
+			share.ready(callback, {});
+		},
+		invalidate: function(callback) {
+			callback = callback || function() {};
+			if(context.watching) {
+				share.ready(callback, {});
+				context.watching.invalidate();
+			} else {
+				callback();
+			}
+		},
+		close: function(callback) {
+			callback = callback || function() {};
+			if(context.watching) context.watching.close(callback);
+			else callback();
+		}
+	};
+	share.setOptions(context.options);
+	share.setFs(context.compiler);
+
+	context.compiler.plugin("done", share.compilerDone);
+	context.compiler.plugin("invalid", share.compilerInvalid);
+	context.compiler.plugin("watch-run", share.compilerInvalid);
+	context.compiler.plugin("run", share.compilerInvalid);
+
+	share.startWatch();
+	return share;
+};