1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 | "use strict";
|
7 |
|
8 | var $interceptModuleExecution$ = undefined;
|
9 | var $moduleCache$ = undefined;
|
10 |
|
11 | var $hmrModuleData$ = undefined;
|
12 |
|
13 | var $hmrDownloadManifest$ = undefined;
|
14 | var $hmrDownloadUpdateHandlers$ = undefined;
|
15 | var $hmrInvalidateModuleHandlers$ = undefined;
|
16 | var __webpack_require__ = undefined;
|
17 |
|
18 | module.exports = function () {
|
19 | var currentModuleData = {};
|
20 | var installedModules = $moduleCache$;
|
21 |
|
22 |
|
23 | var currentChildModule;
|
24 | var currentParents = [];
|
25 |
|
26 |
|
27 | var registeredStatusHandlers = [];
|
28 | var currentStatus = "idle";
|
29 |
|
30 |
|
31 | var blockingPromises = 0;
|
32 | var blockingPromisesWaiting = [];
|
33 |
|
34 |
|
35 | var currentUpdateApplyHandlers;
|
36 | var queuedInvalidatedModules;
|
37 |
|
38 |
|
39 | $hmrModuleData$ = currentModuleData;
|
40 |
|
41 | $interceptModuleExecution$.push(function (options) {
|
42 | var module = options.module;
|
43 | var require = createRequire(options.require, options.id);
|
44 | module.hot = createModuleHotObject(options.id, module);
|
45 | module.parents = currentParents;
|
46 | module.children = [];
|
47 | currentParents = [];
|
48 | options.require = require;
|
49 | });
|
50 |
|
51 | $hmrDownloadUpdateHandlers$ = {};
|
52 | $hmrInvalidateModuleHandlers$ = {};
|
53 |
|
54 | function createRequire(require, moduleId) {
|
55 | var me = installedModules[moduleId];
|
56 | if (!me) return require;
|
57 | var fn = function (request) {
|
58 | if (me.hot.active) {
|
59 | if (installedModules[request]) {
|
60 | var parents = installedModules[request].parents;
|
61 | if (parents.indexOf(moduleId) === -1) {
|
62 | parents.push(moduleId);
|
63 | }
|
64 | } else {
|
65 | currentParents = [moduleId];
|
66 | currentChildModule = request;
|
67 | }
|
68 | if (me.children.indexOf(request) === -1) {
|
69 | me.children.push(request);
|
70 | }
|
71 | } else {
|
72 | console.warn(
|
73 | "[HMR] unexpected require(" +
|
74 | request +
|
75 | ") from disposed module " +
|
76 | moduleId
|
77 | );
|
78 | currentParents = [];
|
79 | }
|
80 | return require(request);
|
81 | };
|
82 | var createPropertyDescriptor = function (name) {
|
83 | return {
|
84 | configurable: true,
|
85 | enumerable: true,
|
86 | get: function () {
|
87 | return require[name];
|
88 | },
|
89 | set: function (value) {
|
90 | require[name] = value;
|
91 | }
|
92 | };
|
93 | };
|
94 | for (var name in require) {
|
95 | if (Object.prototype.hasOwnProperty.call(require, name) && name !== "e") {
|
96 | Object.defineProperty(fn, name, createPropertyDescriptor(name));
|
97 | }
|
98 | }
|
99 | fn.e = function (chunkId) {
|
100 | return trackBlockingPromise(require.e(chunkId));
|
101 | };
|
102 | return fn;
|
103 | }
|
104 |
|
105 | function createModuleHotObject(moduleId, me) {
|
106 | var _main = currentChildModule !== moduleId;
|
107 | var hot = {
|
108 |
|
109 | _acceptedDependencies: {},
|
110 | _acceptedErrorHandlers: {},
|
111 | _declinedDependencies: {},
|
112 | _selfAccepted: false,
|
113 | _selfDeclined: false,
|
114 | _selfInvalidated: false,
|
115 | _disposeHandlers: [],
|
116 | _main: _main,
|
117 | _requireSelf: function () {
|
118 | currentParents = me.parents.slice();
|
119 | currentChildModule = _main ? undefined : moduleId;
|
120 | __webpack_require__(moduleId);
|
121 | },
|
122 |
|
123 |
|
124 | active: true,
|
125 | accept: function (dep, callback, errorHandler) {
|
126 | if (dep === undefined) hot._selfAccepted = true;
|
127 | else if (typeof dep === "function") hot._selfAccepted = dep;
|
128 | else if (typeof dep === "object" && dep !== null) {
|
129 | for (var i = 0; i < dep.length; i++) {
|
130 | hot._acceptedDependencies[dep[i]] = callback || function () {};
|
131 | hot._acceptedErrorHandlers[dep[i]] = errorHandler;
|
132 | }
|
133 | } else {
|
134 | hot._acceptedDependencies[dep] = callback || function () {};
|
135 | hot._acceptedErrorHandlers[dep] = errorHandler;
|
136 | }
|
137 | },
|
138 | decline: function (dep) {
|
139 | if (dep === undefined) hot._selfDeclined = true;
|
140 | else if (typeof dep === "object" && dep !== null)
|
141 | for (var i = 0; i < dep.length; i++)
|
142 | hot._declinedDependencies[dep[i]] = true;
|
143 | else hot._declinedDependencies[dep] = true;
|
144 | },
|
145 | dispose: function (callback) {
|
146 | hot._disposeHandlers.push(callback);
|
147 | },
|
148 | addDisposeHandler: function (callback) {
|
149 | hot._disposeHandlers.push(callback);
|
150 | },
|
151 | removeDisposeHandler: function (callback) {
|
152 | var idx = hot._disposeHandlers.indexOf(callback);
|
153 | if (idx >= 0) hot._disposeHandlers.splice(idx, 1);
|
154 | },
|
155 | invalidate: function () {
|
156 | this._selfInvalidated = true;
|
157 | switch (currentStatus) {
|
158 | case "idle":
|
159 | currentUpdateApplyHandlers = [];
|
160 | Object.keys($hmrInvalidateModuleHandlers$).forEach(function (key) {
|
161 | $hmrInvalidateModuleHandlers$[key](
|
162 | moduleId,
|
163 | currentUpdateApplyHandlers
|
164 | );
|
165 | });
|
166 | setStatus("ready");
|
167 | break;
|
168 | case "ready":
|
169 | Object.keys($hmrInvalidateModuleHandlers$).forEach(function (key) {
|
170 | $hmrInvalidateModuleHandlers$[key](
|
171 | moduleId,
|
172 | currentUpdateApplyHandlers
|
173 | );
|
174 | });
|
175 | break;
|
176 | case "prepare":
|
177 | case "check":
|
178 | case "dispose":
|
179 | case "apply":
|
180 | (queuedInvalidatedModules = queuedInvalidatedModules || []).push(
|
181 | moduleId
|
182 | );
|
183 | break;
|
184 | default:
|
185 |
|
186 | break;
|
187 | }
|
188 | },
|
189 |
|
190 |
|
191 | check: hotCheck,
|
192 | apply: hotApply,
|
193 | status: function (l) {
|
194 | if (!l) return currentStatus;
|
195 | registeredStatusHandlers.push(l);
|
196 | },
|
197 | addStatusHandler: function (l) {
|
198 | registeredStatusHandlers.push(l);
|
199 | },
|
200 | removeStatusHandler: function (l) {
|
201 | var idx = registeredStatusHandlers.indexOf(l);
|
202 | if (idx >= 0) registeredStatusHandlers.splice(idx, 1);
|
203 | },
|
204 |
|
205 |
|
206 | data: currentModuleData[moduleId]
|
207 | };
|
208 | currentChildModule = undefined;
|
209 | return hot;
|
210 | }
|
211 |
|
212 | function setStatus(newStatus) {
|
213 | currentStatus = newStatus;
|
214 | var results = [];
|
215 |
|
216 | for (var i = 0; i < registeredStatusHandlers.length; i++)
|
217 | results[i] = registeredStatusHandlers[i].call(null, newStatus);
|
218 |
|
219 | return Promise.all(results);
|
220 | }
|
221 |
|
222 | function unblock() {
|
223 | if (--blockingPromises === 0) {
|
224 | setStatus("ready").then(function () {
|
225 | if (blockingPromises === 0) {
|
226 | var list = blockingPromisesWaiting;
|
227 | blockingPromisesWaiting = [];
|
228 | for (var i = 0; i < list.length; i++) {
|
229 | list[i]();
|
230 | }
|
231 | }
|
232 | });
|
233 | }
|
234 | }
|
235 |
|
236 | function trackBlockingPromise(promise) {
|
237 | switch (currentStatus) {
|
238 | case "ready":
|
239 | setStatus("prepare");
|
240 |
|
241 | case "prepare":
|
242 | blockingPromises++;
|
243 | promise.then(unblock, unblock);
|
244 | return promise;
|
245 | default:
|
246 | return promise;
|
247 | }
|
248 | }
|
249 |
|
250 | function waitForBlockingPromises(fn) {
|
251 | if (blockingPromises === 0) return fn();
|
252 | return new Promise(function (resolve) {
|
253 | blockingPromisesWaiting.push(function () {
|
254 | resolve(fn());
|
255 | });
|
256 | });
|
257 | }
|
258 |
|
259 | function hotCheck(applyOnUpdate) {
|
260 | if (currentStatus !== "idle") {
|
261 | throw new Error("check() is only allowed in idle status");
|
262 | }
|
263 | return setStatus("check")
|
264 | .then($hmrDownloadManifest$)
|
265 | .then(function (update) {
|
266 | if (!update) {
|
267 | return setStatus(applyInvalidatedModules() ? "ready" : "idle").then(
|
268 | function () {
|
269 | return null;
|
270 | }
|
271 | );
|
272 | }
|
273 |
|
274 | return setStatus("prepare").then(function () {
|
275 | var updatedModules = [];
|
276 | currentUpdateApplyHandlers = [];
|
277 |
|
278 | return Promise.all(
|
279 | Object.keys($hmrDownloadUpdateHandlers$).reduce(function (
|
280 | promises,
|
281 | key
|
282 | ) {
|
283 | $hmrDownloadUpdateHandlers$[key](
|
284 | update.c,
|
285 | update.r,
|
286 | update.m,
|
287 | promises,
|
288 | currentUpdateApplyHandlers,
|
289 | updatedModules
|
290 | );
|
291 | return promises;
|
292 | },
|
293 | [])
|
294 | ).then(function () {
|
295 | return waitForBlockingPromises(function () {
|
296 | if (applyOnUpdate) {
|
297 | return internalApply(applyOnUpdate);
|
298 | } else {
|
299 | return setStatus("ready").then(function () {
|
300 | return updatedModules;
|
301 | });
|
302 | }
|
303 | });
|
304 | });
|
305 | });
|
306 | });
|
307 | }
|
308 |
|
309 | function hotApply(options) {
|
310 | if (currentStatus !== "ready") {
|
311 | return Promise.resolve().then(function () {
|
312 | throw new Error(
|
313 | "apply() is only allowed in ready status (state: " +
|
314 | currentStatus +
|
315 | ")"
|
316 | );
|
317 | });
|
318 | }
|
319 | return internalApply(options);
|
320 | }
|
321 |
|
322 | function internalApply(options) {
|
323 | options = options || {};
|
324 |
|
325 | applyInvalidatedModules();
|
326 |
|
327 | var results = currentUpdateApplyHandlers.map(function (handler) {
|
328 | return handler(options);
|
329 | });
|
330 | currentUpdateApplyHandlers = undefined;
|
331 |
|
332 | var errors = results
|
333 | .map(function (r) {
|
334 | return r.error;
|
335 | })
|
336 | .filter(Boolean);
|
337 |
|
338 | if (errors.length > 0) {
|
339 | return setStatus("abort").then(function () {
|
340 | throw errors[0];
|
341 | });
|
342 | }
|
343 |
|
344 |
|
345 | var disposePromise = setStatus("dispose");
|
346 |
|
347 | results.forEach(function (result) {
|
348 | if (result.dispose) result.dispose();
|
349 | });
|
350 |
|
351 |
|
352 | var applyPromise = setStatus("apply");
|
353 |
|
354 | var error;
|
355 | var reportError = function (err) {
|
356 | if (!error) error = err;
|
357 | };
|
358 |
|
359 | var outdatedModules = [];
|
360 | results.forEach(function (result) {
|
361 | if (result.apply) {
|
362 | var modules = result.apply(reportError);
|
363 | if (modules) {
|
364 | for (var i = 0; i < modules.length; i++) {
|
365 | outdatedModules.push(modules[i]);
|
366 | }
|
367 | }
|
368 | }
|
369 | });
|
370 |
|
371 | return Promise.all([disposePromise, applyPromise]).then(function () {
|
372 |
|
373 | if (error) {
|
374 | return setStatus("fail").then(function () {
|
375 | throw error;
|
376 | });
|
377 | }
|
378 |
|
379 | if (queuedInvalidatedModules) {
|
380 | return internalApply(options).then(function (list) {
|
381 | outdatedModules.forEach(function (moduleId) {
|
382 | if (list.indexOf(moduleId) < 0) list.push(moduleId);
|
383 | });
|
384 | return list;
|
385 | });
|
386 | }
|
387 |
|
388 | return setStatus("idle").then(function () {
|
389 | return outdatedModules;
|
390 | });
|
391 | });
|
392 | }
|
393 |
|
394 | function applyInvalidatedModules() {
|
395 | if (queuedInvalidatedModules) {
|
396 | if (!currentUpdateApplyHandlers) currentUpdateApplyHandlers = [];
|
397 | Object.keys($hmrInvalidateModuleHandlers$).forEach(function (key) {
|
398 | queuedInvalidatedModules.forEach(function (moduleId) {
|
399 | $hmrInvalidateModuleHandlers$[key](
|
400 | moduleId,
|
401 | currentUpdateApplyHandlers
|
402 | );
|
403 | });
|
404 | });
|
405 | queuedInvalidatedModules = undefined;
|
406 | return true;
|
407 | }
|
408 | }
|
409 | };
|