2019-07-19 09:08:36 +00:00
/ * * @ l i c e n s e R e a c t v 1 6 . 8 . 6
2018-02-07 16:33:43 +00:00
* react . production . min . js
2015-08-06 07:27:39 +00:00
*
2019-07-19 09:08:36 +00:00
* Copyright ( c ) Facebook , Inc . and its affiliates .
2015-08-06 07:27:39 +00:00
*
2018-02-07 16:33:43 +00:00
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree .
2015-08-06 07:27:39 +00:00
* /
2018-02-07 16:33:43 +00:00
( function ( global , factory ) {
typeof exports === 'object' && typeof module !== 'undefined' ? module . exports = factory ( ) :
typeof define === 'function' && define . amd ? define ( factory ) :
( global . React = factory ( ) ) ;
} ( this , ( function ( ) { 'use strict' ;
2015-08-06 07:27:39 +00:00
2019-07-19 09:08:36 +00:00
// TODO: this is special because it gets imported during build.
var ReactVersion = '16.8.6' ;
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var hasSymbol = typeof Symbol === 'function' && Symbol . for ;
var REACT _ELEMENT _TYPE = hasSymbol ? Symbol . for ( 'react.element' ) : 0xeac7 ;
var REACT _PORTAL _TYPE = hasSymbol ? Symbol . for ( 'react.portal' ) : 0xeaca ;
var REACT _FRAGMENT _TYPE = hasSymbol ? Symbol . for ( 'react.fragment' ) : 0xeacb ;
var REACT _STRICT _MODE _TYPE = hasSymbol ? Symbol . for ( 'react.strict_mode' ) : 0xeacc ;
var REACT _PROFILER _TYPE = hasSymbol ? Symbol . for ( 'react.profiler' ) : 0xead2 ;
var REACT _PROVIDER _TYPE = hasSymbol ? Symbol . for ( 'react.provider' ) : 0xeacd ;
var REACT _CONTEXT _TYPE = hasSymbol ? Symbol . for ( 'react.context' ) : 0xeace ;
var REACT _CONCURRENT _MODE _TYPE = hasSymbol ? Symbol . for ( 'react.concurrent_mode' ) : 0xeacf ;
var REACT _FORWARD _REF _TYPE = hasSymbol ? Symbol . for ( 'react.forward_ref' ) : 0xead0 ;
var REACT _SUSPENSE _TYPE = hasSymbol ? Symbol . for ( 'react.suspense' ) : 0xead1 ;
var REACT _MEMO _TYPE = hasSymbol ? Symbol . for ( 'react.memo' ) : 0xead3 ;
var REACT _LAZY _TYPE = hasSymbol ? Symbol . for ( 'react.lazy' ) : 0xead4 ;
var MAYBE _ITERATOR _SYMBOL = typeof Symbol === 'function' && Symbol . iterator ;
var FAUX _ITERATOR _SYMBOL = '@@iterator' ;
function getIteratorFn ( maybeIterable ) {
if ( maybeIterable === null || typeof maybeIterable !== 'object' ) {
return null ;
}
var maybeIterator = MAYBE _ITERATOR _SYMBOL && maybeIterable [ MAYBE _ITERATOR _SYMBOL ] || maybeIterable [ FAUX _ITERATOR _SYMBOL ] ;
if ( typeof maybeIterator === 'function' ) {
return maybeIterator ;
}
return null ;
}
2018-02-07 16:33:43 +00:00
/ *
object - assign
( c ) Sindre Sorhus
@ license MIT
* /
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object . getOwnPropertySymbols ;
var hasOwnProperty = Object . prototype . hasOwnProperty ;
var propIsEnumerable = Object . prototype . propertyIsEnumerable ;
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
function toObject ( val ) {
if ( val === null || val === undefined ) {
throw new TypeError ( 'Object.assign cannot be called with null or undefined' ) ;
}
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
return Object ( val ) ;
2015-08-06 07:27:39 +00:00
}
2018-02-07 16:33:43 +00:00
function shouldUseNative ( ) {
try {
if ( ! Object . assign ) {
return false ;
}
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
// Detect buggy property enumeration order in older V8 versions.
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
// https://bugs.chromium.org/p/v8/issues/detail?id=4118
var test1 = new String ( 'abc' ) ; // eslint-disable-line no-new-wrappers
test1 [ 5 ] = 'de' ;
if ( Object . getOwnPropertyNames ( test1 ) [ 0 ] === '5' ) {
return false ;
}
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
var test2 = { } ;
for ( var i = 0 ; i < 10 ; i ++ ) {
test2 [ '_' + String . fromCharCode ( i ) ] = i ;
}
var order2 = Object . getOwnPropertyNames ( test2 ) . map ( function ( n ) {
return test2 [ n ] ;
} ) ;
if ( order2 . join ( '' ) !== '0123456789' ) {
return false ;
}
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
var test3 = { } ;
'abcdefghijklmnopqrst' . split ( '' ) . forEach ( function ( letter ) {
test3 [ letter ] = letter ;
} ) ;
if ( Object . keys ( Object . assign ( { } , test3 ) ) . join ( '' ) !==
'abcdefghijklmnopqrst' ) {
return false ;
}
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
return true ;
} catch ( err ) {
// We don't expect any of the above to throw, but better to be safe.
return false ;
}
2017-09-14 12:32:06 +00:00
}
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
var objectAssign = shouldUseNative ( ) ? Object . assign : function ( target , source ) {
var from ;
var to = toObject ( target ) ;
var symbols ;
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
for ( var s = 1 ; s < arguments . length ; s ++ ) {
from = Object ( arguments [ s ] ) ;
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
for ( var key in from ) {
if ( hasOwnProperty . call ( from , key ) ) {
to [ key ] = from [ key ] ;
}
}
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
if ( getOwnPropertySymbols ) {
symbols = getOwnPropertySymbols ( from ) ;
for ( var i = 0 ; i < symbols . length ; i ++ ) {
if ( propIsEnumerable . call ( from , symbols [ i ] ) ) {
to [ symbols [ i ] ] = from [ symbols [ i ] ] ;
}
}
}
}
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
return to ;
} ;
2018-02-07 19:06:58 +00:00
2018-07-06 09:43:34 +00:00
/ * *
2019-07-19 09:08:36 +00:00
* Use invariant ( ) to assert state which your program assumes to be true .
2018-07-06 09:43:34 +00:00
*
2019-07-19 09:08:36 +00:00
* Provide sprintf - style format ( only % s is supported ) and arguments
* to provide information about what broke and what you were
* expecting .
2018-07-06 09:43:34 +00:00
*
2019-07-19 09:08:36 +00:00
* The invariant message will be stripped in production , but the invariant
* will remain to ensure logic does not differ in production .
2018-07-06 09:43:34 +00:00
* /
function invariant ( condition , format , a , b , c , d , e , f ) {
if ( ! condition ) {
2019-07-19 09:08:36 +00:00
var error = void 0 ;
2018-07-06 09:43:34 +00:00
if ( format === undefined ) {
error = new Error ( 'Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.' ) ;
} else {
var args = [ a , b , c , d , e , f ] ;
var argIndex = 0 ;
error = new Error ( format . replace ( /%s/g , function ( ) {
return args [ argIndex ++ ] ;
} ) ) ;
error . name = 'Invariant Violation' ;
}
error . framesToPop = 1 ; // we don't care about invariant's own frame
throw error ;
}
}
// Relying on the `invariant()` implementation lets us
2019-07-19 09:08:36 +00:00
// preserve the format and params in the www builds.
2015-08-06 07:27:39 +00:00
/ * *
2018-02-07 16:33:43 +00:00
* WARNING : DO NOT manually require this module .
* This is a replacement for ` invariant(...) ` used by the error code system
* and will _only _ be required by the corresponding babel pass .
* It always throws .
2015-08-06 07:27:39 +00:00
* /
2018-02-07 16:33:43 +00:00
function reactProdInvariant ( code ) {
var argCount = arguments . length - 1 ;
2018-07-06 09:43:34 +00:00
var url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code ;
2018-02-07 16:33:43 +00:00
for ( var argIdx = 0 ; argIdx < argCount ; argIdx ++ ) {
2018-07-06 09:43:34 +00:00
url += '&args[]=' + encodeURIComponent ( arguments [ argIdx + 1 ] ) ;
2018-02-07 19:06:58 +00:00
}
2019-07-19 09:08:36 +00:00
// Rename it so that our build transform doesn't attempt
2018-07-06 09:43:34 +00:00
// to replace this invariant() call with reactProdInvariant().
2019-07-19 09:08:36 +00:00
var i = invariant ;
2018-07-06 09:43:34 +00:00
i ( false ,
// The error code is intentionally part of the message (and
// not the format argument) so that we could deduplicate
// different errors in logs based on the code.
'Minified React error #' + code + '; visit %s ' + 'for the full message or use the non-minified dev environment ' + 'for full errors and additional helpful warnings. ' , url ) ;
}
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
/ * *
* Forked from fbjs / warning :
* https : //github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
*
* Only change is we use console . warn instead of console . error ,
* and do nothing when 'console' is not supported .
* This really simplifies the code .
* -- -
* Similar to invariant but only logs a warning if the condition is not met .
* This can be used to log issues in development environments in critical
* paths . Removing the logging code for production environments will keep the
* same logic and follow the same code paths .
* /
2015-08-06 07:27:39 +00:00
/ * *
2019-07-19 09:08:36 +00:00
* Similar to invariant but only logs a warning if the condition is not met .
* This can be used to log issues in development environments in critical
* paths . Removing the logging code for production environments will keep the
* same logic and follow the same code paths .
2018-02-07 19:06:58 +00:00
* /
/ * *
2018-02-07 16:33:43 +00:00
* This is the abstract API for an update queue .
2018-02-07 19:06:58 +00:00
* /
2018-02-07 16:33:43 +00:00
var ReactNoopUpdateQueue = {
/ * *
* Checks whether or not this composite component is mounted .
* @ param { ReactClass } publicInstance The instance we want to test .
* @ return { boolean } True if mounted , false otherwise .
* @ protected
* @ final
* /
isMounted : function ( publicInstance ) {
return false ;
} ,
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
/ * *
* Forces an update . This should only be invoked when it is known with
* certainty that we are * * not * * in a DOM transaction .
*
* You may want to call this when you know that some deeper aspect of the
* component ' s state has changed but ` setState ` was not called .
*
* This will not invoke ` shouldComponentUpdate ` , but it will invoke
* ` componentWillUpdate ` and ` componentDidUpdate ` .
*
* @ param { ReactClass } publicInstance The instance that should rerender .
* @ param { ? function } callback Called after component is updated .
* @ param { ? string } callerName name of the calling function in the public API .
* @ internal
* /
enqueueForceUpdate : function ( publicInstance , callback , callerName ) {
} ,
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
/ * *
* Replaces all of the state . Always use this or ` setState ` to mutate state .
* You should treat ` this.state ` as immutable .
*
* There is no guarantee that ` this.state ` will be immediately updated , so
* accessing ` this.state ` after calling this method may return the old value .
*
* @ param { ReactClass } publicInstance The instance that should rerender .
* @ param { object } completeState Next state .
* @ param { ? function } callback Called after component is updated .
* @ param { ? string } callerName name of the calling function in the public API .
* @ internal
* /
enqueueReplaceState : function ( publicInstance , completeState , callback , callerName ) {
} ,
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
/ * *
* Sets a subset of the state . This only exists because _pendingState is
* internal . This provides a merging strategy that is not available to deep
* properties which is confusing . TODO : Expose pendingState or don ' t use it
* during the merge .
*
* @ param { ReactClass } publicInstance The instance that should rerender .
* @ param { object } partialState Next partial state to be merged with state .
* @ param { ? function } callback Called after component is updated .
* @ param { ? string } Name of the calling function in the public API .
* @ internal
* /
enqueueSetState : function ( publicInstance , partialState , callback , callerName ) {
}
} ;
2015-08-06 07:27:39 +00:00
2019-07-19 09:08:36 +00:00
var emptyObject = { } ;
2015-08-06 07:27:39 +00:00
/ * *
2017-09-14 12:32:06 +00:00
* Base class helpers for the updating state of a component .
2015-08-06 07:27:39 +00:00
* /
2018-02-07 16:33:43 +00:00
function Component ( props , context , updater ) {
2017-09-14 12:32:06 +00:00
this . props = props ;
this . context = context ;
2019-07-19 09:08:36 +00:00
// If a component has string refs, we will assign a different object later.
this . refs = emptyObject ;
2017-09-14 12:32:06 +00:00
// We initialize the default updater but the real one gets injected by the
// renderer.
this . updater = updater || ReactNoopUpdateQueue ;
2015-08-06 07:27:39 +00:00
}
2018-02-07 16:33:43 +00:00
Component . prototype . isReactComponent = { } ;
2015-08-06 07:27:39 +00:00
2017-09-14 12:32:06 +00:00
/ * *
* Sets a subset of the state . Always use this to mutate
* state . You should treat ` this.state ` as immutable .
*
* There is no guarantee that ` this.state ` will be immediately updated , so
* accessing ` this.state ` after calling this method may return the old value .
*
* There is no guarantee that calls to ` setState ` will run synchronously ,
* as they may eventually be batched together . You can provide an optional
* callback that will be executed when the call to setState is actually
* completed .
*
* When a function is provided to setState , it will be called at some point in
* the future ( not synchronously ) . It will be called with the up to date
* component arguments ( state , props , context ) . These values can be different
* from this . * because your function may be called after receiveProps but before
* shouldComponentUpdate , and this new state , props , and context will not yet be
* assigned to this .
*
* @ param { object | function } partialState Next partial state or function to
* produce next partial state to be merged with current state .
* @ param { ? function } callback Called after state is updated .
* @ final
* @ protected
* /
2018-02-07 16:33:43 +00:00
Component . prototype . setState = function ( partialState , callback ) {
! ( typeof partialState === 'object' || typeof partialState === 'function' || partialState == null ) ? reactProdInvariant ( '85' ) : void 0 ;
this . updater . enqueueSetState ( this , partialState , callback , 'setState' ) ;
2017-09-14 12:32:06 +00:00
} ;
2015-08-06 07:27:39 +00:00
2017-09-14 12:32:06 +00:00
/ * *
* Forces an update . This should only be invoked when it is known with
* certainty that we are * * not * * in a DOM transaction .
*
* You may want to call this when you know that some deeper aspect of the
* component ' s state has changed but ` setState ` was not called .
*
* This will not invoke ` shouldComponentUpdate ` , but it will invoke
* ` componentWillUpdate ` and ` componentDidUpdate ` .
*
* @ param { ? function } callback Called after update is complete .
* @ final
* @ protected
* /
2018-02-07 16:33:43 +00:00
Component . prototype . forceUpdate = function ( callback ) {
this . updater . enqueueForceUpdate ( this , callback , 'forceUpdate' ) ;
2017-09-14 12:32:06 +00:00
} ;
2015-08-06 07:27:39 +00:00
/ * *
2017-09-14 12:32:06 +00:00
* Deprecated APIs . These APIs used to exist on classic React classes but since
* we would like to deprecate them , we ' re not going to move them over to this
* modern base class . Instead , we define a getter that warns if it ' s accessed .
2015-08-06 07:27:39 +00:00
* /
2018-07-06 09:43:34 +00:00
function ComponentDummy ( ) { }
ComponentDummy . prototype = Component . prototype ;
2015-08-06 07:27:39 +00:00
/ * *
2018-07-06 09:43:34 +00:00
* Convenience component with default shallow equality check for sCU .
2015-08-06 07:27:39 +00:00
* /
2018-02-07 16:33:43 +00:00
function PureComponent ( props , context , updater ) {
2017-09-14 12:32:06 +00:00
this . props = props ;
this . context = context ;
2019-07-19 09:08:36 +00:00
// If a component has string refs, we will assign a different object later.
this . refs = emptyObject ;
2017-09-14 12:32:06 +00:00
this . updater = updater || ReactNoopUpdateQueue ;
}
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
var pureComponentPrototype = PureComponent . prototype = new ComponentDummy ( ) ;
pureComponentPrototype . constructor = PureComponent ;
2017-09-14 12:32:06 +00:00
// Avoid an extra prototype jump for these methods.
2018-02-07 16:33:43 +00:00
objectAssign ( pureComponentPrototype , Component . prototype ) ;
pureComponentPrototype . isPureReactComponent = true ;
2018-07-06 09:43:34 +00:00
// an immutable object with a single mutable value
function createRef ( ) {
var refObject = {
current : null
} ;
return refObject ;
2018-02-07 16:33:43 +00:00
}
2015-08-06 07:27:39 +00:00
2019-07-19 09:08:36 +00:00
var enableSchedulerDebugging = false ;
/* eslint-disable no-var */
// TODO: Use symbols?
var ImmediatePriority = 1 ;
var UserBlockingPriority = 2 ;
var NormalPriority = 3 ;
var LowPriority = 4 ;
var IdlePriority = 5 ;
// Max 31 bit integer. The max integer size in V8 for 32-bit systems.
// Math.pow(2, 30) - 1
// 0b111111111111111111111111111111
var maxSigned31BitInt = 1073741823 ;
// Times out immediately
var IMMEDIATE _PRIORITY _TIMEOUT = - 1 ;
// Eventually times out
var USER _BLOCKING _PRIORITY = 250 ;
var NORMAL _PRIORITY _TIMEOUT = 5000 ;
var LOW _PRIORITY _TIMEOUT = 10000 ;
// Never times out
var IDLE _PRIORITY = maxSigned31BitInt ;
// Callbacks are stored as a circular, doubly linked list.
var firstCallbackNode = null ;
var currentDidTimeout = false ;
// Pausing the scheduler is useful for debugging.
var isSchedulerPaused = false ;
var currentPriorityLevel = NormalPriority ;
var currentEventStartTime = - 1 ;
var currentExpirationTime = - 1 ;
// This is set when a callback is being executed, to prevent re-entrancy.
var isExecutingCallback = false ;
var isHostCallbackScheduled = false ;
var hasNativePerformanceNow = typeof performance === 'object' && typeof performance . now === 'function' ;
function ensureHostCallbackIsScheduled ( ) {
if ( isExecutingCallback ) {
// Don't schedule work yet; wait until the next time we yield.
return ;
}
// Schedule the host callback using the earliest expiration in the list.
var expirationTime = firstCallbackNode . expirationTime ;
if ( ! isHostCallbackScheduled ) {
isHostCallbackScheduled = true ;
} else {
// Cancel the existing host callback.
cancelHostCallback ( ) ;
}
requestHostCallback ( flushWork , expirationTime ) ;
}
function flushFirstCallback ( ) {
var flushedNode = firstCallbackNode ;
// Remove the node from the list before calling the callback. That way the
// list is in a consistent state even if the callback throws.
var next = firstCallbackNode . next ;
if ( firstCallbackNode === next ) {
// This is the last callback in the list.
firstCallbackNode = null ;
next = null ;
} else {
var lastCallbackNode = firstCallbackNode . previous ;
firstCallbackNode = lastCallbackNode . next = next ;
next . previous = lastCallbackNode ;
}
flushedNode . next = flushedNode . previous = null ;
// Now it's safe to call the callback.
var callback = flushedNode . callback ;
var expirationTime = flushedNode . expirationTime ;
var priorityLevel = flushedNode . priorityLevel ;
var previousPriorityLevel = currentPriorityLevel ;
var previousExpirationTime = currentExpirationTime ;
currentPriorityLevel = priorityLevel ;
currentExpirationTime = expirationTime ;
var continuationCallback ;
try {
continuationCallback = callback ( ) ;
} finally {
currentPriorityLevel = previousPriorityLevel ;
currentExpirationTime = previousExpirationTime ;
}
// A callback may return a continuation. The continuation should be scheduled
// with the same priority and expiration as the just-finished callback.
if ( typeof continuationCallback === 'function' ) {
var continuationNode = {
callback : continuationCallback ,
priorityLevel : priorityLevel ,
expirationTime : expirationTime ,
next : null ,
previous : null
} ;
// Insert the new callback into the list, sorted by its expiration. This is
// almost the same as the code in `scheduleCallback`, except the callback
// is inserted into the list *before* callbacks of equal expiration instead
// of after.
if ( firstCallbackNode === null ) {
// This is the first callback in the list.
firstCallbackNode = continuationNode . next = continuationNode . previous = continuationNode ;
} else {
var nextAfterContinuation = null ;
var node = firstCallbackNode ;
do {
if ( node . expirationTime >= expirationTime ) {
// This callback expires at or after the continuation. We will insert
// the continuation *before* this callback.
nextAfterContinuation = node ;
break ;
}
node = node . next ;
} while ( node !== firstCallbackNode ) ;
if ( nextAfterContinuation === null ) {
// No equal or lower priority callback was found, which means the new
// callback is the lowest priority callback in the list.
nextAfterContinuation = firstCallbackNode ;
} else if ( nextAfterContinuation === firstCallbackNode ) {
// The new callback is the highest priority callback in the list.
firstCallbackNode = continuationNode ;
ensureHostCallbackIsScheduled ( ) ;
}
var previous = nextAfterContinuation . previous ;
previous . next = nextAfterContinuation . previous = continuationNode ;
continuationNode . next = nextAfterContinuation ;
continuationNode . previous = previous ;
}
}
}
function flushImmediateWork ( ) {
if (
// Confirm we've exited the outer most event handler
currentEventStartTime === - 1 && firstCallbackNode !== null && firstCallbackNode . priorityLevel === ImmediatePriority ) {
isExecutingCallback = true ;
try {
do {
flushFirstCallback ( ) ;
} while (
// Keep flushing until there are no more immediate callbacks
firstCallbackNode !== null && firstCallbackNode . priorityLevel === ImmediatePriority ) ;
} finally {
isExecutingCallback = false ;
if ( firstCallbackNode !== null ) {
// There's still work remaining. Request another callback.
ensureHostCallbackIsScheduled ( ) ;
} else {
isHostCallbackScheduled = false ;
}
}
}
}
function flushWork ( didTimeout ) {
// Exit right away if we're currently paused
if ( enableSchedulerDebugging && isSchedulerPaused ) {
return ;
}
isExecutingCallback = true ;
var previousDidTimeout = currentDidTimeout ;
currentDidTimeout = didTimeout ;
try {
if ( didTimeout ) {
// Flush all the expired callbacks without yielding.
while ( firstCallbackNode !== null && ! ( enableSchedulerDebugging && isSchedulerPaused ) ) {
// TODO Wrap in feature flag
// Read the current time. Flush all the callbacks that expire at or
// earlier than that time. Then read the current time again and repeat.
// This optimizes for as few performance.now calls as possible.
var currentTime = getCurrentTime ( ) ;
if ( firstCallbackNode . expirationTime <= currentTime ) {
do {
flushFirstCallback ( ) ;
} while ( firstCallbackNode !== null && firstCallbackNode . expirationTime <= currentTime && ! ( enableSchedulerDebugging && isSchedulerPaused ) ) ;
continue ;
}
break ;
}
} else {
// Keep flushing callbacks until we run out of time in the frame.
if ( firstCallbackNode !== null ) {
do {
if ( enableSchedulerDebugging && isSchedulerPaused ) {
break ;
}
flushFirstCallback ( ) ;
} while ( firstCallbackNode !== null && ! shouldYieldToHost ( ) ) ;
}
}
} finally {
isExecutingCallback = false ;
currentDidTimeout = previousDidTimeout ;
if ( firstCallbackNode !== null ) {
// There's still work remaining. Request another callback.
ensureHostCallbackIsScheduled ( ) ;
} else {
isHostCallbackScheduled = false ;
}
// Before exiting, flush all the immediate work that was scheduled.
flushImmediateWork ( ) ;
}
}
function unstable _runWithPriority ( priorityLevel , eventHandler ) {
switch ( priorityLevel ) {
case ImmediatePriority :
case UserBlockingPriority :
case NormalPriority :
case LowPriority :
case IdlePriority :
break ;
default :
priorityLevel = NormalPriority ;
}
var previousPriorityLevel = currentPriorityLevel ;
var previousEventStartTime = currentEventStartTime ;
currentPriorityLevel = priorityLevel ;
currentEventStartTime = getCurrentTime ( ) ;
try {
return eventHandler ( ) ;
} finally {
currentPriorityLevel = previousPriorityLevel ;
currentEventStartTime = previousEventStartTime ;
// Before exiting, flush all the immediate work that was scheduled.
flushImmediateWork ( ) ;
}
}
function unstable _next ( eventHandler ) {
var priorityLevel = void 0 ;
switch ( currentPriorityLevel ) {
case ImmediatePriority :
case UserBlockingPriority :
case NormalPriority :
// Shift down to normal priority
priorityLevel = NormalPriority ;
break ;
default :
// Anything lower than normal priority should remain at the current level.
priorityLevel = currentPriorityLevel ;
break ;
}
var previousPriorityLevel = currentPriorityLevel ;
var previousEventStartTime = currentEventStartTime ;
currentPriorityLevel = priorityLevel ;
currentEventStartTime = getCurrentTime ( ) ;
try {
return eventHandler ( ) ;
} finally {
currentPriorityLevel = previousPriorityLevel ;
currentEventStartTime = previousEventStartTime ;
// Before exiting, flush all the immediate work that was scheduled.
flushImmediateWork ( ) ;
}
}
function unstable _wrapCallback ( callback ) {
var parentPriorityLevel = currentPriorityLevel ;
return function ( ) {
// This is a fork of runWithPriority, inlined for performance.
var previousPriorityLevel = currentPriorityLevel ;
var previousEventStartTime = currentEventStartTime ;
currentPriorityLevel = parentPriorityLevel ;
currentEventStartTime = getCurrentTime ( ) ;
try {
return callback . apply ( this , arguments ) ;
} finally {
currentPriorityLevel = previousPriorityLevel ;
currentEventStartTime = previousEventStartTime ;
flushImmediateWork ( ) ;
}
} ;
}
function unstable _scheduleCallback ( callback , deprecated _options ) {
var startTime = currentEventStartTime !== - 1 ? currentEventStartTime : getCurrentTime ( ) ;
var expirationTime ;
if ( typeof deprecated _options === 'object' && deprecated _options !== null && typeof deprecated _options . timeout === 'number' ) {
// FIXME: Remove this branch once we lift expiration times out of React.
expirationTime = startTime + deprecated _options . timeout ;
} else {
switch ( currentPriorityLevel ) {
case ImmediatePriority :
expirationTime = startTime + IMMEDIATE _PRIORITY _TIMEOUT ;
break ;
case UserBlockingPriority :
expirationTime = startTime + USER _BLOCKING _PRIORITY ;
break ;
case IdlePriority :
expirationTime = startTime + IDLE _PRIORITY ;
break ;
case LowPriority :
expirationTime = startTime + LOW _PRIORITY _TIMEOUT ;
break ;
case NormalPriority :
default :
expirationTime = startTime + NORMAL _PRIORITY _TIMEOUT ;
}
}
var newNode = {
callback : callback ,
priorityLevel : currentPriorityLevel ,
expirationTime : expirationTime ,
next : null ,
previous : null
} ;
// Insert the new callback into the list, ordered first by expiration, then
// by insertion. So the new callback is inserted any other callback with
// equal expiration.
if ( firstCallbackNode === null ) {
// This is the first callback in the list.
firstCallbackNode = newNode . next = newNode . previous = newNode ;
ensureHostCallbackIsScheduled ( ) ;
} else {
var next = null ;
var node = firstCallbackNode ;
do {
if ( node . expirationTime > expirationTime ) {
// The new callback expires before this one.
next = node ;
break ;
}
node = node . next ;
} while ( node !== firstCallbackNode ) ;
if ( next === null ) {
// No callback with a later expiration was found, which means the new
// callback has the latest expiration in the list.
next = firstCallbackNode ;
} else if ( next === firstCallbackNode ) {
// The new callback has the earliest expiration in the entire list.
firstCallbackNode = newNode ;
ensureHostCallbackIsScheduled ( ) ;
}
var previous = next . previous ;
previous . next = next . previous = newNode ;
newNode . next = next ;
newNode . previous = previous ;
}
return newNode ;
}
function unstable _pauseExecution ( ) {
isSchedulerPaused = true ;
}
function unstable _continueExecution ( ) {
isSchedulerPaused = false ;
if ( firstCallbackNode !== null ) {
ensureHostCallbackIsScheduled ( ) ;
}
}
function unstable _getFirstCallbackNode ( ) {
return firstCallbackNode ;
}
function unstable _cancelCallback ( callbackNode ) {
var next = callbackNode . next ;
if ( next === null ) {
// Already cancelled.
return ;
}
if ( next === callbackNode ) {
// This is the only scheduled callback. Clear the list.
firstCallbackNode = null ;
} else {
// Remove the callback from its position in the list.
if ( callbackNode === firstCallbackNode ) {
firstCallbackNode = next ;
}
var previous = callbackNode . previous ;
previous . next = next ;
next . previous = previous ;
}
callbackNode . next = callbackNode . previous = null ;
}
function unstable _getCurrentPriorityLevel ( ) {
return currentPriorityLevel ;
}
function unstable _shouldYield ( ) {
return ! currentDidTimeout && ( firstCallbackNode !== null && firstCallbackNode . expirationTime < currentExpirationTime || shouldYieldToHost ( ) ) ;
}
// The remaining code is essentially a polyfill for requestIdleCallback. It
// works by scheduling a requestAnimationFrame, storing the time for the start
// of the frame, then scheduling a postMessage which gets scheduled after paint.
// Within the postMessage handler do as much work as possible until time + frame
// rate. By separating the idle call into a separate event tick we ensure that
// layout, paint and other browser work is counted against the available time.
// The frame rate is dynamically adjusted.
// We capture a local reference to any global, in case it gets polyfilled after
// this module is initially evaluated. We want to be using a
// consistent implementation.
var localDate = Date ;
// This initialization code may run even on server environments if a component
// just imports ReactDOM (e.g. for findDOMNode). Some environments might not
// have setTimeout or clearTimeout. However, we always expect them to be defined
// on the client. https://github.com/facebook/react/pull/13088
var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : undefined ;
var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined ;
// We don't expect either of these to necessarily be defined, but we will error
// later if they are missing on the client.
var localRequestAnimationFrame = typeof requestAnimationFrame === 'function' ? requestAnimationFrame : undefined ;
var localCancelAnimationFrame = typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame : undefined ;
var getCurrentTime ;
// requestAnimationFrame does not run when the tab is in the background. If
// we're backgrounded we prefer for that work to happen so that the page
// continues to load in the background. So we also schedule a 'setTimeout' as
// a fallback.
// TODO: Need a better heuristic for backgrounded work.
var ANIMATION _FRAME _TIMEOUT = 100 ;
var rAFID ;
var rAFTimeoutID ;
var requestAnimationFrameWithTimeout = function ( callback ) {
// schedule rAF and also a setTimeout
rAFID = localRequestAnimationFrame ( function ( timestamp ) {
// cancel the setTimeout
localClearTimeout ( rAFTimeoutID ) ;
callback ( timestamp ) ;
} ) ;
rAFTimeoutID = localSetTimeout ( function ( ) {
// cancel the requestAnimationFrame
localCancelAnimationFrame ( rAFID ) ;
callback ( getCurrentTime ( ) ) ;
} , ANIMATION _FRAME _TIMEOUT ) ;
} ;
if ( hasNativePerformanceNow ) {
var Performance = performance ;
getCurrentTime = function ( ) {
return Performance . now ( ) ;
} ;
} else {
getCurrentTime = function ( ) {
return localDate . now ( ) ;
} ;
}
var requestHostCallback ;
var cancelHostCallback ;
var shouldYieldToHost ;
var globalValue = null ;
if ( typeof window !== 'undefined' ) {
globalValue = window ;
} else if ( typeof global !== 'undefined' ) {
globalValue = global ;
}
if ( globalValue && globalValue . _schedMock ) {
// Dynamic injection, only for testing purposes.
var globalImpl = globalValue . _schedMock ;
requestHostCallback = globalImpl [ 0 ] ;
cancelHostCallback = globalImpl [ 1 ] ;
shouldYieldToHost = globalImpl [ 2 ] ;
getCurrentTime = globalImpl [ 3 ] ;
} else if (
// If Scheduler runs in a non-DOM environment, it falls back to a naive
// implementation using setTimeout.
typeof window === 'undefined' ||
// Check if MessageChannel is supported, too.
typeof MessageChannel !== 'function' ) {
// If this accidentally gets imported in a non-browser environment, e.g. JavaScriptCore,
// fallback to a naive implementation.
var _callback = null ;
var _flushCallback = function ( didTimeout ) {
if ( _callback !== null ) {
try {
_callback ( didTimeout ) ;
} finally {
_callback = null ;
}
}
} ;
requestHostCallback = function ( cb , ms ) {
if ( _callback !== null ) {
// Protect against re-entrancy.
setTimeout ( requestHostCallback , 0 , cb ) ;
} else {
_callback = cb ;
setTimeout ( _flushCallback , 0 , false ) ;
}
} ;
cancelHostCallback = function ( ) {
_callback = null ;
} ;
shouldYieldToHost = function ( ) {
return false ;
} ;
} else {
if ( typeof console !== 'undefined' ) {
// TODO: Remove fb.me link
if ( typeof localRequestAnimationFrame !== 'function' ) {
console . error ( "This browser doesn't support requestAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills' ) ;
}
if ( typeof localCancelAnimationFrame !== 'function' ) {
console . error ( "This browser doesn't support cancelAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills' ) ;
}
}
var scheduledHostCallback = null ;
var isMessageEventScheduled = false ;
var timeoutTime = - 1 ;
var isAnimationFrameScheduled = false ;
var isFlushingHostCallback = false ;
var frameDeadline = 0 ;
// We start out assuming that we run at 30fps but then the heuristic tracking
// will adjust this value to a faster fps if we get more frequent animation
// frames.
var previousFrameTime = 33 ;
var activeFrameTime = 33 ;
shouldYieldToHost = function ( ) {
return frameDeadline <= getCurrentTime ( ) ;
} ;
// We use the postMessage trick to defer idle work until after the repaint.
var channel = new MessageChannel ( ) ;
var port = channel . port2 ;
channel . port1 . onmessage = function ( event ) {
isMessageEventScheduled = false ;
var prevScheduledCallback = scheduledHostCallback ;
var prevTimeoutTime = timeoutTime ;
scheduledHostCallback = null ;
timeoutTime = - 1 ;
var currentTime = getCurrentTime ( ) ;
var didTimeout = false ;
if ( frameDeadline - currentTime <= 0 ) {
// There's no time left in this idle period. Check if the callback has
// a timeout and whether it's been exceeded.
if ( prevTimeoutTime !== - 1 && prevTimeoutTime <= currentTime ) {
// Exceeded the timeout. Invoke the callback even though there's no
// time left.
didTimeout = true ;
} else {
// No timeout.
if ( ! isAnimationFrameScheduled ) {
// Schedule another animation callback so we retry later.
isAnimationFrameScheduled = true ;
requestAnimationFrameWithTimeout ( animationTick ) ;
}
// Exit without invoking the callback.
scheduledHostCallback = prevScheduledCallback ;
timeoutTime = prevTimeoutTime ;
return ;
}
}
if ( prevScheduledCallback !== null ) {
isFlushingHostCallback = true ;
try {
prevScheduledCallback ( didTimeout ) ;
} finally {
isFlushingHostCallback = false ;
}
}
} ;
var animationTick = function ( rafTime ) {
if ( scheduledHostCallback !== null ) {
// Eagerly schedule the next animation callback at the beginning of the
// frame. If the scheduler queue is not empty at the end of the frame, it
// will continue flushing inside that callback. If the queue *is* empty,
// then it will exit immediately. Posting the callback at the start of the
// frame ensures it's fired within the earliest possible frame. If we
// waited until the end of the frame to post the callback, we risk the
// browser skipping a frame and not firing the callback until the frame
// after that.
requestAnimationFrameWithTimeout ( animationTick ) ;
} else {
// No pending work. Exit.
isAnimationFrameScheduled = false ;
return ;
}
var nextFrameTime = rafTime - frameDeadline + activeFrameTime ;
if ( nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime ) {
if ( nextFrameTime < 8 ) {
// Defensive coding. We don't support higher frame rates than 120hz.
// If the calculated frame time gets lower than 8, it is probably a bug.
nextFrameTime = 8 ;
}
// If one frame goes long, then the next one can be short to catch up.
// If two frames are short in a row, then that's an indication that we
// actually have a higher frame rate than what we're currently optimizing.
// We adjust our heuristic dynamically accordingly. For example, if we're
// running on 120hz display or 90hz VR display.
// Take the max of the two in case one of them was an anomaly due to
// missed frame deadlines.
activeFrameTime = nextFrameTime < previousFrameTime ? previousFrameTime : nextFrameTime ;
} else {
previousFrameTime = nextFrameTime ;
}
frameDeadline = rafTime + activeFrameTime ;
if ( ! isMessageEventScheduled ) {
isMessageEventScheduled = true ;
port . postMessage ( undefined ) ;
}
} ;
requestHostCallback = function ( callback , absoluteTimeout ) {
scheduledHostCallback = callback ;
timeoutTime = absoluteTimeout ;
if ( isFlushingHostCallback || absoluteTimeout < 0 ) {
// Don't wait for the next frame. Continue working ASAP, in a new event.
port . postMessage ( undefined ) ;
} else if ( ! isAnimationFrameScheduled ) {
// If rAF didn't already schedule one, we need to schedule a frame.
// TODO: If this rAF doesn't materialize because the browser throttles, we
// might want to still have setTimeout trigger rIC as a backup to ensure
// that we keep performing work.
isAnimationFrameScheduled = true ;
requestAnimationFrameWithTimeout ( animationTick ) ;
}
} ;
cancelHostCallback = function ( ) {
scheduledHostCallback = null ;
isMessageEventScheduled = false ;
timeoutTime = - 1 ;
} ;
}
// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:
// In some cases, StrictMode should also double-render lifecycles.
// This can be confusing for tests though,
// And it can be bad for performance in production.
// This feature flag can be used to control the behavior:
// To preserve the "Pause on caught exceptions" behavior of the debugger, we
// replay the begin phase of a failed component inside invokeGuardedCallback.
// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:
// Gather advanced timing metrics for Profiler subtrees.
// Trace which interactions trigger each commit.
var enableSchedulerTracing = false ;
// Only used in www builds.
// TODO: false? Here it might just be false.
// Only used in www builds.
// Only used in www builds.
// React Fire: prevent the value and checked attributes from syncing
// with their related DOM properties
// These APIs will no longer be "unstable" in the upcoming 16.7 release,
// Control this behavior with a flag to support 16.6 minor releases in the meanwhile.
var enableStableConcurrentModeAPIs = false ;
var DEFAULT _THREAD _ID = 0 ;
// Counters used to generate unique IDs.
var interactionIDCounter = 0 ;
var threadIDCounter = 0 ;
// Set of currently traced interactions.
// Interactions "stack"–
// Meaning that newly traced interactions are appended to the previously active set.
// When an interaction goes out of scope, the previous set (if any) is restored.
var interactionsRef = null ;
// Listener(s) to notify when interactions begin and end.
var subscriberRef = null ;
if ( enableSchedulerTracing ) {
interactionsRef = {
current : new Set ( )
} ;
subscriberRef = {
current : null
} ;
}
function unstable _clear ( callback ) {
if ( ! enableSchedulerTracing ) {
return callback ( ) ;
}
var prevInteractions = interactionsRef . current ;
interactionsRef . current = new Set ( ) ;
try {
return callback ( ) ;
} finally {
interactionsRef . current = prevInteractions ;
}
}
function unstable _getCurrent ( ) {
if ( ! enableSchedulerTracing ) {
return null ;
} else {
return interactionsRef . current ;
}
}
function unstable _getThreadID ( ) {
return ++ threadIDCounter ;
}
function unstable _trace ( name , timestamp , callback ) {
var threadID = arguments . length > 3 && arguments [ 3 ] !== undefined ? arguments [ 3 ] : DEFAULT _THREAD _ID ;
if ( ! enableSchedulerTracing ) {
return callback ( ) ;
}
var interaction = {
_ _count : 1 ,
id : interactionIDCounter ++ ,
name : name ,
timestamp : timestamp
} ;
var prevInteractions = interactionsRef . current ;
// Traced interactions should stack/accumulate.
// To do that, clone the current interactions.
// The previous set will be restored upon completion.
var interactions = new Set ( prevInteractions ) ;
interactions . add ( interaction ) ;
interactionsRef . current = interactions ;
var subscriber = subscriberRef . current ;
var returnValue = void 0 ;
try {
if ( subscriber !== null ) {
subscriber . onInteractionTraced ( interaction ) ;
}
} finally {
try {
if ( subscriber !== null ) {
subscriber . onWorkStarted ( interactions , threadID ) ;
}
} finally {
try {
returnValue = callback ( ) ;
} finally {
interactionsRef . current = prevInteractions ;
try {
if ( subscriber !== null ) {
subscriber . onWorkStopped ( interactions , threadID ) ;
}
} finally {
interaction . _ _count -- ;
// If no async work was scheduled for this interaction,
// Notify subscribers that it's completed.
if ( subscriber !== null && interaction . _ _count === 0 ) {
subscriber . onInteractionScheduledWorkCompleted ( interaction ) ;
}
}
}
}
}
return returnValue ;
}
function unstable _wrap ( callback ) {
var threadID = arguments . length > 1 && arguments [ 1 ] !== undefined ? arguments [ 1 ] : DEFAULT _THREAD _ID ;
if ( ! enableSchedulerTracing ) {
return callback ;
}
var wrappedInteractions = interactionsRef . current ;
var subscriber = subscriberRef . current ;
if ( subscriber !== null ) {
subscriber . onWorkScheduled ( wrappedInteractions , threadID ) ;
}
// Update the pending async work count for the current interactions.
// Update after calling subscribers in case of error.
wrappedInteractions . forEach ( function ( interaction ) {
interaction . _ _count ++ ;
} ) ;
var hasRun = false ;
function wrapped ( ) {
var prevInteractions = interactionsRef . current ;
interactionsRef . current = wrappedInteractions ;
subscriber = subscriberRef . current ;
try {
var returnValue = void 0 ;
try {
if ( subscriber !== null ) {
subscriber . onWorkStarted ( wrappedInteractions , threadID ) ;
}
} finally {
try {
returnValue = callback . apply ( undefined , arguments ) ;
} finally {
interactionsRef . current = prevInteractions ;
if ( subscriber !== null ) {
subscriber . onWorkStopped ( wrappedInteractions , threadID ) ;
}
}
}
return returnValue ;
} finally {
if ( ! hasRun ) {
// We only expect a wrapped function to be executed once,
// But in the event that it's executed more than once–
// Only decrement the outstanding interaction counts once.
hasRun = true ;
// Update pending async counts for all wrapped interactions.
// If this was the last scheduled async work for any of them,
// Mark them as completed.
wrappedInteractions . forEach ( function ( interaction ) {
interaction . _ _count -- ;
if ( subscriber !== null && interaction . _ _count === 0 ) {
subscriber . onInteractionScheduledWorkCompleted ( interaction ) ;
}
} ) ;
}
}
}
wrapped . cancel = function cancel ( ) {
subscriber = subscriberRef . current ;
try {
if ( subscriber !== null ) {
subscriber . onWorkCanceled ( wrappedInteractions , threadID ) ;
}
} finally {
// Update pending async counts for all wrapped interactions.
// If this was the last scheduled async work for any of them,
// Mark them as completed.
wrappedInteractions . forEach ( function ( interaction ) {
interaction . _ _count -- ;
if ( subscriber && interaction . _ _count === 0 ) {
subscriber . onInteractionScheduledWorkCompleted ( interaction ) ;
}
} ) ;
}
} ;
return wrapped ;
}
var subscribers = null ;
if ( enableSchedulerTracing ) {
subscribers = new Set ( ) ;
}
function unstable _subscribe ( subscriber ) {
if ( enableSchedulerTracing ) {
subscribers . add ( subscriber ) ;
if ( subscribers . size === 1 ) {
subscriberRef . current = {
onInteractionScheduledWorkCompleted : onInteractionScheduledWorkCompleted ,
onInteractionTraced : onInteractionTraced ,
onWorkCanceled : onWorkCanceled ,
onWorkScheduled : onWorkScheduled ,
onWorkStarted : onWorkStarted ,
onWorkStopped : onWorkStopped
} ;
}
}
}
function unstable _unsubscribe ( subscriber ) {
if ( enableSchedulerTracing ) {
subscribers . delete ( subscriber ) ;
if ( subscribers . size === 0 ) {
subscriberRef . current = null ;
}
}
}
function onInteractionTraced ( interaction ) {
var didCatchError = false ;
var caughtError = null ;
subscribers . forEach ( function ( subscriber ) {
try {
subscriber . onInteractionTraced ( interaction ) ;
} catch ( error ) {
if ( ! didCatchError ) {
didCatchError = true ;
caughtError = error ;
}
}
} ) ;
if ( didCatchError ) {
throw caughtError ;
}
}
function onInteractionScheduledWorkCompleted ( interaction ) {
var didCatchError = false ;
var caughtError = null ;
subscribers . forEach ( function ( subscriber ) {
try {
subscriber . onInteractionScheduledWorkCompleted ( interaction ) ;
} catch ( error ) {
if ( ! didCatchError ) {
didCatchError = true ;
caughtError = error ;
}
}
} ) ;
if ( didCatchError ) {
throw caughtError ;
}
}
function onWorkScheduled ( interactions , threadID ) {
var didCatchError = false ;
var caughtError = null ;
subscribers . forEach ( function ( subscriber ) {
try {
subscriber . onWorkScheduled ( interactions , threadID ) ;
} catch ( error ) {
if ( ! didCatchError ) {
didCatchError = true ;
caughtError = error ;
}
}
} ) ;
if ( didCatchError ) {
throw caughtError ;
}
}
function onWorkStarted ( interactions , threadID ) {
var didCatchError = false ;
var caughtError = null ;
subscribers . forEach ( function ( subscriber ) {
try {
subscriber . onWorkStarted ( interactions , threadID ) ;
} catch ( error ) {
if ( ! didCatchError ) {
didCatchError = true ;
caughtError = error ;
}
}
} ) ;
if ( didCatchError ) {
throw caughtError ;
}
}
function onWorkStopped ( interactions , threadID ) {
var didCatchError = false ;
var caughtError = null ;
subscribers . forEach ( function ( subscriber ) {
try {
subscriber . onWorkStopped ( interactions , threadID ) ;
} catch ( error ) {
if ( ! didCatchError ) {
didCatchError = true ;
caughtError = error ;
}
}
} ) ;
if ( didCatchError ) {
throw caughtError ;
}
}
function onWorkCanceled ( interactions , threadID ) {
var didCatchError = false ;
var caughtError = null ;
subscribers . forEach ( function ( subscriber ) {
try {
subscriber . onWorkCanceled ( interactions , threadID ) ;
} catch ( error ) {
if ( ! didCatchError ) {
didCatchError = true ;
caughtError = error ;
}
}
} ) ;
if ( didCatchError ) {
throw caughtError ;
}
}
/ * *
* Keeps track of the current dispatcher .
* /
var ReactCurrentDispatcher = {
/ * *
* @ internal
* @ type { ReactComponent }
* /
current : null
} ;
2015-08-06 07:27:39 +00:00
/ * *
2018-02-07 16:33:43 +00:00
* Keeps track of the current owner .
2015-08-06 07:27:39 +00:00
*
2018-02-07 16:33:43 +00:00
* The current owner is the component who should own any components that are
* currently being constructed .
2015-08-06 07:27:39 +00:00
* /
2018-02-07 16:33:43 +00:00
var ReactCurrentOwner = {
/ * *
* @ internal
* @ type { ReactComponent }
* /
current : null
} ;
2015-08-06 07:27:39 +00:00
2019-07-19 09:08:36 +00:00
var ReactSharedInternals = {
ReactCurrentDispatcher : ReactCurrentDispatcher ,
ReactCurrentOwner : ReactCurrentOwner ,
// Used by renderers to avoid bundling object-assign twice in UMD bundles:
assign : objectAssign
} ;
{
// Re-export the schedule API(s) for UMD bundles.
// This avoids introducing a dependency on a new UMD global in a minor update,
// Since that would be a breaking change (e.g. for all existing CodeSandboxes).
// This re-export is only required for UMD bundles;
// CJS bundles use the shared NPM package.
objectAssign ( ReactSharedInternals , {
Scheduler : {
unstable _cancelCallback : unstable _cancelCallback ,
unstable _shouldYield : unstable _shouldYield ,
unstable _now : getCurrentTime ,
unstable _scheduleCallback : unstable _scheduleCallback ,
unstable _runWithPriority : unstable _runWithPriority ,
unstable _next : unstable _next ,
unstable _wrapCallback : unstable _wrapCallback ,
unstable _getFirstCallbackNode : unstable _getFirstCallbackNode ,
unstable _pauseExecution : unstable _pauseExecution ,
unstable _continueExecution : unstable _continueExecution ,
unstable _getCurrentPriorityLevel : unstable _getCurrentPriorityLevel ,
unstable _IdlePriority : IdlePriority ,
unstable _ImmediatePriority : ImmediatePriority ,
unstable _LowPriority : LowPriority ,
unstable _NormalPriority : NormalPriority ,
unstable _UserBlockingPriority : UserBlockingPriority
} ,
SchedulerTracing : {
_ _interactionsRef : interactionsRef ,
_ _subscriberRef : subscriberRef ,
unstable _clear : unstable _clear ,
unstable _getCurrent : unstable _getCurrent ,
unstable _getThreadID : unstable _getThreadID ,
unstable _subscribe : unstable _subscribe ,
unstable _trace : unstable _trace ,
unstable _unsubscribe : unstable _unsubscribe ,
unstable _wrap : unstable _wrap
}
} ) ;
}
2018-02-07 16:33:43 +00:00
var hasOwnProperty$1 = Object . prototype . hasOwnProperty ;
2017-09-14 12:32:06 +00:00
2018-02-07 16:33:43 +00:00
var RESERVED _PROPS = {
key : true ,
ref : true ,
_ _self : true ,
_ _source : true
} ;
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
function hasValidRef ( config ) {
return config . ref !== undefined ;
}
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
function hasValidKey ( config ) {
return config . key !== undefined ;
2018-02-07 19:06:58 +00:00
}
2017-09-14 12:32:06 +00:00
2016-11-28 13:38:00 +00:00
/ * *
2018-02-07 16:33:43 +00:00
* Factory method to create a new React element . This no longer adheres to
* the class pattern , so do not use new to call it . Also , no instanceof check
* will work . Instead test $$typeof field against Symbol . for ( 'react.element' ) to check
* if something is a React Element .
*
* @ param { * } type
* @ param { * } key
* @ param { string | object } ref
* @ param { * } self A * temporary * helper to detect places where ` this ` is
* different from the ` owner ` when React . createElement is called , so that we
* can warn . We want to get rid of owner and replace string ` ref ` s with arrow
* functions , and as long as ` this ` and owner are the same , there will be no
* change in behavior .
* @ param { * } source An annotation object ( added by a transpiler or otherwise )
* indicating filename , line number , and / or other information .
* @ param { * } owner
* @ param { * } props
* @ internal
2016-11-28 13:38:00 +00:00
* /
2018-02-07 16:33:43 +00:00
var ReactElement = function ( type , key , ref , self , source , owner , props ) {
var element = {
2018-07-06 09:43:34 +00:00
// This tag allows us to uniquely identify this as a React Element
2018-02-07 16:33:43 +00:00
$$typeof : REACT _ELEMENT _TYPE ,
2016-11-28 13:38:00 +00:00
2018-02-07 16:33:43 +00:00
// Built-in properties that belong on the element
type : type ,
key : key ,
ref : ref ,
props : props ,
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
// Record the component responsible for creating this element.
_owner : owner
2018-02-07 19:06:58 +00:00
} ;
2017-09-14 12:32:06 +00:00
2018-02-07 16:33:43 +00:00
return element ;
2018-02-07 19:06:58 +00:00
} ;
2015-08-06 07:27:39 +00:00
/ * *
2018-02-07 16:33:43 +00:00
* Create and return a new ReactElement of the given type .
* See https : //reactjs.org/docs/react-api.html#createelement
2015-08-06 07:27:39 +00:00
* /
2018-02-07 16:33:43 +00:00
function createElement ( type , config , children ) {
2018-07-06 09:43:34 +00:00
var propName = void 0 ;
2018-02-07 16:33:43 +00:00
2018-02-07 16:33:43 +00:00
// Reserved names are extracted
var props = { } ;
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
var key = null ;
var ref = null ;
var self = null ;
var source = null ;
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
if ( config != null ) {
if ( hasValidRef ( config ) ) {
ref = config . ref ;
}
if ( hasValidKey ( config ) ) {
key = '' + config . key ;
2018-02-07 16:33:43 +00:00
}
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
self = config . _ _self === undefined ? null : config . _ _self ;
source = config . _ _source === undefined ? null : config . _ _source ;
// Remaining properties are added to a new props object
for ( propName in config ) {
if ( hasOwnProperty$1 . call ( config , propName ) && ! RESERVED _PROPS . hasOwnProperty ( propName ) ) {
props [ propName ] = config [ propName ] ;
2018-02-07 19:06:58 +00:00
}
2018-02-07 16:33:43 +00:00
}
2018-02-07 16:33:43 +00:00
}
2018-02-07 16:33:43 +00:00
// Children can be more than one argument, and those are transferred onto
// the newly allocated props object.
var childrenLength = arguments . length - 2 ;
if ( childrenLength === 1 ) {
props . children = children ;
} else if ( childrenLength > 1 ) {
var childArray = Array ( childrenLength ) ;
for ( var i = 0 ; i < childrenLength ; i ++ ) {
childArray [ i ] = arguments [ i + 2 ] ;
2018-02-07 16:33:43 +00:00
}
2018-02-07 16:33:43 +00:00
props . children = childArray ;
}
2018-02-07 16:33:43 +00:00
2018-02-07 16:33:43 +00:00
// Resolve default props
if ( type && type . defaultProps ) {
var defaultProps = type . defaultProps ;
for ( propName in defaultProps ) {
if ( props [ propName ] === undefined ) {
props [ propName ] = defaultProps [ propName ] ;
}
}
}
return ReactElement ( type , key , ref , self , source , ReactCurrentOwner . current , props ) ;
}
2018-02-07 16:33:43 +00:00
/ * *
2018-02-07 16:33:43 +00:00
* Return a function that produces ReactElements of a given type .
* See https : //reactjs.org/docs/react-api.html#createfactory
2018-02-07 16:33:43 +00:00
* /
2018-02-07 16:33:43 +00:00
function createFactory ( type ) {
var factory = createElement . bind ( null , type ) ;
// Expose the type on the factory and the prototype so that it can be
// easily accessed on elements. E.g. `<Foo />.type === Foo`.
// This should not be named `constructor` since this may not be the function
// that created the element, and it may not even be a constructor.
2018-07-06 09:43:34 +00:00
// Legacy hook: remove it
2018-02-07 16:33:43 +00:00
factory . type = type ;
return factory ;
}
2018-02-07 16:33:43 +00:00
2018-02-07 16:33:43 +00:00
function cloneAndReplaceKey ( oldElement , newKey ) {
var newElement = ReactElement ( oldElement . type , newKey , oldElement . ref , oldElement . _self , oldElement . _source , oldElement . _owner , oldElement . props ) ;
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
return newElement ;
2018-02-07 16:33:43 +00:00
}
/ * *
2018-02-07 16:33:43 +00:00
* Clone and return a new ReactElement using element as the starting point .
* See https : //reactjs.org/docs/react-api.html#cloneelement
2018-02-07 16:33:43 +00:00
* /
2018-02-07 16:33:43 +00:00
function cloneElement ( element , config , children ) {
2018-07-06 09:43:34 +00:00
! ! ( element === null || element === undefined ) ? reactProdInvariant ( '267' , element ) : void 0 ;
var propName = void 0 ;
2018-02-07 16:33:43 +00:00
// Original props are copied
var props = objectAssign ( { } , element . props ) ;
// Reserved names are extracted
var key = element . key ;
var ref = element . ref ;
// Self is preserved since the owner is preserved.
var self = element . _self ;
// Source is preserved since cloneElement is unlikely to be targeted by a
// transpiler, and the original source is probably a better indicator of the
// true owner.
var source = element . _source ;
// Owner will be preserved, unless ref is overridden
var owner = element . _owner ;
if ( config != null ) {
if ( hasValidRef ( config ) ) {
// Silently steal the ref from the parent.
ref = config . ref ;
owner = ReactCurrentOwner . current ;
}
if ( hasValidKey ( config ) ) {
key = '' + config . key ;
}
// Remaining properties override existing props
2018-07-06 09:43:34 +00:00
var defaultProps = void 0 ;
2018-02-07 16:33:43 +00:00
if ( element . type && element . type . defaultProps ) {
defaultProps = element . type . defaultProps ;
}
for ( propName in config ) {
if ( hasOwnProperty$1 . call ( config , propName ) && ! RESERVED _PROPS . hasOwnProperty ( propName ) ) {
if ( config [ propName ] === undefined && defaultProps !== undefined ) {
// Resolve default props
props [ propName ] = defaultProps [ propName ] ;
} else {
props [ propName ] = config [ propName ] ;
}
}
}
}
// Children can be more than one argument, and those are transferred onto
// the newly allocated props object.
var childrenLength = arguments . length - 2 ;
if ( childrenLength === 1 ) {
props . children = children ;
} else if ( childrenLength > 1 ) {
var childArray = Array ( childrenLength ) ;
for ( var i = 0 ; i < childrenLength ; i ++ ) {
childArray [ i ] = arguments [ i + 2 ] ;
}
props . children = childArray ;
}
return ReactElement ( element . type , key , ref , self , source , owner , props ) ;
}
/ * *
* Verifies the object is a ReactElement .
* See https : //reactjs.org/docs/react-api.html#isvalidelement
* @ param { ? object } object
2019-07-19 09:08:36 +00:00
* @ return { boolean } True if ` object ` is a ReactElement .
2018-02-07 16:33:43 +00:00
* @ final
* /
function isValidElement ( object ) {
return typeof object === 'object' && object !== null && object . $$typeof === REACT _ELEMENT _TYPE ;
}
var SEPARATOR = '.' ;
var SUBSEPARATOR = ':' ;
/ * *
* Escape and wrap key so it is safe to use as a reactid
*
* @ param { string } key to be escaped .
* @ return { string } the escaped key .
* /
function escape ( key ) {
var escapeRegex = /[=:]/g ;
var escaperLookup = {
'=' : '=0' ,
':' : '=2'
} ;
var escapedString = ( '' + key ) . replace ( escapeRegex , function ( match ) {
return escaperLookup [ match ] ;
} ) ;
return '$' + escapedString ;
}
var userProvidedKeyEscapeRegex = /\/+/g ;
function escapeUserProvidedKey ( text ) {
return ( '' + text ) . replace ( userProvidedKeyEscapeRegex , '$&/' ) ;
}
var POOL _SIZE = 10 ;
var traverseContextPool = [ ] ;
function getPooledTraverseContext ( mapResult , keyPrefix , mapFunction , mapContext ) {
if ( traverseContextPool . length ) {
var traverseContext = traverseContextPool . pop ( ) ;
traverseContext . result = mapResult ;
traverseContext . keyPrefix = keyPrefix ;
traverseContext . func = mapFunction ;
traverseContext . context = mapContext ;
traverseContext . count = 0 ;
return traverseContext ;
} else {
return {
result : mapResult ,
keyPrefix : keyPrefix ,
func : mapFunction ,
context : mapContext ,
count : 0
} ;
}
}
function releaseTraverseContext ( traverseContext ) {
traverseContext . result = null ;
traverseContext . keyPrefix = null ;
traverseContext . func = null ;
traverseContext . context = null ;
traverseContext . count = 0 ;
if ( traverseContextPool . length < POOL _SIZE ) {
traverseContextPool . push ( traverseContext ) ;
}
}
/ * *
* @ param { ? * } children Children tree container .
* @ param { ! string } nameSoFar Name of the key path so far .
* @ param { ! function } callback Callback to invoke with each child found .
* @ param { ? * } traverseContext Used to pass information throughout the traversal
* process .
* @ return { ! number } The number of children in this subtree .
* /
function traverseAllChildrenImpl ( children , nameSoFar , callback , traverseContext ) {
var type = typeof children ;
if ( type === 'undefined' || type === 'boolean' ) {
// All of the above are perceived as null.
children = null ;
}
var invokeCallback = false ;
if ( children === null ) {
invokeCallback = true ;
} else {
switch ( type ) {
case 'string' :
case 'number' :
invokeCallback = true ;
break ;
case 'object' :
switch ( children . $$typeof ) {
case REACT _ELEMENT _TYPE :
case REACT _PORTAL _TYPE :
invokeCallback = true ;
}
}
}
if ( invokeCallback ) {
callback ( traverseContext , children ,
// If it's the only child, treat the name as if it was wrapped in an array
// so that it's consistent if the number of children grows.
nameSoFar === '' ? SEPARATOR + getComponentKey ( children , 0 ) : nameSoFar ) ;
return 1 ;
}
2018-07-06 09:43:34 +00:00
var child = void 0 ;
var nextName = void 0 ;
2018-02-07 16:33:43 +00:00
var subtreeCount = 0 ; // Count of children found in the current subtree.
var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR ;
if ( Array . isArray ( children ) ) {
for ( var i = 0 ; i < children . length ; i ++ ) {
child = children [ i ] ;
nextName = nextNamePrefix + getComponentKey ( child , i ) ;
subtreeCount += traverseAllChildrenImpl ( child , nextName , callback , traverseContext ) ;
}
} else {
var iteratorFn = getIteratorFn ( children ) ;
if ( typeof iteratorFn === 'function' ) {
var iterator = iteratorFn . call ( children ) ;
2018-07-06 09:43:34 +00:00
var step = void 0 ;
2018-02-07 16:33:43 +00:00
var ii = 0 ;
while ( ! ( step = iterator . next ( ) ) . done ) {
child = step . value ;
nextName = nextNamePrefix + getComponentKey ( child , ii ++ ) ;
subtreeCount += traverseAllChildrenImpl ( child , nextName , callback , traverseContext ) ;
}
} else if ( type === 'object' ) {
var addendum = '' ;
var childrenString = '' + children ;
reactProdInvariant ( '31' , childrenString === '[object Object]' ? 'object with keys {' + Object . keys ( children ) . join ( ', ' ) + '}' : childrenString , addendum ) ;
}
}
return subtreeCount ;
}
/ * *
* Traverses children that are typically specified as ` props.children ` , but
* might also be specified through attributes :
*
* - ` traverseAllChildren(this.props.children, ...) `
* - ` traverseAllChildren(this.props.leftPanelChildren, ...) `
*
* The ` traverseContext ` is an optional argument that is passed through the
* entire traversal . It can be used to store accumulations or anything else that
* the callback might find relevant .
*
* @ param { ? * } children Children tree object .
* @ param { ! function } callback To invoke upon traversing each child .
* @ param { ? * } traverseContext Context for traversal .
* @ return { ! number } The number of children in this subtree .
* /
function traverseAllChildren ( children , callback , traverseContext ) {
if ( children == null ) {
return 0 ;
}
return traverseAllChildrenImpl ( children , '' , callback , traverseContext ) ;
}
/ * *
* Generate a key string that identifies a component within a set .
*
* @ param { * } component A component that could contain a manual key .
* @ param { number } index Index that is used if a manual key is not provided .
* @ return { string }
* /
function getComponentKey ( component , index ) {
// Do some typechecking here since we call this blindly. We want to ensure
// that we don't block potential future ES APIs.
if ( typeof component === 'object' && component !== null && component . key != null ) {
// Explicit key
return escape ( component . key ) ;
}
// Implicit key determined by the index in the set
return index . toString ( 36 ) ;
2017-09-14 12:32:06 +00:00
}
2016-11-28 13:38:00 +00:00
2017-09-14 12:32:06 +00:00
function forEachSingleChild ( bookKeeping , child , name ) {
var func = bookKeeping . func ,
context = bookKeeping . context ;
2015-08-06 07:27:39 +00:00
2017-09-14 12:32:06 +00:00
func . call ( context , child , bookKeeping . count ++ ) ;
}
2015-08-06 07:27:39 +00:00
/ * *
2017-09-14 12:32:06 +00:00
* Iterates through children that are typically specified as ` props.children ` .
2015-08-06 07:27:39 +00:00
*
2018-07-06 09:43:34 +00:00
* See https : //reactjs.org/docs/react-api.html#reactchildrenforeach
2017-09-14 12:32:06 +00:00
*
* The provided forEachFunc ( child , index ) will be called for each
* leaf child .
2015-08-06 07:27:39 +00:00
*
2017-09-14 12:32:06 +00:00
* @ param { ? * } children Children tree container .
* @ param { function ( * , int ) } forEachFunc
* @ param { * } forEachContext Context for forEachContext .
2015-08-06 07:27:39 +00:00
* /
2017-09-14 12:32:06 +00:00
function forEachChildren ( children , forEachFunc , forEachContext ) {
if ( children == null ) {
return children ;
}
2018-02-07 16:33:43 +00:00
var traverseContext = getPooledTraverseContext ( null , null , forEachFunc , forEachContext ) ;
2017-09-14 12:32:06 +00:00
traverseAllChildren ( children , forEachSingleChild , traverseContext ) ;
2018-02-07 16:33:43 +00:00
releaseTraverseContext ( traverseContext ) ;
2018-02-07 19:06:58 +00:00
}
2017-09-14 12:32:06 +00:00
function mapSingleChildIntoContext ( bookKeeping , child , childKey ) {
var result = bookKeeping . result ,
keyPrefix = bookKeeping . keyPrefix ,
func = bookKeeping . func ,
context = bookKeeping . context ;
2015-08-06 07:27:39 +00:00
2017-09-14 12:32:06 +00:00
var mappedChild = func . call ( context , child , bookKeeping . count ++ ) ;
if ( Array . isArray ( mappedChild ) ) {
2019-07-19 09:08:36 +00:00
mapIntoWithKeyPrefixInternal ( mappedChild , result , childKey , function ( c ) {
return c ;
} ) ;
2017-09-14 12:32:06 +00:00
} else if ( mappedChild != null ) {
2018-02-07 16:33:43 +00:00
if ( isValidElement ( mappedChild ) ) {
mappedChild = cloneAndReplaceKey ( mappedChild ,
2017-09-14 12:32:06 +00:00
// Keep both the (mapped) and old keys if they differ, just as
// traverseAllChildren used to do for objects as children
keyPrefix + ( mappedChild . key && ( ! child || child . key !== mappedChild . key ) ? escapeUserProvidedKey ( mappedChild . key ) + '/' : '' ) + childKey ) ;
2015-09-30 02:40:00 +00:00
}
2017-09-14 12:32:06 +00:00
result . push ( mappedChild ) ;
2015-08-06 07:27:39 +00:00
}
2017-09-14 12:32:06 +00:00
}
2015-08-06 07:27:39 +00:00
2017-09-14 12:32:06 +00:00
function mapIntoWithKeyPrefixInternal ( children , array , prefix , func , context ) {
var escapedPrefix = '' ;
if ( prefix != null ) {
escapedPrefix = escapeUserProvidedKey ( prefix ) + '/' ;
}
2018-02-07 16:33:43 +00:00
var traverseContext = getPooledTraverseContext ( array , escapedPrefix , func , context ) ;
2017-09-14 12:32:06 +00:00
traverseAllChildren ( children , mapSingleChildIntoContext , traverseContext ) ;
2018-02-07 16:33:43 +00:00
releaseTraverseContext ( traverseContext ) ;
2017-09-14 12:32:06 +00:00
}
2015-08-06 07:27:39 +00:00
/ * *
2017-09-14 12:32:06 +00:00
* Maps children that are typically specified as ` props.children ` .
2015-08-06 07:27:39 +00:00
*
2018-07-06 09:43:34 +00:00
* See https : //reactjs.org/docs/react-api.html#reactchildrenmap
2015-08-06 07:27:39 +00:00
*
2017-09-14 12:32:06 +00:00
* The provided mapFunction ( child , key , index ) will be called for each
* leaf child .
*
* @ param { ? * } children Children tree container .
* @ param { function ( * , int ) } func The map function .
* @ param { * } context Context for mapFunction .
* @ return { object } Object containing the ordered map of results .
2015-08-06 07:27:39 +00:00
* /
2017-09-14 12:32:06 +00:00
function mapChildren ( children , func , context ) {
if ( children == null ) {
return children ;
}
var result = [ ] ;
mapIntoWithKeyPrefixInternal ( children , result , null , func , context ) ;
return result ;
}
2016-11-28 13:38:00 +00:00
/ * *
2017-09-14 12:32:06 +00:00
* Count the number of children that are typically specified as
* ` props.children ` .
2016-11-28 13:38:00 +00:00
*
2018-07-06 09:43:34 +00:00
* See https : //reactjs.org/docs/react-api.html#reactchildrencount
2016-11-28 13:38:00 +00:00
*
2017-09-14 12:32:06 +00:00
* @ param { ? * } children Children tree container .
* @ return { number } The number of children .
2016-11-28 13:38:00 +00:00
* /
2018-07-06 09:43:34 +00:00
function countChildren ( children ) {
2019-07-19 09:08:36 +00:00
return traverseAllChildren ( children , function ( ) {
return null ;
} , null ) ;
2017-09-14 12:32:06 +00:00
}
2016-11-28 13:38:00 +00:00
/ * *
2017-09-14 12:32:06 +00:00
* Flatten a children object ( typically specified as ` props.children ` ) and
* return an array with appropriately re - keyed children .
*
2018-07-06 09:43:34 +00:00
* See https : //reactjs.org/docs/react-api.html#reactchildrentoarray
2016-11-28 13:38:00 +00:00
* /
2017-09-14 12:32:06 +00:00
function toArray ( children ) {
var result = [ ] ;
2019-07-19 09:08:36 +00:00
mapIntoWithKeyPrefixInternal ( children , result , null , function ( child ) {
return child ;
} ) ;
2017-09-14 12:32:06 +00:00
return result ;
}
2016-11-28 13:38:00 +00:00
2015-08-06 07:27:39 +00:00
/ * *
2018-02-07 16:33:43 +00:00
* Returns the first child in a collection of children and verifies that there
* is only one child in the collection .
2015-08-06 07:27:39 +00:00
*
2018-07-06 09:43:34 +00:00
* See https : //reactjs.org/docs/react-api.html#reactchildrenonly
2018-02-07 16:33:43 +00:00
*
2018-02-07 16:33:43 +00:00
* The current implementation of this function assumes that a single child gets
* passed without a wrapper , but the purpose of this helper function is to
* abstract away the particular structure of children .
*
* @ param { ? object } children Child collection structure .
* @ return { ReactElement } The first and only ` ReactElement ` contained in the
* structure .
2015-08-06 07:27:39 +00:00
* /
2018-02-07 16:33:43 +00:00
function onlyChild ( children ) {
! isValidElement ( children ) ? reactProdInvariant ( '143' ) : void 0 ;
return children ;
}
2018-02-07 19:06:58 +00:00
2018-07-06 09:43:34 +00:00
function createContext ( defaultValue , calculateChangedBits ) {
if ( calculateChangedBits === undefined ) {
calculateChangedBits = null ;
} else {
}
var context = {
$$typeof : REACT _CONTEXT _TYPE ,
_calculateChangedBits : calculateChangedBits ,
// As a workaround to support multiple concurrent renderers, we categorize
// some renderers as primary and others as secondary. We only expect
// there to be two concurrent renderers at most: React Native (primary) and
// Fabric (secondary); React DOM (primary) and React ART (secondary).
// Secondary renderers store their context values on separate fields.
2019-07-19 09:08:36 +00:00
_currentValue : defaultValue ,
2018-07-06 09:43:34 +00:00
_currentValue2 : defaultValue ,
2019-07-19 09:08:36 +00:00
// Used to track how many concurrent renderers this context currently
// supports within in a single renderer. Such as parallel server rendering.
_threadCount : 0 ,
2018-07-06 09:43:34 +00:00
// These are circular
Provider : null ,
Consumer : null
} ;
context . Provider = {
$$typeof : REACT _PROVIDER _TYPE ,
_context : context
} ;
2019-07-19 09:08:36 +00:00
{
context . Consumer = context ;
}
2018-07-06 09:43:34 +00:00
return context ;
}
2019-07-19 09:08:36 +00:00
function lazy ( ctor ) {
var lazyType = {
$$typeof : REACT _LAZY _TYPE ,
_ctor : ctor ,
// React uses these fields to store the result.
_status : - 1 ,
_result : null
} ;
return lazyType ;
}
2018-07-06 09:43:34 +00:00
function forwardRef ( render ) {
return {
$$typeof : REACT _FORWARD _REF _TYPE ,
render : render
} ;
}
2019-07-19 09:08:36 +00:00
function memo ( type , compare ) {
return {
$$typeof : REACT _MEMO _TYPE ,
type : type ,
compare : compare === undefined ? null : compare
} ;
}
function resolveDispatcher ( ) {
var dispatcher = ReactCurrentDispatcher . current ;
! ( dispatcher !== null ) ? reactProdInvariant ( '321' ) : void 0 ;
return dispatcher ;
}
function useContext ( Context , unstable _observedBits ) {
var dispatcher = resolveDispatcher ( ) ;
return dispatcher . useContext ( Context , unstable _observedBits ) ;
}
function useState ( initialState ) {
var dispatcher = resolveDispatcher ( ) ;
return dispatcher . useState ( initialState ) ;
}
function useReducer ( reducer , initialArg , init ) {
var dispatcher = resolveDispatcher ( ) ;
return dispatcher . useReducer ( reducer , initialArg , init ) ;
}
function useRef ( initialValue ) {
var dispatcher = resolveDispatcher ( ) ;
return dispatcher . useRef ( initialValue ) ;
}
function useEffect ( create , inputs ) {
var dispatcher = resolveDispatcher ( ) ;
return dispatcher . useEffect ( create , inputs ) ;
}
function useLayoutEffect ( create , inputs ) {
var dispatcher = resolveDispatcher ( ) ;
return dispatcher . useLayoutEffect ( create , inputs ) ;
}
function useCallback ( callback , inputs ) {
var dispatcher = resolveDispatcher ( ) ;
return dispatcher . useCallback ( callback , inputs ) ;
}
function useMemo ( create , inputs ) {
var dispatcher = resolveDispatcher ( ) ;
return dispatcher . useMemo ( create , inputs ) ;
}
function useImperativeHandle ( ref , create , inputs ) {
var dispatcher = resolveDispatcher ( ) ;
return dispatcher . useImperativeHandle ( ref , create , inputs ) ;
}
function useDebugValue ( value , formatterFn ) {
}
2018-02-07 16:33:43 +00:00
/ * *
* Copyright ( c ) 2013 - present , Facebook , Inc .
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree .
* /
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
/ * *
* ReactElementValidator provides a wrapper around a element factory
* which validates the props passed to the element . This is intended to be
* used only in DEV and could be replaced by a static type checker for languages
* that support it .
* /
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
var React = {
Children : {
map : mapChildren ,
forEach : forEachChildren ,
count : countChildren ,
toArray : toArray ,
only : onlyChild
} ,
2018-02-07 19:06:58 +00:00
2018-07-06 09:43:34 +00:00
createRef : createRef ,
2018-02-07 16:33:43 +00:00
Component : Component ,
PureComponent : PureComponent ,
2018-07-06 09:43:34 +00:00
createContext : createContext ,
forwardRef : forwardRef ,
2019-07-19 09:08:36 +00:00
lazy : lazy ,
memo : memo ,
useCallback : useCallback ,
useContext : useContext ,
useEffect : useEffect ,
useImperativeHandle : useImperativeHandle ,
useDebugValue : useDebugValue ,
useLayoutEffect : useLayoutEffect ,
useMemo : useMemo ,
useReducer : useReducer ,
useRef : useRef ,
useState : useState ,
2018-02-07 19:06:58 +00:00
2018-02-07 16:33:43 +00:00
Fragment : REACT _FRAGMENT _TYPE ,
2018-07-06 09:43:34 +00:00
StrictMode : REACT _STRICT _MODE _TYPE ,
2019-07-19 09:08:36 +00:00
Suspense : REACT _SUSPENSE _TYPE ,
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
createElement : createElement ,
cloneElement : cloneElement ,
createFactory : createFactory ,
isValidElement : isValidElement ,
2015-08-06 07:27:39 +00:00
2018-02-07 16:33:43 +00:00
version : ReactVersion ,
2015-08-06 07:27:39 +00:00
2019-07-19 09:08:36 +00:00
unstable _ConcurrentMode : REACT _CONCURRENT _MODE _TYPE ,
unstable _Profiler : REACT _PROFILER _TYPE ,
_ _SECRET _INTERNALS _DO _NOT _USE _OR _YOU _WILL _BE _FIRED : ReactSharedInternals
2018-02-07 16:33:43 +00:00
} ;
2015-08-06 07:27:39 +00:00
2019-07-19 09:08:36 +00:00
// Note: some APIs are added with feature flags.
// Make sure that stable builds for open source
// don't modify the React object to avoid deopts.
// Also let's not expose their names in stable builds.
if ( enableStableConcurrentModeAPIs ) {
React . ConcurrentMode = REACT _CONCURRENT _MODE _TYPE ;
React . Profiler = REACT _PROFILER _TYPE ;
React . unstable _ConcurrentMode = undefined ;
React . unstable _Profiler = undefined ;
2018-07-06 09:43:34 +00:00
}
2015-08-06 07:27:39 +00:00
2018-07-06 09:43:34 +00:00
var React$2 = ( {
2018-02-07 16:33:43 +00:00
default : React
} ) ;
2017-09-14 12:32:06 +00:00
2018-02-07 16:33:43 +00:00
var React$3 = ( React$2 && React ) || React$2 ;
2017-09-14 12:32:06 +00:00
2018-02-07 16:33:43 +00:00
// TODO: decide on the top-level export form.
// This is hacky but makes it work with both Rollup and Jest.
2019-07-19 09:08:36 +00:00
var react = React$3 . default || React$3 ;
2017-09-14 12:32:06 +00:00
2018-02-07 16:33:43 +00:00
return react ;
2017-09-14 12:32:06 +00:00
2018-02-07 16:33:43 +00:00
} ) ) ) ;