webpack/lib/hmr/JavascriptHotModuleReplacement.runtime.js

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

"use strict";

var $options$ = undefined;
var $updateModuleFactories$ = undefined;
var $updateRuntimeModules$ = undefined;
var $moduleCache$ = undefined;
var $moduleFactories$ = undefined;
var $hmrModuleData$ = undefined;
var __webpack_require__ = undefined;

module.exports = function () {
	function getAffectedModuleEffects(updateModuleId) {
		var outdatedModules = [updateModuleId];
		var outdatedDependencies = {};

		var queue = outdatedModules.map(function (id) {
			return {
				chain: [id],
				id: id
			};
		});
		while (queue.length > 0) {
			var queueItem = queue.pop();
			var moduleId = queueItem.id;
			var chain = queueItem.chain;
			var module = $moduleCache$[moduleId];
			if (!module || module.hot._selfAccepted) continue;
			if (module.hot._selfDeclined) {
				return {
					type: "self-declined",
					chain: chain,
					moduleId: moduleId
				};
			}
			if (module.hot._main) {
				return {
					type: "unaccepted",
					chain: chain,
					moduleId: moduleId
				};
			}
			for (var i = 0; i < module.parents.length; i++) {
				var parentId = module.parents[i];
				var parent = $moduleCache$[parentId];
				if (!parent) continue;
				if (parent.hot._declinedDependencies[moduleId]) {
					return {
						type: "declined",
						chain: chain.concat([parentId]),
						moduleId: moduleId,
						parentId: parentId
					};
				}
				if (outdatedModules.indexOf(parentId) !== -1) continue;
				if (parent.hot._acceptedDependencies[moduleId]) {
					if (!outdatedDependencies[parentId])
						outdatedDependencies[parentId] = [];
					addAllToSet(outdatedDependencies[parentId], [moduleId]);
					continue;
				}
				delete outdatedDependencies[parentId];
				outdatedModules.push(parentId);
				queue.push({
					chain: chain.concat([parentId]),
					id: parentId
				});
			}
		}

		return {
			type: "accepted",
			moduleId: updateModuleId,
			outdatedModules: outdatedModules,
			outdatedDependencies: outdatedDependencies
		};
	}

	function addAllToSet(a, b) {
		for (var i = 0; i < b.length; i++) {
			var item = b[i];
			if (a.indexOf(item) === -1) a.push(item);
		}
	}

	// at begin all updates modules are outdated
	// the "outdated" status can propagate to parents if they don't accept the children
	var outdatedDependencies = {};
	var outdatedModules = [];
	var appliedUpdate = {};

	var warnUnexpectedRequire = function warnUnexpectedRequire() {
		console.warn(
			"[HMR] unexpected require(" + result.moduleId + ") to disposed module"
		);
	};

	for (var moduleId in $updateModuleFactories$) {
		if (
			Object.prototype.hasOwnProperty.call($updateModuleFactories$, moduleId)
		) {
			var newModuleFactory = $updateModuleFactories$[moduleId];
			/** @type {TODO} */
			var result;
			if (newModuleFactory) {
				result = getAffectedModuleEffects(moduleId);
			} else {
				result = {
					type: "disposed",
					moduleId: moduleId
				};
			}
			/** @type {Error|false} */
			var abortError = false;
			var doApply = false;
			var doDispose = false;
			var chainInfo = "";
			if (result.chain) {
				chainInfo = "\nUpdate propagation: " + result.chain.join(" -> ");
			}
			switch (result.type) {
				case "self-declined":
					if ($options$.onDeclined) $options$.onDeclined(result);
					if (!$options$.ignoreDeclined)
						abortError = new Error(
							"Aborted because of self decline: " + result.moduleId + chainInfo
						);
					break;
				case "declined":
					if ($options$.onDeclined) $options$.onDeclined(result);
					if (!$options$.ignoreDeclined)
						abortError = new Error(
							"Aborted because of declined dependency: " +
								result.moduleId +
								" in " +
								result.parentId +
								chainInfo
						);
					break;
				case "unaccepted":
					if ($options$.onUnaccepted) $options$.onUnaccepted(result);
					if (!$options$.ignoreUnaccepted)
						abortError = new Error(
							"Aborted because " + moduleId + " is not accepted" + chainInfo
						);
					break;
				case "accepted":
					if ($options$.onAccepted) $options$.onAccepted(result);
					doApply = true;
					break;
				case "disposed":
					if ($options$.onDisposed) $options$.onDisposed(result);
					doDispose = true;
					break;
				default:
					throw new Error("Unexception type " + result.type);
			}
			if (abortError) {
				return {
					error: abortError
				};
			}
			if (doApply) {
				appliedUpdate[moduleId] = newModuleFactory;
				addAllToSet(outdatedModules, result.outdatedModules);
				for (moduleId in result.outdatedDependencies) {
					if (
						Object.prototype.hasOwnProperty.call(
							result.outdatedDependencies,
							moduleId
						)
					) {
						if (!outdatedDependencies[moduleId])
							outdatedDependencies[moduleId] = [];
						addAllToSet(
							outdatedDependencies[moduleId],
							result.outdatedDependencies[moduleId]
						);
					}
				}
			}
			if (doDispose) {
				addAllToSet(outdatedModules, [result.moduleId]);
				appliedUpdate[moduleId] = warnUnexpectedRequire;
			}
		}
	}

	// Store self accepted outdated modules to require them later by the module system
	var outdatedSelfAcceptedModules = [];
	for (var j = 0; j < outdatedModules.length; j++) {
		var outdatedModuleId = outdatedModules[j];
		if (
			$moduleCache$[outdatedModuleId] &&
			$moduleCache$[outdatedModuleId].hot._selfAccepted &&
			// removed self-accepted modules should not be required
			appliedUpdate[outdatedModuleId] !== warnUnexpectedRequire
		) {
			outdatedSelfAcceptedModules.push({
				module: outdatedModuleId,
				require: $moduleCache$[outdatedModuleId].hot._requireSelf,
				errorHandler: $moduleCache$[outdatedModuleId].hot._selfAccepted
			});
		}
	}

	var moduleOutdatedDependencies;

	return {
		dispose: function () {
			// $dispose$

			var idx;
			var queue = outdatedModules.slice();
			while (queue.length > 0) {
				var moduleId = queue.pop();
				var module = $moduleCache$[moduleId];
				if (!module) continue;

				var data = {};

				// Call dispose handlers
				var disposeHandlers = module.hot._disposeHandlers;
				for (j = 0; j < disposeHandlers.length; j++) {
					disposeHandlers[j].call(null, data);
				}
				$hmrModuleData$[moduleId] = data;

				// disable module (this disables requires from this module)
				module.hot.active = false;

				// remove module from cache
				delete $moduleCache$[moduleId];

				// when disposing there is no need to call dispose handler
				delete outdatedDependencies[moduleId];

				// remove "parents" references from all children
				for (j = 0; j < module.children.length; j++) {
					var child = $moduleCache$[module.children[j]];
					if (!child) continue;
					idx = child.parents.indexOf(moduleId);
					if (idx >= 0) {
						child.parents.splice(idx, 1);
					}
				}
			}

			// remove outdated dependency from module children
			var dependency;
			for (var outdatedModuleId in outdatedDependencies) {
				if (
					Object.prototype.hasOwnProperty.call(
						outdatedDependencies,
						outdatedModuleId
					)
				) {
					module = $moduleCache$[outdatedModuleId];
					if (module) {
						moduleOutdatedDependencies = outdatedDependencies[outdatedModuleId];
						for (j = 0; j < moduleOutdatedDependencies.length; j++) {
							dependency = moduleOutdatedDependencies[j];
							idx = module.children.indexOf(dependency);
							if (idx >= 0) module.children.splice(idx, 1);
						}
					}
				}
			}
		},
		apply: function (reportError) {
			// insert new code
			for (var updateModuleId in appliedUpdate) {
				if (
					Object.prototype.hasOwnProperty.call(appliedUpdate, updateModuleId)
				) {
					$moduleFactories$[updateModuleId] = appliedUpdate[updateModuleId];
				}
			}

			// run new runtime modules
			for (var i = 0; i < $updateRuntimeModules$.length; i++) {
				$updateRuntimeModules$[i](__webpack_require__);
			}

			// call accept handlers
			var error = null;
			for (var outdatedModuleId in outdatedDependencies) {
				if (
					Object.prototype.hasOwnProperty.call(
						outdatedDependencies,
						outdatedModuleId
					)
				) {
					var module = $moduleCache$[outdatedModuleId];
					if (module) {
						moduleOutdatedDependencies = outdatedDependencies[outdatedModuleId];
						var callbacks = [];
						for (var j = 0; j < moduleOutdatedDependencies.length; j++) {
							var dependency = moduleOutdatedDependencies[j];
							var acceptCallback = module.hot._acceptedDependencies[dependency];
							if (acceptCallback) {
								if (callbacks.indexOf(acceptCallback) !== -1) continue;
								callbacks.push(acceptCallback);
							}
						}
						for (var k = 0; k < callbacks.length; k++) {
							try {
								callbacks[k].call(null, moduleOutdatedDependencies);
							} catch (err) {
								if ($options$.onErrored) {
									$options$.onErrored({
										type: "accept-errored",
										moduleId: outdatedModuleId,
										dependencyId: moduleOutdatedDependencies[i],
										error: err
									});
								}
								if (!$options$.ignoreErrored) {
									if (!error) error = err;
								}
							}
						}
					}
				}
			}

			// Load self accepted modules
			for (var o = 0; o < outdatedSelfAcceptedModules.length; o++) {
				var item = outdatedSelfAcceptedModules[o];
				var moduleId = item.module;
				try {
					item.require(moduleId);
				} catch (err) {
					if (typeof item.errorHandler === "function") {
						try {
							item.errorHandler(err);
						} catch (err2) {
							if ($options$.onErrored) {
								$options$.onErrored({
									type: "self-accept-error-handler-errored",
									moduleId: moduleId,
									error: err2,
									originalError: err
								});
							}
							if (!$options$.ignoreErrored) {
								reportError(err2);
							}
							reportError(err);
						}
					} else {
						if ($options$.onErrored) {
							$options$.onErrored({
								type: "self-accept-errored",
								moduleId: moduleId,
								error: err
							});
						}
						if (!$options$.ignoreErrored) {
							reportError(err);
						}
					}
				}
			}

			return outdatedModules;
		}
	};
};