1 /** @license React v16.8.4

     2  * react-dom.development.js

     3  *

     4  * Copyright (c) Facebook, Inc. and its affiliates.

     5  *

     6  * This source code is licensed under the MIT license found in the

     7  * LICENSE file in the root directory of this source tree.

     8  */

     9 

    10 'use strict';

    11 

    12 (function (global, factory) {

    13 	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react')) :

    14 	typeof define === 'function' && define.amd ? define(['react'], factory) :

    15 	(global.ReactDOM = factory(global.React));

    16 }(this, (function (React) { 'use strict';

    17 

    18 /**

    19  * Use invariant() to assert state which your program assumes to be true.

    20  *

    21  * Provide sprintf-style format (only %s is supported) and arguments

    22  * to provide information about what broke and what you were

    23  * expecting.

    24  *

    25  * The invariant message will be stripped in production, but the invariant

    26  * will remain to ensure logic does not differ in production.

    27  */

    28 

    29 var validateFormat = function () {};

    30 

    31 {

    32   validateFormat = function (format) {

    33     if (format === undefined) {

    34       throw new Error('invariant requires an error message argument');

    35     }

    36   };

    37 }

    38 

    39 function invariant(condition, format, a, b, c, d, e, f) {

    40   validateFormat(format);

    41 

    42   if (!condition) {

    43     var error = void 0;

    44     if (format === undefined) {

    45       error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');

    46     } else {

    47       var args = [a, b, c, d, e, f];

    48       var argIndex = 0;

    49       error = new Error(format.replace(/%s/g, function () {

    50         return args[argIndex++];

    51       }));

    52       error.name = 'Invariant Violation';

    53     }

    54 

    55     error.framesToPop = 1; // we don't care about invariant's own frame

    56     throw error;

    57   }

    58 }

    59 

    60 // Relying on the `invariant()` implementation lets us

    61 // preserve the format and params in the www builds.

    62 

    63 !React ? invariant(false, 'ReactDOM was loaded before React. Make sure you load the React package before loading ReactDOM.') : void 0;

    64 

    65 var invokeGuardedCallbackImpl = function (name, func, context, a, b, c, d, e, f) {

    66   var funcArgs = Array.prototype.slice.call(arguments, 3);

    67   try {

    68     func.apply(context, funcArgs);

    69   } catch (error) {

    70     this.onError(error);

    71   }

    72 };

    73 

    74 {

    75   // In DEV mode, we swap out invokeGuardedCallback for a special version

    76   // that plays more nicely with the browser's DevTools. The idea is to preserve

    77   // "Pause on exceptions" behavior. Because React wraps all user-provided

    78   // functions in invokeGuardedCallback, and the production version of

    79   // invokeGuardedCallback uses a try-catch, all user exceptions are treated

    80   // like caught exceptions, and the DevTools won't pause unless the developer

    81   // takes the extra step of enabling pause on caught exceptions. This is

    82   // unintuitive, though, because even though React has caught the error, from

    83   // the developer's perspective, the error is uncaught.

    84   //

    85   // To preserve the expected "Pause on exceptions" behavior, we don't use a

    86   // try-catch in DEV. Instead, we synchronously dispatch a fake event to a fake

    87   // DOM node, and call the user-provided callback from inside an event handler

    88   // for that fake event. If the callback throws, the error is "captured" using

    89   // a global event handler. But because the error happens in a different

    90   // event loop context, it does not interrupt the normal program flow.

    91   // Effectively, this gives us try-catch behavior without actually using

    92   // try-catch. Neat!

    93 

    94   // Check that the browser supports the APIs we need to implement our special

    95   // DEV version of invokeGuardedCallback

    96   if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') {

    97     var fakeNode = document.createElement('react');

    98 

    99     var invokeGuardedCallbackDev = function (name, func, context, a, b, c, d, e, f) {

   100       // If document doesn't exist we know for sure we will crash in this method

   101       // when we call document.createEvent(). However this can cause confusing

   102       // errors: https://github.com/facebookincubator/create-react-app/issues/3482

   103       // So we preemptively throw with a better message instead.

   104       !(typeof document !== 'undefined') ? invariant(false, 'The `document` global was defined when React was initialized, but is not defined anymore. This can happen in a test environment if a component schedules an update from an asynchronous callback, but the test has already finished running. To solve this, you can either unmount the component at the end of your test (and ensure that any asynchronous operations get canceled in `componentWillUnmount`), or you can change the test itself to be asynchronous.') : void 0;

   105       var evt = document.createEvent('Event');

   106 

   107       // Keeps track of whether the user-provided callback threw an error. We

   108       // set this to true at the beginning, then set it to false right after

   109       // calling the function. If the function errors, `didError` will never be

   110       // set to false. This strategy works even if the browser is flaky and

   111       // fails to call our global error handler, because it doesn't rely on

   112       // the error event at all.

   113       var didError = true;

   114 

   115       // Keeps track of the value of window.event so that we can reset it

   116       // during the callback to let user code access window.event in the

   117       // browsers that support it.

   118       var windowEvent = window.event;

   119 

   120       // Keeps track of the descriptor of window.event to restore it after event

   121       // dispatching: https://github.com/facebook/react/issues/13688

   122       var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, 'event');

   123 

   124       // Create an event handler for our fake event. We will synchronously

   125       // dispatch our fake event using `dispatchEvent`. Inside the handler, we

   126       // call the user-provided callback.

   127       var funcArgs = Array.prototype.slice.call(arguments, 3);

   128       function callCallback() {

   129         // We immediately remove the callback from event listeners so that

   130         // nested `invokeGuardedCallback` calls do not clash. Otherwise, a

   131         // nested call would trigger the fake event handlers of any call higher

   132         // in the stack.

   133         fakeNode.removeEventListener(evtType, callCallback, false);

   134 

   135         // We check for window.hasOwnProperty('event') to prevent the

   136         // window.event assignment in both IE <= 10 as they throw an error

   137         // "Member not found" in strict mode, and in Firefox which does not

   138         // support window.event.

   139         if (typeof window.event !== 'undefined' && window.hasOwnProperty('event')) {

   140           window.event = windowEvent;

   141         }

   142 

   143         func.apply(context, funcArgs);

   144         didError = false;

   145       }

   146 

   147       // Create a global error event handler. We use this to capture the value

   148       // that was thrown. It's possible that this error handler will fire more

   149       // than once; for example, if non-React code also calls `dispatchEvent`

   150       // and a handler for that event throws. We should be resilient to most of

   151       // those cases. Even if our error event handler fires more than once, the

   152       // last error event is always used. If the callback actually does error,

   153       // we know that the last error event is the correct one, because it's not

   154       // possible for anything else to have happened in between our callback

   155       // erroring and the code that follows the `dispatchEvent` call below. If

   156       // the callback doesn't error, but the error event was fired, we know to

   157       // ignore it because `didError` will be false, as described above.

   158       var error = void 0;

   159       // Use this to track whether the error event is ever called.

   160       var didSetError = false;

   161       var isCrossOriginError = false;

   162 

   163       function handleWindowError(event) {

   164         error = event.error;

   165         didSetError = true;

   166         if (error === null && event.colno === 0 && event.lineno === 0) {

   167           isCrossOriginError = true;

   168         }

   169         if (event.defaultPrevented) {

   170           // Some other error handler has prevented default.

   171           // Browsers silence the error report if this happens.

   172           // We'll remember this to later decide whether to log it or not.

   173           if (error != null && typeof error === 'object') {

   174             try {

   175               error._suppressLogging = true;

   176             } catch (inner) {

   177               // Ignore.

   178             }

   179           }

   180         }

   181       }

   182 

   183       // Create a fake event type.

   184       var evtType = 'react-' + (name ? name : 'invokeguardedcallback');

   185 

   186       // Attach our event handlers

   187       window.addEventListener('error', handleWindowError);

   188       fakeNode.addEventListener(evtType, callCallback, false);

   189 

   190       // Synchronously dispatch our fake event. If the user-provided function

   191       // errors, it will trigger our global error handler.

   192       evt.initEvent(evtType, false, false);

   193       fakeNode.dispatchEvent(evt);

   194 

   195       if (windowEventDescriptor) {

   196         Object.defineProperty(window, 'event', windowEventDescriptor);

   197       }

   198 

   199       if (didError) {

   200         if (!didSetError) {

   201           // The callback errored, but the error event never fired.

   202           error = new Error('An error was thrown inside one of your components, but React ' + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + 'your browser. Try triggering the error in production mode, ' + 'or switching to a modern browser. If you suspect that this is ' + 'actually an issue with React, please file an issue.');

   203         } else if (isCrossOriginError) {

   204           error = new Error("A cross-origin error was thrown. React doesn't have access to " + 'the actual error object in development. ' + 'See https://fb.me/react-crossorigin-error for more information.');

   205         }

   206         this.onError(error);

   207       }

   208 

   209       // Remove our event listeners

   210       window.removeEventListener('error', handleWindowError);

   211     };

   212 

   213     invokeGuardedCallbackImpl = invokeGuardedCallbackDev;

   214   }

   215 }

   216 

   217 var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl;

   218 

   219 // Used by Fiber to simulate a try-catch.

   220 var hasError = false;

   221 var caughtError = null;

   222 

   223 // Used by event system to capture/rethrow the first error.

   224 var hasRethrowError = false;

   225 var rethrowError = null;

   226 

   227 var reporter = {

   228   onError: function (error) {

   229     hasError = true;

   230     caughtError = error;

   231   }

   232 };

   233 

   234 /**

   235  * Call a function while guarding against errors that happens within it.

   236  * Returns an error if it throws, otherwise null.

   237  *

   238  * In production, this is implemented using a try-catch. The reason we don't

   239  * use a try-catch directly is so that we can swap out a different

   240  * implementation in DEV mode.

   241  *

   242  * @param {String} name of the guard to use for logging or debugging

   243  * @param {Function} func The function to invoke

   244  * @param {*} context The context to use when calling the function

   245  * @param {...*} args Arguments for function

   246  */

   247 function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {

   248   hasError = false;

   249   caughtError = null;

   250   invokeGuardedCallbackImpl$1.apply(reporter, arguments);

   251 }

   252 

   253 /**

   254  * Same as invokeGuardedCallback, but instead of returning an error, it stores

   255  * it in a global so it can be rethrown by `rethrowCaughtError` later.

   256  * TODO: See if caughtError and rethrowError can be unified.

   257  *

   258  * @param {String} name of the guard to use for logging or debugging

   259  * @param {Function} func The function to invoke

   260  * @param {*} context The context to use when calling the function

   261  * @param {...*} args Arguments for function

   262  */

   263 function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {

   264   invokeGuardedCallback.apply(this, arguments);

   265   if (hasError) {

   266     var error = clearCaughtError();

   267     if (!hasRethrowError) {

   268       hasRethrowError = true;

   269       rethrowError = error;

   270     }

   271   }

   272 }

   273 

   274 /**

   275  * During execution of guarded functions we will capture the first error which

   276  * we will rethrow to be handled by the top level error handler.

   277  */

   278 function rethrowCaughtError() {

   279   if (hasRethrowError) {

   280     var error = rethrowError;

   281     hasRethrowError = false;

   282     rethrowError = null;

   283     throw error;

   284   }

   285 }

   286 

   287 function hasCaughtError() {

   288   return hasError;

   289 }

   290 

   291 function clearCaughtError() {

   292   if (hasError) {

   293     var error = caughtError;

   294     hasError = false;

   295     caughtError = null;

   296     return error;

   297   } else {

   298     invariant(false, 'clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue.');

   299   }

   300 }

   301 

   302 /**

   303  * Injectable ordering of event plugins.

   304  */

   305 var eventPluginOrder = null;

   306 

   307 /**

   308  * Injectable mapping from names to event plugin modules.

   309  */

   310 var namesToPlugins = {};

   311 

   312 /**

   313  * Recomputes the plugin list using the injected plugins and plugin ordering.

   314  *

   315  * @private

   316  */

   317 function recomputePluginOrdering() {

   318   if (!eventPluginOrder) {

   319     // Wait until an `eventPluginOrder` is injected.

   320     return;

   321   }

   322   for (var pluginName in namesToPlugins) {

   323     var pluginModule = namesToPlugins[pluginName];

   324     var pluginIndex = eventPluginOrder.indexOf(pluginName);

   325     !(pluginIndex > -1) ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.', pluginName) : void 0;

   326     if (plugins[pluginIndex]) {

   327       continue;

   328     }

   329     !pluginModule.extractEvents ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.', pluginName) : void 0;

   330     plugins[pluginIndex] = pluginModule;

   331     var publishedEvents = pluginModule.eventTypes;

   332     for (var eventName in publishedEvents) {

   333       !publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName) ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : void 0;

   334     }

   335   }

   336 }

   337 

   338 /**

   339  * Publishes an event so that it can be dispatched by the supplied plugin.

   340  *

   341  * @param {object} dispatchConfig Dispatch configuration for the event.

   342  * @param {object} PluginModule Plugin publishing the event.

   343  * @return {boolean} True if the event was successfully published.

   344  * @private

   345  */

   346 function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {

   347   !!eventNameDispatchConfigs.hasOwnProperty(eventName) ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.', eventName) : void 0;

   348   eventNameDispatchConfigs[eventName] = dispatchConfig;

   349 

   350   var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;

   351   if (phasedRegistrationNames) {

   352     for (var phaseName in phasedRegistrationNames) {

   353       if (phasedRegistrationNames.hasOwnProperty(phaseName)) {

   354         var phasedRegistrationName = phasedRegistrationNames[phaseName];

   355         publishRegistrationName(phasedRegistrationName, pluginModule, eventName);

   356       }

   357     }

   358     return true;

   359   } else if (dispatchConfig.registrationName) {

   360     publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName);

   361     return true;

   362   }

   363   return false;

   364 }

   365 

   366 /**

   367  * Publishes a registration name that is used to identify dispatched events.

   368  *

   369  * @param {string} registrationName Registration name to add.

   370  * @param {object} PluginModule Plugin publishing the event.

   371  * @private

   372  */

   373 function publishRegistrationName(registrationName, pluginModule, eventName) {

   374   !!registrationNameModules[registrationName] ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.', registrationName) : void 0;

   375   registrationNameModules[registrationName] = pluginModule;

   376   registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;

   377 

   378   {

   379     var lowerCasedName = registrationName.toLowerCase();

   380     possibleRegistrationNames[lowerCasedName] = registrationName;

   381 

   382     if (registrationName === 'onDoubleClick') {

   383       possibleRegistrationNames.ondblclick = registrationName;

   384     }

   385   }

   386 }

   387 

   388 /**

   389  * Registers plugins so that they can extract and dispatch events.

   390  *

   391  * @see {EventPluginHub}

   392  */

   393 

   394 /**

   395  * Ordered list of injected plugins.

   396  */

   397 var plugins = [];

   398 

   399 /**

   400  * Mapping from event name to dispatch config

   401  */

   402 var eventNameDispatchConfigs = {};

   403 

   404 /**

   405  * Mapping from registration name to plugin module

   406  */

   407 var registrationNameModules = {};

   408 

   409 /**

   410  * Mapping from registration name to event name

   411  */

   412 var registrationNameDependencies = {};

   413 

   414 /**

   415  * Mapping from lowercase registration names to the properly cased version,

   416  * used to warn in the case of missing event handlers. Available

   417  * only in true.

   418  * @type {Object}

   419  */

   420 var possibleRegistrationNames = {};

   421 // Trust the developer to only use possibleRegistrationNames in true

   422 

   423 /**

   424  * Injects an ordering of plugins (by plugin name). This allows the ordering

   425  * to be decoupled from injection of the actual plugins so that ordering is

   426  * always deterministic regardless of packaging, on-the-fly injection, etc.

   427  *

   428  * @param {array} InjectedEventPluginOrder

   429  * @internal

   430  * @see {EventPluginHub.injection.injectEventPluginOrder}

   431  */

   432 function injectEventPluginOrder(injectedEventPluginOrder) {

   433   !!eventPluginOrder ? invariant(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.') : void 0;

   434   // Clone the ordering so it cannot be dynamically mutated.

   435   eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);

   436   recomputePluginOrdering();

   437 }

   438 

   439 /**

   440  * Injects plugins to be used by `EventPluginHub`. The plugin names must be

   441  * in the ordering injected by `injectEventPluginOrder`.

   442  *

   443  * Plugins can be injected as part of page initialization or on-the-fly.

   444  *

   445  * @param {object} injectedNamesToPlugins Map from names to plugin modules.

   446  * @internal

   447  * @see {EventPluginHub.injection.injectEventPluginsByName}

   448  */

   449 function injectEventPluginsByName(injectedNamesToPlugins) {

   450   var isOrderingDirty = false;

   451   for (var pluginName in injectedNamesToPlugins) {

   452     if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {

   453       continue;

   454     }

   455     var pluginModule = injectedNamesToPlugins[pluginName];

   456     if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {

   457       !!namesToPlugins[pluginName] ? invariant(false, 'EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.', pluginName) : void 0;

   458       namesToPlugins[pluginName] = pluginModule;

   459       isOrderingDirty = true;

   460     }

   461   }

   462   if (isOrderingDirty) {

   463     recomputePluginOrdering();

   464   }

   465 }

   466 

   467 /**

   468  * Similar to invariant but only logs a warning if the condition is not met.

   469  * This can be used to log issues in development environments in critical

   470  * paths. Removing the logging code for production environments will keep the

   471  * same logic and follow the same code paths.

   472  */

   473 

   474 var warningWithoutStack = function () {};

   475 

   476 {

   477   warningWithoutStack = function (condition, format) {

   478     for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {

   479       args[_key - 2] = arguments[_key];

   480     }

   481 

   482     if (format === undefined) {

   483       throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');

   484     }

   485     if (args.length > 8) {

   486       // Check before the condition to catch violations early.

   487       throw new Error('warningWithoutStack() currently supports at most 8 arguments.');

   488     }

   489     if (condition) {

   490       return;

   491     }

   492     if (typeof console !== 'undefined') {

   493       var argsWithFormat = args.map(function (item) {

   494         return '' + item;

   495       });

   496       argsWithFormat.unshift('Warning: ' + format);

   497 

   498       // We intentionally don't use spread (or .apply) directly because it

   499       // breaks IE9: https://github.com/facebook/react/issues/13610

   500       Function.prototype.apply.call(console.error, console, argsWithFormat);

   501     }

   502     try {

   503       // --- Welcome to debugging React ---

   504       // This error was thrown as a convenience so that you can use this stack

   505       // to find the callsite that caused this warning to fire.

   506       var argIndex = 0;

   507       var message = 'Warning: ' + format.replace(/%s/g, function () {

   508         return args[argIndex++];

   509       });

   510       throw new Error(message);

   511     } catch (x) {}

   512   };

   513 }

   514 

   515 var warningWithoutStack$1 = warningWithoutStack;

   516 

   517 var getFiberCurrentPropsFromNode = null;

   518 var getInstanceFromNode = null;

   519 var getNodeFromInstance = null;

   520 

   521 function setComponentTree(getFiberCurrentPropsFromNodeImpl, getInstanceFromNodeImpl, getNodeFromInstanceImpl) {

   522   getFiberCurrentPropsFromNode = getFiberCurrentPropsFromNodeImpl;

   523   getInstanceFromNode = getInstanceFromNodeImpl;

   524   getNodeFromInstance = getNodeFromInstanceImpl;

   525   {

   526     !(getNodeFromInstance && getInstanceFromNode) ? warningWithoutStack$1(false, 'EventPluginUtils.setComponentTree(...): Injected ' + 'module is missing getNodeFromInstance or getInstanceFromNode.') : void 0;

   527   }

   528 }

   529 

   530 var validateEventDispatches = void 0;

   531 {

   532   validateEventDispatches = function (event) {

   533     var dispatchListeners = event._dispatchListeners;

   534     var dispatchInstances = event._dispatchInstances;

   535 

   536     var listenersIsArr = Array.isArray(dispatchListeners);

   537     var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;

   538 

   539     var instancesIsArr = Array.isArray(dispatchInstances);

   540     var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;

   541 

   542     !(instancesIsArr === listenersIsArr && instancesLen === listenersLen) ? warningWithoutStack$1(false, 'EventPluginUtils: Invalid `event`.') : void 0;

   543   };

   544 }

   545 

   546 /**

   547  * Dispatch the event to the listener.

   548  * @param {SyntheticEvent} event SyntheticEvent to handle

   549  * @param {function} listener Application-level callback

   550  * @param {*} inst Internal component instance

   551  */

   552 function executeDispatch(event, listener, inst) {

   553   var type = event.type || 'unknown-event';

   554   event.currentTarget = getNodeFromInstance(inst);

   555   invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);

   556   event.currentTarget = null;

   557 }

   558 

   559 /**

   560  * Standard/simple iteration through an event's collected dispatches.

   561  */

   562 function executeDispatchesInOrder(event) {

   563   var dispatchListeners = event._dispatchListeners;

   564   var dispatchInstances = event._dispatchInstances;

   565   {

   566     validateEventDispatches(event);

   567   }

   568   if (Array.isArray(dispatchListeners)) {

   569     for (var i = 0; i < dispatchListeners.length; i++) {

   570       if (event.isPropagationStopped()) {

   571         break;

   572       }

   573       // Listeners and Instances are two parallel arrays that are always in sync.

   574       executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);

   575     }

   576   } else if (dispatchListeners) {

   577     executeDispatch(event, dispatchListeners, dispatchInstances);

   578   }

   579   event._dispatchListeners = null;

   580   event._dispatchInstances = null;

   581 }

   582 

   583 /**

   584  * @see executeDispatchesInOrderStopAtTrueImpl

   585  */

   586 

   587 

   588 /**

   589  * Execution of a "direct" dispatch - there must be at most one dispatch

   590  * accumulated on the event or it is considered an error. It doesn't really make

   591  * sense for an event with multiple dispatches (bubbled) to keep track of the

   592  * return values at each dispatch execution, but it does tend to make sense when

   593  * dealing with "direct" dispatches.

   594  *

   595  * @return {*} The return value of executing the single dispatch.

   596  */

   597 

   598 

   599 /**

   600  * @param {SyntheticEvent} event

   601  * @return {boolean} True iff number of dispatches accumulated is greater than 0.

   602  */

   603 

   604 /**

   605  * Accumulates items that must not be null or undefined into the first one. This

   606  * is used to conserve memory by avoiding array allocations, and thus sacrifices

   607  * API cleanness. Since `current` can be null before being passed in and not

   608  * null after this function, make sure to assign it back to `current`:

   609  *

   610  * `a = accumulateInto(a, b);`

   611  *

   612  * This API should be sparingly used. Try `accumulate` for something cleaner.

   613  *

   614  * @return {*|array<*>} An accumulation of items.

   615  */

   616 

   617 function accumulateInto(current, next) {

   618   !(next != null) ? invariant(false, 'accumulateInto(...): Accumulated items must not be null or undefined.') : void 0;

   619 

   620   if (current == null) {

   621     return next;

   622   }

   623 

   624   // Both are not empty. Warning: Never call x.concat(y) when you are not

   625   // certain that x is an Array (x could be a string with concat method).

   626   if (Array.isArray(current)) {

   627     if (Array.isArray(next)) {

   628       current.push.apply(current, next);

   629       return current;

   630     }

   631     current.push(next);

   632     return current;

   633   }

   634 

   635   if (Array.isArray(next)) {

   636     // A bit too dangerous to mutate `next`.

   637     return [current].concat(next);

   638   }

   639 

   640   return [current, next];

   641 }

   642 

   643 /**

   644  * @param {array} arr an "accumulation" of items which is either an Array or

   645  * a single item. Useful when paired with the `accumulate` module. This is a

   646  * simple utility that allows us to reason about a collection of items, but

   647  * handling the case when there is exactly one item (and we do not need to

   648  * allocate an array).

   649  * @param {function} cb Callback invoked with each element or a collection.

   650  * @param {?} [scope] Scope used as `this` in a callback.

   651  */

   652 function forEachAccumulated(arr, cb, scope) {

   653   if (Array.isArray(arr)) {

   654     arr.forEach(cb, scope);

   655   } else if (arr) {

   656     cb.call(scope, arr);

   657   }

   658 }

   659 

   660 /**

   661  * Internal queue of events that have accumulated their dispatches and are

   662  * waiting to have their dispatches executed.

   663  */

   664 var eventQueue = null;

   665 

   666 /**

   667  * Dispatches an event and releases it back into the pool, unless persistent.

   668  *

   669  * @param {?object} event Synthetic event to be dispatched.

   670  * @private

   671  */

   672 var executeDispatchesAndRelease = function (event) {

   673   if (event) {

   674     executeDispatchesInOrder(event);

   675 

   676     if (!event.isPersistent()) {

   677       event.constructor.release(event);

   678     }

   679   }

   680 };

   681 var executeDispatchesAndReleaseTopLevel = function (e) {

   682   return executeDispatchesAndRelease(e);

   683 };

   684 

   685 function isInteractive(tag) {

   686   return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';

   687 }

   688 

   689 function shouldPreventMouseEvent(name, type, props) {

   690   switch (name) {

   691     case 'onClick':

   692     case 'onClickCapture':

   693     case 'onDoubleClick':

   694     case 'onDoubleClickCapture':

   695     case 'onMouseDown':

   696     case 'onMouseDownCapture':

   697     case 'onMouseMove':

   698     case 'onMouseMoveCapture':

   699     case 'onMouseUp':

   700     case 'onMouseUpCapture':

   701       return !!(props.disabled && isInteractive(type));

   702     default:

   703       return false;

   704   }

   705 }

   706 

   707 /**

   708  * This is a unified interface for event plugins to be installed and configured.

   709  *

   710  * Event plugins can implement the following properties:

   711  *

   712  *   `extractEvents` {function(string, DOMEventTarget, string, object): *}

   713  *     Required. When a top-level event is fired, this method is expected to

   714  *     extract synthetic events that will in turn be queued and dispatched.

   715  *

   716  *   `eventTypes` {object}

   717  *     Optional, plugins that fire events must publish a mapping of registration

   718  *     names that are used to register listeners. Values of this mapping must

   719  *     be objects that contain `registrationName` or `phasedRegistrationNames`.

   720  *

   721  *   `executeDispatch` {function(object, function, string)}

   722  *     Optional, allows plugins to override how an event gets dispatched. By

   723  *     default, the listener is simply invoked.

   724  *

   725  * Each plugin that is injected into `EventsPluginHub` is immediately operable.

   726  *

   727  * @public

   728  */

   729 

   730 /**

   731  * Methods for injecting dependencies.

   732  */

   733 var injection = {

   734   /**

   735    * @param {array} InjectedEventPluginOrder

   736    * @public

   737    */

   738   injectEventPluginOrder: injectEventPluginOrder,

   739 

   740   /**

   741    * @param {object} injectedNamesToPlugins Map from names to plugin modules.

   742    */

   743   injectEventPluginsByName: injectEventPluginsByName

   744 };

   745 

   746 /**

   747  * @param {object} inst The instance, which is the source of events.

   748  * @param {string} registrationName Name of listener (e.g. `onClick`).

   749  * @return {?function} The stored callback.

   750  */

   751 function getListener(inst, registrationName) {

   752   var listener = void 0;

   753 

   754   // TODO: shouldPreventMouseEvent is DOM-specific and definitely should not

   755   // live here; needs to be moved to a better place soon

   756   var stateNode = inst.stateNode;

   757   if (!stateNode) {

   758     // Work in progress (ex: onload events in incremental mode).

   759     return null;

   760   }

   761   var props = getFiberCurrentPropsFromNode(stateNode);

   762   if (!props) {

   763     // Work in progress.

   764     return null;

   765   }

   766   listener = props[registrationName];

   767   if (shouldPreventMouseEvent(registrationName, inst.type, props)) {

   768     return null;

   769   }

   770   !(!listener || typeof listener === 'function') ? invariant(false, 'Expected `%s` listener to be a function, instead got a value of `%s` type.', registrationName, typeof listener) : void 0;

   771   return listener;

   772 }

   773 

   774 /**

   775  * Allows registered plugins an opportunity to extract events from top-level

   776  * native browser events.

   777  *

   778  * @return {*} An accumulation of synthetic events.

   779  * @internal

   780  */

   781 function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {

   782   var events = null;

   783   for (var i = 0; i < plugins.length; i++) {

   784     // Not every plugin in the ordering may be loaded at runtime.

   785     var possiblePlugin = plugins[i];

   786     if (possiblePlugin) {

   787       var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);

   788       if (extractedEvents) {

   789         events = accumulateInto(events, extractedEvents);

   790       }

   791     }

   792   }

   793   return events;

   794 }

   795 

   796 function runEventsInBatch(events) {

   797   if (events !== null) {

   798     eventQueue = accumulateInto(eventQueue, events);

   799   }

   800 

   801   // Set `eventQueue` to null before processing it so that we can tell if more

   802   // events get enqueued while processing.

   803   var processingEventQueue = eventQueue;

   804   eventQueue = null;

   805 

   806   if (!processingEventQueue) {

   807     return;

   808   }

   809 

   810   forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);

   811   !!eventQueue ? invariant(false, 'processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.') : void 0;

   812   // This would be a good time to rethrow if any of the event handlers threw.

   813   rethrowCaughtError();

   814 }

   815 

   816 function runExtractedEventsInBatch(topLevelType, targetInst, nativeEvent, nativeEventTarget) {

   817   var events = extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);

   818   runEventsInBatch(events);

   819 }

   820 

   821 var FunctionComponent = 0;

   822 var ClassComponent = 1;

   823 var IndeterminateComponent = 2; // Before we know whether it is function or class

   824 var HostRoot = 3; // Root of a host tree. Could be nested inside another node.

   825 var HostPortal = 4; // A subtree. Could be an entry point to a different renderer.

   826 var HostComponent = 5;

   827 var HostText = 6;

   828 var Fragment = 7;

   829 var Mode = 8;

   830 var ContextConsumer = 9;

   831 var ContextProvider = 10;

   832 var ForwardRef = 11;

   833 var Profiler = 12;

   834 var SuspenseComponent = 13;

   835 var MemoComponent = 14;

   836 var SimpleMemoComponent = 15;

   837 var LazyComponent = 16;

   838 var IncompleteClassComponent = 17;

   839 var DehydratedSuspenseComponent = 18;

   840 

   841 var randomKey = Math.random().toString(36).slice(2);

   842 var internalInstanceKey = '__reactInternalInstance$' + randomKey;

   843 var internalEventHandlersKey = '__reactEventHandlers$' + randomKey;

   844 

   845 function precacheFiberNode(hostInst, node) {

   846   node[internalInstanceKey] = hostInst;

   847 }

   848 

   849 /**

   850  * Given a DOM node, return the closest ReactDOMComponent or

   851  * ReactDOMTextComponent instance ancestor.

   852  */

   853 function getClosestInstanceFromNode(node) {

   854   if (node[internalInstanceKey]) {

   855     return node[internalInstanceKey];

   856   }

   857 

   858   while (!node[internalInstanceKey]) {

   859     if (node.parentNode) {

   860       node = node.parentNode;

   861     } else {

   862       // Top of the tree. This node must not be part of a React tree (or is

   863       // unmounted, potentially).

   864       return null;

   865     }

   866   }

   867 

   868   var inst = node[internalInstanceKey];

   869   if (inst.tag === HostComponent || inst.tag === HostText) {

   870     // In Fiber, this will always be the deepest root.

   871     return inst;

   872   }

   873 

   874   return null;

   875 }

   876 

   877 /**

   878  * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent

   879  * instance, or null if the node was not rendered by this React.

   880  */

   881 function getInstanceFromNode$1(node) {

   882   var inst = node[internalInstanceKey];

   883   if (inst) {

   884     if (inst.tag === HostComponent || inst.tag === HostText) {

   885       return inst;

   886     } else {

   887       return null;

   888     }

   889   }

   890   return null;

   891 }

   892 

   893 /**

   894  * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding

   895  * DOM node.

   896  */

   897 function getNodeFromInstance$1(inst) {

   898   if (inst.tag === HostComponent || inst.tag === HostText) {

   899     // In Fiber this, is just the state node right now. We assume it will be

   900     // a host component or host text.

   901     return inst.stateNode;

   902   }

   903 

   904   // Without this first invariant, passing a non-DOM-component triggers the next

   905   // invariant for a missing parent, which is super confusing.

   906   invariant(false, 'getNodeFromInstance: Invalid argument.');

   907 }

   908 

   909 function getFiberCurrentPropsFromNode$1(node) {

   910   return node[internalEventHandlersKey] || null;

   911 }

   912 

   913 function updateFiberProps(node, props) {

   914   node[internalEventHandlersKey] = props;

   915 }

   916 

   917 function getParent(inst) {

   918   do {

   919     inst = inst.return;

   920     // TODO: If this is a HostRoot we might want to bail out.

   921     // That is depending on if we want nested subtrees (layers) to bubble

   922     // events to their parent. We could also go through parentNode on the

   923     // host node but that wouldn't work for React Native and doesn't let us

   924     // do the portal feature.

   925   } while (inst && inst.tag !== HostComponent);

   926   if (inst) {

   927     return inst;

   928   }

   929   return null;

   930 }

   931 

   932 /**

   933  * Return the lowest common ancestor of A and B, or null if they are in

   934  * different trees.

   935  */

   936 function getLowestCommonAncestor(instA, instB) {

   937   var depthA = 0;

   938   for (var tempA = instA; tempA; tempA = getParent(tempA)) {

   939     depthA++;

   940   }

   941   var depthB = 0;

   942   for (var tempB = instB; tempB; tempB = getParent(tempB)) {

   943     depthB++;

   944   }

   945 

   946   // If A is deeper, crawl up.

   947   while (depthA - depthB > 0) {

   948     instA = getParent(instA);

   949     depthA--;

   950   }

   951 

   952   // If B is deeper, crawl up.

   953   while (depthB - depthA > 0) {

   954     instB = getParent(instB);

   955     depthB--;

   956   }

   957 

   958   // Walk in lockstep until we find a match.

   959   var depth = depthA;

   960   while (depth--) {

   961     if (instA === instB || instA === instB.alternate) {

   962       return instA;

   963     }

   964     instA = getParent(instA);

   965     instB = getParent(instB);

   966   }

   967   return null;

   968 }

   969 

   970 /**

   971  * Return if A is an ancestor of B.

   972  */

   973 

   974 

   975 /**

   976  * Return the parent instance of the passed-in instance.

   977  */

   978 

   979 

   980 /**

   981  * Simulates the traversal of a two-phase, capture/bubble event dispatch.

   982  */

   983 function traverseTwoPhase(inst, fn, arg) {

   984   var path = [];

   985   while (inst) {

   986     path.push(inst);

   987     inst = getParent(inst);

   988   }

   989   var i = void 0;

   990   for (i = path.length; i-- > 0;) {

   991     fn(path[i], 'captured', arg);

   992   }

   993   for (i = 0; i < path.length; i++) {

   994     fn(path[i], 'bubbled', arg);

   995   }

   996 }

   997 

   998 /**

   999  * Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that

  1000  * should would receive a `mouseEnter` or `mouseLeave` event.

  1001  *

  1002  * Does not invoke the callback on the nearest common ancestor because nothing

  1003  * "entered" or "left" that element.

  1004  */

  1005 function traverseEnterLeave(from, to, fn, argFrom, argTo) {

  1006   var common = from && to ? getLowestCommonAncestor(from, to) : null;

  1007   var pathFrom = [];

  1008   while (true) {

  1009     if (!from) {

  1010       break;

  1011     }

  1012     if (from === common) {

  1013       break;

  1014     }

  1015     var alternate = from.alternate;

  1016     if (alternate !== null && alternate === common) {

  1017       break;

  1018     }

  1019     pathFrom.push(from);

  1020     from = getParent(from);

  1021   }

  1022   var pathTo = [];

  1023   while (true) {

  1024     if (!to) {

  1025       break;

  1026     }

  1027     if (to === common) {

  1028       break;

  1029     }

  1030     var _alternate = to.alternate;

  1031     if (_alternate !== null && _alternate === common) {

  1032       break;

  1033     }

  1034     pathTo.push(to);

  1035     to = getParent(to);

  1036   }

  1037   for (var i = 0; i < pathFrom.length; i++) {

  1038     fn(pathFrom[i], 'bubbled', argFrom);

  1039   }

  1040   for (var _i = pathTo.length; _i-- > 0;) {

  1041     fn(pathTo[_i], 'captured', argTo);

  1042   }

  1043 }

  1044 

  1045 /**

  1046  * Some event types have a notion of different registration names for different

  1047  * "phases" of propagation. This finds listeners by a given phase.

  1048  */

  1049 function listenerAtPhase(inst, event, propagationPhase) {

  1050   var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];

  1051   return getListener(inst, registrationName);

  1052 }

  1053 

  1054 /**

  1055  * A small set of propagation patterns, each of which will accept a small amount

  1056  * of information, and generate a set of "dispatch ready event objects" - which

  1057  * are sets of events that have already been annotated with a set of dispatched

  1058  * listener functions/ids. The API is designed this way to discourage these

  1059  * propagation strategies from actually executing the dispatches, since we

  1060  * always want to collect the entire set of dispatches before executing even a

  1061  * single one.

  1062  */

  1063 

  1064 /**

  1065  * Tags a `SyntheticEvent` with dispatched listeners. Creating this function

  1066  * here, allows us to not have to bind or create functions for each event.

  1067  * Mutating the event's members allows us to not have to create a wrapping

  1068  * "dispatch" object that pairs the event with the listener.

  1069  */

  1070 function accumulateDirectionalDispatches(inst, phase, event) {

  1071   {

  1072     !inst ? warningWithoutStack$1(false, 'Dispatching inst must not be null') : void 0;

  1073   }

  1074   var listener = listenerAtPhase(inst, event, phase);

  1075   if (listener) {

  1076     event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);

  1077     event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);

  1078   }

  1079 }

  1080 

  1081 /**

  1082  * Collect dispatches (must be entirely collected before dispatching - see unit

  1083  * tests). Lazily allocate the array to conserve memory.  We must loop through

  1084  * each event and perform the traversal for each one. We cannot perform a

  1085  * single traversal for the entire collection of events because each event may

  1086  * have a different target.

  1087  */

  1088 function accumulateTwoPhaseDispatchesSingle(event) {

  1089   if (event && event.dispatchConfig.phasedRegistrationNames) {

  1090     traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);

  1091   }

  1092 }

  1093 

  1094 /**

  1095  * Accumulates without regard to direction, does not look for phased

  1096  * registration names. Same as `accumulateDirectDispatchesSingle` but without

  1097  * requiring that the `dispatchMarker` be the same as the dispatched ID.

  1098  */

  1099 function accumulateDispatches(inst, ignoredDirection, event) {

  1100   if (inst && event && event.dispatchConfig.registrationName) {

  1101     var registrationName = event.dispatchConfig.registrationName;

  1102     var listener = getListener(inst, registrationName);

  1103     if (listener) {

  1104       event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);

  1105       event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);

  1106     }

  1107   }

  1108 }

  1109 

  1110 /**

  1111  * Accumulates dispatches on an `SyntheticEvent`, but only for the

  1112  * `dispatchMarker`.

  1113  * @param {SyntheticEvent} event

  1114  */

  1115 function accumulateDirectDispatchesSingle(event) {

  1116   if (event && event.dispatchConfig.registrationName) {

  1117     accumulateDispatches(event._targetInst, null, event);

  1118   }

  1119 }

  1120 

  1121 function accumulateTwoPhaseDispatches(events) {

  1122   forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);

  1123 }

  1124 

  1125 

  1126 

  1127 function accumulateEnterLeaveDispatches(leave, enter, from, to) {

  1128   traverseEnterLeave(from, to, accumulateDispatches, leave, enter);

  1129 }

  1130 

  1131 function accumulateDirectDispatches(events) {

  1132   forEachAccumulated(events, accumulateDirectDispatchesSingle);

  1133 }

  1134 

  1135 var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);