1 | 'use strict';
|
2 |
|
3 | Object.defineProperty(exports, '__esModule', { value: true });
|
4 |
|
5 | function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
6 |
|
7 | var React = require('react');
|
8 | var React__default = _interopDefault(React);
|
9 | var shallowEqual = _interopDefault(require('shallowequal'));
|
10 | var levenshtein = _interopDefault(require('fast-levenshtein'));
|
11 | var ReactDOM = _interopDefault(require('react-dom'));
|
12 | var PropTypes = _interopDefault(require('prop-types'));
|
13 | var defaultPolyfill = require('react-lifecycles-compat');
|
14 | var defaultPolyfill__default = _interopDefault(defaultPolyfill);
|
15 | var hoistNonReactStatic = _interopDefault(require('hoist-non-react-statics'));
|
16 |
|
17 | var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
|
18 | return typeof obj;
|
19 | } : function (obj) {
|
20 | return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
21 | };
|
22 |
|
23 | var classCallCheck = function (instance, Constructor) {
|
24 | if (!(instance instanceof Constructor)) {
|
25 | throw new TypeError("Cannot call a class as a function");
|
26 | }
|
27 | };
|
28 |
|
29 | var _extends = Object.assign || function (target) {
|
30 | for (var i = 1; i < arguments.length; i++) {
|
31 | var source = arguments[i];
|
32 |
|
33 | for (var key in source) {
|
34 | if (Object.prototype.hasOwnProperty.call(source, key)) {
|
35 | target[key] = source[key];
|
36 | }
|
37 | }
|
38 | }
|
39 |
|
40 | return target;
|
41 | };
|
42 |
|
43 | var inherits = function (subClass, superClass) {
|
44 | if (typeof superClass !== "function" && superClass !== null) {
|
45 | throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
|
46 | }
|
47 |
|
48 | subClass.prototype = Object.create(superClass && superClass.prototype, {
|
49 | constructor: {
|
50 | value: subClass,
|
51 | enumerable: false,
|
52 | writable: true,
|
53 | configurable: true
|
54 | }
|
55 | });
|
56 | if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
|
57 | };
|
58 |
|
59 | var possibleConstructorReturn = function (self, call) {
|
60 | if (!self) {
|
61 | throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
62 | }
|
63 |
|
64 | return call && (typeof call === "object" || typeof call === "function") ? call : self;
|
65 | };
|
66 |
|
67 |
|
68 |
|
69 | var isCompositeComponent = function isCompositeComponent(type) {
|
70 | return typeof type === 'function';
|
71 | };
|
72 | var isReloadableComponent = function isReloadableComponent(type) {
|
73 | return typeof type === 'function' || (typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object';
|
74 | };
|
75 |
|
76 | var getComponentDisplayName = function getComponentDisplayName(type) {
|
77 | var displayName = type.displayName || type.name;
|
78 | return displayName && displayName !== 'ReactComponent' ? displayName : 'Component';
|
79 | };
|
80 |
|
81 | var reactLifeCycleMountMethods = ['componentWillMount', 'componentDidMount'];
|
82 |
|
83 | function isReactClass(Component) {
|
84 | return !!(Component.prototype && (React__default.Component.prototype.isPrototypeOf(Component.prototype) ||
|
85 |
|
86 | Component.prototype.isReactComponent || Component.prototype.componentWillMount || Component.prototype.componentWillUnmount || Component.prototype.componentDidMount || Component.prototype.componentDidUnmount || Component.prototype.render));
|
87 | }
|
88 |
|
89 | function isReactClassInstance(Component) {
|
90 | return Component && isReactClass({ prototype: Object.getPrototypeOf(Component) });
|
91 | }
|
92 |
|
93 | var getInternalInstance = function getInternalInstance(instance) {
|
94 | return instance._reactInternalFiber ||
|
95 | instance._reactInternalInstance ||
|
96 | null;
|
97 | };
|
98 |
|
99 | var updateInstance = function updateInstance(instance) {
|
100 | var updater = instance.updater,
|
101 | forceUpdate = instance.forceUpdate;
|
102 |
|
103 | if (typeof forceUpdate === 'function') {
|
104 | instance.forceUpdate();
|
105 | } else if (updater && typeof updater.enqueueForceUpdate === 'function') {
|
106 | updater.enqueueForceUpdate(instance);
|
107 | }
|
108 | };
|
109 |
|
110 | var isFragmentNode = function isFragmentNode(_ref) {
|
111 | var type = _ref.type;
|
112 | return React__default.Fragment && type === React__default.Fragment;
|
113 | };
|
114 |
|
115 | var ContextType = React__default.createContext ? React__default.createContext() : null;
|
116 | var ConsumerType = ContextType && ContextType.Consumer.$$typeof;
|
117 | var ProviderType = ContextType && ContextType.Provider.$$typeof;
|
118 | var MemoType = React__default.memo && React__default.memo(function () {
|
119 | return null;
|
120 | }).$$typeof;
|
121 | var LazyType = React__default.lazy && React__default.lazy(function () {
|
122 | return null;
|
123 | }).$$typeof;
|
124 | var ForwardType = React__default.forwardRef && React__default.forwardRef(function () {
|
125 | return null;
|
126 | }).$$typeof;
|
127 |
|
128 | var CONTEXT_CURRENT_VALUE = '_currentValue';
|
129 |
|
130 | var isContextConsumer = function isContextConsumer(_ref2) {
|
131 | var type = _ref2.type;
|
132 | return type && (typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object' && '$$typeof' in type && type.$$typeof === ConsumerType && ConsumerType;
|
133 | };
|
134 | var isContextProvider = function isContextProvider(_ref3) {
|
135 | var type = _ref3.type;
|
136 | return type && (typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object' && '$$typeof' in type && type.$$typeof === ProviderType && ProviderType;
|
137 | };
|
138 | var isMemoType = function isMemoType(_ref4) {
|
139 | var type = _ref4.type;
|
140 | return type && (typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object' && '$$typeof' in type && type.$$typeof === MemoType && MemoType;
|
141 | };
|
142 | var isLazyType = function isLazyType(_ref5) {
|
143 | var type = _ref5.type;
|
144 | return type && (typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object' && '$$typeof' in type && type.$$typeof === LazyType && LazyType;
|
145 | };
|
146 | var isForwardType = function isForwardType(_ref6) {
|
147 | var type = _ref6.type;
|
148 | return type && (typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object' && '$$typeof' in type && type.$$typeof === ForwardType && ForwardType;
|
149 | };
|
150 | var isContextType = function isContextType(type) {
|
151 | return isContextConsumer(type) || isContextProvider(type);
|
152 | };
|
153 |
|
154 | var getElementType = function getElementType(type) {
|
155 | var element = { type: type };
|
156 |
|
157 | if (isContextConsumer(element)) {
|
158 | return 'Consumer';
|
159 | }
|
160 | if (isContextProvider(element)) {
|
161 | return 'Provider';
|
162 | }
|
163 | if (isLazyType(element)) {
|
164 | return 'Lazy';
|
165 | }
|
166 | if (isMemoType(element)) {
|
167 | return 'Memo';
|
168 | }
|
169 | if (isForwardType(element)) {
|
170 | return 'Forward';
|
171 | }
|
172 |
|
173 | if (isReactClass(type)) {
|
174 | return 'Class';
|
175 | }
|
176 |
|
177 | if (typeof element === 'function') {
|
178 | return 'FC';
|
179 | }
|
180 |
|
181 | return 'unknown';
|
182 | };
|
183 |
|
184 | var getContextProvider = function getContextProvider(type) {
|
185 | return type && type._context;
|
186 | };
|
187 |
|
188 | var configuration = {
|
189 |
|
190 | logLevel: 'error',
|
191 |
|
192 |
|
193 | pureSFC: true,
|
194 |
|
195 |
|
196 | pureRender: true,
|
197 |
|
198 |
|
199 | allowSFC: true,
|
200 |
|
201 |
|
202 | reloadHooks: true,
|
203 |
|
204 |
|
205 | reloadLifeCycleHooks: false,
|
206 |
|
207 |
|
208 | reloadHooksOnBodyChange: true,
|
209 |
|
210 |
|
211 | disableHotRenderer: false,
|
212 |
|
213 |
|
214 | integratedComparator: false,
|
215 |
|
216 | integratedResolver: false,
|
217 |
|
218 |
|
219 | disableHotRendererWhenInjected: true,
|
220 |
|
221 |
|
222 | showReactDomPatchNotification: true,
|
223 |
|
224 |
|
225 | onComponentRegister: false,
|
226 |
|
227 |
|
228 | onComponentCreate: false,
|
229 |
|
230 |
|
231 | ignoreSFC: false,
|
232 |
|
233 |
|
234 | ignoreSFCWhenInjected: true,
|
235 |
|
236 |
|
237 | ignoreComponents: false,
|
238 |
|
239 |
|
240 | errorReporter: undefined,
|
241 |
|
242 |
|
243 | ErrorOverlay: undefined,
|
244 |
|
245 |
|
246 | trackTailUpdates: true,
|
247 |
|
248 |
|
249 | IS_REACT_MERGE_ENABLED: false
|
250 | };
|
251 |
|
252 | var internalConfiguration = {
|
253 |
|
254 | disableProxyCreation: false
|
255 | };
|
256 |
|
257 | var setConfiguration = function setConfiguration(config) {
|
258 |
|
259 | for (var i in config) {
|
260 | if (config.hasOwnProperty(i)) {
|
261 | configuration[i] = config[i];
|
262 | }
|
263 | }
|
264 | };
|
265 |
|
266 |
|
267 |
|
268 | var logger = {
|
269 | debug: function debug() {
|
270 | if (['debug'].indexOf(configuration.logLevel) !== -1) {
|
271 | var _console;
|
272 |
|
273 | (_console = console).debug.apply(_console, arguments);
|
274 | }
|
275 | },
|
276 | log: function log() {
|
277 | if (['debug', 'log'].indexOf(configuration.logLevel) !== -1) {
|
278 | var _console2;
|
279 |
|
280 | (_console2 = console).log.apply(_console2, arguments);
|
281 | }
|
282 | },
|
283 | warn: function warn() {
|
284 | if (['debug', 'log', 'warn'].indexOf(configuration.logLevel) !== -1) {
|
285 | var _console3;
|
286 |
|
287 | (_console3 = console).warn.apply(_console3, arguments);
|
288 | }
|
289 | },
|
290 | error: function error() {
|
291 | if (['debug', 'log', 'warn', 'error'].indexOf(configuration.logLevel) !== -1) {
|
292 | var _console4;
|
293 |
|
294 | (_console4 = console).error.apply(_console4, arguments);
|
295 | }
|
296 | }
|
297 | };
|
298 |
|
299 |
|
300 |
|
301 | function safeReactConstructor(Component, lastInstance) {
|
302 | try {
|
303 | if (lastInstance) {
|
304 | return new Component(lastInstance.props, lastInstance.context);
|
305 | }
|
306 | return new Component({}, {});
|
307 | } catch (e) {
|
308 |
|
309 | }
|
310 | return null;
|
311 | }
|
312 |
|
313 | function isNativeFunction(fn) {
|
314 | return typeof fn === 'function' ? fn.toString().indexOf('[native code]') > 0 : false;
|
315 | }
|
316 |
|
317 | var identity = function identity(a) {
|
318 | return a;
|
319 | };
|
320 | var indirectEval = eval;
|
321 |
|
322 | var doesSupportClasses = function () {
|
323 | try {
|
324 | indirectEval('class Test {}');
|
325 | return true;
|
326 | } catch (e) {
|
327 | return false;
|
328 | }
|
329 | }();
|
330 |
|
331 | var ES6ProxyComponentFactory = function ES6ProxyComponentFactory(InitialParent, postConstructionAction) {
|
332 | return indirectEval('\n(function(InitialParent, postConstructionAction) {\n return class ' + (InitialParent.name || 'HotComponent') + ' extends InitialParent {\n /*\n ! THIS IS NOT YOUR COMPONENT !\n ! THIS IS REACT-HOT-LOADER !\n \n this is a "' + InitialParent.name + '" component, patched by React-Hot-Loader\n Sorry, but the real class code was hidden behind this facade\n Please refer to https://github.com/gaearon/react-hot-loader for details...\n */ \n \n constructor(props, context) {\n super(props, context)\n postConstructionAction.call(this)\n }\n }\n})\n')(InitialParent, postConstructionAction);
|
333 | };
|
334 |
|
335 | var ES5ProxyComponentFactory = function ES5ProxyComponentFactory(InitialParent, postConstructionAction) {
|
336 | function ProxyComponent(props, context) {
|
337 | InitialParent.call(this, props, context);
|
338 | postConstructionAction.call(this);
|
339 | }
|
340 | ProxyComponent.prototype = Object.create(InitialParent.prototype);
|
341 | Object.setPrototypeOf(ProxyComponent, InitialParent);
|
342 | return ProxyComponent;
|
343 | };
|
344 |
|
345 | var proxyClassCreator = doesSupportClasses ? ES6ProxyComponentFactory : ES5ProxyComponentFactory;
|
346 |
|
347 | function getOwnKeys(target) {
|
348 | return [].concat(Object.getOwnPropertyNames(target), Object.getOwnPropertySymbols(target));
|
349 | }
|
350 |
|
351 | function shallowStringsEqual(a, b) {
|
352 | for (var key in a) {
|
353 | if (String(a[key]) !== String(b[key])) {
|
354 | return false;
|
355 | }
|
356 | }
|
357 | return true;
|
358 | }
|
359 |
|
360 | function deepPrototypeUpdate(dest, source) {
|
361 | var deepDest = Object.getPrototypeOf(dest);
|
362 | var deepSrc = Object.getPrototypeOf(source);
|
363 | if (deepDest && deepSrc && deepSrc !== deepDest) {
|
364 | deepPrototypeUpdate(deepDest, deepSrc);
|
365 | }
|
366 | if (source.prototype && source.prototype !== dest.prototype) {
|
367 | dest.prototype = source.prototype;
|
368 | }
|
369 | }
|
370 |
|
371 | function safeDefineProperty(target, key, props) {
|
372 | try {
|
373 | Object.defineProperty(target, key, props);
|
374 | } catch (e) {
|
375 | logger.warn('Error while wrapping', key, ' -> ', e);
|
376 | }
|
377 | }
|
378 |
|
379 | var PREFIX = '__reactstandin__';
|
380 | var PROXY_KEY = PREFIX + 'key';
|
381 | var GENERATION = PREFIX + 'proxyGeneration';
|
382 | var REGENERATE_METHOD = PREFIX + 'regenerateByEval';
|
383 | var UNWRAP_PROXY = PREFIX + 'getCurrent';
|
384 | var CACHED_RESULT = PREFIX + 'cachedResult';
|
385 | var PROXY_IS_MOUNTED = PREFIX + 'isMounted';
|
386 |
|
387 | var RENDERED_GENERATION = 'REACT_HOT_LOADER_RENDERED_GENERATION';
|
388 |
|
389 | var RESERVED_STATICS = ['length', 'displayName', 'name', 'arguments', 'caller', 'prototype', 'toString', 'valueOf', 'isStatelessFunctionalProxy', PROXY_KEY, UNWRAP_PROXY];
|
390 |
|
391 | function transferStaticProps(ProxyComponent, savedDescriptors, PreviousComponent, NextComponent) {
|
392 | Object.getOwnPropertyNames(ProxyComponent).forEach(function (key) {
|
393 | if (RESERVED_STATICS.indexOf(key) !== -1) {
|
394 | return;
|
395 | }
|
396 |
|
397 | var prevDescriptor = Object.getOwnPropertyDescriptor(ProxyComponent, key);
|
398 | var savedDescriptor = savedDescriptors[key];
|
399 |
|
400 | if (!shallowEqual(prevDescriptor, savedDescriptor)) {
|
401 | safeDefineProperty(NextComponent, key, prevDescriptor);
|
402 | }
|
403 | });
|
404 |
|
405 |
|
406 | Object.getOwnPropertyNames(NextComponent).forEach(function (key) {
|
407 | if (RESERVED_STATICS.indexOf(key) !== -1) {
|
408 | return;
|
409 | }
|
410 |
|
411 | var prevDescriptor = PreviousComponent && Object.getOwnPropertyDescriptor(ProxyComponent, key);
|
412 | var savedDescriptor = savedDescriptors[key];
|
413 |
|
414 |
|
415 | if (prevDescriptor && savedDescriptor && !shallowEqual(savedDescriptor, prevDescriptor)) {
|
416 | safeDefineProperty(NextComponent, key, prevDescriptor);
|
417 | return;
|
418 | }
|
419 |
|
420 | if (prevDescriptor && !savedDescriptor) {
|
421 | safeDefineProperty(ProxyComponent, key, prevDescriptor);
|
422 | return;
|
423 | }
|
424 |
|
425 | var nextDescriptor = _extends({}, Object.getOwnPropertyDescriptor(NextComponent, key), {
|
426 | configurable: true
|
427 | });
|
428 |
|
429 | savedDescriptors[key] = nextDescriptor;
|
430 | safeDefineProperty(ProxyComponent, key, nextDescriptor);
|
431 | });
|
432 |
|
433 |
|
434 | Object.getOwnPropertyNames(ProxyComponent).forEach(function (key) {
|
435 | if (RESERVED_STATICS.indexOf(key) !== -1) {
|
436 | return;
|
437 | }
|
438 |
|
439 | if (NextComponent.hasOwnProperty(key)) {
|
440 | return;
|
441 | }
|
442 |
|
443 | var proxyDescriptor = Object.getOwnPropertyDescriptor(ProxyComponent, key);
|
444 | if (proxyDescriptor && !proxyDescriptor.configurable) {
|
445 | return;
|
446 | }
|
447 |
|
448 | var prevDescriptor = PreviousComponent && Object.getOwnPropertyDescriptor(PreviousComponent, key);
|
449 | var savedDescriptor = savedDescriptors[key];
|
450 |
|
451 |
|
452 | if (prevDescriptor && savedDescriptor && !shallowEqual(savedDescriptor, prevDescriptor)) {
|
453 | return;
|
454 | }
|
455 |
|
456 | safeDefineProperty(ProxyComponent, key, {
|
457 | value: undefined
|
458 | });
|
459 | });
|
460 |
|
461 | return savedDescriptors;
|
462 | }
|
463 |
|
464 | function mergeComponents(ProxyComponent, NextComponent, InitialComponent, lastInstance, injectedMembers) {
|
465 | var injectedCode = {};
|
466 | try {
|
467 | var nextInstance = safeReactConstructor(NextComponent, lastInstance);
|
468 |
|
469 | try {
|
470 |
|
471 | deepPrototypeUpdate(InitialComponent, NextComponent);
|
472 | } catch (e) {
|
473 |
|
474 | }
|
475 |
|
476 | var proxyInstance = safeReactConstructor(ProxyComponent, lastInstance);
|
477 |
|
478 | if (!nextInstance || !proxyInstance) {
|
479 | return injectedCode;
|
480 | }
|
481 |
|
482 | var mergedAttrs = _extends({}, proxyInstance, nextInstance);
|
483 | var hasRegenerate = proxyInstance[REGENERATE_METHOD];
|
484 | var ownKeys = getOwnKeys(Object.getPrototypeOf(ProxyComponent.prototype));
|
485 | Object.keys(mergedAttrs).forEach(function (key) {
|
486 | if (key.indexOf(PREFIX) === 0) return;
|
487 | var nextAttr = nextInstance[key];
|
488 | var prevAttr = proxyInstance[key];
|
489 | if (nextAttr) {
|
490 | if (isNativeFunction(nextAttr) || isNativeFunction(prevAttr)) {
|
491 |
|
492 | var isSameArity = nextAttr.length === prevAttr.length;
|
493 | var existsInPrototype = ownKeys.indexOf(key) >= 0 || ProxyComponent.prototype[key];
|
494 | if ((isSameArity || !prevAttr) && existsInPrototype) {
|
495 | if (hasRegenerate) {
|
496 | injectedCode[key] = 'Object.getPrototypeOf(this)[\'' + key + '\'].bind(this)';
|
497 | } else {
|
498 | logger.warn('React Hot Loader:,', 'Non-controlled class', ProxyComponent.name, 'contains a new native or bound function ', key, nextAttr, '. Unable to reproduce');
|
499 | }
|
500 | } else {
|
501 | logger.warn('React Hot Loader:', 'Updated class ', ProxyComponent.name, 'contains native or bound function ', key, nextAttr, '. Unable to reproduce, use arrow functions instead.', '(arity: ' + nextAttr.length + '/' + prevAttr.length + ', proto: ' + (existsInPrototype ? 'yes' : 'no'));
|
502 | }
|
503 | return;
|
504 | }
|
505 |
|
506 | var nextString = String(nextAttr);
|
507 | var injectedBefore = injectedMembers[key];
|
508 | var isArrow = nextString.indexOf('=>') >= 0;
|
509 | var isFunction = nextString.indexOf('function') >= 0 || isArrow;
|
510 | var referToThis = nextString.indexOf('this') >= 0;
|
511 | if (nextString !== String(prevAttr) || injectedBefore && nextString !== String(injectedBefore) || isArrow && referToThis) {
|
512 | if (!hasRegenerate) {
|
513 | if (!isFunction) {
|
514 |
|
515 | injectedCode[key] = nextAttr;
|
516 | } else {
|
517 | logger.warn('React Hot Loader:', ' Updated class ', ProxyComponent.name, 'had different code for', key, nextAttr, '. Unable to reproduce. Regeneration support needed.');
|
518 | }
|
519 | } else {
|
520 | injectedCode[key] = nextAttr;
|
521 | }
|
522 | }
|
523 | }
|
524 | });
|
525 | } catch (e) {
|
526 | logger.warn('React Hot Loader:', e);
|
527 | }
|
528 | return injectedCode;
|
529 | }
|
530 |
|
531 | function checkLifeCycleMethods(ProxyComponent, NextComponent) {
|
532 | try {
|
533 | var p1 = Object.getPrototypeOf(ProxyComponent.prototype);
|
534 | var p2 = NextComponent.prototype;
|
535 | reactLifeCycleMountMethods.forEach(function (key) {
|
536 | var d1 = Object.getOwnPropertyDescriptor(p1, key) || { value: p1[key] };
|
537 | var d2 = Object.getOwnPropertyDescriptor(p2, key) || { value: p2[key] };
|
538 | if (!shallowStringsEqual(d1, d2)) {
|
539 | logger.warn('React Hot Loader:', 'You did update', ProxyComponent.name, 's lifecycle method', key, '. Unable to repeat');
|
540 | }
|
541 | });
|
542 | } catch (e) {
|
543 |
|
544 | }
|
545 | }
|
546 |
|
547 | function inject(target, currentGeneration, injectedMembers) {
|
548 | if (target[GENERATION] !== currentGeneration) {
|
549 | var hasRegenerate = !!target[REGENERATE_METHOD];
|
550 | Object.keys(injectedMembers).forEach(function (key) {
|
551 | try {
|
552 | if (hasRegenerate) {
|
553 | var usedThis = String(injectedMembers[key]).match(/_this([\d]+)/gi) || [];
|
554 | target[REGENERATE_METHOD](key, '(function REACT_HOT_LOADER_SANDBOX () {\n var _this = this; // common babel transpile\n ' + usedThis.map(function (name) {
|
555 | return 'var ' + name + ' = this;';
|
556 | }) + '\n\n return ' + injectedMembers[key] + ';\n }).call(this)');
|
557 | } else {
|
558 | target[key] = injectedMembers[key];
|
559 | }
|
560 | } catch (e) {
|
561 | logger.warn('React Hot Loader: Failed to regenerate method ', key, ' of class ', target);
|
562 | logger.warn('got error', e);
|
563 | }
|
564 | });
|
565 |
|
566 | target[GENERATION] = currentGeneration;
|
567 | }
|
568 | }
|
569 |
|
570 | var has = Object.prototype.hasOwnProperty;
|
571 |
|
572 | var proxies = new WeakMap();
|
573 |
|
574 | var resetClassProxies = function resetClassProxies() {
|
575 | proxies = new WeakMap();
|
576 | };
|
577 |
|
578 | var blackListedClassMembers = ['constructor', 'render', 'componentWillMount', 'componentDidMount', 'componentDidCatch', 'componentWillReceiveProps', 'componentWillUnmount', 'hotComponentRender', 'getInitialState', 'getDefaultProps'];
|
579 |
|
580 | var defaultRenderOptions = {
|
581 | componentWillRender: identity,
|
582 | componentDidUpdate: function componentDidUpdate(result) {
|
583 | return result;
|
584 | },
|
585 | componentDidRender: function componentDidRender(result) {
|
586 | return result;
|
587 | }
|
588 | };
|
589 |
|
590 | var filteredPrototypeMethods = function filteredPrototypeMethods(Proto) {
|
591 | return Object.getOwnPropertyNames(Proto).filter(function (prop) {
|
592 | var descriptor = Object.getOwnPropertyDescriptor(Proto, prop);
|
593 | return descriptor && prop.indexOf(PREFIX) !== 0 && blackListedClassMembers.indexOf(prop) < 0 && typeof descriptor.value === 'function';
|
594 | });
|
595 | };
|
596 |
|
597 | var defineClassMember = function defineClassMember(Class, methodName, methodBody) {
|
598 | return safeDefineProperty(Class.prototype, methodName, {
|
599 | configurable: true,
|
600 | writable: true,
|
601 | enumerable: false,
|
602 | value: methodBody
|
603 | });
|
604 | };
|
605 |
|
606 | var defineClassMembers = function defineClassMembers(Class, methods) {
|
607 | return Object.keys(methods).forEach(function (methodName) {
|
608 | return defineClassMember(Class, methodName, methods[methodName]);
|
609 | });
|
610 | };
|
611 |
|
612 | var setSFPFlag = function setSFPFlag(component, flag) {
|
613 | return safeDefineProperty(component, 'isStatelessFunctionalProxy', {
|
614 | configurable: false,
|
615 | writable: false,
|
616 | enumerable: false,
|
617 | value: flag
|
618 | });
|
619 | };
|
620 |
|
621 | var copyMethodDescriptors = function copyMethodDescriptors(target, source) {
|
622 | if (source) {
|
623 |
|
624 | var keys = Object.getOwnPropertyNames(source);
|
625 |
|
626 | keys.forEach(function (key) {
|
627 | return safeDefineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
|
628 | });
|
629 |
|
630 | safeDefineProperty(target, 'toString', {
|
631 | configurable: true,
|
632 | writable: false,
|
633 | enumerable: false,
|
634 | value: function toString() {
|
635 | return String(source);
|
636 | }
|
637 | });
|
638 | }
|
639 |
|
640 | return target;
|
641 | };
|
642 |
|
643 | var knownClassComponents = [];
|
644 |
|
645 | var forEachKnownClass = function forEachKnownClass(cb) {
|
646 | return knownClassComponents.forEach(cb);
|
647 | };
|
648 |
|
649 | function createClassProxy(InitialComponent, proxyKey) {
|
650 | var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
651 |
|
652 | var renderOptions = _extends({}, defaultRenderOptions, options);
|
653 | var proxyConfig = _extends({}, configuration, options.proxy);
|
654 |
|
655 |
|
656 | var existingProxy = proxies.get(InitialComponent);
|
657 |
|
658 | if (existingProxy) {
|
659 | return existingProxy;
|
660 | }
|
661 |
|
662 | var CurrentComponent = void 0;
|
663 | var savedDescriptors = {};
|
664 | var injectedMembers = {};
|
665 | var proxyGeneration = 0;
|
666 | var classUpdatePostponed = null;
|
667 | var instancesCount = 0;
|
668 | var isFunctionalComponent = !isReactClass(InitialComponent);
|
669 |
|
670 | var lastInstance = null;
|
671 |
|
672 | function postConstructionAction() {
|
673 | this[GENERATION] = 0;
|
674 |
|
675 | lastInstance = this;
|
676 |
|
677 | if (classUpdatePostponed) {
|
678 | var callUpdate = classUpdatePostponed;
|
679 | classUpdatePostponed = null;
|
680 | callUpdate();
|
681 | }
|
682 |
|
683 |
|
684 | inject(this, proxyGeneration, injectedMembers);
|
685 | }
|
686 |
|
687 | function proxiedUpdate() {
|
688 | if (this) {
|
689 | inject(this, proxyGeneration, injectedMembers);
|
690 | }
|
691 | }
|
692 |
|
693 | function lifeCycleWrapperFactory(wrapperName) {
|
694 | var sideEffect = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
|
695 |
|
696 | return copyMethodDescriptors(function wrappedMethod() {
|
697 | proxiedUpdate.call(this);
|
698 | sideEffect(this);
|
699 |
|
700 | for (var _len = arguments.length, rest = Array(_len), _key = 0; _key < _len; _key++) {
|
701 | rest[_key] = arguments[_key];
|
702 | }
|
703 |
|
704 | return !isFunctionalComponent && CurrentComponent.prototype[wrapperName] && CurrentComponent.prototype[wrapperName].apply(this, rest);
|
705 | }, InitialComponent.prototype && InitialComponent.prototype[wrapperName]);
|
706 | }
|
707 |
|
708 | function methodWrapperFactory(wrapperName, realMethod) {
|
709 | return copyMethodDescriptors(function wrappedMethod() {
|
710 | for (var _len2 = arguments.length, rest = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
711 | rest[_key2] = arguments[_key2];
|
712 | }
|
713 |
|
714 | return realMethod.apply(this, rest);
|
715 | }, realMethod);
|
716 | }
|
717 |
|
718 | var fakeBasePrototype = function fakeBasePrototype(Proto) {
|
719 | return filteredPrototypeMethods(Proto).reduce(function (acc, key) {
|
720 | acc[key] = methodWrapperFactory(key, Proto[key]);
|
721 | return acc;
|
722 | }, {});
|
723 | };
|
724 |
|
725 | var componentDidMount = lifeCycleWrapperFactory('componentDidMount', function (target) {
|
726 | target[PROXY_IS_MOUNTED] = true;
|
727 | target[RENDERED_GENERATION] = get$1();
|
728 | instancesCount++;
|
729 | });
|
730 | var componentDidUpdate = lifeCycleWrapperFactory('componentDidUpdate', renderOptions.componentDidUpdate);
|
731 | var componentWillUnmount = lifeCycleWrapperFactory('componentWillUnmount', function (target) {
|
732 | target[PROXY_IS_MOUNTED] = false;
|
733 | instancesCount--;
|
734 | });
|
735 |
|
736 | function hotComponentRender() {
|
737 |
|
738 | renderOptions.componentWillRender(this);
|
739 | proxiedUpdate.call(this);
|
740 | var result = void 0;
|
741 |
|
742 |
|
743 |
|
744 | if (has.call(this, CACHED_RESULT)) {
|
745 | result = this[CACHED_RESULT];
|
746 | delete this[CACHED_RESULT];
|
747 | } else if (isFunctionalComponent) {
|
748 | result = CurrentComponent(this.props, this.context);
|
749 | } else {
|
750 | var renderMethod = CurrentComponent.prototype.render || this.render;
|
751 |
|
752 | if (renderMethod === proxiedRender) {
|
753 | throw new Error('React-Hot-Loader: you are trying to render Component without .render method');
|
754 | }
|
755 |
|
756 | result = renderMethod.apply(this,
|
757 |
|
758 | arguments);
|
759 | }
|
760 |
|
761 | return renderOptions.componentDidRender.call(this, result);
|
762 | }
|
763 |
|
764 | function hotComponentUpdate() {
|
765 | renderOptions.componentWillRender(this);
|
766 | proxiedUpdate.call(this);
|
767 | }
|
768 |
|
769 | function proxiedRender() {
|
770 | renderOptions.componentWillRender(this);
|
771 |
|
772 | for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
|
773 | args[_key3] = arguments[_key3];
|
774 | }
|
775 |
|
776 | return hotComponentRender.call.apply(hotComponentRender, [this].concat(args));
|
777 | }
|
778 |
|
779 | var defineProxyMethods = function defineProxyMethods(Proxy) {
|
780 | var Base = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
781 |
|
782 | defineClassMembers(Proxy, _extends({}, fakeBasePrototype(Base), proxyConfig.pureRender ? {} : { render: proxiedRender }, {
|
783 | hotComponentRender: hotComponentRender,
|
784 | hotComponentUpdate: hotComponentUpdate,
|
785 | componentDidMount: componentDidMount,
|
786 | componentDidUpdate: componentDidUpdate,
|
787 | componentWillUnmount: componentWillUnmount
|
788 | }));
|
789 | };
|
790 |
|
791 | var _ProxyFacade = void 0;
|
792 | var ProxyComponent = null;
|
793 | var proxy = void 0;
|
794 |
|
795 | if (!isFunctionalComponent) {
|
796 |
|
797 | ProxyComponent = proxyClassCreator(InitialComponent, postConstructionAction);
|
798 |
|
799 | defineProxyMethods(ProxyComponent, InitialComponent.prototype);
|
800 |
|
801 | knownClassComponents.push(ProxyComponent);
|
802 |
|
803 | _ProxyFacade = ProxyComponent;
|
804 | } else if (!proxyConfig.allowSFC) {
|
805 | proxyConfig.pureRender = false;
|
806 |
|
807 | ProxyComponent = proxyClassCreator(React.Component, postConstructionAction);
|
808 |
|
809 | defineProxyMethods(ProxyComponent);
|
810 | _ProxyFacade = ProxyComponent;
|
811 | } else {
|
812 |
|
813 |
|
814 |
|
815 |
|
816 |
|
817 |
|
818 | _ProxyFacade = function ProxyFacade(props, context) {
|
819 | |
820 |
|
821 |
|
822 |
|
823 |
|
824 |
|
825 |
|
826 |
|
827 | var result = CurrentComponent(props, context);
|
828 |
|
829 |
|
830 |
|
831 |
|
832 | if (isReactClassInstance(result)) {
|
833 | ProxyComponent = null;
|
834 |
|
835 |
|
836 |
|
837 | transferStaticProps(_ProxyFacade, savedDescriptors, null, CurrentComponent);
|
838 |
|
839 | return result;
|
840 | }
|
841 |
|
842 |
|
843 | if (proxyConfig.pureSFC) {
|
844 | if (!CurrentComponent.contextTypes) {
|
845 | if (!_ProxyFacade.isStatelessFunctionalProxy) {
|
846 | setSFPFlag(_ProxyFacade, true);
|
847 | }
|
848 |
|
849 | return renderOptions.componentDidRender(result);
|
850 | }
|
851 | }
|
852 | setSFPFlag(_ProxyFacade, false);
|
853 | proxyConfig.pureRender = false;
|
854 |
|
855 |
|
856 |
|
857 | ProxyComponent = proxyClassCreator(React.Component, postConstructionAction);
|
858 |
|
859 | defineProxyMethods(ProxyComponent);
|
860 |
|
861 | var determinateResult = new ProxyComponent(props, context);
|
862 |
|
863 |
|
864 |
|
865 | determinateResult[CACHED_RESULT] = result;
|
866 | return determinateResult;
|
867 | };
|
868 | }
|
869 |
|
870 | function get$$1() {
|
871 | return _ProxyFacade;
|
872 | }
|
873 |
|
874 | function getCurrent() {
|
875 | return CurrentComponent;
|
876 | }
|
877 |
|
878 | safeDefineProperty(_ProxyFacade, UNWRAP_PROXY, {
|
879 | configurable: false,
|
880 | writable: false,
|
881 | enumerable: false,
|
882 | value: getCurrent
|
883 | });
|
884 |
|
885 | safeDefineProperty(_ProxyFacade, PROXY_KEY, {
|
886 | configurable: false,
|
887 | writable: false,
|
888 | enumerable: false,
|
889 | value: proxyKey
|
890 | });
|
891 |
|
892 | safeDefineProperty(_ProxyFacade, 'toString', {
|
893 | configurable: true,
|
894 | writable: false,
|
895 | enumerable: false,
|
896 | value: function toString() {
|
897 | return String(CurrentComponent);
|
898 | }
|
899 | });
|
900 |
|
901 | function update(NextComponent) {
|
902 | if (typeof NextComponent !== 'function') {
|
903 | throw new Error('Expected a constructor.');
|
904 | }
|
905 |
|
906 | if (NextComponent === CurrentComponent) {
|
907 | return false;
|
908 | }
|
909 |
|
910 |
|
911 | var existingProxy = proxies.get(NextComponent);
|
912 | if (existingProxy) {
|
913 | return false;
|
914 | }
|
915 |
|
916 | isFunctionalComponent = !isReactClass(NextComponent);
|
917 |
|
918 | proxies.set(NextComponent, proxy);
|
919 |
|
920 | proxyGeneration++;
|
921 |
|
922 |
|
923 | var PreviousComponent = CurrentComponent;
|
924 | CurrentComponent = NextComponent;
|
925 |
|
926 |
|
927 | var displayName = getComponentDisplayName(CurrentComponent);
|
928 |
|
929 | safeDefineProperty(_ProxyFacade, 'displayName', {
|
930 | configurable: true,
|
931 | writable: false,
|
932 | enumerable: true,
|
933 | value: displayName
|
934 | });
|
935 |
|
936 | if (ProxyComponent) {
|
937 | safeDefineProperty(ProxyComponent, 'name', {
|
938 | value: displayName
|
939 | });
|
940 | }
|
941 |
|
942 | savedDescriptors = transferStaticProps(_ProxyFacade, savedDescriptors, PreviousComponent, NextComponent);
|
943 |
|
944 | if (isFunctionalComponent || !ProxyComponent) ; else {
|
945 | var classHotReplacement = function classHotReplacement() {
|
946 | checkLifeCycleMethods(ProxyComponent, NextComponent);
|
947 | if (proxyGeneration > 1) {
|
948 | getElementCloseHook(ProxyComponent);
|
949 | filteredPrototypeMethods(ProxyComponent.prototype).forEach(function (methodName) {
|
950 | if (!has.call(NextComponent.prototype, methodName)) {
|
951 | delete ProxyComponent.prototype[methodName];
|
952 | }
|
953 | });
|
954 | }
|
955 | Object.setPrototypeOf(ProxyComponent.prototype, NextComponent.prototype);
|
956 | defineProxyMethods(ProxyComponent, NextComponent.prototype);
|
957 | if (proxyGeneration > 1) {
|
958 | injectedMembers = mergeComponents(ProxyComponent, NextComponent, InitialComponent, lastInstance, injectedMembers);
|
959 | getElementComparisonHook(ProxyComponent);
|
960 | }
|
961 | };
|
962 |
|
963 |
|
964 | if (instancesCount > 0) {
|
965 | classHotReplacement();
|
966 | } else {
|
967 | classUpdatePostponed = classHotReplacement;
|
968 | }
|
969 | }
|
970 |
|
971 | return true;
|
972 | }
|
973 |
|
974 | update(InitialComponent);
|
975 |
|
976 | var dereference = function dereference() {
|
977 | proxies.delete(InitialComponent);
|
978 | proxies.delete(_ProxyFacade);
|
979 | proxies.delete(CurrentComponent);
|
980 | };
|
981 |
|
982 | proxy = { get: get$$1, update: update, dereference: dereference, getCurrent: function getCurrent() {
|
983 | return CurrentComponent;
|
984 | } };
|
985 |
|
986 | proxies.set(InitialComponent, proxy);
|
987 | proxies.set(_ProxyFacade, proxy);
|
988 |
|
989 | safeDefineProperty(proxy, UNWRAP_PROXY, {
|
990 | configurable: false,
|
991 | writable: false,
|
992 | enumerable: false,
|
993 | value: getCurrent
|
994 | });
|
995 |
|
996 | return proxy;
|
997 | }
|
998 |
|
999 |
|
1000 |
|
1001 | var generation = 1;
|
1002 |
|
1003 |
|
1004 | var hotComparisonCounter = 0;
|
1005 | var hotComparisonRuns = 0;
|
1006 | var hotReplacementGeneration = 0;
|
1007 |
|
1008 | var nullFunction = function nullFunction() {
|
1009 | return {};
|
1010 | };
|
1011 |
|
1012 |
|
1013 | var onHotComparisonOpen = nullFunction;
|
1014 | var onHotComparisonElement = nullFunction;
|
1015 | var onHotComparisonClose = nullFunction;
|
1016 |
|
1017 |
|
1018 | var setComparisonHooks = function setComparisonHooks(open, element, close) {
|
1019 | onHotComparisonOpen = open;
|
1020 | onHotComparisonElement = element;
|
1021 | onHotComparisonClose = close;
|
1022 | };
|
1023 |
|
1024 | var getElementComparisonHook = function getElementComparisonHook(component) {
|
1025 | return onHotComparisonElement(component);
|
1026 | };
|
1027 | var getElementCloseHook = function getElementCloseHook(component) {
|
1028 | return onHotComparisonClose(component);
|
1029 | };
|
1030 |
|
1031 | var hotComparisonOpen = function hotComparisonOpen() {
|
1032 | return hotComparisonCounter > 0 && hotComparisonRuns > 0 && hotReplacementGeneration > 0;
|
1033 | };
|
1034 |
|
1035 | var openGeneration = function openGeneration() {
|
1036 | return forEachKnownClass(onHotComparisonElement);
|
1037 | };
|
1038 |
|
1039 | var closeGeneration = function closeGeneration() {
|
1040 | return forEachKnownClass(onHotComparisonClose);
|
1041 | };
|
1042 |
|
1043 | var incrementHot = function incrementHot() {
|
1044 | if (!hotComparisonCounter) {
|
1045 | openGeneration();
|
1046 | onHotComparisonOpen();
|
1047 | }
|
1048 | hotComparisonCounter++;
|
1049 | };
|
1050 | var decrementHot = function decrementHot() {
|
1051 | hotComparisonCounter--;
|
1052 | if (!hotComparisonCounter) {
|
1053 | closeGeneration();
|
1054 | hotComparisonRuns++;
|
1055 | }
|
1056 | };
|
1057 |
|
1058 |
|
1059 | var enterHotUpdate = function enterHotUpdate() {
|
1060 | Promise.resolve(incrementHot()).then(function () {
|
1061 | return setTimeout(decrementHot, 0);
|
1062 | });
|
1063 | };
|
1064 |
|
1065 |
|
1066 | var increment = function increment() {
|
1067 | enterHotUpdate();
|
1068 | return generation++;
|
1069 | };
|
1070 | var get$1 = function get() {
|
1071 | return generation;
|
1072 | };
|
1073 |
|
1074 |
|
1075 | var incrementHotGeneration = function incrementHotGeneration() {
|
1076 | return hotReplacementGeneration++;
|
1077 | };
|
1078 | var getHotGeneration = function getHotGeneration() {
|
1079 | return hotReplacementGeneration;
|
1080 | };
|
1081 |
|
1082 |
|
1083 | var UNDEFINED_NAMES = {
|
1084 | Unknown: true,
|
1085 | Component: true
|
1086 | };
|
1087 |
|
1088 | var areNamesEqual = function areNamesEqual(a, b) {
|
1089 | return a === b || UNDEFINED_NAMES[a] && UNDEFINED_NAMES[b];
|
1090 | };
|
1091 |
|
1092 | var isFunctional = function isFunctional(fn) {
|
1093 | return typeof fn === 'function';
|
1094 | };
|
1095 | var getTypeOf = function getTypeOf(type) {
|
1096 | if (isReactClass(type)) return 'ReactComponent';
|
1097 | if (isFunctional(type)) return 'StatelessFunctional';
|
1098 | return 'Fragment';
|
1099 | };
|
1100 |
|
1101 | function clearStringFast(str) {
|
1102 | return str.length < 12 ? str : (' ' + str).slice(1);
|
1103 | }
|
1104 |
|
1105 | var haveTextSimilarity = function haveTextSimilarity(a, b) {
|
1106 | return (
|
1107 |
|
1108 | a === b || levenshtein.get(clearStringFast(a), clearStringFast(b)) < a.length * 0.2
|
1109 | );
|
1110 | };
|
1111 |
|
1112 | var getBaseProto = function getBaseProto(source) {
|
1113 | return source.prototype.hotComponentRender ? Object.getPrototypeOf(source.prototype) : source.prototype;
|
1114 | };
|
1115 |
|
1116 | var equalClasses = function equalClasses(a, b) {
|
1117 | var prototypeA = getBaseProto(a);
|
1118 | var prototypeB = getBaseProto(b);
|
1119 |
|
1120 | var hits = 0;
|
1121 | var misses = 0;
|
1122 | var comparisons = 0;
|
1123 | Object.getOwnPropertyNames(prototypeA).forEach(function (key) {
|
1124 | var descriptorA = Object.getOwnPropertyDescriptor(prototypeA, key);
|
1125 | var valueA = descriptorA && (descriptorA.value || descriptorA.get || descriptorA.set);
|
1126 | var descriptorB = Object.getOwnPropertyDescriptor(prototypeB, key);
|
1127 | var valueB = descriptorB && (descriptorB.value || descriptorB.get || descriptorB.set);
|
1128 |
|
1129 | if (typeof valueA === 'function' && key !== 'constructor') {
|
1130 | comparisons++;
|
1131 | if (haveTextSimilarity(String(valueA), String(valueB))) {
|
1132 | hits++;
|
1133 | } else {
|
1134 | misses++;
|
1135 | if (key === 'render') {
|
1136 | misses++;
|
1137 | }
|
1138 | }
|
1139 | }
|
1140 | });
|
1141 |
|
1142 | return hits > 0 && misses <= 1 || comparisons === 0;
|
1143 | };
|
1144 |
|
1145 | var areSwappable = function areSwappable(a, b) {
|
1146 |
|
1147 | if (getIdByType(b) && getIdByType(a) === getIdByType(b)) {
|
1148 | return true;
|
1149 | }
|
1150 | if (getTypeOf(a) !== getTypeOf(b)) {
|
1151 | return false;
|
1152 | }
|
1153 | if (isReactClass(a)) {
|
1154 | return areNamesEqual(getComponentDisplayName(a), getComponentDisplayName(b)) && equalClasses(a, b);
|
1155 | }
|
1156 |
|
1157 | if (isFunctional(a)) {
|
1158 | var nameA = getComponentDisplayName(a);
|
1159 | if (!areNamesEqual(nameA, getComponentDisplayName(b))) {
|
1160 | return false;
|
1161 | }
|
1162 | return nameA !== 'Component' || haveTextSimilarity(String(a), String(b));
|
1163 | }
|
1164 | return false;
|
1165 | };
|
1166 |
|
1167 | function merge() {
|
1168 | var acc = {};
|
1169 |
|
1170 | for (var _len = arguments.length, sources = Array(_len), _key = 0; _key < _len; _key++) {
|
1171 | sources[_key] = arguments[_key];
|
1172 | }
|
1173 |
|
1174 | for (var _iterator = sources, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
|
1175 | var _ref;
|
1176 |
|
1177 | if (_isArray) {
|
1178 | if (_i >= _iterator.length) break;
|
1179 | _ref = _iterator[_i++];
|
1180 | } else {
|
1181 | _i = _iterator.next();
|
1182 | if (_i.done) break;
|
1183 | _ref = _i.value;
|
1184 | }
|
1185 |
|
1186 | var source = _ref;
|
1187 |
|
1188 | if (source instanceof Array) {
|
1189 | if (!(acc instanceof Array)) {
|
1190 | acc = [];
|
1191 | }
|
1192 | acc = [].concat(acc, source);
|
1193 | } else if (source instanceof Object) {
|
1194 | for (var _iterator2 = Object.keys(source), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
|
1195 | var _babelHelpers$extends;
|
1196 |
|
1197 | var _ref2;
|
1198 |
|
1199 | if (_isArray2) {
|
1200 | if (_i2 >= _iterator2.length) break;
|
1201 | _ref2 = _iterator2[_i2++];
|
1202 | } else {
|
1203 | _i2 = _iterator2.next();
|
1204 | if (_i2.done) break;
|
1205 | _ref2 = _i2.value;
|
1206 | }
|
1207 |
|
1208 | var key = _ref2;
|
1209 |
|
1210 | var value = source[key];
|
1211 | if (value instanceof Object && key in acc) {
|
1212 | value = merge(acc[key], value);
|
1213 | }
|
1214 | acc = _extends({}, acc, (_babelHelpers$extends = {}, _babelHelpers$extends[key] = value, _babelHelpers$extends));
|
1215 | }
|
1216 | }
|
1217 | }
|
1218 | return acc;
|
1219 | }
|
1220 |
|
1221 | var signatures = void 0;
|
1222 | var proxiesByID = void 0;
|
1223 | var blackListedProxies = void 0;
|
1224 | var registeredComponents = void 0;
|
1225 | var idsByType = void 0;
|
1226 |
|
1227 | var elementCount = 0;
|
1228 | var renderOptions = {};
|
1229 |
|
1230 | var componentOptions = void 0;
|
1231 |
|
1232 | var generateTypeId = function generateTypeId() {
|
1233 | return 'auto-' + elementCount++;
|
1234 | };
|
1235 |
|
1236 | var getIdByType = function getIdByType(type) {
|
1237 | return idsByType.get(type);
|
1238 | };
|
1239 | var isProxyType = function isProxyType(type) {
|
1240 | return type[PROXY_KEY];
|
1241 | };
|
1242 |
|
1243 | var getProxyById = function getProxyById(id) {
|
1244 | return proxiesByID[id];
|
1245 | };
|
1246 | var getProxyByType = function getProxyByType(type) {
|
1247 | return getProxyById(getIdByType(type));
|
1248 | };
|
1249 |
|
1250 | var registerComponent = function registerComponent(type) {
|
1251 | return registeredComponents.set(type, 1);
|
1252 | };
|
1253 | var isRegisteredComponent = function isRegisteredComponent(type) {
|
1254 | return registeredComponents.has(type);
|
1255 | };
|
1256 |
|
1257 | var setStandInOptions = function setStandInOptions(options) {
|
1258 | renderOptions = options;
|
1259 | };
|
1260 |
|
1261 | var updateFunctionProxyById = function updateFunctionProxyById(id, type, updater) {
|
1262 |
|
1263 | idsByType.set(type, id);
|
1264 | var proxy = proxiesByID[id];
|
1265 | if (!proxy) {
|
1266 | proxiesByID[id] = type;
|
1267 | }
|
1268 | updater(proxiesByID[id], type);
|
1269 |
|
1270 |
|
1271 | return proxiesByID[id];
|
1272 | };
|
1273 |
|
1274 | var updateProxyById = function updateProxyById(id, type) {
|
1275 | var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
1276 |
|
1277 | if (!id) {
|
1278 | return null;
|
1279 | }
|
1280 |
|
1281 | idsByType.set(type, id);
|
1282 |
|
1283 | if (!proxiesByID[id]) {
|
1284 | proxiesByID[id] = createClassProxy(type, id, merge({}, renderOptions, { proxy: componentOptions.get(type) || {} }, options));
|
1285 | } else if (proxiesByID[id].update(type)) {
|
1286 |
|
1287 | incrementHotGeneration();
|
1288 | }
|
1289 | return proxiesByID[id];
|
1290 | };
|
1291 |
|
1292 | var createProxyForType = function createProxyForType(type, options) {
|
1293 | return getProxyByType(type) || updateProxyById(generateTypeId(), type, options);
|
1294 | };
|
1295 |
|
1296 | var isColdType = function isColdType(type) {
|
1297 | return blackListedProxies.has(type);
|
1298 | };
|
1299 |
|
1300 | var isTypeBlacklisted = function isTypeBlacklisted(type) {
|
1301 | return isColdType(type) || isCompositeComponent(type) && (configuration.ignoreSFC && !isReactClass(type) || configuration.ignoreComponents && isReactClass(type));
|
1302 | };
|
1303 | var blacklistByType = function blacklistByType(type) {
|
1304 | return blackListedProxies.set(type, true);
|
1305 | };
|
1306 |
|
1307 | var setComponentOptions = function setComponentOptions(component, options) {
|
1308 | return componentOptions.set(component, options);
|
1309 | };
|
1310 |
|
1311 | var addSignature = function addSignature(type, signature) {
|
1312 | return signatures.set(type, signature);
|
1313 | };
|
1314 | var getSignature = function getSignature(type) {
|
1315 | return signatures.get(type);
|
1316 | };
|
1317 |
|
1318 | var resetProxies = function resetProxies() {
|
1319 | proxiesByID = {};
|
1320 | idsByType = new WeakMap();
|
1321 | blackListedProxies = new WeakMap();
|
1322 | registeredComponents = new WeakMap();
|
1323 | componentOptions = new WeakMap();
|
1324 | signatures = new WeakMap();
|
1325 | resetClassProxies();
|
1326 | };
|
1327 |
|
1328 | resetProxies();
|
1329 |
|
1330 | var tune = {
|
1331 | allowSFC: false
|
1332 | };
|
1333 |
|
1334 | var preactAdapter = function preactAdapter(instance, resolveType) {
|
1335 | var oldHandler = instance.options.vnode;
|
1336 |
|
1337 | setConfiguration(tune);
|
1338 |
|
1339 | instance.options.vnode = function (vnode) {
|
1340 | if (vnode.type) {
|
1341 | vnode.type = resolveType(vnode.type);
|
1342 | } else if (vnode.nodeName) {
|
1343 | vnode.nodeName = resolveType(vnode.nodeName);
|
1344 | }
|
1345 | if (oldHandler) {
|
1346 | oldHandler(vnode);
|
1347 | }
|
1348 | };
|
1349 | };
|
1350 |
|
1351 |
|
1352 |
|
1353 | var lastError = [];
|
1354 |
|
1355 | var overlayStyle = {
|
1356 | position: 'fixed',
|
1357 | left: 0,
|
1358 | top: 0,
|
1359 | right: 0,
|
1360 |
|
1361 | backgroundColor: 'rgba(255,200,200,0.9)',
|
1362 |
|
1363 | color: '#000',
|
1364 | fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif',
|
1365 | fontSize: '12px',
|
1366 | margin: 0,
|
1367 | padding: '16px',
|
1368 | maxHeight: '50%',
|
1369 | overflow: 'auto'
|
1370 | };
|
1371 |
|
1372 | var inlineErrorStyle = {
|
1373 | backgroundColor: '#FEE'
|
1374 | };
|
1375 |
|
1376 | var liCounter = {
|
1377 | position: 'absolute',
|
1378 | left: '10px'
|
1379 | };
|
1380 |
|
1381 | var listStyle = {};
|
1382 |
|
1383 | var EmptyErrorPlaceholder = function EmptyErrorPlaceholder(_ref) {
|
1384 | var component = _ref.component;
|
1385 | return React__default.createElement(
|
1386 | 'span',
|
1387 | { style: inlineErrorStyle, role: 'img', 'aria-label': 'Rect-Hot-Loader Error' },
|
1388 | '\u269B\uFE0F\uD83D\uDD25\uD83E\uDD15 (',
|
1389 | component ? getComponentDisplayName(component.constructor || component) : 'Unknown location',
|
1390 | ')',
|
1391 | component && component.retryHotLoaderError && React__default.createElement(
|
1392 | 'button',
|
1393 | { onClick: function onClick() {
|
1394 | return component.retryHotLoaderError();
|
1395 | }, title: 'Retry' },
|
1396 | '\u27F3'
|
1397 | )
|
1398 | );
|
1399 | };
|
1400 |
|
1401 | var errorHeader = function errorHeader(component, componentStack) {
|
1402 | if (component || componentStack) {
|
1403 | return React__default.createElement(
|
1404 | 'span',
|
1405 | null,
|
1406 | '(',
|
1407 | component ? getComponentDisplayName(component.constructor || component) : 'Unknown location',
|
1408 | component && ', ',
|
1409 | componentStack && componentStack.split('\n').filter(Boolean)[0],
|
1410 | ')'
|
1411 | );
|
1412 | }
|
1413 | return null;
|
1414 | };
|
1415 |
|
1416 | var mapError = function mapError(_ref2) {
|
1417 | var error = _ref2.error,
|
1418 | errorInfo = _ref2.errorInfo,
|
1419 | component = _ref2.component;
|
1420 |
|
1421 | if (!error) {
|
1422 | error = { message: 'undefined error' };
|
1423 | }
|
1424 |
|
1425 | return React__default.createElement(
|
1426 | React__default.Fragment,
|
1427 | null,
|
1428 | React__default.createElement(
|
1429 | 'p',
|
1430 | { style: { color: 'red' } },
|
1431 | errorHeader(component, errorInfo && errorInfo.componentStack),
|
1432 | ' ',
|
1433 | error.toString ? error.toString() : error && error.message || 'undefined error'
|
1434 | ),
|
1435 | errorInfo && errorInfo.componentStack ? React__default.createElement(
|
1436 | 'div',
|
1437 | null,
|
1438 | React__default.createElement(
|
1439 | 'div',
|
1440 | null,
|
1441 | 'Stack trace:'
|
1442 | ),
|
1443 | React__default.createElement(
|
1444 | 'ul',
|
1445 | { style: { color: 'red', marginTop: '10px' } },
|
1446 | error.stack.split('\n').slice(1, 2).map(function (line, i) {
|
1447 | return React__default.createElement(
|
1448 | 'li',
|
1449 | { key: String(i) },
|
1450 | line
|
1451 | );
|
1452 | }),
|
1453 | React__default.createElement('hr', null),
|
1454 | errorInfo.componentStack.split('\n').filter(Boolean).map(function (line, i) {
|
1455 | return React__default.createElement(
|
1456 | 'li',
|
1457 | { key: String(i) },
|
1458 | line
|
1459 | );
|
1460 | })
|
1461 | )
|
1462 | ) : error.stack && React__default.createElement(
|
1463 | 'div',
|
1464 | null,
|
1465 | React__default.createElement(
|
1466 | 'div',
|
1467 | null,
|
1468 | 'Stack trace:'
|
1469 | ),
|
1470 | React__default.createElement(
|
1471 | 'ul',
|
1472 | { style: { color: 'red', marginTop: '10px' } },
|
1473 | error.stack.split('\n').map(function (line, i) {
|
1474 | return React__default.createElement(
|
1475 | 'li',
|
1476 | { key: String(i) },
|
1477 | line
|
1478 | );
|
1479 | })
|
1480 | )
|
1481 | )
|
1482 | );
|
1483 | };
|
1484 |
|
1485 | var ErrorOverlay = function (_React$Component) {
|
1486 | inherits(ErrorOverlay, _React$Component);
|
1487 |
|
1488 | function ErrorOverlay() {
|
1489 | var _temp, _this, _ret;
|
1490 |
|
1491 | classCallCheck(this, ErrorOverlay);
|
1492 |
|
1493 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
1494 | args[_key] = arguments[_key];
|
1495 | }
|
1496 |
|
1497 | return _ret = (_temp = (_this = possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {
|
1498 | visible: true
|
1499 | }, _this.toggle = function () {
|
1500 | return _this.setState({ visible: !_this.state.visible });
|
1501 | }, _this.retry = function () {
|
1502 | return _this.setState(function () {
|
1503 | var errors = _this.props.errors;
|
1504 |
|
1505 | enterHotUpdate();
|
1506 | clearExceptions();
|
1507 | errors.map(function (_ref3) {
|
1508 | var component = _ref3.component;
|
1509 | return component;
|
1510 | }).filter(Boolean).filter(function (_ref4) {
|
1511 | var retryHotLoaderError = _ref4.retryHotLoaderError;
|
1512 | return !!retryHotLoaderError;
|
1513 | }).forEach(function (component) {
|
1514 | return component.retryHotLoaderError();
|
1515 | });
|
1516 |
|
1517 | return {};
|
1518 | });
|
1519 | }, _temp), possibleConstructorReturn(_this, _ret);
|
1520 | }
|
1521 |
|
1522 | ErrorOverlay.prototype.render = function render() {
|
1523 | var errors = this.props.errors;
|
1524 |
|
1525 | if (!errors.length) {
|
1526 | return null;
|
1527 | }
|
1528 | var visible = this.state.visible;
|
1529 |
|
1530 | return React__default.createElement(
|
1531 | 'div',
|
1532 | { style: overlayStyle },
|
1533 | React__default.createElement(
|
1534 | 'h2',
|
1535 | { style: { margin: 0 } },
|
1536 | '\u269B\uFE0F\uD83D\uDD25\uD83D\uDE2D: hot update was not successful ',
|
1537 | React__default.createElement(
|
1538 | 'button',
|
1539 | { onClick: this.toggle },
|
1540 | visible ? 'collapse' : 'expand'
|
1541 | ),
|
1542 | React__default.createElement(
|
1543 | 'button',
|
1544 | { onClick: this.retry },
|
1545 | 'Retry'
|
1546 | )
|
1547 | ),
|
1548 | visible && React__default.createElement(
|
1549 | 'ul',
|
1550 | { style: listStyle },
|
1551 | errors.map(function (err, i) {
|
1552 | return React__default.createElement(
|
1553 | 'li',
|
1554 | { key: i },
|
1555 | React__default.createElement(
|
1556 | 'span',
|
1557 | { style: liCounter },
|
1558 | '(',
|
1559 | i + 1,
|
1560 | '/',
|
1561 | errors.length,
|
1562 | ')'
|
1563 | ),
|
1564 | mapError(err)
|
1565 | );
|
1566 | })
|
1567 | )
|
1568 | );
|
1569 | };
|
1570 |
|
1571 | return ErrorOverlay;
|
1572 | }(React__default.Component);
|
1573 |
|
1574 | var initErrorOverlay = function initErrorOverlay() {
|
1575 | if (typeof document === 'undefined' || !document.body) {
|
1576 | return;
|
1577 | }
|
1578 | var div = document.querySelector('.react-hot-loader-error-overlay');
|
1579 | if (!div) {
|
1580 | div = document.createElement('div');
|
1581 | div.className = 'react-hot-loader-error-overlay';
|
1582 | document.body.appendChild(div);
|
1583 | }
|
1584 | if (lastError.length) {
|
1585 | var Overlay = configuration.ErrorOverlay || ErrorOverlay;
|
1586 | ReactDOM.render(React__default.createElement(Overlay, { errors: lastError }), div);
|
1587 | } else {
|
1588 | div.parentNode.removeChild(div);
|
1589 | }
|
1590 | };
|
1591 |
|
1592 | function clearExceptions() {
|
1593 | if (lastError.length) {
|
1594 | lastError = [];
|
1595 | initErrorOverlay();
|
1596 | }
|
1597 | }
|
1598 |
|
1599 | function logException(error, errorInfo, component) {
|
1600 |
|
1601 |
|
1602 |
|
1603 | console.error(error);
|
1604 |
|
1605 |
|
1606 | lastError.push({ error: error, errorInfo: errorInfo, component: component });
|
1607 | initErrorOverlay();
|
1608 | }
|
1609 |
|
1610 |
|
1611 |
|
1612 | var hotRenderWithHooks = ReactDOM.hotRenderWithHooks || function (fiber, render) {
|
1613 | return render();
|
1614 | };
|
1615 |
|
1616 | function pushStack(stack, node) {
|
1617 | stack.type = node.type;
|
1618 | stack.elementType = node.elementType || node.type;
|
1619 | stack.children = [];
|
1620 | stack.instance = typeof node.type === 'function' ? node.stateNode : stack;
|
1621 | stack.fiber = node;
|
1622 |
|
1623 | if (!stack.instance) {
|
1624 | stack.instance = {
|
1625 | SFC_fake: stack.type,
|
1626 | props: {},
|
1627 | render: function render() {
|
1628 | return hotRenderWithHooks(node, function () {
|
1629 | return stack.type(stack.instance.props);
|
1630 | });
|
1631 | }
|
1632 | };
|
1633 | }
|
1634 | }
|
1635 |
|
1636 | function hydrateFiberStack(node, stack) {
|
1637 | pushStack(stack, node);
|
1638 | if (node.child) {
|
1639 | var child = node.child;
|
1640 |
|
1641 | do {
|
1642 | var childStack = {};
|
1643 | hydrateFiberStack(child, childStack);
|
1644 | stack.children.push(childStack);
|
1645 | child = child.sibling;
|
1646 | } while (child);
|
1647 | }
|
1648 | }
|
1649 |
|
1650 |
|
1651 |
|
1652 | function pushState(stack, type, instance) {
|
1653 | stack.type = type;
|
1654 | stack.elementType = type;
|
1655 | stack.children = [];
|
1656 | stack.instance = instance || stack;
|
1657 |
|
1658 | if (typeof type === 'function' && type.isStatelessFunctionalProxy) {
|
1659 |
|
1660 | stack.instance = {
|
1661 | SFC_fake: type,
|
1662 | props: {},
|
1663 | render: function render() {
|
1664 | return type(stack.instance.props);
|
1665 | }
|
1666 | };
|
1667 | }
|
1668 | }
|
1669 |
|
1670 | function hydrateLegacyStack(node, stack) {
|
1671 | if (node._currentElement) {
|
1672 | pushState(stack, node._currentElement.type, node._instance || stack);
|
1673 | }
|
1674 |
|
1675 | if (node._renderedComponent) {
|
1676 | var childStack = {};
|
1677 | hydrateLegacyStack(node._renderedComponent, childStack);
|
1678 | stack.children.push(childStack);
|
1679 | } else if (node._renderedChildren) {
|
1680 | Object.keys(node._renderedChildren).forEach(function (key) {
|
1681 | var childStack = {};
|
1682 | hydrateLegacyStack(node._renderedChildren[key], childStack);
|
1683 | stack.children.push(childStack);
|
1684 | });
|
1685 | }
|
1686 | }
|
1687 |
|
1688 | var shouldNotPatchComponent = function shouldNotPatchComponent(type) {
|
1689 | return isTypeBlacklisted(type);
|
1690 | };
|
1691 |
|
1692 | function resolveUtility(type) {
|
1693 |
|
1694 |
|
1695 |
|
1696 |
|
1697 |
|
1698 | if ((typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object') {
|
1699 | if (configuration.integratedComparator) {
|
1700 | return type;
|
1701 | }
|
1702 | var element = { type: type };
|
1703 | if (isLazyType(element) || isMemoType(element) || isForwardType(element) || isContextType(element)) {
|
1704 | return getProxyByType(type) || type;
|
1705 | }
|
1706 | }
|
1707 |
|
1708 | return undefined;
|
1709 | }
|
1710 |
|
1711 | function resolveComponent(type) {
|
1712 | var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
1713 |
|
1714 | var existingProxy = getProxyByType(type);
|
1715 |
|
1716 |
|
1717 | if (shouldNotPatchComponent(type)) {
|
1718 | return existingProxy ? existingProxy.getCurrent() : type;
|
1719 | }
|
1720 |
|
1721 | if (!existingProxy && configuration.onComponentCreate) {
|
1722 | configuration.onComponentCreate(type, getComponentDisplayName(type));
|
1723 | if (shouldNotPatchComponent(type)) {
|
1724 | return type;
|
1725 | }
|
1726 | }
|
1727 |
|
1728 | var proxy = internalConfiguration.disableProxyCreation ? existingProxy : createProxyForType(type, options);
|
1729 |
|
1730 | return proxy ? proxy.get() : undefined;
|
1731 | }
|
1732 |
|
1733 | function resolveProxy(type) {
|
1734 | if (isProxyType(type)) {
|
1735 | return type;
|
1736 | }
|
1737 |
|
1738 | return undefined;
|
1739 | }
|
1740 |
|
1741 | function resolveNotComponent(type) {
|
1742 | if (!isCompositeComponent(type)) {
|
1743 | return type;
|
1744 | }
|
1745 |
|
1746 | return undefined;
|
1747 | }
|
1748 |
|
1749 | var getLatestTypeVersion = function getLatestTypeVersion(type) {
|
1750 | var existingProxy = getProxyByType(type);
|
1751 | return existingProxy && existingProxy.getCurrent && existingProxy.getCurrent();
|
1752 | };
|
1753 |
|
1754 | var resolveSimpleType = function resolveSimpleType(type) {
|
1755 | if (!type) {
|
1756 | return type;
|
1757 | }
|
1758 |
|
1759 | var simpleResult = resolveProxy(type) || resolveUtility(type) || resolveNotComponent(type);
|
1760 | if (simpleResult) {
|
1761 | return simpleResult;
|
1762 | }
|
1763 |
|
1764 | var lastType = getLatestTypeVersion(type);
|
1765 |
|
1766 |
|
1767 |
|
1768 |
|
1769 |
|
1770 |
|
1771 |
|
1772 | return lastType || type;
|
1773 | };
|
1774 |
|
1775 | var resolveType = function resolveType(type) {
|
1776 | var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
1777 |
|
1778 | if (!type) {
|
1779 | return type;
|
1780 | }
|
1781 |
|
1782 | return resolveProxy(type) || resolveUtility(type) || resolveNotComponent(type) || resolveComponent(type, options) || type;
|
1783 | };
|
1784 |
|
1785 |
|
1786 |
|
1787 | function getReactStack(instance) {
|
1788 | var rootNode = getInternalInstance(instance);
|
1789 | var stack = {};
|
1790 | if (rootNode) {
|
1791 |
|
1792 | var isFiber = typeof rootNode.tag === 'number';
|
1793 | if (isFiber) {
|
1794 | hydrateFiberStack(rootNode, stack);
|
1795 | } else {
|
1796 | hydrateLegacyStack(rootNode, stack);
|
1797 | }
|
1798 | }
|
1799 |
|
1800 | return stack;
|
1801 | }
|
1802 |
|
1803 | var markUpdate = function markUpdate(_ref) {
|
1804 | var fiber = _ref.fiber;
|
1805 |
|
1806 |
|
1807 | if (!fiber || typeof fiber.type === 'string') {
|
1808 | return;
|
1809 | }
|
1810 |
|
1811 | var mostResentType = resolveType(fiber.type) || fiber.type;
|
1812 | if (fiber.elementType === fiber.type) {
|
1813 | fiber.elementType = mostResentType;
|
1814 | }
|
1815 | fiber.type = mostResentType;
|
1816 |
|
1817 | fiber.expirationTime = 1;
|
1818 | if (fiber.alternate) {
|
1819 | fiber.alternate.expirationTime = 1;
|
1820 | fiber.alternate.type = fiber.type;
|
1821 |
|
1822 | if ('elementType' in fiber.alternate) {
|
1823 | fiber.alternate.elementType = fiber.elementType;
|
1824 | }
|
1825 | }
|
1826 |
|
1827 | if (fiber.memoizedProps && _typeof(fiber.memoizedProps) === 'object') {
|
1828 | fiber.memoizedProps = _extends({
|
1829 | cacheBusterProp: true
|
1830 | }, fiber.memoizedProps);
|
1831 | }
|
1832 |
|
1833 | if (fiber.stateNode) ;
|
1834 | };
|
1835 |
|
1836 | var cleanupReact = function cleanupReact() {
|
1837 | if (ReactDOM.hotCleanup) {
|
1838 | ReactDOM.hotCleanup();
|
1839 | }
|
1840 | };
|
1841 |
|
1842 | var deepMarkUpdate = function deepMarkUpdate(stack) {
|
1843 | markUpdate(stack);
|
1844 | if (stack.children) {
|
1845 | stack.children.forEach(deepMarkUpdate);
|
1846 | }
|
1847 | };
|
1848 |
|
1849 | var renderStack = [];
|
1850 |
|
1851 | var stackReport = function stackReport() {
|
1852 | var rev = renderStack.slice().reverse();
|
1853 | logger.warn('in', rev[0].name, rev);
|
1854 | };
|
1855 |
|
1856 | var emptyMap = new Map();
|
1857 | var stackContext = function stackContext() {
|
1858 | return (renderStack[renderStack.length - 1] || {}).context || emptyMap;
|
1859 | };
|
1860 |
|
1861 | var shouldUseRenderMethod = function shouldUseRenderMethod(fn) {
|
1862 | return fn && (isReactClassInstance(fn) || fn.SFC_fake);
|
1863 | };
|
1864 |
|
1865 | var getElementType$1 = function getElementType$$1(child) {
|
1866 | return child.type[UNWRAP_PROXY] ? child.type[UNWRAP_PROXY]() : child.type;
|
1867 | };
|
1868 |
|
1869 | var filterNullArray = function filterNullArray(a) {
|
1870 | if (!a) return [];
|
1871 | return a.filter(function (x) {
|
1872 | return !!x;
|
1873 | });
|
1874 | };
|
1875 |
|
1876 | var unflatten = function unflatten(a) {
|
1877 | return a.reduce(function (acc, a) {
|
1878 | if (Array.isArray(a)) {
|
1879 | acc.push.apply(acc, unflatten(a));
|
1880 | } else {
|
1881 | acc.push(a);
|
1882 | }
|
1883 | return acc;
|
1884 | }, []);
|
1885 | };
|
1886 |
|
1887 | var isArray = function isArray(fn) {
|
1888 | return Array.isArray(fn);
|
1889 | };
|
1890 | var asArray = function asArray(a) {
|
1891 | return isArray(a) ? a : [a];
|
1892 | };
|
1893 |
|
1894 | var render = function render(component, stack) {
|
1895 | if (!component) {
|
1896 | return [];
|
1897 | }
|
1898 | if (component.hotComponentUpdate) {
|
1899 | component.hotComponentUpdate();
|
1900 | }
|
1901 | if (shouldUseRenderMethod(component)) {
|
1902 |
|
1903 |
|
1904 | return component.hotComponentRender ? component.hotComponentRender() : component.render();
|
1905 | }
|
1906 | if (isForwardType(component)) {
|
1907 |
|
1908 | return hotRenderWithHooks(stack.fiber, function () {
|
1909 | return component.type.render(component.props, null);
|
1910 | });
|
1911 | }
|
1912 | if (isArray(component)) {
|
1913 | return component.map(render);
|
1914 | }
|
1915 | if (component.children) {
|
1916 | return component.children;
|
1917 | }
|
1918 |
|
1919 | return [];
|
1920 | };
|
1921 |
|
1922 | var NO_CHILDREN = { children: [] };
|
1923 | var mapChildren = function mapChildren(children, instances) {
|
1924 | return {
|
1925 | children: children.filter(function (c) {
|
1926 | return c;
|
1927 | }).map(function (child, index) {
|
1928 | if ((typeof child === 'undefined' ? 'undefined' : _typeof(child)) !== 'object' || child.isMerged) {
|
1929 | return child;
|
1930 | }
|
1931 | var instanceLine = instances[index] || {};
|
1932 | var oldChildren = asArray(instanceLine.children || []);
|
1933 |
|
1934 | if (Array.isArray(child)) {
|
1935 | return _extends({
|
1936 | type: null
|
1937 | }, mapChildren(child, oldChildren));
|
1938 | }
|
1939 |
|
1940 | var newChildren = asArray(child.props && child.props.children || child.children || []);
|
1941 | var nextChildren = child.type !== 'function' && oldChildren.length && mapChildren(newChildren, oldChildren);
|
1942 |
|
1943 | return _extends({
|
1944 | nextProps: child.props,
|
1945 | isMerged: true
|
1946 | }, instanceLine, nextChildren || {}, {
|
1947 | type: child.type
|
1948 | });
|
1949 | })
|
1950 | };
|
1951 | };
|
1952 |
|
1953 | var mergeInject = function mergeInject(a, b, instance) {
|
1954 | if (a && !Array.isArray(a)) {
|
1955 | return mergeInject([a], b);
|
1956 | }
|
1957 | if (b && !Array.isArray(b)) {
|
1958 | return mergeInject(a, [b]);
|
1959 | }
|
1960 |
|
1961 | if (!a || !b) {
|
1962 | return NO_CHILDREN;
|
1963 | }
|
1964 | if (a.length === b.length) {
|
1965 | return mapChildren(a, b);
|
1966 | }
|
1967 |
|
1968 |
|
1969 |
|
1970 |
|
1971 |
|
1972 | var nonNullA = filterNullArray(a);
|
1973 | if (nonNullA.length === b.length) {
|
1974 | return mapChildren(nonNullA, b);
|
1975 | }
|
1976 |
|
1977 | var flatA = unflatten(nonNullA);
|
1978 | var flatB = unflatten(b);
|
1979 | if (flatA.length === flatB.length) {
|
1980 | return mapChildren(flatA, flatB);
|
1981 | }
|
1982 | if (flatB.length === 0 && flatA.length === 1 && _typeof(flatA[0]) !== 'object') ; else if (!configuration.IS_REACT_MERGE_ENABLED) {
|
1983 | logger.warn('React-hot-loader: unable to merge ', a, 'and children of ', instance);
|
1984 | stackReport();
|
1985 | }
|
1986 | return NO_CHILDREN;
|
1987 | };
|
1988 |
|
1989 | var transformFlowNode = function transformFlowNode(flow) {
|
1990 | return flow.reduce(function (acc, node) {
|
1991 | if (node && isFragmentNode(node)) {
|
1992 | if (node.props && node.props.children) {
|
1993 | return [].concat(acc, filterNullArray(asArray(node.props.children)));
|
1994 | }
|
1995 | if (node.children) {
|
1996 | return [].concat(acc, filterNullArray(asArray(node.children)));
|
1997 | }
|
1998 | }
|
1999 | return [].concat(acc, [node]);
|
2000 | }, []);
|
2001 | };
|
2002 |
|
2003 | var scheduledUpdates = [];
|
2004 | var scheduledUpdate = 0;
|
2005 |
|
2006 | var flushScheduledUpdates = function flushScheduledUpdates() {
|
2007 | var instances = scheduledUpdates;
|
2008 | scheduledUpdates = [];
|
2009 | scheduledUpdate = 0;
|
2010 | instances.forEach(function (instance) {
|
2011 | return instance[PROXY_IS_MOUNTED] && updateInstance(instance);
|
2012 | });
|
2013 | };
|
2014 |
|
2015 | var unscheduleUpdate = function unscheduleUpdate(instance) {
|
2016 | scheduledUpdates = scheduledUpdates.filter(function (inst) {
|
2017 | return inst !== instance;
|
2018 | });
|
2019 | };
|
2020 |
|
2021 | var scheduleInstanceUpdate = function scheduleInstanceUpdate(instance) {
|
2022 | scheduledUpdates.push(instance);
|
2023 | if (!scheduledUpdate) {
|
2024 | scheduledUpdate = setTimeout(flushScheduledUpdates, 4);
|
2025 | }
|
2026 | };
|
2027 |
|
2028 | var hotReplacementRender = function hotReplacementRender(instance, stack) {
|
2029 | if (isReactClassInstance(instance)) {
|
2030 | var type = getElementType$1(stack);
|
2031 |
|
2032 | renderStack.push({
|
2033 | name: getComponentDisplayName(type),
|
2034 | type: type,
|
2035 | props: stack.instance.props,
|
2036 | context: stackContext()
|
2037 | });
|
2038 | }
|
2039 |
|
2040 | try {
|
2041 | var flow = transformFlowNode(filterNullArray(asArray(render(instance, stack))));
|
2042 |
|
2043 | var children = stack.children;
|
2044 |
|
2045 |
|
2046 | flow.forEach(function (child, index) {
|
2047 | var childType = child.type;
|
2048 | var stackChild = children[index];
|
2049 | var next = function next(instance) {
|
2050 |
|
2051 |
|
2052 | var realProps = instance.props;
|
2053 | var nextProps = _extends({}, realProps, child.nextProps || {}, child.props || {});
|
2054 |
|
2055 | if (isReactClassInstance(instance) && instance.componentWillUpdate) {
|
2056 |
|
2057 | instance.componentWillUpdate(_extends({}, realProps), instance.state);
|
2058 | }
|
2059 | instance.props = nextProps;
|
2060 | hotReplacementRender(instance, stackChild);
|
2061 | instance.props = realProps;
|
2062 | };
|
2063 |
|
2064 |
|
2065 | if ((typeof child === 'undefined' ? 'undefined' : _typeof(child)) !== 'object' || !stackChild || !stackChild.instance) {
|
2066 | if (stackChild && stackChild.children && stackChild.children.length) {
|
2067 | logger.error('React-hot-loader: reconciliation failed', 'could not dive into [', child, '] while some elements are still present in the tree.');
|
2068 | stackReport();
|
2069 | }
|
2070 | return;
|
2071 | }
|
2072 |
|
2073 |
|
2074 | if ((typeof childType === 'undefined' ? 'undefined' : _typeof(childType)) !== _typeof(stackChild.elementType)) {
|
2075 |
|
2076 | if (childType && stackChild.type) {
|
2077 | logger.warn('React-hot-loader: got ', childType, 'instead of', stackChild.type);
|
2078 | stackReport();
|
2079 | }
|
2080 | return;
|
2081 | }
|
2082 |
|
2083 | if (isMemoType(child) || isLazyType(child)) {
|
2084 |
|
2085 | if (stackChild.children && stackChild.children[0]) {
|
2086 | scheduleInstanceUpdate(stackChild.children[0].instance);
|
2087 | }
|
2088 | childType = childType.type || childType;
|
2089 | }
|
2090 |
|
2091 | if (isForwardType(child)) {
|
2092 | next(stackChild.instance);
|
2093 | } else if (isContextConsumer(child)) {
|
2094 | try {
|
2095 | var contextValue = stackContext().get(getContextProvider(childType));
|
2096 | next({
|
2097 | children: (child.props ? child.props.children : child.children[0])(contextValue !== undefined ? contextValue : childType[CONTEXT_CURRENT_VALUE])
|
2098 | });
|
2099 | } catch (e) {
|
2100 |
|
2101 | }
|
2102 | } else if (typeof childType !== 'function') {
|
2103 |
|
2104 | var childName = childType ? getComponentDisplayName(childType) : 'empty';
|
2105 | var extraContext = stackContext();
|
2106 |
|
2107 | if (isContextProvider(child)) {
|
2108 | extraContext = new Map(extraContext);
|
2109 | extraContext.set(getContextProvider(childType), _extends({}, child.nextProps || {}, child.props || {}).value);
|
2110 | childName = 'ContextProvider';
|
2111 | }
|
2112 |
|
2113 | renderStack.push({
|
2114 | name: childName,
|
2115 | type: childType,
|
2116 | props: stack.instance.props,
|
2117 | context: extraContext
|
2118 | });
|
2119 |
|
2120 | next(
|
2121 |
|
2122 | mergeInject(transformFlowNode(asArray(child.props ? child.props.children : child.children)), stackChild.instance.children, stackChild.instance));
|
2123 | renderStack.pop();
|
2124 | } else {
|
2125 | if (childType === stackChild.type) {
|
2126 | next(stackChild.instance);
|
2127 | } else {
|
2128 |
|
2129 | var _childType = getElementType$1(child);
|
2130 |
|
2131 | if (isMemoType(child)) {
|
2132 | _childType = _childType.type || _childType;
|
2133 | }
|
2134 |
|
2135 | if (!stackChild.type[PROXY_KEY]) {
|
2136 | if (!configuration.IS_REACT_MERGE_ENABLED) {
|
2137 | if (isTypeBlacklisted(stackChild.type)) {
|
2138 | logger.warn('React-hot-loader: cold element got updated ', stackChild.type);
|
2139 | }
|
2140 | }
|
2141 | }
|
2142 |
|
2143 | if (isRegisteredComponent(_childType) || isRegisteredComponent(stackChild.type)) {
|
2144 |
|
2145 | if (resolveType(_childType) === resolveType(stackChild.type)) {
|
2146 | next(stackChild.instance);
|
2147 | }
|
2148 | } else if (areSwappable(_childType, stackChild.type)) {
|
2149 |
|
2150 |
|
2151 |
|
2152 | updateProxyById(stackChild.type[PROXY_KEY] || getIdByType(stackChild.type), _childType);
|
2153 |
|
2154 | next(stackChild.instance);
|
2155 | } else {
|
2156 | logger.warn('React-hot-loader: a ' + getComponentDisplayName(_childType) + ' was found where a ' + getComponentDisplayName(stackChild) + ' was expected.\n ' + _childType);
|
2157 | stackReport();
|
2158 | }
|
2159 | }
|
2160 |
|
2161 | scheduleInstanceUpdate(stackChild.instance);
|
2162 | }
|
2163 | });
|
2164 | } catch (e) {
|
2165 | if (e.then) ; else {
|
2166 | logger.warn('React-hot-loader: run time error during reconciliation', e);
|
2167 | }
|
2168 | }
|
2169 |
|
2170 | if (isReactClassInstance(instance)) {
|
2171 | renderStack.pop();
|
2172 | }
|
2173 | };
|
2174 |
|
2175 | var hotReplacementRender$1 = (function (instance, stack) {
|
2176 | if (configuration.disableHotRenderer) {
|
2177 | return;
|
2178 | }
|
2179 | try {
|
2180 |
|
2181 | internalConfiguration.disableProxyCreation = true;
|
2182 | renderStack = [];
|
2183 | hotReplacementRender(instance, stack);
|
2184 | } catch (e) {
|
2185 | logger.warn('React-hot-loader: reconcilation failed due to error', e);
|
2186 | } finally {
|
2187 | internalConfiguration.disableProxyCreation = false;
|
2188 | }
|
2189 | });
|
2190 |
|
2191 | var reconcileHotReplacement = function reconcileHotReplacement(ReactInstance) {
|
2192 | var stack = getReactStack(ReactInstance);
|
2193 | hotReplacementRender$1(ReactInstance, stack);
|
2194 | cleanupReact();
|
2195 | deepMarkUpdate(stack);
|
2196 | };
|
2197 |
|
2198 | var renderReconciler = function renderReconciler(target, force) {
|
2199 |
|
2200 | var currentGeneration = get$1();
|
2201 | var componentGeneration = target[RENDERED_GENERATION];
|
2202 |
|
2203 | target[RENDERED_GENERATION] = currentGeneration;
|
2204 |
|
2205 | if (!internalConfiguration.disableProxyCreation) {
|
2206 | if ((componentGeneration || force) && componentGeneration !== currentGeneration) {
|
2207 | enterHotUpdate();
|
2208 | reconcileHotReplacement(target);
|
2209 | return true;
|
2210 | }
|
2211 | }
|
2212 | return false;
|
2213 | };
|
2214 |
|
2215 | function asyncReconciledRender(target) {
|
2216 | renderReconciler(target, false);
|
2217 | }
|
2218 |
|
2219 | function proxyWrapper(element) {
|
2220 |
|
2221 | if (!internalConfiguration.disableProxyCreation) {
|
2222 | unscheduleUpdate(this);
|
2223 | }
|
2224 |
|
2225 | if (!element) {
|
2226 | return element;
|
2227 | }
|
2228 | if (Array.isArray(element)) {
|
2229 | return element.map(proxyWrapper);
|
2230 | }
|
2231 | if (typeof element.type === 'function') {
|
2232 | var proxy = getProxyByType(element.type);
|
2233 | if (proxy) {
|
2234 | return _extends({}, element, {
|
2235 | type: proxy.get()
|
2236 | });
|
2237 | }
|
2238 | }
|
2239 | return element;
|
2240 | }
|
2241 |
|
2242 | var ERROR_STATE = 'react_hot_loader_catched_error';
|
2243 | var ERROR_STATE_PROTO = 'react_hot_loader_catched_error-prototype';
|
2244 | var OLD_RENDER = 'react_hot_loader_original_render';
|
2245 |
|
2246 | function componentDidCatch(error, errorInfo) {
|
2247 | this[ERROR_STATE] = {
|
2248 | location: 'boundary',
|
2249 | error: error,
|
2250 | errorInfo: errorInfo,
|
2251 | generation: get$1()
|
2252 | };
|
2253 | Object.getPrototypeOf(this)[ERROR_STATE_PROTO] = this[ERROR_STATE];
|
2254 | if (!configuration.errorReporter) {
|
2255 | logException(error, errorInfo, this);
|
2256 | }
|
2257 | this.forceUpdate();
|
2258 | }
|
2259 |
|
2260 | function componentRender() {
|
2261 | var _ref = this[ERROR_STATE] || {},
|
2262 | error = _ref.error,
|
2263 | errorInfo = _ref.errorInfo,
|
2264 | generation = _ref.generation;
|
2265 |
|
2266 | if (error && generation === get$1()) {
|
2267 | return React__default.createElement(configuration.errorReporter || EmptyErrorPlaceholder, {
|
2268 | error: error,
|
2269 | errorInfo: errorInfo,
|
2270 | component: this
|
2271 | });
|
2272 | }
|
2273 |
|
2274 | if (this.hotComponentUpdate) {
|
2275 | this.hotComponentUpdate();
|
2276 | }
|
2277 | try {
|
2278 | var _OLD_RENDER$render;
|
2279 |
|
2280 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
2281 | args[_key] = arguments[_key];
|
2282 | }
|
2283 |
|
2284 | return (_OLD_RENDER$render = this[OLD_RENDER].render).call.apply(_OLD_RENDER$render, [this].concat(args));
|
2285 | } catch (renderError) {
|
2286 | this[ERROR_STATE] = {
|
2287 | location: 'render',
|
2288 | error: renderError,
|
2289 | generation: get$1()
|
2290 | };
|
2291 | if (!configuration.errorReporter) {
|
2292 | logException(renderError, undefined, this);
|
2293 | }
|
2294 | return componentRender.call(this);
|
2295 | }
|
2296 | }
|
2297 |
|
2298 | function retryHotLoaderError() {
|
2299 | delete this[ERROR_STATE];
|
2300 | this.forceUpdate();
|
2301 | }
|
2302 |
|
2303 | setComparisonHooks(function () {
|
2304 | return {};
|
2305 | }, function (component) {
|
2306 | if (!hotComparisonOpen()) {
|
2307 | return;
|
2308 | }
|
2309 | var prototype = component.prototype;
|
2310 |
|
2311 | if (!prototype[OLD_RENDER]) {
|
2312 | var renderDescriptior = Object.getOwnPropertyDescriptor(prototype, 'render');
|
2313 | prototype[OLD_RENDER] = {
|
2314 | descriptor: renderDescriptior ? renderDescriptior.value : undefined,
|
2315 | render: prototype.render
|
2316 | };
|
2317 | prototype.componentDidCatch = componentDidCatch;
|
2318 | prototype.retryHotLoaderError = retryHotLoaderError;
|
2319 |
|
2320 | prototype.render = componentRender;
|
2321 | }
|
2322 | delete prototype[ERROR_STATE];
|
2323 | }, function (_ref2) {
|
2324 | var prototype = _ref2.prototype;
|
2325 |
|
2326 | if (prototype[OLD_RENDER]) {
|
2327 | var _ref3 = prototype[ERROR_STATE_PROTO] || {},
|
2328 | generation = _ref3.generation;
|
2329 |
|
2330 | if (generation === get$1()) ; else {
|
2331 | delete prototype.componentDidCatch;
|
2332 | delete prototype.retryHotLoaderError;
|
2333 |
|
2334 |
|
2335 | if (prototype.render === componentRender) {
|
2336 | if (!prototype[OLD_RENDER].descriptor) {
|
2337 | delete prototype.render;
|
2338 | } else {
|
2339 | prototype.render = prototype[OLD_RENDER].descriptor;
|
2340 | }
|
2341 | } else {
|
2342 | console.error('React-Hot-Loader: something unexpectedly mutated Component', prototype);
|
2343 | }
|
2344 | delete prototype[ERROR_STATE_PROTO];
|
2345 | delete prototype[OLD_RENDER];
|
2346 | }
|
2347 | }
|
2348 | });
|
2349 |
|
2350 | setStandInOptions({
|
2351 | componentWillRender: asyncReconciledRender,
|
2352 | componentDidRender: proxyWrapper,
|
2353 | componentDidUpdate: function componentDidUpdate(component) {
|
2354 | component[RENDERED_GENERATION] = get$1();
|
2355 | flushScheduledUpdates();
|
2356 | }
|
2357 | });
|
2358 |
|
2359 | var AppContainer = function (_React$Component) {
|
2360 | inherits(AppContainer, _React$Component);
|
2361 |
|
2362 | AppContainer.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {
|
2363 | if (prevState.generation !== get$1()) {
|
2364 |
|
2365 | return {
|
2366 | error: null,
|
2367 | generation: get$1()
|
2368 | };
|
2369 | }
|
2370 | return null;
|
2371 | };
|
2372 |
|
2373 | function AppContainer(props) {
|
2374 | classCallCheck(this, AppContainer);
|
2375 |
|
2376 | var _this = possibleConstructorReturn(this, _React$Component.call(this, props));
|
2377 |
|
2378 | if (configuration.showReactDomPatchNotification) {
|
2379 | configuration.showReactDomPatchNotification = false;
|
2380 | console.warn('React-Hot-Loader: react-🔥-dom patch is not detected. React 16.6+ features may not work.');
|
2381 | }
|
2382 |
|
2383 | _this.state = {
|
2384 | error: null,
|
2385 | errorInfo: null,
|
2386 |
|
2387 | generation: 0
|
2388 | };
|
2389 | return _this;
|
2390 | }
|
2391 |
|
2392 | AppContainer.prototype.shouldComponentUpdate = function shouldComponentUpdate(prevProps, prevState) {
|
2393 |
|
2394 |
|
2395 |
|
2396 | if (prevState.error && this.state.error) {
|
2397 | return false;
|
2398 | }
|
2399 |
|
2400 | return true;
|
2401 | };
|
2402 |
|
2403 | AppContainer.prototype.componentDidCatch = function componentDidCatch(error, errorInfo) {
|
2404 | logger.error(error);
|
2405 |
|
2406 | if (!hotComparisonOpen()) {
|
2407 |
|
2408 |
|
2409 |
|
2410 | this.setState({});
|
2411 | throw error;
|
2412 | }
|
2413 | var _props$errorReporter = this.props.errorReporter,
|
2414 | errorReporter = _props$errorReporter === undefined ? configuration.errorReporter : _props$errorReporter;
|
2415 |
|
2416 | if (!errorReporter) {
|
2417 | logException(error, errorInfo, this);
|
2418 | }
|
2419 | this.setState({
|
2420 | error: error,
|
2421 | errorInfo: errorInfo
|
2422 | });
|
2423 | };
|
2424 |
|
2425 | AppContainer.prototype.retryHotLoaderError = function retryHotLoaderError$$1() {
|
2426 | var _this2 = this;
|
2427 |
|
2428 | this.setState({ error: null }, function () {
|
2429 | retryHotLoaderError.call(_this2);
|
2430 | });
|
2431 | };
|
2432 |
|
2433 | AppContainer.prototype.render = function render() {
|
2434 | var _state = this.state,
|
2435 | error = _state.error,
|
2436 | errorInfo = _state.errorInfo;
|
2437 | var _props$errorReporter2 = this.props.errorReporter,
|
2438 | ErrorReporter = _props$errorReporter2 === undefined ? configuration.errorReporter || EmptyErrorPlaceholder : _props$errorReporter2;
|
2439 |
|
2440 |
|
2441 | if (error && this.props.errorBoundary) {
|
2442 | return React__default.createElement(ErrorReporter, { error: error, errorInfo: errorInfo, component: this });
|
2443 | }
|
2444 |
|
2445 | if (this.hotComponentUpdate) {
|
2446 | this.hotComponentUpdate();
|
2447 | } else {
|
2448 | throw new Error('React-Hot-Loader: AppContainer should be patched');
|
2449 | }
|
2450 |
|
2451 | return React__default.Children.only(this.props.children);
|
2452 | };
|
2453 |
|
2454 | return AppContainer;
|
2455 | }(React__default.Component);
|
2456 |
|
2457 | AppContainer.reactHotLoadable = false;
|
2458 |
|
2459 |
|
2460 | AppContainer.propTypes = {
|
2461 | children: function children(props) {
|
2462 | if (React__default.Children.count(props.children) !== 1) {
|
2463 | return new Error('Invalid prop "children" supplied to AppContainer. ' + 'Expected a single React element with your app’s root component, e.g. <App />.');
|
2464 | }
|
2465 |
|
2466 | return undefined;
|
2467 | },
|
2468 |
|
2469 | errorReporter: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
|
2470 | errorBoundary: PropTypes.bool
|
2471 | };
|
2472 |
|
2473 | AppContainer.defaultProps = {
|
2474 | errorBoundary: true
|
2475 | };
|
2476 |
|
2477 |
|
2478 | var realPolyfill = defaultPolyfill.polyfill || defaultPolyfill__default;
|
2479 | realPolyfill(AppContainer);
|
2480 |
|
2481 | var lazyConstructor = '_ctor';
|
2482 |
|
2483 | var patchLazyConstructor = function patchLazyConstructor(target) {
|
2484 | if (!configuration.trackTailUpdates && !target[lazyConstructor].isPatchedByReactHotLoader) {
|
2485 | var ctor = target[lazyConstructor];
|
2486 | target[lazyConstructor] = function () {
|
2487 | return ctor().then(function (m) {
|
2488 | var C = resolveType(m.default);
|
2489 |
|
2490 | enterHotUpdate();
|
2491 | if (!React__default.forwardRef) {
|
2492 | return {
|
2493 | default: function _default(props) {
|
2494 | return React__default.createElement(
|
2495 | AppContainer,
|
2496 | null,
|
2497 | React__default.createElement(C, props)
|
2498 | );
|
2499 | }
|
2500 | };
|
2501 | }
|
2502 | return {
|
2503 | default: React__default.forwardRef(function (props, ref) {
|
2504 | return React__default.createElement(
|
2505 | AppContainer,
|
2506 | null,
|
2507 | React__default.createElement(C, _extends({}, props, { ref: ref }))
|
2508 | );
|
2509 | })
|
2510 | };
|
2511 | });
|
2512 | };
|
2513 | target[lazyConstructor].isPatchedByReactHotLoader = true;
|
2514 | }
|
2515 | };
|
2516 |
|
2517 | var updateLazy = function updateLazy(target, type) {
|
2518 | var ctor = type[lazyConstructor];
|
2519 | if (target[lazyConstructor] !== type[lazyConstructor]) {
|
2520 |
|
2521 | ctor();
|
2522 | }
|
2523 | patchLazyConstructor(target);
|
2524 | patchLazyConstructor(type);
|
2525 | };
|
2526 |
|
2527 | var updateMemo = function updateMemo(target, _ref) {
|
2528 | var type = _ref.type;
|
2529 |
|
2530 | target.type = resolveType(type);
|
2531 | };
|
2532 |
|
2533 | var updateForward = function updateForward(target, _ref2) {
|
2534 | var render = _ref2.render;
|
2535 |
|
2536 | target.render = render;
|
2537 | };
|
2538 |
|
2539 | var updateContext = function updateContext() {
|
2540 |
|
2541 | };
|
2542 |
|
2543 | var getInnerComponentType = function getInnerComponentType(component) {
|
2544 | var unwrapper = component[UNWRAP_PROXY];
|
2545 | return unwrapper ? unwrapper() : component;
|
2546 | };
|
2547 |
|
2548 | function haveEqualSignatures(prevType, nextType) {
|
2549 | try {
|
2550 | var prevSignature = getSignature(prevType);
|
2551 | var nextSignature = getSignature(nextType);
|
2552 |
|
2553 | if (prevSignature === undefined && nextSignature === undefined) {
|
2554 | return true;
|
2555 | }
|
2556 | if (prevSignature === undefined || nextSignature === undefined) {
|
2557 | return false;
|
2558 | }
|
2559 | if (prevSignature.key !== nextSignature.key) {
|
2560 | return false;
|
2561 | }
|
2562 |
|
2563 |
|
2564 |
|
2565 | var prevCustomHooks = prevSignature.getCustomHooks();
|
2566 | var nextCustomHooks = nextSignature.getCustomHooks();
|
2567 | if (prevCustomHooks.length !== nextCustomHooks.length) {
|
2568 | return false;
|
2569 | }
|
2570 |
|
2571 | for (var i = 0; i < nextCustomHooks.length; i++) {
|
2572 | if (!haveEqualSignatures(prevCustomHooks[i], nextCustomHooks[i])) {
|
2573 | return false;
|
2574 | }
|
2575 | }
|
2576 | } catch (e) {
|
2577 | logger.error('React-Hot-Loader: error occurred while comparing hook signature', e);
|
2578 | return false;
|
2579 | }
|
2580 |
|
2581 | return true;
|
2582 | }
|
2583 |
|
2584 | var areSignaturesCompatible = function areSignaturesCompatible(a, b) {
|
2585 |
|
2586 |
|
2587 |
|
2588 |
|
2589 |
|
2590 | if (!haveEqualSignatures(a, b)) {
|
2591 | logger.warn('⚛️🔥🎣 Hook order change detected: component', a, 'has been remounted');
|
2592 | return false;
|
2593 | }
|
2594 | return true;
|
2595 | };
|
2596 |
|
2597 | var compareRegistered = function compareRegistered(a, b) {
|
2598 | return getIdByType(a) === getIdByType(b) && getProxyByType(a) === getProxyByType(b) && areSignaturesCompatible(a, b);
|
2599 | };
|
2600 |
|
2601 | var areDeepSwappable = function areDeepSwappable(oldType, newType) {
|
2602 | var type = { type: oldType };
|
2603 |
|
2604 | if (typeof oldType === 'function') {
|
2605 | return areSwappable(oldType, newType);
|
2606 | }
|
2607 |
|
2608 | if (isForwardType(type)) {
|
2609 | return areDeepSwappable(oldType.render, newType.render);
|
2610 | }
|
2611 |
|
2612 | if (isMemoType(type)) {
|
2613 | return areDeepSwappable(oldType.type, newType.type);
|
2614 | }
|
2615 |
|
2616 |
|
2617 |
|
2618 |
|
2619 |
|
2620 |
|
2621 | return false;
|
2622 | };
|
2623 |
|
2624 | var compareComponents = function compareComponents(oldType, newType, setNewType, baseType) {
|
2625 | var defaultResult = oldType === newType;
|
2626 |
|
2627 | if (oldType && !newType || !oldType && newType || (typeof oldType === 'undefined' ? 'undefined' : _typeof(oldType)) !== (typeof newType === 'undefined' ? 'undefined' : _typeof(newType)) || getElementType(oldType) !== getElementType(newType) || 0) {
|
2628 | return defaultResult;
|
2629 | }
|
2630 |
|
2631 | if (getIdByType(newType) || getIdByType(oldType)) {
|
2632 | if (!compareRegistered(oldType, newType)) {
|
2633 | return false;
|
2634 | }
|
2635 | defaultResult = true;
|
2636 | }
|
2637 |
|
2638 | if (isForwardType({ type: oldType }) && isForwardType({ type: newType })) {
|
2639 | if (!compareRegistered(oldType.render, newType.render)) {
|
2640 | return false;
|
2641 | }
|
2642 | if (oldType.render === newType.render || areDeepSwappable(oldType, newType)) {
|
2643 | setNewType(newType);
|
2644 | return true;
|
2645 | }
|
2646 | return defaultResult;
|
2647 | }
|
2648 |
|
2649 | if (isMemoType({ type: oldType }) && isMemoType({ type: newType })) {
|
2650 | if (!compareRegistered(oldType.type, newType.type)) {
|
2651 | return false;
|
2652 | }
|
2653 | if (oldType.type === newType.type || areDeepSwappable(oldType, newType)) {
|
2654 | if (baseType) {
|
2655 |
|
2656 | if (baseType.$$typeof === newType.$$typeof) {
|
2657 | setNewType(newType);
|
2658 | } else {
|
2659 | setNewType(newType.type);
|
2660 | }
|
2661 | } else {
|
2662 | logger.warn('Please update hot-loader/react-dom');
|
2663 | if (isReactClass(newType.type)) {
|
2664 | setNewType(newType);
|
2665 | } else {
|
2666 | setNewType(newType.type);
|
2667 | }
|
2668 | }
|
2669 |
|
2670 | return true;
|
2671 | }
|
2672 | return defaultResult;
|
2673 | }
|
2674 |
|
2675 | if (isLazyType({ type: oldType })) {
|
2676 | updateLazy(oldType, newType);
|
2677 |
|
2678 |
|
2679 | return defaultResult;
|
2680 | }
|
2681 |
|
2682 | if (isContextType({ type: oldType })) {
|
2683 |
|
2684 | setNewType(newType);
|
2685 | return defaultResult;
|
2686 | }
|
2687 |
|
2688 | if (typeof newType === 'function' && (defaultResult || newType !== oldType && areSignaturesCompatible(newType, oldType) && areSwappable(newType, oldType))) {
|
2689 | var unwrapFactory = newType[UNWRAP_PROXY];
|
2690 | var oldProxy = unwrapFactory && getProxyByType(unwrapFactory());
|
2691 | if (oldProxy) {
|
2692 | oldProxy.dereference();
|
2693 | updateProxyById(oldType[PROXY_KEY] || getIdByType(oldType), getInnerComponentType(newType));
|
2694 | } else {
|
2695 | setNewType(newType);
|
2696 | }
|
2697 | return true;
|
2698 | }
|
2699 |
|
2700 | return defaultResult;
|
2701 | };
|
2702 |
|
2703 | var knownPairs = new WeakMap();
|
2704 | var emptyMap$1 = new WeakMap();
|
2705 |
|
2706 | var getKnownPair = function getKnownPair(oldType, newType) {
|
2707 | var pair = knownPairs.get(oldType) || emptyMap$1;
|
2708 | return pair.get(newType);
|
2709 | };
|
2710 |
|
2711 | var hotComponentCompare = function hotComponentCompare(oldType, preNewType, setNewType, baseType) {
|
2712 | var hotActive = hotComparisonOpen();
|
2713 | var newType = configuration.integratedResolver ? resolveType(preNewType) : preNewType;
|
2714 |
|
2715 |
|
2716 |
|
2717 |
|
2718 |
|
2719 |
|
2720 |
|
2721 |
|
2722 | var result = oldType === newType;
|
2723 |
|
2724 | if (hotActive) {
|
2725 |
|
2726 | if (!isReloadableComponent(oldType) || !isReloadableComponent(newType) || isColdType(oldType) || isColdType(oldType) || !oldType || !newType || 0) {
|
2727 | return result;
|
2728 | }
|
2729 |
|
2730 | result = compareComponents(oldType, newType, setNewType, baseType);
|
2731 | var pair = knownPairs.get(oldType) || new WeakMap();
|
2732 | pair.set(newType, result);
|
2733 | knownPairs.set(oldType, pair);
|
2734 | return result;
|
2735 | }
|
2736 |
|
2737 |
|
2738 | return result || getKnownPair(oldType, newType) || false;
|
2739 | };
|
2740 |
|
2741 |
|
2742 |
|
2743 | var forceSimpleSFC = { proxy: { pureSFC: true } };
|
2744 |
|
2745 | var hookWrapper = function hookWrapper(hook) {
|
2746 | var wrappedHook = function wrappedHook(cb, deps) {
|
2747 | if (configuration.reloadHooks && deps) {
|
2748 | var inputs = [].concat(deps);
|
2749 |
|
2750 |
|
2751 | if (configuration.reloadHooksOnBodyChange) {
|
2752 | inputs.push(String(cb));
|
2753 | }
|
2754 |
|
2755 | if (
|
2756 |
|
2757 | deps.length > 0 ||
|
2758 |
|
2759 | configuration.reloadLifeCycleHooks && deps.length === 0) {
|
2760 | inputs.push(getHotGeneration());
|
2761 | }
|
2762 |
|
2763 | return hook(cb, inputs);
|
2764 | }
|
2765 | return hook(cb, deps);
|
2766 | };
|
2767 | wrappedHook.isPatchedByReactHotLoader = true;
|
2768 | return wrappedHook;
|
2769 | };
|
2770 |
|
2771 | var noDeps = function noDeps() {
|
2772 | return [];
|
2773 | };
|
2774 |
|
2775 | var reactHotLoader = {
|
2776 | signature: function signature(type, key) {
|
2777 | var getCustomHooks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : noDeps;
|
2778 |
|
2779 | addSignature(type, { key: key, getCustomHooks: getCustomHooks });
|
2780 | return type;
|
2781 | },
|
2782 | register: function register(type, uniqueLocalName, fileName) {
|
2783 | var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
|
2784 |
|
2785 | var id = fileName + '#' + uniqueLocalName;
|
2786 |
|
2787 | if (isCompositeComponent(type) && typeof uniqueLocalName === 'string' && uniqueLocalName && typeof fileName === 'string' && fileName) {
|
2788 | var proxy = getProxyById(id);
|
2789 |
|
2790 | if (proxy && proxy.getCurrent() !== type) {
|
2791 | if (!configuration.IS_REACT_MERGE_ENABLED) {
|
2792 | if (isTypeBlacklisted(type) || isTypeBlacklisted(proxy.getCurrent())) {
|
2793 | logger.error('React-hot-loader: Cold component', uniqueLocalName, 'at', fileName, 'has been updated');
|
2794 | }
|
2795 | }
|
2796 | }
|
2797 |
|
2798 | if (configuration.onComponentRegister) {
|
2799 | configuration.onComponentRegister(type, uniqueLocalName, fileName);
|
2800 | }
|
2801 | if (configuration.onComponentCreate) {
|
2802 | configuration.onComponentCreate(type, getComponentDisplayName(type));
|
2803 | }
|
2804 |
|
2805 | registerComponent(updateProxyById(id, type, options).get(), 2);
|
2806 | registerComponent(type);
|
2807 | increment();
|
2808 | }
|
2809 | if (isContextType({ type: type })) {
|
2810 |
|
2811 | ['Provider', 'Consumer'].forEach(function (prop) {
|
2812 | var descriptor = Object.getOwnPropertyDescriptor(type, prop);
|
2813 | if (descriptor && descriptor.value) {
|
2814 | updateFunctionProxyById(id + ':' + prop, descriptor.value, updateContext);
|
2815 | }
|
2816 | });
|
2817 | updateFunctionProxyById(id, type, updateContext);
|
2818 | increment();
|
2819 | }
|
2820 | if (isLazyType({ type: type })) {
|
2821 | updateFunctionProxyById(id, type, updateLazy);
|
2822 | increment();
|
2823 | }
|
2824 | if (isForwardType({ type: type })) {
|
2825 | reactHotLoader.register(type.render, uniqueLocalName + ':render', fileName, forceSimpleSFC);
|
2826 | updateFunctionProxyById(id, type, updateForward);
|
2827 | increment();
|
2828 | }
|
2829 | if (isMemoType({ type: type })) {
|
2830 | reactHotLoader.register(type.type, uniqueLocalName + ':memo', fileName, forceSimpleSFC);
|
2831 | updateFunctionProxyById(id, type, updateMemo);
|
2832 | increment();
|
2833 | }
|
2834 | },
|
2835 | reset: function reset() {
|
2836 | resetProxies();
|
2837 | },
|
2838 | preact: function preact(instance) {
|
2839 | preactAdapter(instance, resolveType);
|
2840 | },
|
2841 | resolveType: function resolveType$$1(type) {
|
2842 | return resolveType(type);
|
2843 | },
|
2844 | patch: function patch(React$$1, ReactDOM$$1) {
|
2845 | var typeResolver = resolveType;
|
2846 |
|
2847 | if (ReactDOM$$1 && !ReactDOM$$1.render) {
|
2848 | logger.error('React-Hot-Loader: broken state detected, please import React-Hot-Loader before react-dom, see https://github.com/gaearon/react-hot-loader/issues/1315');
|
2849 | }
|
2850 | if (ReactDOM$$1 && ReactDOM$$1.setHotElementComparator) {
|
2851 | ReactDOM$$1.setHotElementComparator(hotComponentCompare);
|
2852 | configuration.disableHotRenderer = configuration.disableHotRendererWhenInjected;
|
2853 |
|
2854 | configuration.ignoreSFC = configuration.ignoreSFCWhenInjected;
|
2855 |
|
2856 | configuration.IS_REACT_MERGE_ENABLED = true;
|
2857 | configuration.showReactDomPatchNotification = false;
|
2858 | configuration.integratedComparator = true;
|
2859 |
|
2860 | if (ReactDOM$$1.setHotTypeResolver) {
|
2861 | configuration.integratedResolver = true;
|
2862 | typeResolver = resolveSimpleType;
|
2863 | ReactDOM$$1.setHotTypeResolver(resolveType);
|
2864 | }
|
2865 | }
|
2866 |
|
2867 |
|
2868 |
|
2869 |
|
2870 | if (!React$$1.createElement.isPatchedByReactHotLoader) {
|
2871 | var originalCreateElement = React$$1.createElement;
|
2872 |
|
2873 |
|
2874 |
|
2875 | React$$1.createElement = function (type) {
|
2876 | for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
2877 | args[_key - 1] = arguments[_key];
|
2878 | }
|
2879 |
|
2880 | return originalCreateElement.apply(undefined, [typeResolver(type)].concat(args));
|
2881 | };
|
2882 | React$$1.createElement.isPatchedByReactHotLoader = true;
|
2883 | }
|
2884 |
|
2885 | if (!React$$1.cloneElement.isPatchedByReactHotLoader) {
|
2886 | var originalCloneElement = React$$1.cloneElement;
|
2887 |
|
2888 | React$$1.cloneElement = function (element) {
|
2889 | for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
2890 | args[_key2 - 1] = arguments[_key2];
|
2891 | }
|
2892 |
|
2893 | var newType = element.type && typeResolver(element.type);
|
2894 | if (newType && newType !== element.type) {
|
2895 | return originalCloneElement.apply(undefined, [_extends({}, element, {
|
2896 | type: newType
|
2897 | })].concat(args));
|
2898 | }
|
2899 | return originalCloneElement.apply(undefined, [element].concat(args));
|
2900 | };
|
2901 |
|
2902 | React$$1.cloneElement.isPatchedByReactHotLoader = true;
|
2903 | }
|
2904 |
|
2905 | if (!React$$1.createFactory.isPatchedByReactHotLoader) {
|
2906 |
|
2907 |
|
2908 |
|
2909 | React$$1.createFactory = function (type) {
|
2910 | var factory = React$$1.createElement.bind(null, type);
|
2911 | factory.type = type;
|
2912 | return factory;
|
2913 | };
|
2914 | React$$1.createFactory.isPatchedByReactHotLoader = true;
|
2915 | }
|
2916 |
|
2917 | if (!React$$1.Children.only.isPatchedByReactHotLoader) {
|
2918 | var originalChildrenOnly = React$$1.Children.only;
|
2919 |
|
2920 | React$$1.Children.only = function (children) {
|
2921 | return originalChildrenOnly(_extends({}, children, {
|
2922 | type: typeResolver(children.type)
|
2923 | }));
|
2924 | };
|
2925 | React$$1.Children.only.isPatchedByReactHotLoader = true;
|
2926 | }
|
2927 |
|
2928 |
|
2929 |
|
2930 | if (React$$1.useEffect && !React$$1.useEffect.isPatchedByReactHotLoader) {
|
2931 | React$$1.useEffect = hookWrapper(React$$1.useEffect);
|
2932 | React$$1.useLayoutEffect = hookWrapper(React$$1.useLayoutEffect);
|
2933 | React$$1.useCallback = hookWrapper(React$$1.useCallback);
|
2934 | React$$1.useMemo = hookWrapper(React$$1.useMemo);
|
2935 |
|
2936 |
|
2937 | var useContext = React$$1.useContext;
|
2938 |
|
2939 | React$$1.useContext = function (context) {
|
2940 | for (var _len3 = arguments.length, args = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
|
2941 | args[_key3 - 1] = arguments[_key3];
|
2942 | }
|
2943 |
|
2944 | return useContext.apply(undefined, [typeResolver(context)].concat(args));
|
2945 | };
|
2946 | }
|
2947 |
|
2948 |
|
2949 | }
|
2950 | };
|
2951 |
|
2952 | var openedModules = {};
|
2953 | var lastModuleOpened = '';
|
2954 | var getLastModuleOpened = function getLastModuleOpened() {
|
2955 | return lastModuleOpened;
|
2956 | };
|
2957 |
|
2958 | var hotModules = {};
|
2959 |
|
2960 | var createHotModule = function createHotModule() {
|
2961 | return { instances: [], updateTimeout: 0 };
|
2962 | };
|
2963 |
|
2964 | var hotModule = function hotModule(moduleId) {
|
2965 | if (!hotModules[moduleId]) {
|
2966 | hotModules[moduleId] = createHotModule();
|
2967 | }
|
2968 | return hotModules[moduleId];
|
2969 | };
|
2970 |
|
2971 | var isOpened = function isOpened(sourceModule) {
|
2972 | return sourceModule && !!openedModules[sourceModule.id];
|
2973 | };
|
2974 |
|
2975 | var enter = function enter(sourceModule) {
|
2976 | if (sourceModule && sourceModule.id) {
|
2977 | lastModuleOpened = sourceModule.id;
|
2978 | openedModules[sourceModule.id] = true;
|
2979 | } else {
|
2980 | logger.warn('React-hot-loader: no `module` variable found. Did you shadow a system variable?');
|
2981 | }
|
2982 | };
|
2983 |
|
2984 | var leave = function leave(sourceModule) {
|
2985 | if (sourceModule && sourceModule.id) {
|
2986 | delete openedModules[sourceModule.id];
|
2987 | }
|
2988 | };
|
2989 |
|
2990 | var createQueue = function createQueue() {
|
2991 | var runner = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function (a) {
|
2992 | return a();
|
2993 | };
|
2994 |
|
2995 | var promise = void 0;
|
2996 | var queue = [];
|
2997 |
|
2998 | var runAll = function runAll() {
|
2999 | var oldQueue = queue;
|
3000 | oldQueue.forEach(function (cb) {
|
3001 | return cb();
|
3002 | });
|
3003 | queue = [];
|
3004 | };
|
3005 |
|
3006 | var add = function add(cb) {
|
3007 | if (queue.length === 0) {
|
3008 | promise = Promise.resolve().then(function () {
|
3009 | return runner(runAll);
|
3010 | });
|
3011 | }
|
3012 | queue.push(cb);
|
3013 |
|
3014 | return promise;
|
3015 | };
|
3016 |
|
3017 | return add;
|
3018 | };
|
3019 |
|
3020 |
|
3021 | var requireIndirect = typeof __webpack_require__ !== 'undefined' ? __webpack_require__ : require;
|
3022 |
|
3023 |
|
3024 | var chargeFailbackTimer = function chargeFailbackTimer(id) {
|
3025 | return setTimeout(function () {
|
3026 | var error = 'hot update failed for module "' + id + '". Last file processed: "' + getLastModuleOpened() + '".';
|
3027 | logger.error(error);
|
3028 | logException({
|
3029 | toString: function toString() {
|
3030 | return error;
|
3031 | }
|
3032 | });
|
3033 |
|
3034 | }, 100);
|
3035 | };
|
3036 |
|
3037 | var clearFailbackTimer = function clearFailbackTimer(timerId) {
|
3038 | return clearTimeout(timerId);
|
3039 | };
|
3040 |
|
3041 | var createHoc = function createHoc(SourceComponent, TargetComponent) {
|
3042 | hoistNonReactStatic(TargetComponent, SourceComponent);
|
3043 | TargetComponent.displayName = 'HotExported' + getComponentDisplayName(SourceComponent);
|
3044 | return TargetComponent;
|
3045 | };
|
3046 |
|
3047 | var runInRequireQueue = createQueue();
|
3048 | var runInRenderQueue = createQueue(function (cb) {
|
3049 | if (ReactDOM.unstable_batchedUpdates) {
|
3050 | ReactDOM.unstable_batchedUpdates(cb);
|
3051 | } else {
|
3052 | cb();
|
3053 | }
|
3054 | });
|
3055 |
|
3056 | var makeHotExport = function makeHotExport(sourceModule, moduleId) {
|
3057 | var updateInstances = function updateInstances(possibleError) {
|
3058 | if (possibleError && possibleError instanceof Error) {
|
3059 | console.error(possibleError);
|
3060 | return;
|
3061 | }
|
3062 | var module = hotModule(moduleId);
|
3063 |
|
3064 | var deepUpdate = function deepUpdate() {
|
3065 |
|
3066 | runInRenderQueue(function () {
|
3067 | enterHotUpdate();
|
3068 | var gen = getHotGeneration();
|
3069 | module.instances.forEach(function (inst) {
|
3070 | return inst.forceUpdate();
|
3071 | });
|
3072 |
|
3073 | if (configuration.trackTailUpdates) {
|
3074 | var runLimit = 0;
|
3075 | var checkTailUpdates = function checkTailUpdates() {
|
3076 | setTimeout(function () {
|
3077 | if (getHotGeneration() !== gen) {
|
3078 |
|
3079 |
|
3080 |
|
3081 | logger.warn('React-Hot-Loader: some components were updated out-of-bound. Updating your app to reconcile the changes.');
|
3082 | deepUpdate();
|
3083 | } else if (++runLimit < 5) {
|
3084 | checkTailUpdates();
|
3085 | }
|
3086 | }, 16);
|
3087 | };
|
3088 |
|
3089 | checkTailUpdates();
|
3090 | }
|
3091 | });
|
3092 | };
|
3093 |
|
3094 |
|
3095 | runInRequireQueue(function () {
|
3096 | try {
|
3097 |
|
3098 |
|
3099 | requireIndirect(moduleId);
|
3100 | } catch (e) {
|
3101 | console.error('React-Hot-Loader: error detected while loading', moduleId);
|
3102 | console.error(e);
|
3103 | }
|
3104 | }).then(deepUpdate);
|
3105 | };
|
3106 |
|
3107 | if (sourceModule.hot) {
|
3108 |
|
3109 |
|
3110 | sourceModule.hot.accept(updateInstances);
|
3111 |
|
3112 |
|
3113 | if (sourceModule.hot.addStatusHandler) {
|
3114 | if (sourceModule.hot.status() === 'idle') {
|
3115 | sourceModule.hot.addStatusHandler(function (status) {
|
3116 | if (status === 'apply') {
|
3117 | clearExceptions();
|
3118 | updateInstances();
|
3119 | }
|
3120 | });
|
3121 | }
|
3122 | }
|
3123 | } else {
|
3124 | logger.warn('React-hot-loader: Hot Module Replacement is not enabled');
|
3125 | }
|
3126 | };
|
3127 |
|
3128 | var hot = function hot(sourceModule) {
|
3129 | if (!sourceModule) {
|
3130 |
|
3131 | throw new Error('React-hot-loader: `hot` was called without any argument provided');
|
3132 | }
|
3133 | var moduleId = sourceModule.id || sourceModule.i || sourceModule.filename;
|
3134 | if (!moduleId) {
|
3135 | console.error('`module` provided', sourceModule);
|
3136 | throw new Error('React-hot-loader: `hot` could not find the `name` of the the `module` you have provided');
|
3137 | }
|
3138 | var module = hotModule(moduleId);
|
3139 | makeHotExport(sourceModule, moduleId);
|
3140 |
|
3141 | clearExceptions();
|
3142 | var failbackTimer = chargeFailbackTimer(moduleId);
|
3143 | var firstHotRegistered = false;
|
3144 |
|
3145 |
|
3146 |
|
3147 | return function (WrappedComponent, props) {
|
3148 | clearFailbackTimer(failbackTimer);
|
3149 |
|
3150 |
|
3151 | if (!firstHotRegistered) {
|
3152 | firstHotRegistered = true;
|
3153 | reactHotLoader.register(WrappedComponent, getComponentDisplayName(WrappedComponent), 'RHL' + moduleId);
|
3154 | }
|
3155 |
|
3156 | return createHoc(WrappedComponent, function (_Component) {
|
3157 | inherits(ExportedComponent, _Component);
|
3158 |
|
3159 | function ExportedComponent() {
|
3160 | classCallCheck(this, ExportedComponent);
|
3161 | return possibleConstructorReturn(this, _Component.apply(this, arguments));
|
3162 | }
|
3163 |
|
3164 | ExportedComponent.prototype.componentDidMount = function componentDidMount() {
|
3165 | module.instances.push(this);
|
3166 | };
|
3167 |
|
3168 | ExportedComponent.prototype.componentWillUnmount = function componentWillUnmount() {
|
3169 | var _this2 = this;
|
3170 |
|
3171 | if (isOpened(sourceModule)) {
|
3172 | var componentName = getComponentDisplayName(WrappedComponent);
|
3173 | logger.error('React-hot-loader: Detected AppContainer unmount on module \'' + moduleId + '\' update.\n' + ('Did you use "hot(' + componentName + ')" and "ReactDOM.render()" in the same file?\n') + ('"hot(' + componentName + ')" shall only be used as export.\n') + 'Please refer to "Getting Started" (https://github.com/gaearon/react-hot-loader/).');
|
3174 | }
|
3175 | module.instances = module.instances.filter(function (a) {
|
3176 | return a !== _this2;
|
3177 | });
|
3178 | };
|
3179 |
|
3180 | ExportedComponent.prototype.render = function render() {
|
3181 | return React__default.createElement(
|
3182 | AppContainer,
|
3183 | props,
|
3184 | React__default.createElement(WrappedComponent, this.props)
|
3185 | );
|
3186 | };
|
3187 |
|
3188 | return ExportedComponent;
|
3189 | }(React.Component));
|
3190 | };
|
3191 | };
|
3192 |
|
3193 | var getProxyOrType = function getProxyOrType(type) {
|
3194 | var proxy = getProxyByType(type);
|
3195 | return proxy ? proxy.get() : type;
|
3196 | };
|
3197 |
|
3198 | var areComponentsEqual = function areComponentsEqual(a, b) {
|
3199 | return getProxyOrType(a) === getProxyOrType(b);
|
3200 | };
|
3201 |
|
3202 | var compareOrSwap = function compareOrSwap(oldType, newType) {
|
3203 | return hotComponentCompare(oldType, newType);
|
3204 | };
|
3205 |
|
3206 | var cold = function cold(type) {
|
3207 | blacklistByType(type);
|
3208 | return type;
|
3209 | };
|
3210 |
|
3211 | var configureComponent = function configureComponent(component, options) {
|
3212 | return setComponentOptions(component, options);
|
3213 | };
|
3214 |
|
3215 | var setConfig = function setConfig(config) {
|
3216 | return setConfiguration(config);
|
3217 | };
|
3218 |
|
3219 | reactHotLoader.patch(React__default, ReactDOM);
|
3220 |
|
3221 | exports.default = reactHotLoader;
|
3222 | exports.AppContainer = AppContainer;
|
3223 | exports.hot = hot;
|
3224 | exports.enterModule = enter;
|
3225 | exports.leaveModule = leave;
|
3226 | exports.areComponentsEqual = areComponentsEqual;
|
3227 | exports.compareOrSwap = compareOrSwap;
|
3228 | exports.cold = cold;
|
3229 | exports.configureComponent = configureComponent;
|
3230 | exports.setConfig = setConfig;
|