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 ReactDOM = _interopDefault(require('react-dom'));
|
11 | var levenshtein = _interopDefault(require('fast-levenshtein'));
|
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 getContextProvider = function getContextProvider(type) {
|
155 | return type && type._context;
|
156 | };
|
157 |
|
158 | var configuration = {
|
159 |
|
160 | logLevel: 'error',
|
161 |
|
162 |
|
163 | pureSFC: true,
|
164 |
|
165 |
|
166 | pureRender: true,
|
167 |
|
168 |
|
169 | allowSFC: true,
|
170 |
|
171 |
|
172 | disableHotRenderer: false,
|
173 |
|
174 |
|
175 | disableHotRendererWhenInjected: false,
|
176 |
|
177 |
|
178 | onComponentRegister: false,
|
179 |
|
180 |
|
181 | onComponentCreate: false,
|
182 |
|
183 |
|
184 | ignoreSFC: false,
|
185 |
|
186 |
|
187 | ignoreSFCWhenInjected: true,
|
188 |
|
189 |
|
190 | ignoreComponents: false,
|
191 |
|
192 |
|
193 | errorReporter: undefined,
|
194 |
|
195 |
|
196 | ErrorOverlay: undefined
|
197 | };
|
198 |
|
199 | var internalConfiguration = {
|
200 |
|
201 | disableProxyCreation: false
|
202 | };
|
203 |
|
204 |
|
205 |
|
206 | var logger = {
|
207 | debug: function debug() {
|
208 | if (['debug'].indexOf(configuration.logLevel) !== -1) {
|
209 | var _console;
|
210 |
|
211 | (_console = console).debug.apply(_console, arguments);
|
212 | }
|
213 | },
|
214 | log: function log() {
|
215 | if (['debug', 'log'].indexOf(configuration.logLevel) !== -1) {
|
216 | var _console2;
|
217 |
|
218 | (_console2 = console).log.apply(_console2, arguments);
|
219 | }
|
220 | },
|
221 | warn: function warn() {
|
222 | if (['debug', 'log', 'warn'].indexOf(configuration.logLevel) !== -1) {
|
223 | var _console3;
|
224 |
|
225 | (_console3 = console).warn.apply(_console3, arguments);
|
226 | }
|
227 | },
|
228 | error: function error() {
|
229 | if (['debug', 'log', 'warn', 'error'].indexOf(configuration.logLevel) !== -1) {
|
230 | var _console4;
|
231 |
|
232 | (_console4 = console).error.apply(_console4, arguments);
|
233 | }
|
234 | }
|
235 | };
|
236 |
|
237 |
|
238 |
|
239 | function safeReactConstructor(Component, lastInstance) {
|
240 | try {
|
241 | if (lastInstance) {
|
242 | return new Component(lastInstance.props, lastInstance.context);
|
243 | }
|
244 | return new Component({}, {});
|
245 | } catch (e) {
|
246 |
|
247 | }
|
248 | return null;
|
249 | }
|
250 |
|
251 | function isNativeFunction(fn) {
|
252 | return typeof fn === 'function' ? fn.toString().indexOf('[native code]') > 0 : false;
|
253 | }
|
254 |
|
255 | var identity = function identity(a) {
|
256 | return a;
|
257 | };
|
258 | var indirectEval = eval;
|
259 |
|
260 | var doesSupportClasses = function () {
|
261 | try {
|
262 | indirectEval('class Test {}');
|
263 | return true;
|
264 | } catch (e) {
|
265 | return false;
|
266 | }
|
267 | }();
|
268 |
|
269 | var ES6ProxyComponentFactory = function ES6ProxyComponentFactory(InitialParent, postConstructionAction) {
|
270 | return indirectEval('\n(function(InitialParent, postConstructionAction) {\n return class ' + (InitialParent.name || 'HotComponent') + ' extends InitialParent {\n constructor(props, context) {\n super(props, context)\n postConstructionAction.call(this)\n }\n }\n})\n')(InitialParent, postConstructionAction);
|
271 | };
|
272 |
|
273 | var ES5ProxyComponentFactory = function ES5ProxyComponentFactory(InitialParent, postConstructionAction) {
|
274 | function ProxyComponent(props, context) {
|
275 | InitialParent.call(this, props, context);
|
276 | postConstructionAction.call(this);
|
277 | }
|
278 | ProxyComponent.prototype = Object.create(InitialParent.prototype);
|
279 | Object.setPrototypeOf(ProxyComponent, InitialParent);
|
280 | return ProxyComponent;
|
281 | };
|
282 |
|
283 | var proxyClassCreator = doesSupportClasses ? ES6ProxyComponentFactory : ES5ProxyComponentFactory;
|
284 |
|
285 | function getOwnKeys(target) {
|
286 | return [].concat(Object.getOwnPropertyNames(target), Object.getOwnPropertySymbols(target));
|
287 | }
|
288 |
|
289 | function shallowStringsEqual(a, b) {
|
290 | for (var key in a) {
|
291 | if (String(a[key]) !== String(b[key])) {
|
292 | return false;
|
293 | }
|
294 | }
|
295 | return true;
|
296 | }
|
297 |
|
298 | function deepPrototypeUpdate(dest, source) {
|
299 | var deepDest = Object.getPrototypeOf(dest);
|
300 | var deepSrc = Object.getPrototypeOf(source);
|
301 | if (deepDest && deepSrc && deepSrc !== deepDest) {
|
302 | deepPrototypeUpdate(deepDest, deepSrc);
|
303 | }
|
304 | if (source.prototype && source.prototype !== dest.prototype) {
|
305 | dest.prototype = source.prototype;
|
306 | }
|
307 | }
|
308 |
|
309 | function safeDefineProperty(target, key, props) {
|
310 | try {
|
311 | Object.defineProperty(target, key, props);
|
312 | } catch (e) {
|
313 | logger.warn('Error while wrapping', key, ' -> ', e);
|
314 | }
|
315 | }
|
316 |
|
317 | var PREFIX = '__reactstandin__';
|
318 | var PROXY_KEY = PREFIX + 'key';
|
319 | var GENERATION = PREFIX + 'proxyGeneration';
|
320 | var REGENERATE_METHOD = PREFIX + 'regenerateByEval';
|
321 | var UNWRAP_PROXY = PREFIX + 'getCurrent';
|
322 | var CACHED_RESULT = PREFIX + 'cachedResult';
|
323 | var PROXY_IS_MOUNTED = PREFIX + 'isMounted';
|
324 |
|
325 | var RENDERED_GENERATION = 'REACT_HOT_LOADER_RENDERED_GENERATION';
|
326 |
|
327 | var RESERVED_STATICS = ['length', 'displayName', 'name', 'arguments', 'caller', 'prototype', 'toString', 'valueOf', 'isStatelessFunctionalProxy', PROXY_KEY, UNWRAP_PROXY];
|
328 |
|
329 | function transferStaticProps(ProxyComponent, savedDescriptors, PreviousComponent, NextComponent) {
|
330 | Object.getOwnPropertyNames(ProxyComponent).forEach(function (key) {
|
331 | if (RESERVED_STATICS.indexOf(key) !== -1) {
|
332 | return;
|
333 | }
|
334 |
|
335 | var prevDescriptor = Object.getOwnPropertyDescriptor(ProxyComponent, key);
|
336 | var savedDescriptor = savedDescriptors[key];
|
337 |
|
338 | if (!shallowEqual(prevDescriptor, savedDescriptor)) {
|
339 | safeDefineProperty(NextComponent, key, prevDescriptor);
|
340 | }
|
341 | });
|
342 |
|
343 |
|
344 | Object.getOwnPropertyNames(NextComponent).forEach(function (key) {
|
345 | if (RESERVED_STATICS.indexOf(key) !== -1) {
|
346 | return;
|
347 | }
|
348 |
|
349 | var prevDescriptor = PreviousComponent && Object.getOwnPropertyDescriptor(ProxyComponent, key);
|
350 | var savedDescriptor = savedDescriptors[key];
|
351 |
|
352 |
|
353 | if (prevDescriptor && savedDescriptor && !shallowEqual(savedDescriptor, prevDescriptor)) {
|
354 | safeDefineProperty(NextComponent, key, prevDescriptor);
|
355 | return;
|
356 | }
|
357 |
|
358 | if (prevDescriptor && !savedDescriptor) {
|
359 | safeDefineProperty(ProxyComponent, key, prevDescriptor);
|
360 | return;
|
361 | }
|
362 |
|
363 | var nextDescriptor = _extends({}, Object.getOwnPropertyDescriptor(NextComponent, key), {
|
364 | configurable: true
|
365 | });
|
366 |
|
367 | savedDescriptors[key] = nextDescriptor;
|
368 | safeDefineProperty(ProxyComponent, key, nextDescriptor);
|
369 | });
|
370 |
|
371 |
|
372 | Object.getOwnPropertyNames(ProxyComponent).forEach(function (key) {
|
373 | if (RESERVED_STATICS.indexOf(key) !== -1) {
|
374 | return;
|
375 | }
|
376 |
|
377 | if (NextComponent.hasOwnProperty(key)) {
|
378 | return;
|
379 | }
|
380 |
|
381 | var proxyDescriptor = Object.getOwnPropertyDescriptor(ProxyComponent, key);
|
382 | if (proxyDescriptor && !proxyDescriptor.configurable) {
|
383 | return;
|
384 | }
|
385 |
|
386 | var prevDescriptor = PreviousComponent && Object.getOwnPropertyDescriptor(PreviousComponent, key);
|
387 | var savedDescriptor = savedDescriptors[key];
|
388 |
|
389 |
|
390 | if (prevDescriptor && savedDescriptor && !shallowEqual(savedDescriptor, prevDescriptor)) {
|
391 | return;
|
392 | }
|
393 |
|
394 | safeDefineProperty(ProxyComponent, key, {
|
395 | value: undefined
|
396 | });
|
397 | });
|
398 |
|
399 | return savedDescriptors;
|
400 | }
|
401 |
|
402 | function mergeComponents(ProxyComponent, NextComponent, InitialComponent, lastInstance, injectedMembers) {
|
403 | var injectedCode = {};
|
404 | try {
|
405 | var nextInstance = safeReactConstructor(NextComponent, lastInstance);
|
406 |
|
407 | try {
|
408 |
|
409 | deepPrototypeUpdate(InitialComponent, NextComponent);
|
410 | } catch (e) {
|
411 |
|
412 | }
|
413 |
|
414 | var proxyInstance = safeReactConstructor(ProxyComponent, lastInstance);
|
415 |
|
416 | if (!nextInstance || !proxyInstance) {
|
417 | return injectedCode;
|
418 | }
|
419 |
|
420 | var mergedAttrs = _extends({}, proxyInstance, nextInstance);
|
421 | var hasRegenerate = proxyInstance[REGENERATE_METHOD];
|
422 | var ownKeys = getOwnKeys(Object.getPrototypeOf(ProxyComponent.prototype));
|
423 | Object.keys(mergedAttrs).forEach(function (key) {
|
424 | if (key.indexOf(PREFIX) === 0) return;
|
425 | var nextAttr = nextInstance[key];
|
426 | var prevAttr = proxyInstance[key];
|
427 | if (nextAttr) {
|
428 | if (isNativeFunction(nextAttr) || isNativeFunction(prevAttr)) {
|
429 |
|
430 | var isSameArity = nextAttr.length === prevAttr.length;
|
431 | var existsInPrototype = ownKeys.indexOf(key) >= 0 || ProxyComponent.prototype[key];
|
432 | if ((isSameArity || !prevAttr) && existsInPrototype) {
|
433 | if (hasRegenerate) {
|
434 | injectedCode[key] = 'Object.getPrototypeOf(this)[\'' + key + '\'].bind(this)';
|
435 | } else {
|
436 | logger.warn('React Hot Loader:,', 'Non-controlled class', ProxyComponent.name, 'contains a new native or bound function ', key, nextAttr, '. Unable to reproduce');
|
437 | }
|
438 | } else {
|
439 | 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'));
|
440 | }
|
441 | return;
|
442 | }
|
443 |
|
444 | var nextString = String(nextAttr);
|
445 | var injectedBefore = injectedMembers[key];
|
446 | var isArrow = nextString.indexOf('=>') >= 0;
|
447 | var isFunction = nextString.indexOf('function') >= 0 || isArrow;
|
448 | var referToThis = nextString.indexOf('this') >= 0;
|
449 | if (nextString !== String(prevAttr) || injectedBefore && nextString !== String(injectedBefore) || isArrow && referToThis) {
|
450 | if (!hasRegenerate) {
|
451 | if (!isFunction) {
|
452 |
|
453 | injectedCode[key] = nextAttr;
|
454 | } else {
|
455 | logger.warn('React Hot Loader:', ' Updated class ', ProxyComponent.name, 'had different code for', key, nextAttr, '. Unable to reproduce. Regeneration support needed.');
|
456 | }
|
457 | } else {
|
458 | injectedCode[key] = nextAttr;
|
459 | }
|
460 | }
|
461 | }
|
462 | });
|
463 | } catch (e) {
|
464 | logger.warn('React Hot Loader:', e);
|
465 | }
|
466 | return injectedCode;
|
467 | }
|
468 |
|
469 | function checkLifeCycleMethods(ProxyComponent, NextComponent) {
|
470 | try {
|
471 | var p1 = Object.getPrototypeOf(ProxyComponent.prototype);
|
472 | var p2 = NextComponent.prototype;
|
473 | reactLifeCycleMountMethods.forEach(function (key) {
|
474 | var d1 = Object.getOwnPropertyDescriptor(p1, key) || { value: p1[key] };
|
475 | var d2 = Object.getOwnPropertyDescriptor(p2, key) || { value: p2[key] };
|
476 | if (!shallowStringsEqual(d1, d2)) {
|
477 | logger.warn('React Hot Loader:', 'You did update', ProxyComponent.name, 's lifecycle method', key, '. Unable to repeat');
|
478 | }
|
479 | });
|
480 | } catch (e) {
|
481 |
|
482 | }
|
483 | }
|
484 |
|
485 | function inject(target, currentGeneration, injectedMembers) {
|
486 | if (target[GENERATION] !== currentGeneration) {
|
487 | var hasRegenerate = !!target[REGENERATE_METHOD];
|
488 | Object.keys(injectedMembers).forEach(function (key) {
|
489 | try {
|
490 | if (hasRegenerate) {
|
491 | var usedThis = String(injectedMembers[key]).match(/_this([\d]+)/gi) || [];
|
492 | target[REGENERATE_METHOD](key, '(function REACT_HOT_LOADER_SANDBOX () {\n var _this = this; // common babel transpile\n ' + usedThis.map(function (name) {
|
493 | return 'var ' + name + ' = this;';
|
494 | }) + '\n\n return ' + injectedMembers[key] + ';\n }).call(this)');
|
495 | } else {
|
496 | target[key] = injectedMembers[key];
|
497 | }
|
498 | } catch (e) {
|
499 | logger.warn('React Hot Loader: Failed to regenerate method ', key, ' of class ', target);
|
500 | logger.warn('got error', e);
|
501 | }
|
502 | });
|
503 |
|
504 | target[GENERATION] = currentGeneration;
|
505 | }
|
506 | }
|
507 |
|
508 | var has = Object.prototype.hasOwnProperty;
|
509 |
|
510 | var proxies = new WeakMap();
|
511 |
|
512 | var resetClassProxies = function resetClassProxies() {
|
513 | proxies = new WeakMap();
|
514 | };
|
515 |
|
516 | var blackListedClassMembers = ['constructor', 'render', 'componentWillMount', 'componentDidMount', 'componentDidCatch', 'componentWillReceiveProps', 'componentWillUnmount', 'hotComponentRender', 'getInitialState', 'getDefaultProps'];
|
517 |
|
518 | var defaultRenderOptions = {
|
519 | componentWillRender: identity,
|
520 | componentDidUpdate: function componentDidUpdate(result) {
|
521 | return result;
|
522 | },
|
523 | componentDidRender: function componentDidRender(result) {
|
524 | return result;
|
525 | }
|
526 | };
|
527 |
|
528 | var filteredPrototypeMethods = function filteredPrototypeMethods(Proto) {
|
529 | return Object.getOwnPropertyNames(Proto).filter(function (prop) {
|
530 | var descriptor = Object.getOwnPropertyDescriptor(Proto, prop);
|
531 | return descriptor && prop.indexOf(PREFIX) !== 0 && blackListedClassMembers.indexOf(prop) < 0 && typeof descriptor.value === 'function';
|
532 | });
|
533 | };
|
534 |
|
535 | var defineClassMember = function defineClassMember(Class, methodName, methodBody) {
|
536 | return safeDefineProperty(Class.prototype, methodName, {
|
537 | configurable: true,
|
538 | writable: true,
|
539 | enumerable: false,
|
540 | value: methodBody
|
541 | });
|
542 | };
|
543 |
|
544 | var defineClassMembers = function defineClassMembers(Class, methods) {
|
545 | return Object.keys(methods).forEach(function (methodName) {
|
546 | return defineClassMember(Class, methodName, methods[methodName]);
|
547 | });
|
548 | };
|
549 |
|
550 | var setSFPFlag = function setSFPFlag(component, flag) {
|
551 | return safeDefineProperty(component, 'isStatelessFunctionalProxy', {
|
552 | configurable: false,
|
553 | writable: false,
|
554 | enumerable: false,
|
555 | value: flag
|
556 | });
|
557 | };
|
558 |
|
559 | var copyMethodDescriptors = function copyMethodDescriptors(target, source) {
|
560 | if (source) {
|
561 |
|
562 | var keys = Object.getOwnPropertyNames(source);
|
563 |
|
564 | keys.forEach(function (key) {
|
565 | return safeDefineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
|
566 | });
|
567 |
|
568 | safeDefineProperty(target, 'toString', {
|
569 | configurable: true,
|
570 | writable: false,
|
571 | enumerable: false,
|
572 | value: function toString() {
|
573 | return String(source);
|
574 | }
|
575 | });
|
576 | }
|
577 |
|
578 | return target;
|
579 | };
|
580 |
|
581 | var knownClassComponents = [];
|
582 |
|
583 | var forEachKnownClass = function forEachKnownClass(cb) {
|
584 | return knownClassComponents.forEach(cb);
|
585 | };
|
586 |
|
587 | function createClassProxy(InitialComponent, proxyKey) {
|
588 | var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
589 |
|
590 | var renderOptions = _extends({}, defaultRenderOptions, options);
|
591 | var proxyConfig = _extends({}, configuration, options.proxy);
|
592 |
|
593 |
|
594 | var existingProxy = proxies.get(InitialComponent);
|
595 |
|
596 | if (existingProxy) {
|
597 | return existingProxy;
|
598 | }
|
599 |
|
600 | var CurrentComponent = void 0;
|
601 | var savedDescriptors = {};
|
602 | var injectedMembers = {};
|
603 | var proxyGeneration = 0;
|
604 | var classUpdatePostponed = null;
|
605 | var instancesCount = 0;
|
606 | var isFunctionalComponent = !isReactClass(InitialComponent);
|
607 |
|
608 | var lastInstance = null;
|
609 |
|
610 | function postConstructionAction() {
|
611 | this[GENERATION] = 0;
|
612 |
|
613 | lastInstance = this;
|
614 |
|
615 | if (classUpdatePostponed) {
|
616 | var callUpdate = classUpdatePostponed;
|
617 | classUpdatePostponed = null;
|
618 | callUpdate();
|
619 | }
|
620 |
|
621 |
|
622 | inject(this, proxyGeneration, injectedMembers);
|
623 | }
|
624 |
|
625 | function proxiedUpdate() {
|
626 | if (this) {
|
627 | inject(this, proxyGeneration, injectedMembers);
|
628 | }
|
629 | }
|
630 |
|
631 | function lifeCycleWrapperFactory(wrapperName) {
|
632 | var sideEffect = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
|
633 |
|
634 | return copyMethodDescriptors(function wrappedMethod() {
|
635 | proxiedUpdate.call(this);
|
636 | sideEffect(this);
|
637 |
|
638 | for (var _len = arguments.length, rest = Array(_len), _key = 0; _key < _len; _key++) {
|
639 | rest[_key] = arguments[_key];
|
640 | }
|
641 |
|
642 | return !isFunctionalComponent && CurrentComponent.prototype[wrapperName] && CurrentComponent.prototype[wrapperName].apply(this, rest);
|
643 | }, InitialComponent.prototype && InitialComponent.prototype[wrapperName]);
|
644 | }
|
645 |
|
646 | function methodWrapperFactory(wrapperName, realMethod) {
|
647 | return copyMethodDescriptors(function wrappedMethod() {
|
648 | for (var _len2 = arguments.length, rest = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
649 | rest[_key2] = arguments[_key2];
|
650 | }
|
651 |
|
652 | return realMethod.apply(this, rest);
|
653 | }, realMethod);
|
654 | }
|
655 |
|
656 | var fakeBasePrototype = function fakeBasePrototype(Proto) {
|
657 | return filteredPrototypeMethods(Proto).reduce(function (acc, key) {
|
658 | acc[key] = methodWrapperFactory(key, Proto[key]);
|
659 | return acc;
|
660 | }, {});
|
661 | };
|
662 |
|
663 | var componentDidMount = lifeCycleWrapperFactory('componentDidMount', function (target) {
|
664 | target[PROXY_IS_MOUNTED] = true;
|
665 | target[RENDERED_GENERATION] = get$1();
|
666 | instancesCount++;
|
667 | });
|
668 | var componentDidUpdate = lifeCycleWrapperFactory('componentDidUpdate', renderOptions.componentDidUpdate);
|
669 | var componentWillUnmount = lifeCycleWrapperFactory('componentWillUnmount', function (target) {
|
670 | target[PROXY_IS_MOUNTED] = false;
|
671 | instancesCount--;
|
672 | });
|
673 |
|
674 | function hotComponentRender() {
|
675 |
|
676 | renderOptions.componentWillRender(this);
|
677 | proxiedUpdate.call(this);
|
678 | var result = void 0;
|
679 |
|
680 |
|
681 |
|
682 | if (has.call(this, CACHED_RESULT)) {
|
683 | result = this[CACHED_RESULT];
|
684 | delete this[CACHED_RESULT];
|
685 | } else if (isFunctionalComponent) {
|
686 | result = CurrentComponent(this.props, this.context);
|
687 | } else {
|
688 | var renderMethod = CurrentComponent.prototype.render || this.render;
|
689 |
|
690 | if (renderMethod === proxiedRender) {
|
691 | throw new Error('React-Hot-Loader: you are trying to render Component without .render method');
|
692 | }
|
693 |
|
694 | result = renderMethod.apply(this,
|
695 |
|
696 | arguments);
|
697 | }
|
698 |
|
699 | return renderOptions.componentDidRender.call(this, result);
|
700 | }
|
701 |
|
702 | function hotComponentUpdate() {
|
703 | renderOptions.componentWillRender(this);
|
704 | proxiedUpdate.call(this);
|
705 | }
|
706 |
|
707 | function proxiedRender() {
|
708 | renderOptions.componentWillRender(this);
|
709 |
|
710 | for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
|
711 | args[_key3] = arguments[_key3];
|
712 | }
|
713 |
|
714 | return hotComponentRender.call.apply(hotComponentRender, [this].concat(args));
|
715 | }
|
716 |
|
717 | var defineProxyMethods = function defineProxyMethods(Proxy) {
|
718 | var Base = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
719 |
|
720 | defineClassMembers(Proxy, _extends({}, fakeBasePrototype(Base), proxyConfig.pureRender ? {} : { render: proxiedRender }, {
|
721 | hotComponentRender: hotComponentRender,
|
722 | hotComponentUpdate: hotComponentUpdate,
|
723 | componentDidMount: componentDidMount,
|
724 | componentDidUpdate: componentDidUpdate,
|
725 | componentWillUnmount: componentWillUnmount
|
726 | }));
|
727 | };
|
728 |
|
729 | var _ProxyFacade = void 0;
|
730 | var ProxyComponent = null;
|
731 | var proxy = void 0;
|
732 |
|
733 | if (!isFunctionalComponent) {
|
734 |
|
735 | ProxyComponent = proxyClassCreator(InitialComponent, postConstructionAction);
|
736 |
|
737 | defineProxyMethods(ProxyComponent, InitialComponent.prototype);
|
738 |
|
739 | knownClassComponents.push(ProxyComponent);
|
740 |
|
741 | _ProxyFacade = ProxyComponent;
|
742 | } else if (!proxyConfig.allowSFC) {
|
743 | proxyConfig.pureRender = false;
|
744 |
|
745 | ProxyComponent = proxyClassCreator(React.Component, postConstructionAction);
|
746 |
|
747 | defineProxyMethods(ProxyComponent);
|
748 | _ProxyFacade = ProxyComponent;
|
749 | } else {
|
750 |
|
751 |
|
752 |
|
753 |
|
754 |
|
755 |
|
756 | _ProxyFacade = function ProxyFacade(props, context) {
|
757 | var result = CurrentComponent(props, context);
|
758 |
|
759 |
|
760 |
|
761 |
|
762 | if (isReactClassInstance(result)) {
|
763 | ProxyComponent = null;
|
764 |
|
765 |
|
766 |
|
767 | transferStaticProps(_ProxyFacade, savedDescriptors, null, CurrentComponent);
|
768 |
|
769 | return result;
|
770 | }
|
771 |
|
772 |
|
773 | if (proxyConfig.pureSFC) {
|
774 | if (!CurrentComponent.contextTypes) {
|
775 | if (!_ProxyFacade.isStatelessFunctionalProxy) {
|
776 | setSFPFlag(_ProxyFacade, true);
|
777 | }
|
778 |
|
779 | return renderOptions.componentDidRender(result);
|
780 | }
|
781 | }
|
782 | setSFPFlag(_ProxyFacade, false);
|
783 | proxyConfig.pureRender = false;
|
784 |
|
785 |
|
786 |
|
787 | ProxyComponent = proxyClassCreator(React.Component, postConstructionAction);
|
788 |
|
789 | defineProxyMethods(ProxyComponent);
|
790 |
|
791 | var determinateResult = new ProxyComponent(props, context);
|
792 |
|
793 |
|
794 |
|
795 | determinateResult[CACHED_RESULT] = result;
|
796 | return determinateResult;
|
797 | };
|
798 | }
|
799 |
|
800 | function get$$1() {
|
801 | return _ProxyFacade;
|
802 | }
|
803 |
|
804 | function getCurrent() {
|
805 | return CurrentComponent;
|
806 | }
|
807 |
|
808 | safeDefineProperty(_ProxyFacade, UNWRAP_PROXY, {
|
809 | configurable: false,
|
810 | writable: false,
|
811 | enumerable: false,
|
812 | value: getCurrent
|
813 | });
|
814 |
|
815 | safeDefineProperty(_ProxyFacade, PROXY_KEY, {
|
816 | configurable: false,
|
817 | writable: false,
|
818 | enumerable: false,
|
819 | value: proxyKey
|
820 | });
|
821 |
|
822 | safeDefineProperty(_ProxyFacade, 'toString', {
|
823 | configurable: true,
|
824 | writable: false,
|
825 | enumerable: false,
|
826 | value: function toString() {
|
827 | return String(CurrentComponent);
|
828 | }
|
829 | });
|
830 |
|
831 | function update(NextComponent) {
|
832 | if (typeof NextComponent !== 'function') {
|
833 | throw new Error('Expected a constructor.');
|
834 | }
|
835 |
|
836 | if (NextComponent === CurrentComponent) {
|
837 | return;
|
838 | }
|
839 |
|
840 |
|
841 | var existingProxy = proxies.get(NextComponent);
|
842 | if (existingProxy) {
|
843 | return;
|
844 | }
|
845 |
|
846 | isFunctionalComponent = !isReactClass(NextComponent);
|
847 |
|
848 | proxies.set(NextComponent, proxy);
|
849 |
|
850 | proxyGeneration++;
|
851 |
|
852 |
|
853 | var PreviousComponent = CurrentComponent;
|
854 | CurrentComponent = NextComponent;
|
855 |
|
856 |
|
857 | var displayName = getComponentDisplayName(CurrentComponent);
|
858 |
|
859 | safeDefineProperty(_ProxyFacade, 'displayName', {
|
860 | configurable: true,
|
861 | writable: false,
|
862 | enumerable: true,
|
863 | value: displayName
|
864 | });
|
865 |
|
866 | if (ProxyComponent) {
|
867 | safeDefineProperty(ProxyComponent, 'name', {
|
868 | value: displayName
|
869 | });
|
870 | }
|
871 |
|
872 | savedDescriptors = transferStaticProps(_ProxyFacade, savedDescriptors, PreviousComponent, NextComponent);
|
873 |
|
874 | if (isFunctionalComponent || !ProxyComponent) ; else {
|
875 | var classHotReplacement = function classHotReplacement() {
|
876 | getElementCloseHook(ProxyComponent);
|
877 | checkLifeCycleMethods(ProxyComponent, NextComponent);
|
878 | if (proxyGeneration > 1) {
|
879 | filteredPrototypeMethods(ProxyComponent.prototype).forEach(function (methodName) {
|
880 | if (!has.call(NextComponent.prototype, methodName)) {
|
881 | delete ProxyComponent.prototype[methodName];
|
882 | }
|
883 | });
|
884 | }
|
885 | Object.setPrototypeOf(ProxyComponent.prototype, NextComponent.prototype);
|
886 | defineProxyMethods(ProxyComponent, NextComponent.prototype);
|
887 | if (proxyGeneration > 1) {
|
888 | injectedMembers = mergeComponents(ProxyComponent, NextComponent, InitialComponent, lastInstance, injectedMembers);
|
889 | }
|
890 | getElementComparisonHook(ProxyComponent);
|
891 | };
|
892 |
|
893 |
|
894 | if (instancesCount > 0) {
|
895 | classHotReplacement();
|
896 | } else {
|
897 | classUpdatePostponed = classHotReplacement;
|
898 | }
|
899 | }
|
900 | }
|
901 |
|
902 | update(InitialComponent);
|
903 |
|
904 | var dereference = function dereference() {
|
905 | proxies.delete(InitialComponent);
|
906 | proxies.delete(_ProxyFacade);
|
907 | proxies.delete(CurrentComponent);
|
908 | };
|
909 |
|
910 | proxy = { get: get$$1, update: update, dereference: dereference, getCurrent: function getCurrent() {
|
911 | return CurrentComponent;
|
912 | } };
|
913 |
|
914 | proxies.set(InitialComponent, proxy);
|
915 | proxies.set(_ProxyFacade, proxy);
|
916 |
|
917 | safeDefineProperty(proxy, UNWRAP_PROXY, {
|
918 | configurable: false,
|
919 | writable: false,
|
920 | enumerable: false,
|
921 | value: getCurrent
|
922 | });
|
923 |
|
924 | return proxy;
|
925 | }
|
926 |
|
927 | var generation = 1;
|
928 | var hotComparisonCounter = 0;
|
929 | var hotComparisonRuns = 0;
|
930 | var nullFunction = function nullFunction() {
|
931 | return {};
|
932 | };
|
933 | var onHotComparisonOpen = nullFunction;
|
934 | var onHotComparisonElement = nullFunction;
|
935 | var onHotComparisonClose = nullFunction;
|
936 |
|
937 | var setComparisonHooks = function setComparisonHooks(open, element, close) {
|
938 | onHotComparisonOpen = open;
|
939 | onHotComparisonElement = element;
|
940 | onHotComparisonClose = close;
|
941 | };
|
942 |
|
943 | var getElementComparisonHook = function getElementComparisonHook(component) {
|
944 | return onHotComparisonElement(component);
|
945 | };
|
946 | var getElementCloseHook = function getElementCloseHook(component) {
|
947 | return onHotComparisonClose(component);
|
948 | };
|
949 |
|
950 | var hotComparisonOpen = function hotComparisonOpen() {
|
951 | return hotComparisonCounter > 0 && hotComparisonRuns > 0;
|
952 | };
|
953 |
|
954 | var openGeneration = function openGeneration() {
|
955 | return forEachKnownClass(onHotComparisonElement);
|
956 | };
|
957 |
|
958 | var closeGeneration = function closeGeneration() {
|
959 | return forEachKnownClass(onHotComparisonClose);
|
960 | };
|
961 |
|
962 | var incrementHot = function incrementHot() {
|
963 | if (!hotComparisonCounter) {
|
964 | openGeneration();
|
965 | onHotComparisonOpen();
|
966 | }
|
967 | hotComparisonCounter++;
|
968 | };
|
969 | var decrementHot = function decrementHot() {
|
970 | hotComparisonCounter--;
|
971 | if (!hotComparisonCounter) {
|
972 | closeGeneration();
|
973 | hotComparisonRuns++;
|
974 | }
|
975 | };
|
976 |
|
977 | var enterHotUpdate = function enterHotUpdate() {
|
978 | Promise.resolve(incrementHot()).then(function () {
|
979 | return setTimeout(decrementHot, 0);
|
980 | });
|
981 | };
|
982 |
|
983 | var increment = function increment() {
|
984 | enterHotUpdate();
|
985 | return generation++;
|
986 | };
|
987 | var get$1 = function get() {
|
988 | return generation;
|
989 | };
|
990 |
|
991 | var merge = require('lodash/merge');
|
992 |
|
993 | var proxiesByID = void 0;
|
994 | var blackListedProxies = void 0;
|
995 | var registeredComponents = void 0;
|
996 | var idsByType = void 0;
|
997 |
|
998 | var elementCount = 0;
|
999 | var renderOptions = {};
|
1000 |
|
1001 | var componentOptions = void 0;
|
1002 |
|
1003 | var generateTypeId = function generateTypeId() {
|
1004 | return 'auto-' + elementCount++;
|
1005 | };
|
1006 |
|
1007 | var getIdByType = function getIdByType(type) {
|
1008 | return idsByType.get(type);
|
1009 | };
|
1010 | var isProxyType = function isProxyType(type) {
|
1011 | return type[PROXY_KEY];
|
1012 | };
|
1013 |
|
1014 | var getProxyById = function getProxyById(id) {
|
1015 | return proxiesByID[id];
|
1016 | };
|
1017 | var getProxyByType = function getProxyByType(type) {
|
1018 | return getProxyById(getIdByType(type));
|
1019 | };
|
1020 |
|
1021 | var registerComponent = function registerComponent(type) {
|
1022 | return registeredComponents.set(type, 1);
|
1023 | };
|
1024 | var isRegisteredComponent = function isRegisteredComponent(type) {
|
1025 | return registeredComponents.has(type);
|
1026 | };
|
1027 |
|
1028 | var setStandInOptions = function setStandInOptions(options) {
|
1029 | renderOptions = options;
|
1030 | };
|
1031 |
|
1032 | var updateFunctionProxyById = function updateFunctionProxyById(id, type, updater) {
|
1033 |
|
1034 | idsByType.set(type, id);
|
1035 | var proxy = proxiesByID[id];
|
1036 | if (!proxy) {
|
1037 | idsByType.set(type, id);
|
1038 | proxiesByID[id] = type;
|
1039 | }
|
1040 | updater(proxiesByID[id], type);
|
1041 |
|
1042 | return proxiesByID[id];
|
1043 | };
|
1044 |
|
1045 | var updateProxyById = function updateProxyById(id, type) {
|
1046 | var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
1047 |
|
1048 | if (!id) {
|
1049 | return null;
|
1050 | }
|
1051 |
|
1052 | idsByType.set(type, id);
|
1053 |
|
1054 | if (!proxiesByID[id]) {
|
1055 | proxiesByID[id] = createClassProxy(type, id, merge({}, renderOptions, { proxy: componentOptions.get(type) || {} }, options));
|
1056 | } else {
|
1057 | proxiesByID[id].update(type);
|
1058 | }
|
1059 | return proxiesByID[id];
|
1060 | };
|
1061 |
|
1062 | var createProxyForType = function createProxyForType(type, options) {
|
1063 | return getProxyByType(type) || updateProxyById(generateTypeId(), type, options);
|
1064 | };
|
1065 |
|
1066 | var isColdType = function isColdType(type) {
|
1067 | return blackListedProxies.has(type);
|
1068 | };
|
1069 |
|
1070 | var isTypeBlacklisted = function isTypeBlacklisted(type) {
|
1071 | return isColdType(type) || isCompositeComponent(type) && (configuration.ignoreSFC && !isReactClass(type) || configuration.ignoreComponents && isReactClass(type));
|
1072 | };
|
1073 | var blacklistByType = function blacklistByType(type) {
|
1074 | return blackListedProxies.set(type, true);
|
1075 | };
|
1076 |
|
1077 | var setComponentOptions = function setComponentOptions(component, options) {
|
1078 | return componentOptions.set(component, options);
|
1079 | };
|
1080 |
|
1081 | var resetProxies = function resetProxies() {
|
1082 | proxiesByID = {};
|
1083 | idsByType = new WeakMap();
|
1084 | blackListedProxies = new WeakMap();
|
1085 | registeredComponents = new WeakMap();
|
1086 | componentOptions = new WeakMap();
|
1087 | resetClassProxies();
|
1088 | };
|
1089 |
|
1090 | resetProxies();
|
1091 |
|
1092 | var tune = {
|
1093 | allowSFC: false
|
1094 | };
|
1095 |
|
1096 | var preactAdapter = function preactAdapter(instance, resolveType) {
|
1097 | var oldHandler = instance.options.vnode;
|
1098 |
|
1099 | Object.assign(configuration, tune);
|
1100 |
|
1101 | instance.options.vnode = function (vnode) {
|
1102 | vnode.nodeName = resolveType(vnode.nodeName);
|
1103 | if (oldHandler) {
|
1104 | oldHandler(vnode);
|
1105 | }
|
1106 | };
|
1107 | };
|
1108 |
|
1109 |
|
1110 |
|
1111 | var lastError = [];
|
1112 |
|
1113 | var overlayStyle = {
|
1114 | position: 'fixed',
|
1115 | left: 0,
|
1116 | top: 0,
|
1117 | right: 0,
|
1118 |
|
1119 | backgroundColor: 'rgba(255,200,200,0.9)',
|
1120 |
|
1121 | color: '#000',
|
1122 | fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif',
|
1123 | fontSize: '12px',
|
1124 | margin: 0,
|
1125 | padding: '16px',
|
1126 | maxHeight: '50%',
|
1127 | overflow: 'auto'
|
1128 | };
|
1129 |
|
1130 | var inlineErrorStyle = {
|
1131 | backgroundColor: '#FEE'
|
1132 | };
|
1133 |
|
1134 | var liCounter = {
|
1135 | position: 'absolute',
|
1136 | left: '10px'
|
1137 | };
|
1138 |
|
1139 | var listStyle = {};
|
1140 |
|
1141 | var EmptyErrorPlaceholder = function EmptyErrorPlaceholder(_ref) {
|
1142 | var component = _ref.component;
|
1143 | return React__default.createElement(
|
1144 | 'span',
|
1145 | { style: inlineErrorStyle, role: 'img', 'aria-label': 'Rect-Hot-Loader Error' },
|
1146 | '\u269B\uFE0F\uD83D\uDD25\uD83E\uDD15 (',
|
1147 | component ? getComponentDisplayName(component.constructor || component) : 'Unknown location',
|
1148 | ')',
|
1149 | component && component.retryHotLoaderError && React__default.createElement(
|
1150 | 'button',
|
1151 | { onClick: function onClick() {
|
1152 | return component.retryHotLoaderError();
|
1153 | }, title: 'Retry' },
|
1154 | '\u27F3'
|
1155 | )
|
1156 | );
|
1157 | };
|
1158 |
|
1159 | var errorHeader = function errorHeader(component, componentStack) {
|
1160 | if (component || componentStack) {
|
1161 | return React__default.createElement(
|
1162 | 'span',
|
1163 | null,
|
1164 | '(',
|
1165 | component ? getComponentDisplayName(component.constructor || component) : 'Unknown location',
|
1166 | component && ', ',
|
1167 | componentStack && componentStack.split('\n').filter(Boolean)[0],
|
1168 | ')'
|
1169 | );
|
1170 | }
|
1171 | return null;
|
1172 | };
|
1173 |
|
1174 | var mapError = function mapError(_ref2) {
|
1175 | var error = _ref2.error,
|
1176 | errorInfo = _ref2.errorInfo,
|
1177 | component = _ref2.component;
|
1178 | return React__default.createElement(
|
1179 | React__default.Fragment,
|
1180 | null,
|
1181 | React__default.createElement(
|
1182 | 'p',
|
1183 | { style: { color: 'red' } },
|
1184 | errorHeader(component, errorInfo && errorInfo.componentStack),
|
1185 | ' ',
|
1186 | error.toString ? error.toString() : error.message || 'undefined error'
|
1187 | ),
|
1188 | errorInfo && errorInfo.componentStack ? React__default.createElement(
|
1189 | 'div',
|
1190 | null,
|
1191 | React__default.createElement(
|
1192 | 'div',
|
1193 | null,
|
1194 | 'Stack trace:'
|
1195 | ),
|
1196 | React__default.createElement(
|
1197 | 'ul',
|
1198 | { style: { color: 'red', marginTop: '10px' } },
|
1199 | error.stack.split('\n').slice(1, 2).map(function (line, i) {
|
1200 | return React__default.createElement(
|
1201 | 'li',
|
1202 | { key: String(i) },
|
1203 | line
|
1204 | );
|
1205 | }),
|
1206 | React__default.createElement('hr', null),
|
1207 | errorInfo.componentStack.split('\n').filter(Boolean).map(function (line, i) {
|
1208 | return React__default.createElement(
|
1209 | 'li',
|
1210 | { key: String(i) },
|
1211 | line
|
1212 | );
|
1213 | })
|
1214 | )
|
1215 | ) : error.stack && React__default.createElement(
|
1216 | 'div',
|
1217 | null,
|
1218 | React__default.createElement(
|
1219 | 'div',
|
1220 | null,
|
1221 | 'Stack trace:'
|
1222 | ),
|
1223 | React__default.createElement(
|
1224 | 'ul',
|
1225 | { style: { color: 'red', marginTop: '10px' } },
|
1226 | error.stack.split('\n').map(function (line, i) {
|
1227 | return React__default.createElement(
|
1228 | 'li',
|
1229 | { key: String(i) },
|
1230 | line
|
1231 | );
|
1232 | })
|
1233 | )
|
1234 | )
|
1235 | );
|
1236 | };
|
1237 |
|
1238 | var ErrorOverlay = function (_React$Component) {
|
1239 | inherits(ErrorOverlay, _React$Component);
|
1240 |
|
1241 | function ErrorOverlay() {
|
1242 | var _temp, _this, _ret;
|
1243 |
|
1244 | classCallCheck(this, ErrorOverlay);
|
1245 |
|
1246 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
1247 | args[_key] = arguments[_key];
|
1248 | }
|
1249 |
|
1250 | return _ret = (_temp = (_this = possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {
|
1251 | visible: true
|
1252 | }, _this.toggle = function () {
|
1253 | return _this.setState({ visible: !_this.state.visible });
|
1254 | }, _this.retry = function () {
|
1255 | return _this.setState(function () {
|
1256 | var errors = _this.props.errors;
|
1257 |
|
1258 | enterHotUpdate();
|
1259 | clearExceptions();
|
1260 | errors.map(function (_ref3) {
|
1261 | var component = _ref3.component;
|
1262 | return component;
|
1263 | }).filter(Boolean).filter(function (_ref4) {
|
1264 | var retryHotLoaderError = _ref4.retryHotLoaderError;
|
1265 | return !!retryHotLoaderError;
|
1266 | }).forEach(function (component) {
|
1267 | return component.retryHotLoaderError();
|
1268 | });
|
1269 |
|
1270 | return {};
|
1271 | });
|
1272 | }, _temp), possibleConstructorReturn(_this, _ret);
|
1273 | }
|
1274 |
|
1275 | ErrorOverlay.prototype.render = function render() {
|
1276 | var errors = this.props.errors;
|
1277 |
|
1278 | if (!errors.length) {
|
1279 | return null;
|
1280 | }
|
1281 | var visible = this.state.visible;
|
1282 |
|
1283 | return React__default.createElement(
|
1284 | 'div',
|
1285 | { style: overlayStyle },
|
1286 | React__default.createElement(
|
1287 | 'h2',
|
1288 | { style: { margin: 0 } },
|
1289 | '\u269B\uFE0F\uD83D\uDD25\uD83D\uDE2D: hot update was not successful',
|
1290 | ' ',
|
1291 | React__default.createElement(
|
1292 | 'button',
|
1293 | { onClick: this.toggle },
|
1294 | visible ? 'collapse' : 'expand'
|
1295 | ),
|
1296 | React__default.createElement(
|
1297 | 'button',
|
1298 | { onClick: this.retry },
|
1299 | 'Retry'
|
1300 | )
|
1301 | ),
|
1302 | visible && React__default.createElement(
|
1303 | 'ul',
|
1304 | { style: listStyle },
|
1305 | errors.map(function (err, i) {
|
1306 | return React__default.createElement(
|
1307 | 'li',
|
1308 | { key: i },
|
1309 | React__default.createElement(
|
1310 | 'span',
|
1311 | { style: liCounter },
|
1312 | '(',
|
1313 | i + 1,
|
1314 | '/',
|
1315 | errors.length,
|
1316 | ')'
|
1317 | ),
|
1318 | mapError(err)
|
1319 | );
|
1320 | })
|
1321 | )
|
1322 | );
|
1323 | };
|
1324 |
|
1325 | return ErrorOverlay;
|
1326 | }(React__default.Component);
|
1327 |
|
1328 | var initErrorOverlay = function initErrorOverlay() {
|
1329 | if (typeof document === 'undefined' || !document.body) {
|
1330 | return;
|
1331 | }
|
1332 | var div = document.querySelector('.react-hot-loader-error-overlay');
|
1333 | if (!div) {
|
1334 | div = document.createElement('div');
|
1335 | div.className = 'react-hot-loader-error-overlay';
|
1336 | document.body.appendChild(div);
|
1337 | }
|
1338 | if (lastError.length) {
|
1339 | var Overlay = configuration.ErrorOverlay || ErrorOverlay;
|
1340 | ReactDOM.render(React__default.createElement(Overlay, { errors: lastError }), div);
|
1341 | } else {
|
1342 | div.parentNode.removeChild(div);
|
1343 | }
|
1344 | };
|
1345 |
|
1346 | function clearExceptions() {
|
1347 | if (lastError.length) {
|
1348 | lastError = [];
|
1349 | initErrorOverlay();
|
1350 | }
|
1351 | }
|
1352 |
|
1353 | function logException(error, errorInfo, component) {
|
1354 |
|
1355 |
|
1356 |
|
1357 | console.error(error);
|
1358 |
|
1359 |
|
1360 | lastError.push({ error: error, errorInfo: errorInfo, component: component });
|
1361 | initErrorOverlay();
|
1362 | }
|
1363 |
|
1364 |
|
1365 |
|
1366 | var hotRenderWithHooks = ReactDOM.hotRenderWithHooks || function (fiber, render) {
|
1367 | return render();
|
1368 | };
|
1369 |
|
1370 | function pushStack(stack, node) {
|
1371 | stack.type = node.type;
|
1372 | stack.elementType = node.elementType || node.type;
|
1373 | stack.children = [];
|
1374 | stack.instance = typeof node.type === 'function' ? node.stateNode : stack;
|
1375 | stack.fiber = node;
|
1376 |
|
1377 | if (!stack.instance) {
|
1378 | stack.instance = {
|
1379 | SFC_fake: stack.type,
|
1380 | props: {},
|
1381 | render: function render() {
|
1382 | return hotRenderWithHooks(node, function () {
|
1383 | return stack.type(stack.instance.props);
|
1384 | });
|
1385 | }
|
1386 | };
|
1387 | }
|
1388 | }
|
1389 |
|
1390 | function hydrateFiberStack(node, stack) {
|
1391 | pushStack(stack, node);
|
1392 | if (node.child) {
|
1393 | var child = node.child;
|
1394 |
|
1395 | do {
|
1396 | var childStack = {};
|
1397 | hydrateFiberStack(child, childStack);
|
1398 | stack.children.push(childStack);
|
1399 | child = child.sibling;
|
1400 | } while (child);
|
1401 | }
|
1402 | }
|
1403 |
|
1404 |
|
1405 |
|
1406 | function pushState(stack, type, instance) {
|
1407 | stack.type = type;
|
1408 | stack.elementType = type;
|
1409 | stack.children = [];
|
1410 | stack.instance = instance || stack;
|
1411 |
|
1412 | if (typeof type === 'function' && type.isStatelessFunctionalProxy) {
|
1413 |
|
1414 | stack.instance = {
|
1415 | SFC_fake: type,
|
1416 | props: {},
|
1417 | render: function render() {
|
1418 | return type(stack.instance.props);
|
1419 | }
|
1420 | };
|
1421 | }
|
1422 | }
|
1423 |
|
1424 | function hydrateLegacyStack(node, stack) {
|
1425 | if (node._currentElement) {
|
1426 | pushState(stack, node._currentElement.type, node._instance || stack);
|
1427 | }
|
1428 |
|
1429 | if (node._renderedComponent) {
|
1430 | var childStack = {};
|
1431 | hydrateLegacyStack(node._renderedComponent, childStack);
|
1432 | stack.children.push(childStack);
|
1433 | } else if (node._renderedChildren) {
|
1434 | Object.keys(node._renderedChildren).forEach(function (key) {
|
1435 | var childStack = {};
|
1436 | hydrateLegacyStack(node._renderedChildren[key], childStack);
|
1437 | stack.children.push(childStack);
|
1438 | });
|
1439 | }
|
1440 | }
|
1441 |
|
1442 |
|
1443 |
|
1444 | function getReactStack(instance) {
|
1445 | var rootNode = getInternalInstance(instance);
|
1446 | var stack = {};
|
1447 | if (rootNode) {
|
1448 |
|
1449 | var isFiber = typeof rootNode.tag === 'number';
|
1450 | if (isFiber) {
|
1451 | hydrateFiberStack(rootNode, stack);
|
1452 | } else {
|
1453 | hydrateLegacyStack(rootNode, stack);
|
1454 | }
|
1455 | }
|
1456 |
|
1457 | return stack;
|
1458 | }
|
1459 |
|
1460 | var markUpdate = function markUpdate(_ref) {
|
1461 | var fiber = _ref.fiber;
|
1462 |
|
1463 | if (!fiber) {
|
1464 | return;
|
1465 | }
|
1466 | fiber.expirationTime = 1;
|
1467 | if (fiber.alternate) {
|
1468 | fiber.alternate.expirationTime = 1;
|
1469 | fiber.alternate.type = fiber.type;
|
1470 | }
|
1471 |
|
1472 | if (fiber.memoizedProps && _typeof(fiber.memoizedProps) === 'object') {
|
1473 | fiber.memoizedProps = Object.assign({ cacheBusterProp: true }, fiber.memoizedProps);
|
1474 | }
|
1475 | };
|
1476 |
|
1477 | var cleanupReact = function cleanupReact() {
|
1478 | if (ReactDOM.hotCleanup) {
|
1479 | ReactDOM.hotCleanup();
|
1480 | }
|
1481 | };
|
1482 |
|
1483 | var deepMarkUpdate = function deepMarkUpdate(stack) {
|
1484 | markUpdate(stack);
|
1485 | if (stack.children) {
|
1486 | stack.children.forEach(deepMarkUpdate);
|
1487 | }
|
1488 | };
|
1489 |
|
1490 |
|
1491 | var UNDEFINED_NAMES = {
|
1492 | Unknown: true,
|
1493 | Component: true
|
1494 | };
|
1495 |
|
1496 | var areNamesEqual = function areNamesEqual(a, b) {
|
1497 | return a === b || UNDEFINED_NAMES[a] && UNDEFINED_NAMES[b];
|
1498 | };
|
1499 |
|
1500 | var isFunctional = function isFunctional(fn) {
|
1501 | return typeof fn === 'function';
|
1502 | };
|
1503 | var getTypeOf = function getTypeOf(type) {
|
1504 | if (isReactClass(type)) return 'ReactComponent';
|
1505 | if (isFunctional(type)) return 'StatelessFunctional';
|
1506 | return 'Fragment';
|
1507 | };
|
1508 |
|
1509 | var haveTextSimilarity = function haveTextSimilarity(a, b) {
|
1510 | return (
|
1511 |
|
1512 | a === b || levenshtein.get(a, b) < a.length * 0.2
|
1513 | );
|
1514 | };
|
1515 |
|
1516 | var getBaseProto = function getBaseProto(source) {
|
1517 | return source.prototype.hotComponentRender ? Object.getPrototypeOf(source.prototype) : source.prototype;
|
1518 | };
|
1519 |
|
1520 | var equalClasses = function equalClasses(a, b) {
|
1521 | var prototypeA = getBaseProto(a);
|
1522 | var prototypeB = getBaseProto(b);
|
1523 |
|
1524 | var hits = 0;
|
1525 | var misses = 0;
|
1526 | var comparisons = 0;
|
1527 | Object.getOwnPropertyNames(prototypeA).forEach(function (key) {
|
1528 | var descriptorA = Object.getOwnPropertyDescriptor(prototypeA, key);
|
1529 | var valueA = descriptorA && (descriptorA.value || descriptorA.get || descriptorA.set);
|
1530 | var descriptorB = Object.getOwnPropertyDescriptor(prototypeB, key);
|
1531 | var valueB = descriptorB && (descriptorB.value || descriptorB.get || descriptorB.set);
|
1532 |
|
1533 | if (typeof valueA === 'function' && key !== 'constructor') {
|
1534 | comparisons++;
|
1535 | if (haveTextSimilarity(String(valueA), String(valueB))) {
|
1536 | hits++;
|
1537 | } else {
|
1538 | misses++;
|
1539 | if (key === 'render') {
|
1540 | misses++;
|
1541 | }
|
1542 | }
|
1543 | }
|
1544 | });
|
1545 |
|
1546 | return hits > 0 && misses <= 1 || comparisons === 0;
|
1547 | };
|
1548 |
|
1549 | var areSwappable = function areSwappable(a, b) {
|
1550 |
|
1551 | if (getIdByType(b) && getIdByType(a) === getIdByType(b)) {
|
1552 | return true;
|
1553 | }
|
1554 | if (getTypeOf(a) !== getTypeOf(b)) {
|
1555 | return false;
|
1556 | }
|
1557 | if (isReactClass(a)) {
|
1558 | return areNamesEqual(getComponentDisplayName(a), getComponentDisplayName(b)) && equalClasses(a, b);
|
1559 | }
|
1560 |
|
1561 | if (isFunctional(a)) {
|
1562 | var nameA = getComponentDisplayName(a);
|
1563 | return areNamesEqual(nameA, getComponentDisplayName(b)) || nameA !== 'Component' && haveTextSimilarity(String(a), String(b));
|
1564 | }
|
1565 | return false;
|
1566 | };
|
1567 |
|
1568 | var shouldNotPatchComponent = function shouldNotPatchComponent(type) {
|
1569 | return isTypeBlacklisted(type);
|
1570 | };
|
1571 |
|
1572 | function resolveType(type) {
|
1573 | var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
1574 |
|
1575 | if (isLazyType({ type: type }) || isMemoType({ type: type }) || isForwardType({ type: type })) {
|
1576 | return getProxyByType(type) || type;
|
1577 | }
|
1578 |
|
1579 | if (!isCompositeComponent(type) || isProxyType(type)) {
|
1580 | return type;
|
1581 | }
|
1582 |
|
1583 | var existingProxy = getProxyByType(type);
|
1584 |
|
1585 | if (shouldNotPatchComponent(type)) {
|
1586 | return existingProxy ? existingProxy.getCurrent() : type;
|
1587 | }
|
1588 |
|
1589 | if (!existingProxy && configuration.onComponentCreate) {
|
1590 | configuration.onComponentCreate(type, getComponentDisplayName(type));
|
1591 | if (shouldNotPatchComponent(type)) return type;
|
1592 | }
|
1593 |
|
1594 | var proxy = internalConfiguration.disableProxyCreation ? existingProxy : createProxyForType(type, options);
|
1595 |
|
1596 | return proxy ? proxy.get() : type;
|
1597 | }
|
1598 |
|
1599 | var renderStack = [];
|
1600 |
|
1601 | var stackReport = function stackReport() {
|
1602 | var rev = renderStack.slice().reverse();
|
1603 | logger.warn('in', rev[0].name, rev);
|
1604 | };
|
1605 |
|
1606 | var emptyMap = new Map();
|
1607 | var stackContext = function stackContext() {
|
1608 | return (renderStack[renderStack.length - 1] || {}).context || emptyMap;
|
1609 | };
|
1610 |
|
1611 | var shouldUseRenderMethod = function shouldUseRenderMethod(fn) {
|
1612 | return fn && (isReactClassInstance(fn) || fn.SFC_fake);
|
1613 | };
|
1614 |
|
1615 | var getElementType = function getElementType(child) {
|
1616 | return child.type[UNWRAP_PROXY] ? child.type[UNWRAP_PROXY]() : child.type;
|
1617 | };
|
1618 |
|
1619 | var filterNullArray = function filterNullArray(a) {
|
1620 | if (!a) return [];
|
1621 | return a.filter(function (x) {
|
1622 | return !!x;
|
1623 | });
|
1624 | };
|
1625 |
|
1626 | var unflatten = function unflatten(a) {
|
1627 | return a.reduce(function (acc, a) {
|
1628 | if (Array.isArray(a)) {
|
1629 | acc.push.apply(acc, unflatten(a));
|
1630 | } else {
|
1631 | acc.push(a);
|
1632 | }
|
1633 | return acc;
|
1634 | }, []);
|
1635 | };
|
1636 |
|
1637 | var isArray = function isArray(fn) {
|
1638 | return Array.isArray(fn);
|
1639 | };
|
1640 | var asArray = function asArray(a) {
|
1641 | return isArray(a) ? a : [a];
|
1642 | };
|
1643 |
|
1644 | var render = function render(component) {
|
1645 | if (!component) {
|
1646 | return [];
|
1647 | }
|
1648 | if (component.hotComponentUpdate) {
|
1649 | component.hotComponentUpdate();
|
1650 | }
|
1651 | if (shouldUseRenderMethod(component)) {
|
1652 |
|
1653 |
|
1654 | return component.hotComponentRender ? component.hotComponentRender() : component.render();
|
1655 | }
|
1656 | if (isForwardType(component)) {
|
1657 | return component.type.render(component.props, null);
|
1658 | }
|
1659 | if (isArray(component)) {
|
1660 | return component.map(render);
|
1661 | }
|
1662 | if (component.children) {
|
1663 | return component.children;
|
1664 | }
|
1665 |
|
1666 | return [];
|
1667 | };
|
1668 |
|
1669 | var NO_CHILDREN = { children: [] };
|
1670 | var mapChildren = function mapChildren(children, instances) {
|
1671 | return {
|
1672 | children: children.filter(function (c) {
|
1673 | return c;
|
1674 | }).map(function (child, index) {
|
1675 | if ((typeof child === 'undefined' ? 'undefined' : _typeof(child)) !== 'object' || child.isMerged) {
|
1676 | return child;
|
1677 | }
|
1678 | var instanceLine = instances[index] || {};
|
1679 | var oldChildren = asArray(instanceLine.children || []);
|
1680 |
|
1681 | if (Array.isArray(child)) {
|
1682 | return _extends({
|
1683 | type: null
|
1684 | }, mapChildren(child, oldChildren));
|
1685 | }
|
1686 |
|
1687 | var newChildren = asArray(child.props && child.props.children || child.children || []);
|
1688 | var nextChildren = child.type !== 'function' && oldChildren.length && mapChildren(newChildren, oldChildren);
|
1689 |
|
1690 | return _extends({
|
1691 | nextProps: child.props,
|
1692 | isMerged: true
|
1693 | }, instanceLine, nextChildren || {}, {
|
1694 | type: child.type
|
1695 | });
|
1696 | })
|
1697 | };
|
1698 | };
|
1699 |
|
1700 | var mergeInject = function mergeInject(a, b, instance) {
|
1701 | if (a && !Array.isArray(a)) {
|
1702 | return mergeInject([a], b);
|
1703 | }
|
1704 | if (b && !Array.isArray(b)) {
|
1705 | return mergeInject(a, [b]);
|
1706 | }
|
1707 |
|
1708 | if (!a || !b) {
|
1709 | return NO_CHILDREN;
|
1710 | }
|
1711 | if (a.length === b.length) {
|
1712 | return mapChildren(a, b);
|
1713 | }
|
1714 |
|
1715 |
|
1716 |
|
1717 |
|
1718 |
|
1719 | var nonNullA = filterNullArray(a);
|
1720 | if (nonNullA.length === b.length) {
|
1721 | return mapChildren(nonNullA, b);
|
1722 | }
|
1723 |
|
1724 | var flatA = unflatten(nonNullA);
|
1725 | var flatB = unflatten(b);
|
1726 | if (flatA.length === flatB.length) {
|
1727 | return mapChildren(flatA, flatB);
|
1728 | }
|
1729 | if (flatB.length === 0 && flatA.length === 1 && _typeof(flatA[0]) !== 'object') ; else {
|
1730 | logger.warn('React-hot-loader: unable to merge ', a, 'and children of ', instance);
|
1731 | stackReport();
|
1732 | }
|
1733 | return NO_CHILDREN;
|
1734 | };
|
1735 |
|
1736 | var transformFlowNode = function transformFlowNode(flow) {
|
1737 | return flow.reduce(function (acc, node) {
|
1738 | if (node && isFragmentNode(node)) {
|
1739 | if (node.props && node.props.children) {
|
1740 | return [].concat(acc, filterNullArray(asArray(node.props.children)));
|
1741 | }
|
1742 | if (node.children) {
|
1743 | return [].concat(acc, filterNullArray(asArray(node.children)));
|
1744 | }
|
1745 | }
|
1746 | return [].concat(acc, [node]);
|
1747 | }, []);
|
1748 | };
|
1749 |
|
1750 | var scheduledUpdates = [];
|
1751 | var scheduledUpdate = 0;
|
1752 |
|
1753 | var flushScheduledUpdates = function flushScheduledUpdates() {
|
1754 | var instances = scheduledUpdates;
|
1755 | scheduledUpdates = [];
|
1756 | scheduledUpdate = 0;
|
1757 | instances.forEach(function (instance) {
|
1758 | return instance[PROXY_IS_MOUNTED] && updateInstance(instance);
|
1759 | });
|
1760 | };
|
1761 |
|
1762 | var unscheduleUpdate = function unscheduleUpdate(instance) {
|
1763 | scheduledUpdates = scheduledUpdates.filter(function (inst) {
|
1764 | return inst !== instance;
|
1765 | });
|
1766 | };
|
1767 |
|
1768 | var scheduleInstanceUpdate = function scheduleInstanceUpdate(instance) {
|
1769 | scheduledUpdates.push(instance);
|
1770 | if (!scheduledUpdate) {
|
1771 | scheduledUpdate = setTimeout(flushScheduledUpdates, 4);
|
1772 | }
|
1773 | };
|
1774 |
|
1775 | var hotReplacementRender = function hotReplacementRender(instance, stack) {
|
1776 | if (isReactClassInstance(instance)) {
|
1777 | var type = getElementType(stack);
|
1778 |
|
1779 | renderStack.push({
|
1780 | name: getComponentDisplayName(type),
|
1781 | type: type,
|
1782 | props: stack.instance.props,
|
1783 | context: stackContext()
|
1784 | });
|
1785 | }
|
1786 |
|
1787 | try {
|
1788 | var flow = transformFlowNode(filterNullArray(asArray(render(instance))));
|
1789 |
|
1790 | var children = stack.children;
|
1791 |
|
1792 |
|
1793 | flow.forEach(function (child, index) {
|
1794 | var childType = child.type;
|
1795 | var stackChild = children[index];
|
1796 | var next = function next(instance) {
|
1797 |
|
1798 |
|
1799 | var realProps = instance.props;
|
1800 | var nextProps = _extends({}, realProps, child.nextProps || {}, child.props || {});
|
1801 |
|
1802 | if (isReactClassInstance(instance) && instance.componentWillUpdate) {
|
1803 |
|
1804 | instance.componentWillUpdate(_extends({}, realProps), instance.state);
|
1805 | }
|
1806 | instance.props = nextProps;
|
1807 | hotReplacementRender(instance, stackChild);
|
1808 | instance.props = realProps;
|
1809 | };
|
1810 |
|
1811 |
|
1812 | if ((typeof child === 'undefined' ? 'undefined' : _typeof(child)) !== 'object' || !stackChild || !stackChild.instance) {
|
1813 | if (stackChild && stackChild.children && stackChild.children.length) {
|
1814 | logger.error('React-hot-loader: reconciliation failed', 'could not dive into [', child, '] while some elements are still present in the tree.');
|
1815 | stackReport();
|
1816 | }
|
1817 | return;
|
1818 | }
|
1819 |
|
1820 |
|
1821 | if ((typeof childType === 'undefined' ? 'undefined' : _typeof(childType)) !== _typeof(stackChild.elementType)) {
|
1822 |
|
1823 | if (childType && stackChild.type) {
|
1824 | logger.warn('React-hot-loader: got ', childType, 'instead of', stackChild.type);
|
1825 | stackReport();
|
1826 | }
|
1827 | return;
|
1828 | }
|
1829 |
|
1830 | if (isMemoType(child) || isLazyType(child)) {
|
1831 |
|
1832 | if (stackChild.children && stackChild.children[0]) {
|
1833 | scheduleInstanceUpdate(stackChild.children[0].instance);
|
1834 | }
|
1835 | childType = childType.type || childType;
|
1836 | }
|
1837 |
|
1838 | if (isForwardType(child)) {
|
1839 | next(stackChild.instance);
|
1840 | } else if (isContextConsumer(child)) {
|
1841 | try {
|
1842 | next({
|
1843 | children: (child.props ? child.props.children : child.children[0])(stackContext().get(getContextProvider(childType)) || childType[CONTEXT_CURRENT_VALUE])
|
1844 | });
|
1845 | } catch (e) {
|
1846 |
|
1847 | }
|
1848 | } else if (typeof childType !== 'function') {
|
1849 |
|
1850 | var childName = childType ? getComponentDisplayName(childType) : 'empty';
|
1851 | var extraContext = stackContext();
|
1852 |
|
1853 | if (isContextProvider(child)) {
|
1854 | extraContext = new Map(extraContext);
|
1855 | extraContext.set(getContextProvider(childType), _extends({}, child.nextProps || {}, child.props || {}).value);
|
1856 | childName = 'ContextProvider';
|
1857 | }
|
1858 |
|
1859 | renderStack.push({
|
1860 | name: childName,
|
1861 | type: childType,
|
1862 | props: stack.instance.props,
|
1863 | context: extraContext
|
1864 | });
|
1865 |
|
1866 | next(
|
1867 |
|
1868 | mergeInject(transformFlowNode(asArray(child.props ? child.props.children : child.children)), stackChild.instance.children, stackChild.instance));
|
1869 | renderStack.pop();
|
1870 | } else {
|
1871 | if (childType === stackChild.type) {
|
1872 | next(stackChild.instance);
|
1873 | } else {
|
1874 |
|
1875 | var _childType = getElementType(child);
|
1876 |
|
1877 | if (isMemoType(child)) {
|
1878 | _childType = _childType.type || _childType;
|
1879 | }
|
1880 |
|
1881 | if (!stackChild.type[PROXY_KEY]) {
|
1882 | if (!reactHotLoader.IS_REACT_MERGE_ENABLED) {
|
1883 | if (isTypeBlacklisted(stackChild.type)) {
|
1884 | logger.warn('React-hot-loader: cold element got updated ', stackChild.type);
|
1885 | }
|
1886 | }
|
1887 | }
|
1888 |
|
1889 | if (isRegisteredComponent(_childType) || isRegisteredComponent(stackChild.type)) {
|
1890 |
|
1891 | if (resolveType(_childType) === resolveType(stackChild.type)) {
|
1892 | next(stackChild.instance);
|
1893 | }
|
1894 | } else if (areSwappable(_childType, stackChild.type)) {
|
1895 |
|
1896 |
|
1897 |
|
1898 | updateProxyById(stackChild.type[PROXY_KEY] || getIdByType(stackChild.type), _childType);
|
1899 |
|
1900 | next(stackChild.instance);
|
1901 | } else {
|
1902 | logger.warn('React-hot-loader: a ' + getComponentDisplayName(_childType) + ' was found where a ' + getComponentDisplayName(stackChild) + ' was expected.\n ' + _childType);
|
1903 | stackReport();
|
1904 | }
|
1905 | }
|
1906 |
|
1907 | scheduleInstanceUpdate(stackChild.instance);
|
1908 | }
|
1909 | });
|
1910 | } catch (e) {
|
1911 | if (e.then) ; else {
|
1912 | logger.warn('React-hot-loader: run time error during reconciliation', e);
|
1913 | }
|
1914 | }
|
1915 |
|
1916 | if (isReactClassInstance(instance)) {
|
1917 | renderStack.pop();
|
1918 | }
|
1919 | };
|
1920 |
|
1921 | var hotReplacementRender$1 = (function (instance, stack) {
|
1922 | if (configuration.disableHotRenderer) {
|
1923 | return;
|
1924 | }
|
1925 | try {
|
1926 |
|
1927 | internalConfiguration.disableProxyCreation = true;
|
1928 | renderStack = [];
|
1929 | hotReplacementRender(instance, stack);
|
1930 | } catch (e) {
|
1931 | logger.warn('React-hot-loader: reconcilation failed due to error', e);
|
1932 | } finally {
|
1933 | internalConfiguration.disableProxyCreation = false;
|
1934 | }
|
1935 | });
|
1936 |
|
1937 | var reconcileHotReplacement = function reconcileHotReplacement(ReactInstance) {
|
1938 | var stack = getReactStack(ReactInstance);
|
1939 | hotReplacementRender$1(ReactInstance, stack);
|
1940 | cleanupReact();
|
1941 | deepMarkUpdate(stack);
|
1942 | };
|
1943 |
|
1944 | var renderReconciler = function renderReconciler(target, force) {
|
1945 |
|
1946 | var currentGeneration = get$1();
|
1947 | var componentGeneration = target[RENDERED_GENERATION];
|
1948 |
|
1949 | target[RENDERED_GENERATION] = currentGeneration;
|
1950 |
|
1951 | if (!internalConfiguration.disableProxyCreation) {
|
1952 | if ((componentGeneration || force) && componentGeneration !== currentGeneration) {
|
1953 | enterHotUpdate();
|
1954 | reconcileHotReplacement(target);
|
1955 | return true;
|
1956 | }
|
1957 | }
|
1958 | return false;
|
1959 | };
|
1960 |
|
1961 | function asyncReconciledRender(target) {
|
1962 | renderReconciler(target, false);
|
1963 | }
|
1964 |
|
1965 | function proxyWrapper(element) {
|
1966 |
|
1967 | if (!internalConfiguration.disableProxyCreation) {
|
1968 | unscheduleUpdate(this);
|
1969 | }
|
1970 |
|
1971 | if (!element) {
|
1972 | return element;
|
1973 | }
|
1974 | if (Array.isArray(element)) {
|
1975 | return element.map(proxyWrapper);
|
1976 | }
|
1977 | if (typeof element.type === 'function') {
|
1978 | var proxy = getProxyByType(element.type);
|
1979 | if (proxy) {
|
1980 | return _extends({}, element, {
|
1981 | type: proxy.get()
|
1982 | });
|
1983 | }
|
1984 | }
|
1985 | return element;
|
1986 | }
|
1987 |
|
1988 | var ERROR_STATE = 'react_hot_loader_catched_error';
|
1989 | var ERROR_STATE_PROTO = 'react_hot_loader_catched_error-prototype';
|
1990 | var OLD_RENDER = 'react_hot_loader_original_render';
|
1991 |
|
1992 | function componentDidCatch(error, errorInfo) {
|
1993 | this[ERROR_STATE] = {
|
1994 | location: 'boundary',
|
1995 | error: error,
|
1996 | errorInfo: errorInfo,
|
1997 | generation: get$1()
|
1998 | };
|
1999 | Object.getPrototypeOf(this)[ERROR_STATE_PROTO] = this[ERROR_STATE];
|
2000 | if (!configuration.errorReporter) {
|
2001 | logException(error, errorInfo, this);
|
2002 | }
|
2003 | this.forceUpdate();
|
2004 | }
|
2005 |
|
2006 | function componentRender() {
|
2007 | var _ref = this[ERROR_STATE] || {},
|
2008 | error = _ref.error,
|
2009 | errorInfo = _ref.errorInfo,
|
2010 | generation = _ref.generation;
|
2011 |
|
2012 | if (error && generation === get$1()) {
|
2013 | return React__default.createElement(configuration.errorReporter || EmptyErrorPlaceholder, { error: error, errorInfo: errorInfo, component: this });
|
2014 | }
|
2015 |
|
2016 | if (this.hotComponentUpdate) {
|
2017 | this.hotComponentUpdate();
|
2018 | }
|
2019 | try {
|
2020 | var _OLD_RENDER$render;
|
2021 |
|
2022 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
2023 | args[_key] = arguments[_key];
|
2024 | }
|
2025 |
|
2026 | return (_OLD_RENDER$render = this[OLD_RENDER].render).call.apply(_OLD_RENDER$render, [this].concat(args));
|
2027 | } catch (renderError) {
|
2028 | this[ERROR_STATE] = {
|
2029 | location: 'render',
|
2030 | error: renderError,
|
2031 | generation: get$1()
|
2032 | };
|
2033 | if (!configuration.errorReporter) {
|
2034 | logException(renderError, undefined, this);
|
2035 | }
|
2036 | return componentRender.call(this);
|
2037 | }
|
2038 | }
|
2039 |
|
2040 | function retryHotLoaderError() {
|
2041 | delete this[ERROR_STATE];
|
2042 | this.forceUpdate();
|
2043 | }
|
2044 |
|
2045 | setComparisonHooks(function () {
|
2046 | return {};
|
2047 | }, function (component) {
|
2048 | if (!hotComparisonOpen()) {
|
2049 | return;
|
2050 | }
|
2051 | var prototype = component.prototype;
|
2052 |
|
2053 | if (!prototype[OLD_RENDER]) {
|
2054 | var renderDescriptior = Object.getOwnPropertyDescriptor(prototype, 'render');
|
2055 | prototype[OLD_RENDER] = {
|
2056 | descriptor: renderDescriptior ? renderDescriptior.value : undefined,
|
2057 | render: prototype.render
|
2058 | };
|
2059 | prototype.componentDidCatch = componentDidCatch;
|
2060 | prototype.retryHotLoaderError = retryHotLoaderError;
|
2061 |
|
2062 | prototype.render = componentRender;
|
2063 | }
|
2064 | delete prototype[ERROR_STATE];
|
2065 | }, function (_ref2) {
|
2066 | var prototype = _ref2.prototype;
|
2067 |
|
2068 | if (prototype[OLD_RENDER]) {
|
2069 | var _ref3 = prototype[ERROR_STATE_PROTO] || {},
|
2070 | generation = _ref3.generation;
|
2071 |
|
2072 | if (generation === get$1()) ; else {
|
2073 | delete prototype.componentDidCatch;
|
2074 | delete prototype.retryHotLoaderError;
|
2075 | if (!prototype[OLD_RENDER].descriptor) {
|
2076 | delete prototype.render;
|
2077 | } else {
|
2078 | prototype.render = prototype[OLD_RENDER].descriptor;
|
2079 | }
|
2080 | delete prototype[ERROR_STATE_PROTO];
|
2081 | delete prototype[OLD_RENDER];
|
2082 | }
|
2083 | }
|
2084 | });
|
2085 |
|
2086 | setStandInOptions({
|
2087 | componentWillRender: asyncReconciledRender,
|
2088 | componentDidRender: proxyWrapper,
|
2089 | componentDidUpdate: function componentDidUpdate(component) {
|
2090 | component[RENDERED_GENERATION] = get$1();
|
2091 | flushScheduledUpdates();
|
2092 | }
|
2093 | });
|
2094 |
|
2095 | var AppContainer = function (_React$Component) {
|
2096 | inherits(AppContainer, _React$Component);
|
2097 |
|
2098 | function AppContainer() {
|
2099 | var _temp, _this, _ret;
|
2100 |
|
2101 | classCallCheck(this, AppContainer);
|
2102 |
|
2103 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
2104 | args[_key] = arguments[_key];
|
2105 | }
|
2106 |
|
2107 | return _ret = (_temp = (_this = possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {
|
2108 | error: null,
|
2109 | errorInfo: null,
|
2110 |
|
2111 | generation: 0
|
2112 | }, _temp), possibleConstructorReturn(_this, _ret);
|
2113 | }
|
2114 |
|
2115 | AppContainer.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {
|
2116 | if (prevState.generation !== get$1()) {
|
2117 |
|
2118 | return {
|
2119 | error: null,
|
2120 | generation: get$1()
|
2121 | };
|
2122 | }
|
2123 | return null;
|
2124 | };
|
2125 |
|
2126 | AppContainer.prototype.shouldComponentUpdate = function shouldComponentUpdate(prevProps, prevState) {
|
2127 |
|
2128 |
|
2129 |
|
2130 | if (prevState.error && this.state.error) {
|
2131 | return false;
|
2132 | }
|
2133 |
|
2134 | return true;
|
2135 | };
|
2136 |
|
2137 | AppContainer.prototype.componentDidCatch = function componentDidCatch(error, errorInfo) {
|
2138 | logger.error(error);
|
2139 |
|
2140 | if (!hotComparisonOpen()) {
|
2141 |
|
2142 |
|
2143 |
|
2144 | this.setState({});
|
2145 | throw error;
|
2146 | }
|
2147 | var _props$errorReporter = this.props.errorReporter,
|
2148 | errorReporter = _props$errorReporter === undefined ? configuration.errorReporter : _props$errorReporter;
|
2149 |
|
2150 | if (!errorReporter) {
|
2151 | logException(error, errorInfo, this);
|
2152 | }
|
2153 | this.setState({
|
2154 | error: error,
|
2155 | errorInfo: errorInfo
|
2156 | });
|
2157 | };
|
2158 |
|
2159 | AppContainer.prototype.retryHotLoaderError = function retryHotLoaderError$$1() {
|
2160 | var _this2 = this;
|
2161 |
|
2162 | this.setState({ error: null }, function () {
|
2163 | retryHotLoaderError.call(_this2);
|
2164 | });
|
2165 | };
|
2166 |
|
2167 | AppContainer.prototype.render = function render() {
|
2168 | var _state = this.state,
|
2169 | error = _state.error,
|
2170 | errorInfo = _state.errorInfo;
|
2171 | var _props$errorReporter2 = this.props.errorReporter,
|
2172 | ErrorReporter = _props$errorReporter2 === undefined ? configuration.errorReporter || EmptyErrorPlaceholder : _props$errorReporter2;
|
2173 |
|
2174 |
|
2175 | if (error && this.props.errorBoundary) {
|
2176 | return React__default.createElement(ErrorReporter, { error: error, errorInfo: errorInfo, component: this });
|
2177 | }
|
2178 |
|
2179 | if (this.hotComponentUpdate) {
|
2180 | this.hotComponentUpdate();
|
2181 | } else {
|
2182 | throw new Error('React-Hot-Loader: AppContainer should be patched');
|
2183 | }
|
2184 |
|
2185 | return React__default.Children.only(this.props.children);
|
2186 | };
|
2187 |
|
2188 | return AppContainer;
|
2189 | }(React__default.Component);
|
2190 |
|
2191 | AppContainer.reactHotLoadable = false;
|
2192 |
|
2193 |
|
2194 | AppContainer.propTypes = {
|
2195 | children: function children(props) {
|
2196 | if (React__default.Children.count(props.children) !== 1) {
|
2197 | return new Error('Invalid prop "children" supplied to AppContainer. ' + 'Expected a single React element with your app’s root component, e.g. <App />.');
|
2198 | }
|
2199 |
|
2200 | return undefined;
|
2201 | },
|
2202 |
|
2203 | errorReporter: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
|
2204 | errorBoundary: PropTypes.bool
|
2205 | };
|
2206 |
|
2207 | AppContainer.defaultProps = {
|
2208 | errorBoundary: true
|
2209 |
|
2210 |
|
2211 | };var realPolyfill = defaultPolyfill.polyfill || defaultPolyfill__default;
|
2212 | realPolyfill(AppContainer);
|
2213 |
|
2214 | var lazyConstructor = '_ctor';
|
2215 |
|
2216 | var updateLazy = function updateLazy(target, type) {
|
2217 | var ctor = type[lazyConstructor];
|
2218 | if (target[lazyConstructor] !== type[lazyConstructor]) {
|
2219 |
|
2220 | ctor();
|
2221 | }
|
2222 | if (!target[lazyConstructor].isPatchedByReactHotLoader) {
|
2223 | target[lazyConstructor] = function () {
|
2224 | return ctor().then(function (m) {
|
2225 | var C = resolveType(m.default);
|
2226 |
|
2227 | enterHotUpdate();
|
2228 | return {
|
2229 | default: function _default(props) {
|
2230 | return React__default.createElement(
|
2231 | AppContainer,
|
2232 | null,
|
2233 | React__default.createElement(C, props)
|
2234 | );
|
2235 | }
|
2236 | };
|
2237 | });
|
2238 | };
|
2239 | target[lazyConstructor].isPatchedByReactHotLoader = true;
|
2240 | }
|
2241 | };
|
2242 |
|
2243 | var updateMemo = function updateMemo(target, _ref) {
|
2244 | var type = _ref.type;
|
2245 |
|
2246 | target.type = resolveType(type);
|
2247 | };
|
2248 |
|
2249 | var updateForward = function updateForward(target, _ref2) {
|
2250 | var render = _ref2.render;
|
2251 |
|
2252 | target.render = render;
|
2253 | };
|
2254 |
|
2255 | var updateContext = function updateContext() {
|
2256 |
|
2257 | };
|
2258 |
|
2259 | var getInnerComponentType = function getInnerComponentType(component) {
|
2260 | var unwrapper = component[UNWRAP_PROXY];
|
2261 | return unwrapper ? unwrapper() : component;
|
2262 | };
|
2263 |
|
2264 | var compareComponents = function compareComponents(oldType, newType, setNewType, baseType) {
|
2265 | var defaultResult = oldType === newType;
|
2266 |
|
2267 | if (oldType && !newType || !oldType && newType) {
|
2268 | return false;
|
2269 | }
|
2270 |
|
2271 | if (isRegisteredComponent(oldType) || isRegisteredComponent(newType)) {
|
2272 | if (resolveType(oldType) !== resolveType(newType)) {
|
2273 | return false;
|
2274 | }
|
2275 | defaultResult = true;
|
2276 | }
|
2277 |
|
2278 | if (isForwardType({ type: oldType }) && isForwardType({ type: newType })) {
|
2279 | if (oldType.render === newType.render || areSwappable(oldType.render, newType.render)) {
|
2280 | setNewType(newType);
|
2281 | return true;
|
2282 | }
|
2283 | return defaultResult;
|
2284 | }
|
2285 |
|
2286 | if (isMemoType({ type: oldType }) && isMemoType({ type: newType })) {
|
2287 | if (oldType.type === newType.type || areSwappable(oldType.type, newType.type)) {
|
2288 | if (baseType) {
|
2289 |
|
2290 | if (oldType === baseType) {
|
2291 | setNewType(newType);
|
2292 | } else {
|
2293 | setNewType(newType.type);
|
2294 | }
|
2295 | } else {
|
2296 | logger.warn('Please update hot-loader/react-dom');
|
2297 | if (isReactClass(newType.type)) {
|
2298 | setNewType(newType);
|
2299 | } else {
|
2300 | setNewType(newType.type);
|
2301 | }
|
2302 | }
|
2303 |
|
2304 | return true;
|
2305 | }
|
2306 | return defaultResult;
|
2307 | }
|
2308 |
|
2309 | if (newType !== oldType && areSwappable(newType, oldType)) {
|
2310 | var unwrapFactory = newType[UNWRAP_PROXY];
|
2311 | var oldProxy = unwrapFactory && getProxyByType(unwrapFactory());
|
2312 | if (oldProxy) {
|
2313 | oldProxy.dereference();
|
2314 | updateProxyById(oldType[PROXY_KEY] || getIdByType(oldType), getInnerComponentType(newType));
|
2315 | } else {
|
2316 | setNewType(newType);
|
2317 | }
|
2318 | return true;
|
2319 | }
|
2320 |
|
2321 | return defaultResult;
|
2322 | };
|
2323 |
|
2324 | var knownPairs = new WeakMap();
|
2325 | var emptyMap$1 = new WeakMap();
|
2326 |
|
2327 | var hotComponentCompare = function hotComponentCompare(oldType, newType, setNewType, baseType) {
|
2328 | var hotActive = hotComparisonOpen();
|
2329 | var result = oldType === newType;
|
2330 |
|
2331 | if (!isReloadableComponent(oldType) || !isReloadableComponent(newType) || isColdType(oldType) || isColdType(oldType) || !oldType || !newType || 0) {
|
2332 | return result;
|
2333 | }
|
2334 |
|
2335 |
|
2336 |
|
2337 | if (hotActive) {
|
2338 | result = compareComponents(oldType, newType, setNewType, baseType);
|
2339 | var _pair = knownPairs.get(oldType) || new WeakMap();
|
2340 | _pair.set(newType, result);
|
2341 | knownPairs.set(oldType, _pair);
|
2342 | return result;
|
2343 | }
|
2344 |
|
2345 | if (result) {
|
2346 | return result;
|
2347 | }
|
2348 |
|
2349 | var pair = knownPairs.get(oldType) || emptyMap$1;
|
2350 | return pair.get(newType) || false;
|
2351 | };
|
2352 |
|
2353 |
|
2354 |
|
2355 | var forceSimpleSFC = { proxy: { pureSFC: true } };
|
2356 |
|
2357 | var reactHotLoader = {
|
2358 | IS_REACT_MERGE_ENABLED: false,
|
2359 | register: function register(type, uniqueLocalName, fileName) {
|
2360 | var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
|
2361 |
|
2362 | var id = fileName + '#' + uniqueLocalName;
|
2363 |
|
2364 | if (isCompositeComponent(type) && typeof uniqueLocalName === 'string' && uniqueLocalName && typeof fileName === 'string' && fileName) {
|
2365 | var proxy = getProxyById(id);
|
2366 |
|
2367 | if (proxy && proxy.getCurrent() !== type) {
|
2368 |
|
2369 | increment();
|
2370 |
|
2371 | if (!reactHotLoader.IS_REACT_MERGE_ENABLED) {
|
2372 | if (isTypeBlacklisted(type) || isTypeBlacklisted(proxy.getCurrent())) {
|
2373 | logger.error('React-hot-loader: Cold component', uniqueLocalName, 'at', fileName, 'has been updated');
|
2374 | }
|
2375 | }
|
2376 | }
|
2377 |
|
2378 | if (configuration.onComponentRegister) {
|
2379 | configuration.onComponentRegister(type, uniqueLocalName, fileName);
|
2380 | }
|
2381 | if (configuration.onComponentCreate) {
|
2382 | configuration.onComponentCreate(type, getComponentDisplayName(type));
|
2383 | }
|
2384 |
|
2385 | registerComponent(updateProxyById(id, type, options).get(), 2);
|
2386 | registerComponent(type);
|
2387 | }
|
2388 | if (isContextType({ type: type })) {
|
2389 | ['Provider', 'Consumer'].forEach(function (prop) {
|
2390 | var descriptor = Object.getOwnPropertyDescriptor(type, prop);
|
2391 | if (descriptor && descriptor.value) {
|
2392 | updateFunctionProxyById(id + ':' + prop, descriptor.value, updateContext);
|
2393 | }
|
2394 | });
|
2395 | updateFunctionProxyById(id, type, updateContext);
|
2396 | increment();
|
2397 | }
|
2398 | if (isLazyType({ type: type })) {
|
2399 | updateFunctionProxyById(id, type, updateLazy);
|
2400 | increment();
|
2401 | }
|
2402 | if (isForwardType({ type: type })) {
|
2403 | updateFunctionProxyById(id, type, updateForward);
|
2404 | increment();
|
2405 | }
|
2406 | if (isMemoType({ type: type })) {
|
2407 | reactHotLoader.register(type.type, uniqueLocalName + ':memo', fileName, forceSimpleSFC);
|
2408 | updateFunctionProxyById(id, type, updateMemo);
|
2409 | increment();
|
2410 | }
|
2411 | },
|
2412 | reset: function reset() {
|
2413 | resetProxies();
|
2414 | },
|
2415 | preact: function preact(instance) {
|
2416 | preactAdapter(instance, resolveType);
|
2417 | },
|
2418 | resolveType: function resolveType$$1(type) {
|
2419 | return resolveType(type);
|
2420 | },
|
2421 | patch: function patch(React$$1, ReactDOM$$1) {
|
2422 |
|
2423 | if (ReactDOM$$1 && ReactDOM$$1.setHotElementComparator) {
|
2424 | ReactDOM$$1.setHotElementComparator(hotComponentCompare);
|
2425 | configuration.disableHotRenderer = configuration.disableHotRendererWhenInjected;
|
2426 |
|
2427 | configuration.ignoreSFC = configuration.ignoreSFCWhenInjected;
|
2428 |
|
2429 | reactHotLoader.IS_REACT_MERGE_ENABLED = true;
|
2430 | } else {
|
2431 |
|
2432 | console.warn('React-Hot-Loader: react-🔥-dom patch is not detected. React 16.6+ features may not work.');
|
2433 | }
|
2434 |
|
2435 | if (!React$$1.createElement.isPatchedByReactHotLoader) {
|
2436 | var originalCreateElement = React$$1.createElement;
|
2437 |
|
2438 |
|
2439 |
|
2440 | React$$1.createElement = function (type) {
|
2441 | for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
2442 | args[_key - 1] = arguments[_key];
|
2443 | }
|
2444 |
|
2445 | return originalCreateElement.apply(undefined, [resolveType(type)].concat(args));
|
2446 | };
|
2447 | React$$1.createElement.isPatchedByReactHotLoader = true;
|
2448 | }
|
2449 |
|
2450 | if (!React$$1.cloneElement.isPatchedByReactHotLoader) {
|
2451 | var originalCloneElement = React$$1.cloneElement;
|
2452 |
|
2453 | React$$1.cloneElement = function (element) {
|
2454 | for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
2455 | args[_key2 - 1] = arguments[_key2];
|
2456 | }
|
2457 |
|
2458 | var newType = element.type && resolveType(element.type);
|
2459 | if (newType && newType !== element.type) {
|
2460 | return originalCloneElement.apply(undefined, [_extends({}, element, {
|
2461 | type: newType
|
2462 | })].concat(args));
|
2463 | }
|
2464 | return originalCloneElement.apply(undefined, [element].concat(args));
|
2465 | };
|
2466 |
|
2467 | React$$1.cloneElement.isPatchedByReactHotLoader = true;
|
2468 | }
|
2469 |
|
2470 | if (!React$$1.createFactory.isPatchedByReactHotLoader) {
|
2471 |
|
2472 |
|
2473 |
|
2474 | React$$1.createFactory = function (type) {
|
2475 | var factory = React$$1.createElement.bind(null, type);
|
2476 | factory.type = type;
|
2477 | return factory;
|
2478 | };
|
2479 | React$$1.createFactory.isPatchedByReactHotLoader = true;
|
2480 | }
|
2481 |
|
2482 | if (!React$$1.Children.only.isPatchedByReactHotLoader) {
|
2483 | var originalChildrenOnly = React$$1.Children.only;
|
2484 |
|
2485 | React$$1.Children.only = function (children) {
|
2486 | return originalChildrenOnly(_extends({}, children, { type: resolveType(children.type) }));
|
2487 | };
|
2488 | React$$1.Children.only.isPatchedByReactHotLoader = true;
|
2489 | }
|
2490 |
|
2491 |
|
2492 | }
|
2493 | };
|
2494 |
|
2495 | var openedModules = {};
|
2496 | var lastModuleOpened = '';
|
2497 | var getLastModuleOpened = function getLastModuleOpened() {
|
2498 | return lastModuleOpened;
|
2499 | };
|
2500 |
|
2501 | var hotModules = {};
|
2502 |
|
2503 | var createHotModule = function createHotModule() {
|
2504 | return { instances: [], updateTimeout: 0 };
|
2505 | };
|
2506 |
|
2507 | var hotModule = function hotModule(moduleId) {
|
2508 | if (!hotModules[moduleId]) {
|
2509 | hotModules[moduleId] = createHotModule();
|
2510 | }
|
2511 | return hotModules[moduleId];
|
2512 | };
|
2513 |
|
2514 | var isOpened = function isOpened(sourceModule) {
|
2515 | return sourceModule && !!openedModules[sourceModule.id];
|
2516 | };
|
2517 |
|
2518 | var enter = function enter(sourceModule) {
|
2519 | if (sourceModule && sourceModule.id) {
|
2520 | lastModuleOpened = sourceModule.id;
|
2521 | openedModules[sourceModule.id] = true;
|
2522 | } else {
|
2523 | logger.warn('React-hot-loader: no `module` variable found. Did you shadow a system variable?');
|
2524 | }
|
2525 | };
|
2526 |
|
2527 | var leave = function leave(sourceModule) {
|
2528 | if (sourceModule && sourceModule.id) {
|
2529 | delete openedModules[sourceModule.id];
|
2530 | }
|
2531 | };
|
2532 |
|
2533 |
|
2534 | var requireIndirect = typeof __webpack_require__ !== 'undefined' ? __webpack_require__ : require;
|
2535 |
|
2536 |
|
2537 | var chargeFailbackTimer = function chargeFailbackTimer(id) {
|
2538 | return setTimeout(function () {
|
2539 | var error = 'hot update failed for module "' + id + '". Last file processed: "' + getLastModuleOpened() + '".';
|
2540 | logger.error(error);
|
2541 | logException({
|
2542 | toString: function toString() {
|
2543 | return error;
|
2544 | }
|
2545 | });
|
2546 |
|
2547 | }, 100);
|
2548 | };
|
2549 |
|
2550 | var clearFailbackTimer = function clearFailbackTimer(timerId) {
|
2551 | return clearTimeout(timerId);
|
2552 | };
|
2553 |
|
2554 | var createHoc = function createHoc(SourceComponent, TargetComponent) {
|
2555 | hoistNonReactStatic(TargetComponent, SourceComponent);
|
2556 | TargetComponent.displayName = 'HotExported' + getComponentDisplayName(SourceComponent);
|
2557 | return TargetComponent;
|
2558 | };
|
2559 |
|
2560 | var makeHotExport = function makeHotExport(sourceModule) {
|
2561 | var updateInstances = function updateInstances(possibleError) {
|
2562 | if (possibleError && possibleError instanceof Error) {
|
2563 | console.error(possibleError);
|
2564 | return;
|
2565 | }
|
2566 | var module = hotModule(sourceModule.id);
|
2567 | clearTimeout(module.updateTimeout);
|
2568 | module.updateTimeout = setTimeout(function () {
|
2569 | try {
|
2570 | requireIndirect(sourceModule.id);
|
2571 | } catch (e) {
|
2572 | console.error('React-Hot-Loader: error detected while loading', sourceModule.id);
|
2573 | console.error(e);
|
2574 | }
|
2575 | module.instances.forEach(function (inst) {
|
2576 | return inst.forceUpdate();
|
2577 | });
|
2578 | });
|
2579 | };
|
2580 |
|
2581 | if (sourceModule.hot) {
|
2582 |
|
2583 |
|
2584 | sourceModule.hot.accept(updateInstances);
|
2585 |
|
2586 |
|
2587 | if (sourceModule.hot.addStatusHandler) {
|
2588 | if (sourceModule.hot.status() === 'idle') {
|
2589 | sourceModule.hot.addStatusHandler(function (status) {
|
2590 | if (status === 'apply') {
|
2591 | clearExceptions();
|
2592 | updateInstances();
|
2593 | }
|
2594 | });
|
2595 | }
|
2596 | }
|
2597 | }
|
2598 | };
|
2599 |
|
2600 | var hot = function hot(sourceModule) {
|
2601 | if (!sourceModule || !sourceModule.id) {
|
2602 |
|
2603 | throw new Error('React-hot-loader: `hot` could not find the `id` property in the `module` you have provided');
|
2604 | }
|
2605 | var moduleId = sourceModule.id;
|
2606 | var module = hotModule(moduleId);
|
2607 | makeHotExport(sourceModule);
|
2608 |
|
2609 | clearExceptions();
|
2610 | var failbackTimer = chargeFailbackTimer(sourceModule.id);
|
2611 | var firstHotRegistered = false;
|
2612 |
|
2613 |
|
2614 |
|
2615 | return function (WrappedComponent, props) {
|
2616 | clearFailbackTimer(failbackTimer);
|
2617 |
|
2618 |
|
2619 | if (!firstHotRegistered) {
|
2620 | firstHotRegistered = true;
|
2621 | reactHotLoader.register(WrappedComponent, getComponentDisplayName(WrappedComponent), 'RHL' + moduleId);
|
2622 | }
|
2623 |
|
2624 | return createHoc(WrappedComponent, function (_Component) {
|
2625 | inherits(ExportedComponent, _Component);
|
2626 |
|
2627 | function ExportedComponent() {
|
2628 | classCallCheck(this, ExportedComponent);
|
2629 | return possibleConstructorReturn(this, _Component.apply(this, arguments));
|
2630 | }
|
2631 |
|
2632 | ExportedComponent.prototype.componentDidMount = function componentDidMount() {
|
2633 | module.instances.push(this);
|
2634 | };
|
2635 |
|
2636 | ExportedComponent.prototype.componentWillUnmount = function componentWillUnmount() {
|
2637 | var _this2 = this;
|
2638 |
|
2639 | if (isOpened(sourceModule)) {
|
2640 | var componentName = getComponentDisplayName(WrappedComponent);
|
2641 | 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/).');
|
2642 | }
|
2643 | module.instances = module.instances.filter(function (a) {
|
2644 | return a !== _this2;
|
2645 | });
|
2646 | };
|
2647 |
|
2648 | ExportedComponent.prototype.render = function render() {
|
2649 | return React__default.createElement(
|
2650 | AppContainer,
|
2651 | props,
|
2652 | React__default.createElement(WrappedComponent, this.props)
|
2653 | );
|
2654 | };
|
2655 |
|
2656 | return ExportedComponent;
|
2657 | }(React.Component));
|
2658 | };
|
2659 | };
|
2660 |
|
2661 | var getProxyOrType = function getProxyOrType(type) {
|
2662 | var proxy = getProxyByType(type);
|
2663 | return proxy ? proxy.get() : type;
|
2664 | };
|
2665 |
|
2666 | var areComponentsEqual = function areComponentsEqual(a, b) {
|
2667 | return getProxyOrType(a) === getProxyOrType(b);
|
2668 | };
|
2669 |
|
2670 | var compareOrSwap = function compareOrSwap(oldType, newType) {
|
2671 | return hotComponentCompare(oldType, newType);
|
2672 | };
|
2673 |
|
2674 | var cold = function cold(type) {
|
2675 | blacklistByType(type);
|
2676 | return type;
|
2677 | };
|
2678 |
|
2679 | var configureComponent = function configureComponent(component, options) {
|
2680 | return setComponentOptions(component, options);
|
2681 | };
|
2682 |
|
2683 | var setConfig = function setConfig(config) {
|
2684 | return Object.assign(configuration, config);
|
2685 | };
|
2686 |
|
2687 | reactHotLoader.patch(React__default, ReactDOM);
|
2688 |
|
2689 | exports.default = reactHotLoader;
|
2690 | exports.AppContainer = AppContainer;
|
2691 | exports.hot = hot;
|
2692 | exports.enterModule = enter;
|
2693 | exports.leaveModule = leave;
|
2694 | exports.areComponentsEqual = areComponentsEqual;
|
2695 | exports.compareOrSwap = compareOrSwap;
|
2696 | exports.cold = cold;
|
2697 | exports.configureComponent = configureComponent;
|
2698 | exports.setConfig = setConfig;
|