155 

   156 var validateFormat = function () {};

   157 

   158 {

   159   validateFormat = function (format) {

   160     if (format === undefined) {

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

   162     }

   163   };

   164 }

   165 

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

   167   validateFormat(format);

   168 

   169   if (!condition) {

   170     var error = void 0;

   171     if (format === undefined) {

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

   173     } else {

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

   175       var argIndex = 0;

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

   177         return args[argIndex++];

   178       }));

   179       error.name = 'Invariant Violation';

   180     }

   181 

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

   183     throw error;

   184   }

   185 }

   186 

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

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

   500 var enableSchedulerDebugging = false;

   501 

   502 /* eslint-disable no-var */

   503 

   504 // TODO: Use symbols?

   505 var ImmediatePriority = 1;

   506 var UserBlockingPriority = 2;

   507 var NormalPriority = 3;

   508 var LowPriority = 4;

   509 var IdlePriority = 5;

   510 

   511 // Max 31 bit integer. The max integer size in V8 for 32-bit systems.

   512 // Math.pow(2, 30) - 1

   513 // 0b111111111111111111111111111111

   514 var maxSigned31BitInt = 1073741823;

   515 

   516 // Times out immediately

   517 var IMMEDIATE_PRIORITY_TIMEOUT = -1;

   518 // Eventually times out

   519 var USER_BLOCKING_PRIORITY = 250;

   520 var NORMAL_PRIORITY_TIMEOUT = 5000;

   521 var LOW_PRIORITY_TIMEOUT = 10000;

   522 // Never times out

   523 var IDLE_PRIORITY = maxSigned31BitInt;

   524 

   525 // Callbacks are stored as a circular, doubly linked list.

   526 var firstCallbackNode = null;

   527 

   528 var currentDidTimeout = false;

   529 // Pausing the scheduler is useful for debugging.

   530 var isSchedulerPaused = false;

   531 

   532 var currentPriorityLevel = NormalPriority;

   533 var currentEventStartTime = -1;

   534 var currentExpirationTime = -1;

   535 

   536 // This is set when a callback is being executed, to prevent re-entrancy.

   537 var isExecutingCallback = false;

   538 

   539 var isHostCallbackScheduled = false;

   540 

   541 var hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';

   542 

   543 function ensureHostCallbackIsScheduled() {

   544   if (isExecutingCallback) {

   545     // Don't schedule work yet; wait until the next time we yield.

   546     return;

   547   }

   548   // Schedule the host callback using the earliest expiration in the list.

   549   var expirationTime = firstCallbackNode.expirationTime;

   550   if (!isHostCallbackScheduled) {

   551     isHostCallbackScheduled = true;

   552   } else {

   553     // Cancel the existing host callback.

   554     cancelHostCallback();

   555   }

   556   requestHostCallback(flushWork, expirationTime);

   557 }

   558 

   559 function flushFirstCallback() {

   560   var flushedNode = firstCallbackNode;

   561 

   562   // Remove the node from the list before calling the callback. That way the

   563   // list is in a consistent state even if the callback throws.

   564   var next = firstCallbackNode.next;

   565   if (firstCallbackNode === next) {

   566     // This is the last callback in the list.

   567     firstCallbackNode = null;

   568     next = null;

   569   } else {

   570     var lastCallbackNode = firstCallbackNode.previous;

   571     firstCallbackNode = lastCallbackNode.next = next;

   572     next.previous = lastCallbackNode;

   573   }

   574 

   575   flushedNode.next = flushedNode.previous = null;

   576 

   577   // Now it's safe to call the callback.

   578   var callback = flushedNode.callback;

   579   var expirationTime = flushedNode.expirationTime;

   580   var priorityLevel = flushedNode.priorityLevel;

   581   var previousPriorityLevel = currentPriorityLevel;

   582   var previousExpirationTime = currentExpirationTime;

   583   currentPriorityLevel = priorityLevel;

   584   currentExpirationTime = expirationTime;

   585   var continuationCallback;

   586   try {

   587     continuationCallback = callback();

   588   } finally {

   589     currentPriorityLevel = previousPriorityLevel;

   590     currentExpirationTime = previousExpirationTime;

   591   }

   592 

   593   // A callback may return a continuation. The continuation should be scheduled

   594   // with the same priority and expiration as the just-finished callback.

   595   if (typeof continuationCallback === 'function') {

   596     var continuationNode = {

   597       callback: continuationCallback,

   598       priorityLevel: priorityLevel,

   599       expirationTime: expirationTime,

   600       next: null,

   601       previous: null

   602     };

   603 

   604     // Insert the new callback into the list, sorted by its expiration. This is

   605     // almost the same as the code in `scheduleCallback`, except the callback

   606     // is inserted into the list *before* callbacks of equal expiration instead

   607     // of after.

   608     if (firstCallbackNode === null) {

   609       // This is the first callback in the list.

   610       firstCallbackNode = continuationNode.next = continuationNode.previous = continuationNode;

   611     } else {

   612       var nextAfterContinuation = null;

   613       var node = firstCallbackNode;

   614       do {

   615         if (node.expirationTime >= expirationTime) {

   616           // This callback expires at or after the continuation. We will insert

   617           // the continuation *before* this callback.

   618           nextAfterContinuation = node;

   619           break;

   620         }

   621         node = node.next;

   622       } while (node !== firstCallbackNode);

   623 

   624       if (nextAfterContinuation === null) {

   625         // No equal or lower priority callback was found, which means the new

   626         // callback is the lowest priority callback in the list.

   627         nextAfterContinuation = firstCallbackNode;

   628       } else if (nextAfterContinuation === firstCallbackNode) {

   629         // The new callback is the highest priority callback in the list.

   630         firstCallbackNode = continuationNode;

   631         ensureHostCallbackIsScheduled();

   632       }

   633 

   634       var previous = nextAfterContinuation.previous;

   635       previous.next = nextAfterContinuation.previous = continuationNode;

   636       continuationNode.next = nextAfterContinuation;

   637       continuationNode.previous = previous;

   638     }

   639   }

   640 }

   641 

   642 function flushImmediateWork() {

   643   if (

   644   // Confirm we've exited the outer most event handler

   645   currentEventStartTime === -1 && firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority) {

   646     isExecutingCallback = true;

   647     try {

   648       do {

   649         flushFirstCallback();

   650       } while (

   651       // Keep flushing until there are no more immediate callbacks

   652       firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority);

   653     } finally {

   654       isExecutingCallback = false;

   655       if (firstCallbackNode !== null) {

   656         // There's still work remaining. Request another callback.

   657         ensureHostCallbackIsScheduled();

   658       } else {

   659         isHostCallbackScheduled = false;

   660       }

   661     }

   662   }

   663 }

   664 

   665 function flushWork(didTimeout) {

   666   // Exit right away if we're currently paused

   667 

   668   if (enableSchedulerDebugging && isSchedulerPaused) {

   669     return;

   670   }

   671 

   672   isExecutingCallback = true;

   673   var previousDidTimeout = currentDidTimeout;

   674   currentDidTimeout = didTimeout;

   675   try {

   676     if (didTimeout) {

   677       // Flush all the expired callbacks without yielding.

   678       while (firstCallbackNode !== null && !(enableSchedulerDebugging && isSchedulerPaused)) {

   679         // TODO Wrap in feature flag

   680         // Read the current time. Flush all the callbacks that expire at or

   681         // earlier than that time. Then read the current time again and repeat.

   682         // This optimizes for as few performance.now calls as possible.

   683         var currentTime = getCurrentTime();

   684         if (firstCallbackNode.expirationTime <= currentTime) {

   685           do {

   686             flushFirstCallback();

   687           } while (firstCallbackNode !== null && firstCallbackNode.expirationTime <= currentTime && !(enableSchedulerDebugging && isSchedulerPaused));

   688           continue;

   689         }

   690         break;

   691       }

   692     } else {

   693       // Keep flushing callbacks until we run out of time in the frame.

   694       if (firstCallbackNode !== null) {

   695         do {

   696           if (enableSchedulerDebugging && isSchedulerPaused) {

   697             break;

   698           }

   699           flushFirstCallback();

   700         } while (firstCallbackNode !== null && !shouldYieldToHost());

   701       }

   702     }

   703   } finally {

   704     isExecutingCallback = false;

   705     currentDidTimeout = previousDidTimeout;

   706     if (firstCallbackNode !== null) {

   707       // There's still work remaining. Request another callback.

   708       ensureHostCallbackIsScheduled();

   709     } else {

   710       isHostCallbackScheduled = false;

   711     }

   712     // Before exiting, flush all the immediate work that was scheduled.

   713     flushImmediateWork();

   714   }

   715 }

   716 

   717 function unstable_runWithPriority(priorityLevel, eventHandler) {

   718   switch (priorityLevel) {

   719     case ImmediatePriority:

   720     case UserBlockingPriority:

   721     case NormalPriority:

   722     case LowPriority:

   723     case IdlePriority:

   724       break;

   725     default:

   726       priorityLevel = NormalPriority;

   727   }

   728 

   729   var previousPriorityLevel = currentPriorityLevel;

   730   var previousEventStartTime = currentEventStartTime;

   731   currentPriorityLevel = priorityLevel;

   732   currentEventStartTime = getCurrentTime();

   733 

   734   try {

   735     return eventHandler();

   736   } finally {

   737     currentPriorityLevel = previousPriorityLevel;

   738     currentEventStartTime = previousEventStartTime;

   739 

   740     // Before exiting, flush all the immediate work that was scheduled.

   741     flushImmediateWork();

   742   }

   743 }

   744 

   745 function unstable_next(eventHandler) {

   746   var priorityLevel = void 0;

   747   switch (currentPriorityLevel) {

   748     case ImmediatePriority:

   749     case UserBlockingPriority:

   750     case NormalPriority:

   751       // Shift down to normal priority

   752       priorityLevel = NormalPriority;

   753       break;

   754     default:

   755       // Anything lower than normal priority should remain at the current level.

   756       priorityLevel = currentPriorityLevel;

   757       break;

   758   }

   759 

   760   var previousPriorityLevel = currentPriorityLevel;

   761   var previousEventStartTime = currentEventStartTime;

   762   currentPriorityLevel = priorityLevel;

   763   currentEventStartTime = getCurrentTime();

   764 

   765   try {

   766     return eventHandler();

   767   } finally {

   768     currentPriorityLevel = previousPriorityLevel;

   769     currentEventStartTime = previousEventStartTime;

   770 

   771     // Before exiting, flush all the immediate work that was scheduled.

   772     flushImmediateWork();

   773   }

   774 }

   775 

   776 function unstable_wrapCallback(callback) {

   777   var parentPriorityLevel = currentPriorityLevel;

   778   return function () {

   779     // This is a fork of runWithPriority, inlined for performance.

   780     var previousPriorityLevel = currentPriorityLevel;

   781     var previousEventStartTime = currentEventStartTime;

   782     currentPriorityLevel = parentPriorityLevel;

   783     currentEventStartTime = getCurrentTime();

   784 

   785     try {

   786       return callback.apply(this, arguments);

   787     } finally {

   788       currentPriorityLevel = previousPriorityLevel;

   789       currentEventStartTime = previousEventStartTime;

   790       flushImmediateWork();

   791     }

   792   };

   793 }

   794 

   795 function unstable_scheduleCallback(callback, deprecated_options) {

   796   var startTime = currentEventStartTime !== -1 ? currentEventStartTime : getCurrentTime();

   797 

   798   var expirationTime;

   799   if (typeof deprecated_options === 'object' && deprecated_options !== null && typeof deprecated_options.timeout === 'number') {

   800     // FIXME: Remove this branch once we lift expiration times out of React.

   801     expirationTime = startTime + deprecated_options.timeout;

   802   } else {

   803     switch (currentPriorityLevel) {

   804       case ImmediatePriority:

   805         expirationTime = startTime + IMMEDIATE_PRIORITY_TIMEOUT;

   806         break;

   807       case UserBlockingPriority:

   808         expirationTime = startTime + USER_BLOCKING_PRIORITY;

   809         break;

   810       case IdlePriority:

   811         expirationTime = startTime + IDLE_PRIORITY;

   812         break;

   813       case LowPriority:

   814         expirationTime = startTime + LOW_PRIORITY_TIMEOUT;

   815         break;

   816       case NormalPriority:

   817       default:

   818         expirationTime = startTime + NORMAL_PRIORITY_TIMEOUT;

   819     }

   820   }

   821 

   822   var newNode = {

   823     callback: callback,

   824     priorityLevel: currentPriorityLevel,

   825     expirationTime: expirationTime,

   826     next: null,

   827     previous: null

   828   };

   829 

   830   // Insert the new callback into the list, ordered first by expiration, then

   831   // by insertion. So the new callback is inserted any other callback with

   832   // equal expiration.

   833   if (firstCallbackNode === null) {

   834     // This is the first callback in the list.

   835     firstCallbackNode = newNode.next = newNode.previous = newNode;

   836     ensureHostCallbackIsScheduled();

   837   } else {

   838     var next = null;

   839     var node = firstCallbackNode;

   840     do {

   841       if (node.expirationTime > expirationTime) {

   842         // The new callback expires before this one.

   843         next = node;

   844         break;

   845       }

   846       node = node.next;

   847     } while (node !== firstCallbackNode);

   848 

   849     if (next === null) {

   850       // No callback with a later expiration was found, which means the new

   851       // callback has the latest expiration in the list.

   852       next = firstCallbackNode;

   853     } else if (next === firstCallbackNode) {

   854       // The new callback has the earliest expiration in the entire list.

   855       firstCallbackNode = newNode;

   856       ensureHostCallbackIsScheduled();

   857     }

   858 

   859     var previous = next.previous;

   860     previous.next = next.previous = newNode;

   861     newNode.next = next;

   862     newNode.previous = previous;

   863   }

   864 

   865   return newNode;

   866 }

   867 

   868 function unstable_pauseExecution() {

   869   isSchedulerPaused = true;

   870 }

   871 

   872 function unstable_continueExecution() {

   873   isSchedulerPaused = false;

   874   if (firstCallbackNode !== null) {

   875     ensureHostCallbackIsScheduled();

   876   }

   877 }

   878 

   879 function unstable_getFirstCallbackNode() {

   880   return firstCallbackNode;

   881 }

   882 

   883 function unstable_cancelCallback(callbackNode) {

   884   var next = callbackNode.next;

   885   if (next === null) {

   886     // Already cancelled.

   887     return;

   888   }

   889 

   890   if (next === callbackNode) {

   891     // This is the only scheduled callback. Clear the list.

   892     firstCallbackNode = null;

   893   } else {

   894     // Remove the callback from its position in the list.

   895     if (callbackNode === firstCallbackNode) {

   896       firstCallbackNode = next;

   897     }

   898     var previous = callbackNode.previous;

   899     previous.next = next;

   900     next.previous = previous;

   901   }

   902 

   903   callbackNode.next = callbackNode.previous = null;

   904 }

   905 

   906 function unstable_getCurrentPriorityLevel() {

   907   return currentPriorityLevel;

   908 }

   909 

   910 function unstable_shouldYield() {

   911   return !currentDidTimeout && (firstCallbackNode !== null && firstCallbackNode.expirationTime < currentExpirationTime || shouldYieldToHost());

   912 }

   913 

   914 // The remaining code is essentially a polyfill for requestIdleCallback. It

   915 // works by scheduling a requestAnimationFrame, storing the time for the start

   916 // of the frame, then scheduling a postMessage which gets scheduled after paint.

   917 // Within the postMessage handler do as much work as possible until time + frame

   918 // rate. By separating the idle call into a separate event tick we ensure that

   919 // layout, paint and other browser work is counted against the available time.

   920 // The frame rate is dynamically adjusted.

   921 

   922 // We capture a local reference to any global, in case it gets polyfilled after

   923 // this module is initially evaluated. We want to be using a

   924 // consistent implementation.

   925 var localDate = Date;

   926 

   927 // This initialization code may run even on server environments if a component

   928 // just imports ReactDOM (e.g. for findDOMNode). Some environments might not

   929 // have setTimeout or clearTimeout. However, we always expect them to be defined

   930 // on the client. https://github.com/facebook/react/pull/13088

   931 var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;

   932 var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;

   933 

   934 // We don't expect either of these to necessarily be defined, but we will error

   935 // later if they are missing on the client.

   936 var localRequestAnimationFrame = typeof requestAnimationFrame === 'function' ? requestAnimationFrame : undefined;

   937 var localCancelAnimationFrame = typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame : undefined;

   938 

   939 var getCurrentTime;

   940 

   941 // requestAnimationFrame does not run when the tab is in the background. If

   942 // we're backgrounded we prefer for that work to happen so that the page

   943 // continues to load in the background. So we also schedule a 'setTimeout' as

   944 // a fallback.

   945 // TODO: Need a better heuristic for backgrounded work.

   946 var ANIMATION_FRAME_TIMEOUT = 100;

   947 var rAFID;

   948 var rAFTimeoutID;

   949 var requestAnimationFrameWithTimeout = function (callback) {

   950   // schedule rAF and also a setTimeout

   951   rAFID = localRequestAnimationFrame(function (timestamp) {

   952     // cancel the setTimeout

   953     localClearTimeout(rAFTimeoutID);

   954     callback(timestamp);

   955   });

   956   rAFTimeoutID = localSetTimeout(function () {

   957     // cancel the requestAnimationFrame

   958     localCancelAnimationFrame(rAFID);

   959     callback(getCurrentTime());

   960   }, ANIMATION_FRAME_TIMEOUT);

   961 };

   962 

   963 if (hasNativePerformanceNow) {

   964   var Performance = performance;

   965   getCurrentTime = function () {

   966     return Performance.now();

   967   };

   968 } else {

   969   getCurrentTime = function () {

   970     return localDate.now();

   971   };

   972 }

   973 

   974 var requestHostCallback;

   975 var cancelHostCallback;

   976 var shouldYieldToHost;

   977 

   978 var globalValue = null;

   979 if (typeof window !== 'undefined') {

   980   globalValue = window;

   981 } else if (typeof global !== 'undefined') {

   982   globalValue = global;

   983 }

   984 

   985 if (globalValue && globalValue._schedMock) {

   986   // Dynamic injection, only for testing purposes.

   987   var globalImpl = globalValue._schedMock;

   988   requestHostCallback = globalImpl[0];

   989   cancelHostCallback = globalImpl[1];

   990   shouldYieldToHost = globalImpl[2];

   991   getCurrentTime = globalImpl[3];

   992 } else if (

   993 // If Scheduler runs in a non-DOM environment, it falls back to a naive

   994 // implementation using setTimeout.

   995 typeof window === 'undefined' ||

   996 // Check if MessageChannel is supported, too.

   997 typeof MessageChannel !== 'function') {

   998   // If this accidentally gets imported in a non-browser environment, e.g. JavaScriptCore,

   999   // fallback to a naive implementation.

  1000   var _callback = null;

  1001   var _flushCallback = function (didTimeout) {

  1002     if (_callback !== null) {

  1003       try {

  1004         _callback(didTimeout);

  1005       } finally {

  1006         _callback = null;

  1007       }

  1008     }

  1009   };

  1010   requestHostCallback = function (cb, ms) {

  1011     if (_callback !== null) {

  1012       // Protect against re-entrancy.

  1013       setTimeout(requestHostCallback, 0, cb);

  1014     } else {

  1015       _callback = cb;

  1016       setTimeout(_flushCallback, 0, false);

  1017     }

  1018   };

  1019   cancelHostCallback = function () {

  1020     _callback = null;

  1021   };

  1022   shouldYieldToHost = function () {

  1023     return false;

  1024   };

  1025 } else {

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

  1027     // TODO: Remove fb.me link

  1028     if (typeof localRequestAnimationFrame !== 'function') {

  1029       console.error("This browser doesn't support requestAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');

  1030     }

  1031     if (typeof localCancelAnimationFrame !== 'function') {

  1032       console.error("This browser doesn't support cancelAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');

  1033     }

  1034   }

  1035 

  1036   var scheduledHostCallback = null;

  1037   var isMessageEventScheduled = false;

  1038   var timeoutTime = -1;

  1039 

  1040   var isAnimationFrameScheduled = false;

  1041 

  1042   var isFlushingHostCallback = false;

  1043 

  1044   var frameDeadline = 0;

  1045   // We start out assuming that we run at 30fps but then the heuristic tracking

  1046   // will adjust this value to a faster fps if we get more frequent animation

  1047   // frames.

  1048   var previousFrameTime = 33;

  1049   var activeFrameTime = 33;

  1050 

  1051   shouldYieldToHost = function () {

  1052     return frameDeadline <= getCurrentTime();

  1053   };

  1054 

  1055   // We use the postMessage trick to defer idle work until after the repaint.

  1056   var channel = new MessageChannel();

  1057   var port = channel.port2;

  1058   channel.port1.onmessage = function (event) {

  1059     isMessageEventScheduled = false;

  1060 

  1061     var prevScheduledCallback = scheduledHostCallback;

  1062     var prevTimeoutTime = timeoutTime;

  1063     scheduledHostCallback = null;

  1064     timeoutTime = -1;

  1065 

  1066     var currentTime = getCurrentTime();

  1067 

  1068     var didTimeout = false;

  1069     if (frameDeadline - currentTime <= 0) {

  1070       // There's no time left in this idle period. Check if the callback has

  1071       // a timeout and whether it's been exceeded.

  1072       if (prevTimeoutTime !== -1 && prevTimeoutTime <= currentTime) {

  1073         // Exceeded the timeout. Invoke the callback even though there's no

  1074         // time left.

  1075         didTimeout = true;

  1076       } else {

  1077         // No timeout.

  1078         if (!isAnimationFrameScheduled) {

  1079           // Schedule another animation callback so we retry later.

  1080           isAnimationFrameScheduled = true;

  1081           requestAnimationFrameWithTimeout(animationTick);

  1082         }

  1083         // Exit without invoking the callback.

  1084         scheduledHostCallback = prevScheduledCallback;

  1085         timeoutTime = prevTimeoutTime;

  1086         return;

  1087       }

  1088     }

  1089 

  1090     if (prevScheduledCallback !== null) {

  1091       isFlushingHostCallback = true;

  1092       try {

  1093         prevScheduledCallback(didTimeout);

  1094       } finally {

  1095         isFlushingHostCallback = false;

  1096       }

  1097     }

  1098   };

  1099 

  1100   var animationTick = function (rafTime) {

  1101     if (scheduledHostCallback !== null) {

  1102       // Eagerly schedule the next animation callback at the beginning of the

  1103       // frame. If the scheduler queue is not empty at the end of the frame, it

  1104       // will continue flushing inside that callback. If the queue *is* empty,

  1105       // then it will exit immediately. Posting the callback at the start of the

  1106       // frame ensures it's fired within the earliest possible frame. If we

  1107       // waited until the end of the frame to post the callback, we risk the

  1108       // browser skipping a frame and not firing the callback until the frame

  1109       // after that.

  1110       requestAnimationFrameWithTimeout(animationTick);

  1111     } else {

  1112       // No pending work. Exit.

  1113       isAnimationFrameScheduled = false;

  1114       return;

  1115     }

  1116 

  1117     var nextFrameTime = rafTime - frameDeadline + activeFrameTime;

  1118     if (nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime) {

  1119       if (nextFrameTime < 8) {

  1120         // Defensive coding. We don't support higher frame rates than 120hz.

  1121         // If the calculated frame time gets lower than 8, it is probably a bug.

  1122         nextFrameTime = 8;

  1123       }

  1124       // If one frame goes long, then the next one can be short to catch up.

  1125       // If two frames are short in a row, then that's an indication that we

  1126       // actually have a higher frame rate than what we're currently optimizing.

  1127       // We adjust our heuristic dynamically accordingly. For example, if we're

  1128       // running on 120hz display or 90hz VR display.

  1129       // Take the max of the two in case one of them was an anomaly due to

  1130       // missed frame deadlines.

  1131       activeFrameTime = nextFrameTime < previousFrameTime ? previousFrameTime : nextFrameTime;

  1132     } else {

  1133       previousFrameTime = nextFrameTime;

  1134     }

  1135     frameDeadline = rafTime + activeFrameTime;

  1136     if (!isMessageEventScheduled) {

  1137       isMessageEventScheduled = true;

  1138       port.postMessage(undefined);

  1139     }

  1140   };

  1141 

  1142   requestHostCallback = function (callback, absoluteTimeout) {

  1143     scheduledHostCallback = callback;

  1144     timeoutTime = absoluteTimeout;

  1145     if (isFlushingHostCallback || absoluteTimeout < 0) {

  1146       // Don't wait for the next frame. Continue working ASAP, in a new event.

  1147       port.postMessage(undefined);

  1148     } else if (!isAnimationFrameScheduled) {

  1149       // If rAF didn't already schedule one, we need to schedule a frame.

  1150       // TODO: If this rAF doesn't materialize because the browser throttles, we

  1151       // might want to still have setTimeout trigger rIC as a backup to ensure

  1152       // that we keep performing work.

  1153       isAnimationFrameScheduled = true;

  1154       requestAnimationFrameWithTimeout(animationTick);

  1155     }

  1156   };

  1157 

  1158   cancelHostCallback = function () {

  1159     scheduledHostCallback = null;

  1160     isMessageEventScheduled = false;

  1161     timeoutTime = -1;

  1162   };

  1163 }

  1164 

  1165 // Helps identify side effects in begin-phase lifecycle hooks and setState reducers:

  1166 

  1167 

  1168 // In some cases, StrictMode should also double-render lifecycles.

  1169 // This can be confusing for tests though,

  1170 // And it can be bad for performance in production.

  1171 // This feature flag can be used to control the behavior:

  1172 

  1173 

  1174 // To preserve the "Pause on caught exceptions" behavior of the debugger, we

  1175 // replay the begin phase of a failed component inside invokeGuardedCallback.

  1176 

  1177 

  1178 // Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:

  1179 

  1180 

  1181 // Gather advanced timing metrics for Profiler subtrees.

  1182 

  1183 

  1184 // Trace which interactions trigger each commit.

  1185 var enableSchedulerTracing = true;

  1186 

  1187 // Only used in www builds.

  1188  // TODO: true? Here it might just be false.

  1189 

  1190 // Only used in www builds.

  1191 

  1192 

  1193 // Only used in www builds.

  1194 

  1195 

  1196 // React Fire: prevent the value and checked attributes from syncing

  1197 // with their related DOM properties

  1198 

  1199 

  1200 // These APIs will no longer be "unstable" in the upcoming 16.7 release,

  1201 // Control this behavior with a flag to support 16.6 minor releases in the meanwhile.

  1202 var enableStableConcurrentModeAPIs = false;

  1203 

  1204 var DEFAULT_THREAD_ID = 0;

  1205 

  1206 // Counters used to generate unique IDs.

  1207 var interactionIDCounter = 0;

  1208 var threadIDCounter = 0;

  1209 

  1210 // Set of currently traced interactions.

  1211 // Interactions "stack"–

  1212 // Meaning that newly traced interactions are appended to the previously active set.

  1213 // When an interaction goes out of scope, the previous set (if any) is restored.

  1214 var interactionsRef = null;

  1215 

  1216 // Listener(s) to notify when interactions begin and end.

  1217 var subscriberRef = null;

  1218 

  1219 if (enableSchedulerTracing) {

  1220   interactionsRef = {

  1221     current: new Set()

  1222   };

  1223   subscriberRef = {

  1224     current: null

  1225   };

  1226 }

  1227 

  1228 function unstable_clear(callback) {

  1229   if (!enableSchedulerTracing) {

  1230     return callback();

  1231   }

  1232 

  1233   var prevInteractions = interactionsRef.current;

  1234   interactionsRef.current = new Set();

  1235 

  1236   try {

  1237     return callback();

  1238   } finally {

  1239     interactionsRef.current = prevInteractions;

  1240   }

  1241 }

  1242 

  1243 function unstable_getCurrent() {

  1244   if (!enableSchedulerTracing) {

  1245     return null;

  1246   } else {

  1247     return interactionsRef.current;

  1248   }

  1249 }

  1250 

  1251 function unstable_getThreadID() {

  1252   return ++threadIDCounter;

  1253 }

  1254 

  1255 function unstable_trace(name, timestamp, callback) {

  1256   var threadID = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULT_THREAD_ID;

  1257 

  1258   if (!enableSchedulerTracing) {

  1259     return callback();

  1260   }

  1261 

  1262   var interaction = {

  1263     __count: 1,

  1264     id: interactionIDCounter++,

  1265     name: name,

  1266     timestamp: timestamp

  1267   };

  1268 

  1269   var prevInteractions = interactionsRef.current;

  1270 

  1271   // Traced interactions should stack/accumulate.

  1272   // To do that, clone the current interactions.

  1273   // The previous set will be restored upon completion.

  1274   var interactions = new Set(prevInteractions);

  1275   interactions.add(interaction);

  1276   interactionsRef.current = interactions;

  1277 

  1278   var subscriber = subscriberRef.current;

  1279   var returnValue = void 0;

  1280 

  1281   try {

  1282     if (subscriber !== null) {

  1283       subscriber.onInteractionTraced(interaction);

  1284     }

  1285   } finally {

  1286     try {

  1287       if (subscriber !== null) {

  1288         subscriber.onWorkStarted(interactions, threadID);

  1289       }

  1290     } finally {

  1291       try {

  1292         returnValue = callback();

  1293       } finally {

  1294         interactionsRef.current = prevInteractions;

  1295 

  1296         try {

  1297           if (subscriber !== null) {

  1298             subscriber.onWorkStopped(interactions, threadID);

  1299           }

  1300         } finally {

  1301           interaction.__count--;

  1302 

  1303           // If no async work was scheduled for this interaction,

  1304           // Notify subscribers that it's completed.

  1305           if (subscriber !== null && interaction.__count === 0) {

  1306             subscriber.onInteractionScheduledWorkCompleted(interaction);

  1307           }

  1308         }

  1309       }

  1310     }

  1311   }

  1312 

  1313   return returnValue;

  1314 }

  1315 

  1316 function unstable_wrap(callback) {

  1317   var threadID = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_THREAD_ID;

  1318 

  1319   if (!enableSchedulerTracing) {

  1320     return callback;

  1321   }

  1322 

  1323   var wrappedInteractions = interactionsRef.current;

  1324 

  1325   var subscriber = subscriberRef.current;

  1326   if (subscriber !== null) {

  1327     subscriber.onWorkScheduled(wrappedInteractions, threadID);

  1328   }

  1329 

  1330   // Update the pending async work count for the current interactions.

  1331   // Update after calling subscribers in case of error.

  1332   wrappedInteractions.forEach(function (interaction) {

  1333     interaction.__count++;

  1334   });

  1335 

  1336   var hasRun = false;

  1337 

  1338   function wrapped() {

  1339     var prevInteractions = interactionsRef.current;

  1340     interactionsRef.current = wrappedInteractions;

  1341 

  1342     subscriber = subscriberRef.current;

  1343 

  1344     try {

  1345       var returnValue = void 0;

  1346 

  1347       try {

  1348         if (subscriber !== null) {

  1349           subscriber.onWorkStarted(wrappedInteractions, threadID);

  1350         }

  1351       } finally {

  1352         try {

  1353           returnValue = callback.apply(undefined, arguments);

  1354         } finally {

  1355           interactionsRef.current = prevInteractions;

  1356 

  1357           if (subscriber !== null) {

  1358             subscriber.onWorkStopped(wrappedInteractions, threadID);

  1359           }

  1360         }

  1361       }

  1362 

  1363       return returnValue;

  1364     } finally {

  1365       if (!hasRun) {

  1366         // We only expect a wrapped function to be executed once,

  1367         // But in the event that it's executed more than once–

  1368         // Only decrement the outstanding interaction counts once.

  1369         hasRun = true;

  1370 

  1371         // Update pending async counts for all wrapped interactions.

  1372         // If this was the last scheduled async work for any of them,

  1373         // Mark them as completed.

  1374         wrappedInteractions.forEach(function (interaction) {

  1375           interaction.__count--;

  1376 

  1377           if (subscriber !== null && interaction.__count === 0) {

  1378             subscriber.onInteractionScheduledWorkCompleted(interaction);

  1379           }

  1380         });

  1381       }

  1382     }

  1383   }

  1384 

  1385   wrapped.cancel = function cancel() {

  1386     subscriber = subscriberRef.current;

  1387 

  1388     try {

  1389       if (subscriber !== null) {

  1390         subscriber.onWorkCanceled(wrappedInteractions, threadID);

  1391       }

  1392     } finally {

  1393       // Update pending async counts for all wrapped interactions.

  1394       // If this was the last scheduled async work for any of them,

  1395       // Mark them as completed.

  1396       wrappedInteractions.forEach(function (interaction) {

  1397         interaction.__count--;

  1398 

  1399         if (subscriber && interaction.__count === 0) {

  1400           subscriber.onInteractionScheduledWorkCompleted(interaction);

  1401         }

  1402       });

  1403     }

  1404   };

  1405 

  1406   return wrapped;

  1407 }

  1408 

  1409 var subscribers = null;

  1410 if (enableSchedulerTracing) {

  1411   subscribers = new Set();

  1412 }

  1413 

  1414 function unstable_subscribe(subscriber) {

  1415   if (enableSchedulerTracing) {

  1416     subscribers.add(subscriber);

  1417 

  1418     if (subscribers.size === 1) {

  1419       subscriberRef.current = {

  1420         onInteractionScheduledWorkCompleted: onInteractionScheduledWorkCompleted,

  1421         onInteractionTraced: onInteractionTraced,

  1422         onWorkCanceled: onWorkCanceled,

  1423         onWorkScheduled: onWorkScheduled,

  1424         onWorkStarted: onWorkStarted,

  1425         onWorkStopped: onWorkStopped

  1426       };

  1427     }

  1428   }

  1429 }

  1430 

  1431 function unstable_unsubscribe(subscriber) {

  1432   if (enableSchedulerTracing) {

  1433     subscribers.delete(subscriber);

  1434 

  1435     if (subscribers.size === 0) {

  1436       subscriberRef.current = null;

  1437     }

  1438   }

  1439 }

  1440 

  1441 function onInteractionTraced(interaction) {

  1442   var didCatchError = false;

  1443   var caughtError = null;

  1444 

  1445   subscribers.forEach(function (subscriber) {

  1446     try {

  1447       subscriber.onInteractionTraced(interaction);

  1448     } catch (error) {

  1449       if (!didCatchError) {

  1450         didCatchError = true;

  1451         caughtError = error;

  1452       }

  1453     }

  1454   });

  1455 

  1456   if (didCatchError) {

  1457     throw caughtError;

  1458   }

  1459 }

  1460 

  1461 function onInteractionScheduledWorkCompleted(interaction) {

  1462   var didCatchError = false;

  1463   var caughtError = null;

  1464 

  1465   subscribers.forEach(function (subscriber) {

  1466     try {

  1467       subscriber.onInteractionScheduledWorkCompleted(interaction);

  1468     } catch (error) {

  1469       if (!didCatchError) {

  1470         didCatchError = true;

  1471         caughtError = error;

  1472       }

  1473     }

  1474   });

  1475 

  1476   if (didCatchError) {

  1477     throw caughtError;

  1478   }

  1479 }

  1480 

  1481 function onWorkScheduled(interactions, threadID) {

  1482   var didCatchError = false;

  1483   var caughtError = null;

  1484 

  1485   subscribers.forEach(function (subscriber) {

  1486     try {

  1487       subscriber.onWorkScheduled(interactions, threadID);

  1488     } catch (error) {

  1489       if (!didCatchError) {

  1490         didCatchError = true;

  1491         caughtError = error;

  1492       }

  1493     }

  1494   });

  1495 

  1496   if (didCatchError) {

  1497     throw caughtError;

  1498   }

  1499 }

  1500 

  1501 function onWorkStarted(interactions, threadID) {

  1502   var didCatchError = false;

  1503   var caughtError = null;

  1504 

  1505   subscribers.forEach(function (subscriber) {

  1506     try {