Skip to content

Instantly share code, notes, and snippets.

@jawkha

jawkha/react.js

Created May 2, 2021 19:59
Show Gist options
  • Save jawkha/94844de5c7d8c9752264bafdbdcebb52 to your computer and use it in GitHub Desktop.
Save jawkha/94844de5c7d8c9752264bafdbdcebb52 to your computer and use it in GitHub Desktop.
Download ZIP
React Source Code v16.7.0
Raw
react.js
/** @license React v16.7.0
* react.development.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
'use strict'
;(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'
// TODO: this is special because it gets imported during build.
var ReactVersion = '16.7.0'
// 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
}
var enableHooks = false
// 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 = true
// Only used in www builds.
// TODO: true? Here it might just be false.
// Only used in www builds.
var enableSchedulerDebugging = true
// 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
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/
/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols
var hasOwnProperty = Object.prototype.hasOwnProperty
var propIsEnumerable = Object.prototype.propertyIsEnumerable
function toObject(val) {
if (val === null || val === undefined) {
throw new TypeError('Object.assign cannot be called with null or undefined')
}
return Object(val)
}
function shouldUseNative() {
try {
if (!Object.assign) {
return false
}
// Detect buggy property enumeration order in older V8 versions.
// 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
}
// 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
}
// 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
}
return true
} catch (err) {
// We don't expect any of the above to throw, but better to be safe.
return false
}
}
var objectAssign = shouldUseNative()
? Object.assign
: function (target, source) {
var from
var to = toObject(target)
var symbols
for (var s = 1; s < arguments.length; s++) {
from = Object(arguments[s])
for (var key in from) {
if (hasOwnProperty.call(from, key)) {
to[key] = from[key]
}
}
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]]
}
}
}
}
return to
}
/**
* Use invariant() to assert state which your program assumes to be true.
*
* Provide sprintf-style format (only %s is supported) and arguments
* to provide information about what broke and what you were
* expecting.
*
* The invariant message will be stripped in production, but the invariant
* will remain to ensure logic does not differ in production.
*/
var validateFormat = function () {}
{
validateFormat = function (format) {
if (format === undefined) {
throw new Error('invariant requires an error message argument')
}
}
}
function invariant(condition, format, a, b, c, d, e, f) {
validateFormat(format)
if (!condition) {
var error = void 0
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
// preserve the format and params in the www builds.
/**
* 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.
*/
var lowPriorityWarning = function () {}
{
var printWarning = function (format) {
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key]
}
var argIndex = 0
var message =
'Warning: ' +
format.replace(/%s/g, function () {
return args[argIndex++]
})
if (typeof console !== 'undefined') {
console.warn(message)
}
try {
// --- Welcome to debugging React ---
// This error was thrown as a convenience so that you can use this stack
// to find the callsite that caused this warning to fire.
throw new Error(message)
} catch (x) {}
}
lowPriorityWarning = function (condition, format) {
if (format === undefined) {
throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument')
}
if (!condition) {
for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
args[_key2 - 2] = arguments[_key2]
}
printWarning.apply(undefined, [format].concat(args))
}
}
}
var lowPriorityWarning$1 = lowPriorityWarning
/**
* 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.
*/
var warningWithoutStack = function () {}
{
warningWithoutStack = function (condition, format) {
for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
args[_key - 2] = arguments[_key]
}
if (format === undefined) {
throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument')
}
if (args.length > 8) {
// Check before the condition to catch violations early.
throw new Error('warningWithoutStack() currently supports at most 8 arguments.')
}
if (condition) {
return
}
if (typeof console !== 'undefined') {
var argsWithFormat = args.map(function (item) {
return '' + item
})
argsWithFormat.unshift('Warning: ' + format)
// We intentionally don't use spread (or .apply) directly because it
// breaks IE9: https://github.com/facebook/react/issues/13610
Function.prototype.apply.call(console.error, console, argsWithFormat)
}
try {
// --- Welcome to debugging React ---
// This error was thrown as a convenience so that you can use this stack
// to find the callsite that caused this warning to fire.
var argIndex = 0
var message =
'Warning: ' +
format.replace(/%s/g, function () {
return args[argIndex++]
})
throw new Error(message)
} catch (x) {}
}
}
var warningWithoutStack$1 = warningWithoutStack
var didWarnStateUpdateForUnmountedComponent = {}
function warnNoop(publicInstance, callerName) {
{
var _constructor = publicInstance.constructor
var componentName = (_constructor && (_constructor.displayName || _constructor.name)) || 'ReactClass'
var warningKey = componentName + '.' + callerName
if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
return
}
warningWithoutStack$1(
false,
"Can't call %s on a component that is not yet mounted. " +
'This is a no-op, but it might indicate a bug in your application. ' +
'Instead, assign to `this.state` directly or define a `state = {};` ' +
'class property with the desired state in the %s component.',
callerName,
componentName
)
didWarnStateUpdateForUnmountedComponent[warningKey] = true
}
}
/**
* This is the abstract API for an update queue.
*/
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
},
/**
* 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) {
warnNoop(publicInstance, 'forceUpdate')
},
/**
* 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) {
warnNoop(publicInstance, 'replaceState')
},
/**
* 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) {
warnNoop(publicInstance, 'setState')
},
}
var emptyObject = {}
{
Object.freeze(emptyObject)
}
/**
* Base class helpers for the updating state of a component.
*/
function Component(props, context, updater) {
this.props = props
this.context = context
// If a component has string refs, we will assign a different object later.
this.refs = emptyObject
// We initialize the default updater but the real one gets injected by the
// renderer.
this.updater = updater || ReactNoopUpdateQueue
}
Component.prototype.isReactComponent = {}
/**
* 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
*/
Component.prototype.setState = function (partialState, callback) {
!(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null)
? invariant(
false,
'setState(...): takes an object of state variables to update or a function which returns an object of state variables.'
)
: void 0
this.updater.enqueueSetState(this, partialState, callback, 'setState')
}
/**
* 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
*/
Component.prototype.forceUpdate = function (callback) {
this.updater.enqueueForceUpdate(this, callback, 'forceUpdate')
}
/**
* 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.
*/
{
var deprecatedAPIs = {
isMounted: [
'isMounted',
'Instead, make sure to clean up subscriptions and pending requests in ' +
'componentWillUnmount to prevent memory leaks.',
],
replaceState: [
'replaceState',
'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).',
],
}
var defineDeprecationWarning = function (methodName, info) {
Object.defineProperty(Component.prototype, methodName, {
get: function () {
lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1])
return undefined
},
})
}
for (var fnName in deprecatedAPIs) {
if (deprecatedAPIs.hasOwnProperty(fnName)) {
defineDeprecationWarning(fnName, deprecatedAPIs[fnName])
}
}
}
function ComponentDummy() {}
ComponentDummy.prototype = Component.prototype
/**
* Convenience component with default shallow equality check for sCU.
*/
function PureComponent(props, context, updater) {
this.props = props
this.context = context
// If a component has string refs, we will assign a different object later.
this.refs = emptyObject
this.updater = updater || ReactNoopUpdateQueue
}
var pureComponentPrototype = (PureComponent.prototype = new ComponentDummy())
pureComponentPrototype.constructor = PureComponent
// Avoid an extra prototype jump for these methods.
objectAssign(pureComponentPrototype, Component.prototype)
pureComponentPrototype.isPureReactComponent = true
// an immutable object with a single mutable value
function createRef() {
var refObject = {
current: null,
}
{
Object.seal(refObject)
}
return refObject
}
/* 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 i nfeature 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_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
}
}
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 owner.
*
* The current owner is the component who should own any components that are
* currently being constructed.
*/
var ReactCurrentOwner = {
/**
* @internal
* @type {ReactComponent}
*/
current: null,
currentDispatcher: null,
}
var BEFORE_SLASH_RE = /^(.*)[\\\/]/
var describeComponentFrame = function (name, source, ownerName) {
var sourceInfo = ''
if (source) {
var path = source.fileName
var fileName = path.replace(BEFORE_SLASH_RE, '')
{
// In DEV, include code for a common special case:
// prefer "folder/index.js" instead of just "index.js".
if (/^index\./.test(fileName)) {
var match = path.match(BEFORE_SLASH_RE)
if (match) {
var pathBeforeSlash = match[1]
if (pathBeforeSlash) {
var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '')
fileName = folderName + '/' + fileName
}
}
}
}
sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')'
} else if (ownerName) {
sourceInfo = ' (created by ' + ownerName + ')'
}
return '\n in ' + (name || 'Unknown') + sourceInfo
}
var Resolved = 1
function refineResolvedLazyComponent(lazyComponent) {
return lazyComponent._status === Resolved ? lazyComponent._result : null
}
function getWrappedName(outerType, innerType, wrapperName) {
var functionName = innerType.displayName || innerType.name || ''
return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName)
}
function getComponentName(type) {
if (type == null) {
// Host root, text node or just invalid type.
return null
}
{
if (typeof type.tag === 'number') {
warningWithoutStack$1(
false,
'Received an unexpected object in getComponentName(). ' +
'This is likely a bug in React. Please file an issue.'
)
}
}
if (typeof type === 'function') {
return type.displayName || type.name || null
}
if (typeof type === 'string') {
return type
}
switch (type) {
case REACT_CONCURRENT_MODE_TYPE:
return 'ConcurrentMode'
case REACT_FRAGMENT_TYPE:
return 'Fragment'
case REACT_PORTAL_TYPE:
return 'Portal'
case REACT_PROFILER_TYPE:
return 'Profiler'
case REACT_STRICT_MODE_TYPE:
return 'StrictMode'
case REACT_SUSPENSE_TYPE:
return 'Suspense'
}
if (typeof type === 'object') {
switch (type.$$typeof) {
case REACT_CONTEXT_TYPE:
return 'Context.Consumer'
case REACT_PROVIDER_TYPE:
return 'Context.Provider'
case REACT_FORWARD_REF_TYPE:
return getWrappedName(type, type.render, 'ForwardRef')
case REACT_MEMO_TYPE:
return getComponentName(type.type)
case REACT_LAZY_TYPE: {
var thenable = type
var resolvedThenable = refineResolvedLazyComponent(thenable)
if (resolvedThenable) {
return getComponentName(resolvedThenable)
}
}
}
}
return null
}
var ReactDebugCurrentFrame = {}
var currentlyValidatingElement = null
function setCurrentlyValidatingElement(element) {
{
currentlyValidatingElement = element
}
}
{
// Stack implementation injected by the current renderer.
ReactDebugCurrentFrame.getCurrentStack = null
ReactDebugCurrentFrame.getStackAddendum = function () {
var stack = ''
// Add an extra top frame while an element is being validated
if (currentlyValidatingElement) {
var name = getComponentName(currentlyValidatingElement.type)
var owner = currentlyValidatingElement._owner
stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type))
}
// Delegate to the injected renderer-specific implementation
var impl = ReactDebugCurrentFrame.getCurrentStack
if (impl) {
stack += impl() || ''
}
return stack
}
}
var ReactSharedInternals = {
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_wrapCallback: unstable_wrapCallback,
unstable_getFirstCallbackNode: unstable_getFirstCallbackNode,
unstable_pauseExecution: unstable_pauseExecution,
unstable_continueExecution: unstable_continueExecution,
unstable_getCurrentPriorityLevel: unstable_getCurrentPriorityLevel,
},
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,
},
})
}
{
objectAssign(ReactSharedInternals, {
// These should not be included in production.
ReactDebugCurrentFrame: ReactDebugCurrentFrame,
// Shim for React DOM 16.0.0 which still destructured (but not used) this.
// TODO: remove in React 17.0.
ReactComponentTreeHook: {},
})
}
/**
* 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.
*/
var warning = warningWithoutStack$1
{
warning = function (condition, format) {
if (condition) {
return
}
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame
var stack = ReactDebugCurrentFrame.getStackAddendum()
// eslint-disable-next-line react-internal/warning-and-invariant-args
for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
args[_key - 2] = arguments[_key]
}
warningWithoutStack$1.apply(undefined, [false, format + '%s'].concat(args, [stack]))
}
}
var warning$1 = warning
var hasOwnProperty$1 = Object.prototype.hasOwnProperty
var RESERVED_PROPS = {
key: true,
ref: true,
__self: true,
__source: true,
}
var specialPropKeyWarningShown = void 0
var specialPropRefWarningShown = void 0
function hasValidRef(config) {
{
if (hasOwnProperty$1.call(config, 'ref')) {
var getter = Object.getOwnPropertyDescriptor(config, 'ref').get
if (getter && getter.isReactWarning) {
return false
}
}
}
return config.ref !== undefined
}
function hasValidKey(config) {
{
if (hasOwnProperty$1.call(config, 'key')) {
var getter = Object.getOwnPropertyDescriptor(config, 'key').get
if (getter && getter.isReactWarning) {
return false
}
}
}
return config.key !== undefined
}
function defineKeyPropWarningGetter(props, displayName) {
var warnAboutAccessingKey = function () {
if (!specialPropKeyWarningShown) {
specialPropKeyWarningShown = true
warningWithoutStack$1(
false,
'%s: `key` is not a prop. Trying to access it will result ' +
'in `undefined` being returned. If you need to access the same ' +
'value within the child component, you should pass it as a different ' +
'prop. (https://fb.me/react-special-props)',
displayName
)
}
}
warnAboutAccessingKey.isReactWarning = true
Object.defineProperty(props, 'key', {
get: warnAboutAccessingKey,
configurable: true,
})
}
function defineRefPropWarningGetter(props, displayName) {
var warnAboutAccessingRef = function () {
if (!specialPropRefWarningShown) {
specialPropRefWarningShown = true
warningWithoutStack$1(
false,
'%s: `ref` is not a prop. Trying to access it will result ' +
'in `undefined` being returned. If you need to access the same ' +
'value within the child component, you should pass it as a different ' +
'prop. (https://fb.me/react-special-props)',
displayName
)
}
}
warnAboutAccessingRef.isReactWarning = true
Object.defineProperty(props, 'ref', {
get: warnAboutAccessingRef,
configurable: true,
})
}
/**
* 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
*/
var ReactElement = function (type, key, ref, self, source, owner, props) {
var element = {
// This tag allows us to uniquely identify this as a React Element
$$typeof: REACT_ELEMENT_TYPE,
// Built-in properties that belong on the element
type: type,
key: key,
ref: ref,
props: props,
// Record the component responsible for creating this element.
_owner: owner,
}
{
// The validation flag is currently mutative. We put it on
// an external backing store so that we can freeze the whole object.
// This can be replaced with a WeakMap once they are implemented in
// commonly used development environments.
element._store = {}
// To make comparing ReactElements easier for testing purposes, we make
// the validation flag non-enumerable (where possible, which should
// include every environment we run tests in), so the test framework
// ignores it.
Object.defineProperty(element._store, 'validated', {
configurable: false,
enumerable: false,
writable: true,
value: false,
})
// self and source are DEV only properties.
Object.defineProperty(element, '_self', {
configurable: false,
enumerable: false,
writable: false,
value: self,
})
// Two elements created in two different places should be considered
// equal for testing purposes and therefore we hide it from enumeration.
Object.defineProperty(element, '_source', {
configurable: false,
enumerable: false,
writable: false,
value: source,
})
if (Object.freeze) {
Object.freeze(element.props)
Object.freeze(element)
}
}
return element
}
/**
* Create and return a new ReactElement of the given type.
* See https://reactjs.org/docs/react-api.html#createelement
*/
function createElement(type, config, children) {
var propName = void 0
// Reserved names are extracted
var props = {}
var key = null
var ref = null
var self = null
var source = null
if (config != null) {
if (hasValidRef(config)) {
ref = config.ref
}
if (hasValidKey(config)) {
key = '' + config.key
}
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]
}
}
}
// 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]
}
{
if (Object.freeze) {
Object.freeze(childArray)
}
}
props.children = childArray
}
// Resolve default props
if (type && type.defaultProps) {
var defaultProps = type.defaultProps
for (propName in defaultProps) {
if (props[propName] === undefined) {
props[propName] = defaultProps[propName]
}
}
}
{
if (key || ref) {
var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type
if (key) {
defineKeyPropWarningGetter(props, displayName)
}
if (ref) {
defineRefPropWarningGetter(props, displayName)
}
}
}
return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props)
}
/**
* Return a function that produces ReactElements of a given type.
* See https://reactjs.org/docs/react-api.html#createfactory
*/
function cloneAndReplaceKey(oldElement, newKey) {
var newElement = ReactElement(
oldElement.type,
newKey,
oldElement.ref,
oldElement._self,
oldElement._source,
oldElement._owner,
oldElement.props
)
return newElement
}
/**
* Clone and return a new ReactElement using element as the starting point.
* See https://reactjs.org/docs/react-api.html#cloneelement
*/
function cloneElement(element, config, children) {
!!(element === null || element === undefined)
? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element)
: void 0
var propName = void 0
// 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
var defaultProps = void 0
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
* @return {boolean} True if `object` is a ReactElement.
* @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
}
/**
* TODO: Test that a single child and an array with one item have the same key
* pattern.
*/
var didWarnAboutMaps = false
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
}
var child = void 0
var nextName = void 0
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') {
{
// Warn about using Maps as children
if (iteratorFn === children.entries) {
!didWarnAboutMaps
? warning$1(
false,
'Using Maps as children is unsupported and will likely yield ' +
'unexpected results. Convert it to a sequence/iterable of keyed ' +
'ReactElements instead.'
)
: void 0
didWarnAboutMaps = true
}
}
var iterator = iteratorFn.call(children)
var step = void 0
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 = ''
{
addendum =
' If you meant to render a collection of children, use an array ' +
'instead.' +
ReactDebugCurrentFrame.getStackAddendum()
}
var childrenString = '' + children
invariant(
false,
'Objects are not valid as a React child (found: %s).%s',
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)
}
function forEachSingleChild(bookKeeping, child, name) {
var func = bookKeeping.func,
context = bookKeeping.context
func.call(context, child, bookKeeping.count++)
}
/**
* Iterates through children that are typically specified as `props.children`.
*
* See https://reactjs.org/docs/react-api.html#reactchildrenforeach
*
* The provided forEachFunc(child, index) will be called for each
* leaf child.
*
* @param {?*} children Children tree container.
* @param {function(*, int)} forEachFunc
* @param {*} forEachContext Context for forEachContext.
*/
function forEachChildren(children, forEachFunc, forEachContext) {
if (children == null) {
return children
}
var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext)
traverseAllChildren(children, forEachSingleChild, traverseContext)
releaseTraverseContext(traverseContext)
}
function mapSingleChildIntoContext(bookKeeping, child, childKey) {
var result = bookKeeping.result,
keyPrefix = bookKeeping.keyPrefix,
func = bookKeeping.func,
context = bookKeeping.context
var mappedChild = func.call(context, child, bookKeeping.count++)
if (Array.isArray(mappedChild)) {
mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, function (c) {
return c
})
} else if (mappedChild != null) {
if (isValidElement(mappedChild)) {
mappedChild = cloneAndReplaceKey(
mappedChild,
// 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
)
}
result.push(mappedChild)
}
}
function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
var escapedPrefix = ''
if (prefix != null) {
escapedPrefix = escapeUserProvidedKey(prefix) + '/'
}
var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context)
traverseAllChildren(children, mapSingleChildIntoContext, traverseContext)
releaseTraverseContext(traverseContext)
}
/**
* Maps children that are typically specified as `props.children`.
*
* See https://reactjs.org/docs/react-api.html#reactchildrenmap
*
* 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.
*/
function mapChildren(children, func, context) {
if (children == null) {
return children
}
var result = []
mapIntoWithKeyPrefixInternal(children, result, null, func, context)
return result
}
/**
* Count the number of children that are typically specified as
* `props.children`.
*
* See https://reactjs.org/docs/react-api.html#reactchildrencount
*
* @param {?*} children Children tree container.
* @return {number} The number of children.
*/
function countChildren(children) {
return traverseAllChildren(
children,
function () {
return null
},
null
)
}
/**
* Flatten a children object (typically specified as `props.children`) and
* return an array with appropriately re-keyed children.
*
* See https://reactjs.org/docs/react-api.html#reactchildrentoarray
*/
function toArray(children) {
var result = []
mapIntoWithKeyPrefixInternal(children, result, null, function (child) {
return child
})
return result
}
/**
* Returns the first child in a collection of children and verifies that there
* is only one child in the collection.
*
* See https://reactjs.org/docs/react-api.html#reactchildrenonly
*
* 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.
*/
function onlyChild(children) {
!isValidElement(children)
? invariant(false, 'React.Children.only expected to receive a single React element child.')
: void 0
return children
}
function createContext(defaultValue, calculateChangedBits) {
if (calculateChangedBits === undefined) {
calculateChangedBits = null
} else {
{
!(calculateChangedBits === null || typeof calculateChangedBits === 'function')
? warningWithoutStack$1(
false,
'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s',
calculateChangedBits
)
: void 0
}
}
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.
_currentValue: defaultValue,
_currentValue2: defaultValue,
// Used to track how many concurrent renderers this context currently
// supports within in a single renderer. Such as parallel server rendering.
_threadCount: 0,
// These are circular
Provider: null,
Consumer: null,
}
context.Provider = {
$$typeof: REACT_PROVIDER_TYPE,
_context: context,
}
var hasWarnedAboutUsingNestedContextConsumers = false
var hasWarnedAboutUsingConsumerProvider = false
{
// A separate object, but proxies back to the original context object for
// backwards compatibility. It has a different $$typeof, so we can properly
// warn for the incorrect usage of Context as a Consumer.
var Consumer = {
$$typeof: REACT_CONTEXT_TYPE,
_context: context,
_calculateChangedBits: context._calculateChangedBits,
}
// $FlowFixMe: Flow complains about not setting a value, which is intentional here
Object.defineProperties(Consumer, {
Provider: {
get: function () {
if (!hasWarnedAboutUsingConsumerProvider) {
hasWarnedAboutUsingConsumerProvider = true
warning$1(
false,
'Rendering <Context.Consumer.Provider> is not supported and will be removed in ' +
'a future major release. Did you mean to render <Context.Provider> instead?'
)
}
return context.Provider
},
set: function (_Provider) {
context.Provider = _Provider
},
},
_currentValue: {
get: function () {
return context._currentValue
},
set: function (_currentValue) {
context._currentValue = _currentValue
},
},
_currentValue2: {
get: function () {
return context._currentValue2
},
set: function (_currentValue2) {
context._currentValue2 = _currentValue2
},
},
_threadCount: {
get: function () {
return context._threadCount
},
set: function (_threadCount) {
context._threadCount = _threadCount
},
},
Consumer: {
get: function () {
if (!hasWarnedAboutUsingNestedContextConsumers) {
hasWarnedAboutUsingNestedContextConsumers = true
warning$1(
false,
'Rendering <Context.Consumer.Consumer> is not supported and will be removed in ' +
'a future major release. Did you mean to render <Context.Consumer> instead?'
)
}
return context.Consumer
},
},
})
// $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
context.Consumer = Consumer
}
{
context._currentRenderer = null
context._currentRenderer2 = null
}
return context
}
function lazy(ctor) {
var lazyType = {
$$typeof: REACT_LAZY_TYPE,
_ctor: ctor,
// React uses these fields to store the result.
_status: -1,
_result: null,
}
{
// In production, this would just set it on the object.
var defaultProps = void 0
var propTypes = void 0
Object.defineProperties(lazyType, {
defaultProps: {
configurable: true,
get: function () {
return defaultProps
},
set: function (newDefaultProps) {
warning$1(
false,
'React.lazy(...): It is not supported to assign `defaultProps` to ' +
'a lazy component import. Either specify them where the component ' +
'is defined, or create a wrapping component around it.'
)
defaultProps = newDefaultProps
// Match production behavior more closely:
Object.defineProperty(lazyType, 'defaultProps', {
enumerable: true,
})
},
},
propTypes: {
configurable: true,
get: function () {
return propTypes
},
set: function (newPropTypes) {
warning$1(
false,
'React.lazy(...): It is not supported to assign `propTypes` to ' +
'a lazy component import. Either specify them where the component ' +
'is defined, or create a wrapping component around it.'
)
propTypes = newPropTypes
// Match production behavior more closely:
Object.defineProperty(lazyType, 'propTypes', {
enumerable: true,
})
},
},
})
}
return lazyType
}
function forwardRef(render) {
{
if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
warningWithoutStack$1(
false,
'forwardRef requires a render function but received a `memo` ' +
'component. Instead of forwardRef(memo(...)), use ' +
'memo(forwardRef(...)).'
)
} else if (typeof render !== 'function') {
warningWithoutStack$1(
false,
'forwardRef requires a render function but was given %s.',
render === null ? 'null' : typeof render
)
} else {
!(
// Do not warn for 0 arguments because it could be due to usage of the 'arguments' object
(render.length === 0 || render.length === 2)
)
? warningWithoutStack$1(
false,
'forwardRef render functions accept exactly two parameters: props and ref. %s',
render.length === 1
? 'Did you forget to use the ref parameter?'
: 'Any additional parameter will be undefined.'
)
: void 0
}
if (render != null) {
!(render.defaultProps == null && render.propTypes == null)
? warningWithoutStack$1(
false,
'forwardRef render functions do not support propTypes or defaultProps. ' +
'Did you accidentally pass a React component?'
)
: void 0
}
}
return {
$$typeof: REACT_FORWARD_REF_TYPE,
render: render,
}
}
function isValidElementType(type) {
return (
typeof type === 'string' ||
typeof type === 'function' ||
// Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
type === REACT_FRAGMENT_TYPE ||
type === REACT_CONCURRENT_MODE_TYPE ||
type === REACT_PROFILER_TYPE ||
type === REACT_STRICT_MODE_TYPE ||
type === REACT_SUSPENSE_TYPE ||
(typeof type === 'object' &&
type !== null &&
(type.$$typeof === REACT_LAZY_TYPE ||
type.$$typeof === REACT_MEMO_TYPE ||
type.$$typeof === REACT_PROVIDER_TYPE ||
type.$$typeof === REACT_CONTEXT_TYPE ||
type.$$typeof === REACT_FORWARD_REF_TYPE))
)
}
function memo(type, compare) {
{
if (!isValidElementType(type)) {
warningWithoutStack$1(
false,
'memo: The first argument must be a component. Instead ' + 'received: %s',
type === null ? 'null' : typeof type
)
}
}
return {
$$typeof: REACT_MEMO_TYPE,
type: type,
compare: compare === undefined ? null : compare,
}
}
function resolveDispatcher() {
var dispatcher = ReactCurrentOwner.currentDispatcher
!(dispatcher !== null)
? invariant(false, 'Hooks can only be called inside the body of a function component.')
: void 0
return dispatcher
}
function useContext(Context, observedBits) {
var dispatcher = resolveDispatcher()
{
// TODO: add a more generic warning for invalid values.
if (Context._context !== undefined) {
var realContext = Context._context
// Don't deduplicate because this legitimately causes bugs
// and nobody should be using this in existing code.
if (realContext.Consumer === Context) {
warning$1(
false,
'Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' +
'removed in a future major release. Did you mean to call useContext(Context) instead?'
)
} else if (realContext.Provider === Context) {
warning$1(
false,
'Calling useContext(Context.Provider) is not supported. ' +
'Did you mean to call useContext(Context) instead?'
)
}
}
}
return dispatcher.useContext(Context, observedBits)
}
function useState(initialState) {
var dispatcher = resolveDispatcher()
return dispatcher.useState(initialState)
}
function useReducer(reducer, initialState, initialAction) {
var dispatcher = resolveDispatcher()
return dispatcher.useReducer(reducer, initialState, initialAction)
}
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 useImperativeMethods(ref, create, inputs) {
var dispatcher = resolveDispatcher()
return dispatcher.useImperativeMethods(ref, create, inputs)
}
/**
* 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.
*/
var ReactPropTypesSecret$1 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'
var ReactPropTypesSecret_1 = ReactPropTypesSecret$1
/**
* 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.
*/
var printWarning$1 = function () {}
{
var ReactPropTypesSecret = ReactPropTypesSecret_1
var loggedTypeFailures = {}
printWarning$1 = function (text) {
var message = 'Warning: ' + text
if (typeof console !== 'undefined') {
console.error(message)
}
try {
// --- Welcome to debugging React ---
// This error was thrown as a convenience so that you can use this stack
// to find the callsite that caused this warning to fire.
throw new Error(message)
} catch (x) {}
}
}
/**
* Assert that the values match with the type specs.
* Error messages are memorized and will only be shown once.
*
* @param {object} typeSpecs Map of name to a ReactPropType
* @param {object} values Runtime values that need to be type-checked
* @param {string} location e.g. "prop", "context", "child context"
* @param {string} componentName Name of the component for error messages.
* @param {?Function} getStack Returns the component stack.
* @private
*/
function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
{
for (var typeSpecName in typeSpecs) {
if (typeSpecs.hasOwnProperty(typeSpecName)) {
var error
// Prop type validation may throw. In case they do, we don't want to
// fail the render phase where it didn't fail before. So we log it.
// After these have been cleaned up, we'll let them throw.
try {
// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
if (typeof typeSpecs[typeSpecName] !== 'function') {
var err = Error(
(componentName || 'React class') +
': ' +
location +
' type `' +
typeSpecName +
'` is invalid; ' +
'it must be a function, usually from the `prop-types` package, but received `' +
typeof typeSpecs[typeSpecName] +
'`.'
)
err.name = 'Invariant Violation'
throw err
}
error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret)
} catch (ex) {
error = ex
}
if (error && !(error instanceof Error)) {
printWarning$1(
(componentName || 'React class') +
': type specification of ' +
location +
' `' +
typeSpecName +
'` is invalid; the type checker ' +
'function must return `null` or an `Error` but returned a ' +
typeof error +
'. ' +
'You may have forgotten to pass an argument to the type checker ' +
'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
'shape all require an argument).'
)
}
if (error instanceof Error && !(error.message in loggedTypeFailures)) {
// Only monitor this failure once because there tends to be a lot of the
// same error.
loggedTypeFailures[error.message] = true
var stack = getStack ? getStack() : ''
printWarning$1('Failed ' + location + ' type: ' + error.message + (stack != null ? stack : ''))
}
}
}
}
}
var checkPropTypes_1 = checkPropTypes
/**
* 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.
*/
var propTypesMisspellWarningShown = void 0
{
propTypesMisspellWarningShown = false
}
function getDeclarationErrorAddendum() {
if (ReactCurrentOwner.current) {
var name = getComponentName(ReactCurrentOwner.current.type)
if (name) {
return '\n\nCheck the render method of `' + name + '`.'
}
}
return ''
}
function getSourceInfoErrorAddendum(elementProps) {
if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {
var source = elementProps.__source
var fileName = source.fileName.replace(/^.*[\\\/]/, '')
var lineNumber = source.lineNumber
return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.'
}
return ''
}
/**
* Warn if there's no key explicitly set on dynamic arrays of children or
* object keys are not valid. This allows us to keep track of children between
* updates.
*/
var ownerHasKeyUseWarning = {}
function getCurrentComponentErrorInfo(parentType) {
var info = getDeclarationErrorAddendum()
if (!info) {
var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name
if (parentName) {
info = '\n\nCheck the top-level render call using <' + parentName + '>.'
}
}
return info
}
/**
* Warn if the element doesn't have an explicit key assigned to it.
* This element is in an array. The array could grow and shrink or be
* reordered. All children that haven't already been validated are required to
* have a "key" property assigned to it. Error statuses are cached so a warning
* will only be shown once.
*
* @internal
* @param {ReactElement} element Element that requires a key.
* @param {*} parentType element's parent's type.
*/
function validateExplicitKey(element, parentType) {
if (!element._store || element._store.validated || element.key != null) {
return
}
element._store.validated = true
var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType)
if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
return
}
ownerHasKeyUseWarning[currentComponentErrorInfo] = true
// Usually the current owner is the offender, but if it accepts children as a
// property, it may be the creator of the child that's responsible for
// assigning it a key.
var childOwner = ''
if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
// Give the component that originally created this child.
childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '.'
}
setCurrentlyValidatingElement(element)
{
warning$1(
false,
'Each child in an array or iterator should have a unique "key" prop.' +
'%s%s See https://fb.me/react-warning-keys for more information.',
currentComponentErrorInfo,
childOwner
)
}
setCurrentlyValidatingElement(null)
}
/**
* Ensure that every element either is passed in a static location, in an
* array with an explicit keys property defined, or in an object literal
* with valid key property.
*
* @internal
* @param {ReactNode} node Statically passed child of any type.
* @param {*} parentType node's parent's type.
*/
function validateChildKeys(node, parentType) {
if (typeof node !== 'object') {
return
}
if (Array.isArray(node)) {
for (var i = 0; i < node.length; i++) {
var child = node[i]
if (isValidElement(child)) {
validateExplicitKey(child, parentType)
}
}
} else if (isValidElement(node)) {
// This element was passed in a valid location.
if (node._store) {
node._store.validated = true
}
} else if (node) {
var iteratorFn = getIteratorFn(node)
if (typeof iteratorFn === 'function') {
// Entry iterators used to provide implicit keys,
// but now we print a separate warning for them later.
if (iteratorFn !== node.entries) {
var iterator = iteratorFn.call(node)
var step = void 0
while (!(step = iterator.next()).done) {
if (isValidElement(step.value)) {
validateExplicitKey(step.value, parentType)
}
}
}
}
}
}
/**
* Given an element, validate that its props follow the propTypes definition,
* provided by the type.
*
* @param {ReactElement} element
*/
function validatePropTypes(element) {
var type = element.type
if (type === null || type === undefined || typeof type === 'string') {
return
}
var name = getComponentName(type)
var propTypes = void 0
if (typeof type === 'function') {
propTypes = type.propTypes
} else if (
typeof type === 'object' &&
(type.$$typeof === REACT_FORWARD_REF_TYPE ||
// Note: Memo only checks outer props here.
// Inner props are checked in the reconciler.
type.$$typeof === REACT_MEMO_TYPE)
) {
propTypes = type.propTypes
} else {
return
}
if (propTypes) {
setCurrentlyValidatingElement(element)
checkPropTypes_1(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum)
setCurrentlyValidatingElement(null)
} else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
propTypesMisspellWarningShown = true
warningWithoutStack$1(
false,
'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?',
name || 'Unknown'
)
}
if (typeof type.getDefaultProps === 'function') {
!type.getDefaultProps.isReactClassApproved
? warningWithoutStack$1(
false,
'getDefaultProps is only used on classic React.createClass ' +
'definitions. Use a static property named `defaultProps` instead.'
)
: void 0
}
}
/**
* Given a fragment, validate that it can only be provided with fragment props
* @param {ReactElement} fragment
*/
function validateFragmentProps(fragment) {
setCurrentlyValidatingElement(fragment)
var keys = Object.keys(fragment.props)
for (var i = 0; i < keys.length; i++) {
var key = keys[i]
if (key !== 'children' && key !== 'key') {
warning$1(
false,
'Invalid prop `%s` supplied to `React.Fragment`. ' +
'React.Fragment can only have `key` and `children` props.',
key
)
break
}
}
if (fragment.ref !== null) {
warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.')
}
setCurrentlyValidatingElement(null)
}
function createElementWithValidation(type, props, children) {
var validType = isValidElementType(type)
// We warn in this case but don't throw. We expect the element creation to
// succeed and there will likely be errors in render.
if (!validType) {
var info = ''
if (type === undefined || (typeof type === 'object' && type !== null && Object.keys(type).length === 0)) {
info +=
' You likely forgot to export your component from the file ' +
"it's defined in, or you might have mixed up default and named imports."
}
var sourceInfo = getSourceInfoErrorAddendum(props)
if (sourceInfo) {
info += sourceInfo
} else {
info += getDeclarationErrorAddendum()
}
var typeString = void 0
if (type === null) {
typeString = 'null'
} else if (Array.isArray(type)) {
typeString = 'array'
} else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
typeString = '<' + (getComponentName(type.type) || 'Unknown') + ' />'
info = ' Did you accidentally export a JSX literal instead of a component?'
} else {
typeString = typeof type
}
warning$1(
false,
'React.createElement: type is invalid -- expected a string (for ' +
'built-in components) or a class/function (for composite ' +
'components) but got: %s.%s',
typeString,
info
)
}
var element = createElement.apply(this, arguments)
// The result can be nullish if a mock or a custom function is used.
// TODO: Drop this when these are no longer allowed as the type argument.
if (element == null) {
return element
}
// Skip key warning if the type isn't valid since our key validation logic
// doesn't expect a non-string/function type and can throw confusing errors.
// We don't want exception behavior to differ between dev and prod.
// (Rendering will throw with a helpful message and as soon as the type is
// fixed, the key warnings will appear.)
if (validType) {
for (var i = 2; i < arguments.length; i++) {
validateChildKeys(arguments[i], type)
}
}
if (type === REACT_FRAGMENT_TYPE) {
validateFragmentProps(element)
} else {
validatePropTypes(element)
}
return element
}
function createFactoryWithValidation(type) {
var validatedFactory = createElementWithValidation.bind(null, type)
validatedFactory.type = type
// Legacy hook: remove it
{
Object.defineProperty(validatedFactory, 'type', {
enumerable: false,
get: function () {
lowPriorityWarning$1(
false,
'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.'
)
Object.defineProperty(this, 'type', {
value: type,
})
return type
},
})
}
return validatedFactory
}
function cloneElementWithValidation(element, props, children) {
var newElement = cloneElement.apply(this, arguments)
for (var i = 2; i < arguments.length; i++) {
validateChildKeys(arguments[i], newElement.type)
}
validatePropTypes(newElement)
return newElement
}
var React = {
Children: {
map: mapChildren,
forEach: forEachChildren,
count: countChildren,
toArray: toArray,
only: onlyChild,
},
createRef: createRef,
Component: Component,
PureComponent: PureComponent,
createContext: createContext,
forwardRef: forwardRef,
lazy: lazy,
memo: memo,
Fragment: REACT_FRAGMENT_TYPE,
StrictMode: REACT_STRICT_MODE_TYPE,
Suspense: REACT_SUSPENSE_TYPE,
createElement: createElementWithValidation,
cloneElement: cloneElementWithValidation,
createFactory: createFactoryWithValidation,
isValidElement: isValidElement,
version: ReactVersion,
unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,
unstable_Profiler: REACT_PROFILER_TYPE,
__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals,
}
// 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
}
if (enableHooks) {
React.useCallback = useCallback
React.useContext = useContext
React.useEffect = useEffect
React.useImperativeMethods = useImperativeMethods
React.useLayoutEffect = useLayoutEffect
React.useMemo = useMemo
React.useReducer = useReducer
React.useRef = useRef
React.useState = useState
}
var React$2 = Object.freeze({
default: React,
})
var React$3 = (React$2 && React) || React$2
// TODO: decide on the top-level export form.
// This is hacky but makes it work with both Rollup and Jest.
var react = React$3.default || React$3
return react
})
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment