You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3029 lines
96 KiB
3029 lines
96 KiB
/** @license React v16.6.1 |
|
* 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.6.3'; |
|
|
|
// 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. |
|
|
|
|
|
// 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; |
|
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) { |
|
isExecutingCallback = true; |
|
var previousDidTimeout = currentDidTimeout; |
|
currentDidTimeout = didTimeout; |
|
try { |
|
if (didTimeout) { |
|
// Flush all the expired callbacks without yielding. |
|
while (firstCallbackNode !== null) { |
|
// 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); |
|
continue; |
|
} |
|
break; |
|
} |
|
} else { |
|
// Keep flushing callbacks until we run out of time in the frame. |
|
if (firstCallbackNode !== null) { |
|
do { |
|
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_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; |
|
|
|
if (typeof window !== 'undefined' && window._schedMock) { |
|
// Dynamic injection, only for testing purposes. |
|
var impl = window._schedMock; |
|
requestHostCallback = impl[0]; |
|
cancelHostCallback = impl[1]; |
|
shouldYieldToHost = impl[2]; |
|
} else if ( |
|
// If Scheduler runs in a non-DOM environment, it falls back to a naive |
|
// implementation using setTimeout. |
|
typeof window === 'undefined' || |
|
// "addEventListener" might not be available on the window object |
|
// if this is a mocked "window" object. So we need to validate that too. |
|
typeof window.addEventListener !== 'function') { |
|
var _callback = null; |
|
var _currentTime = -1; |
|
var _flushCallback = function (didTimeout, ms) { |
|
if (_callback !== null) { |
|
var cb = _callback; |
|
_callback = null; |
|
try { |
|
_currentTime = ms; |
|
cb(didTimeout); |
|
} finally { |
|
_currentTime = -1; |
|
} |
|
} |
|
}; |
|
requestHostCallback = function (cb, ms) { |
|
if (_currentTime !== -1) { |
|
// Protect against re-entrancy. |
|
setTimeout(requestHostCallback, 0, cb, ms); |
|
} else { |
|
_callback = cb; |
|
setTimeout(_flushCallback, ms, true, ms); |
|
setTimeout(_flushCallback, maxSigned31BitInt, false, maxSigned31BitInt); |
|
} |
|
}; |
|
cancelHostCallback = function () { |
|
_callback = null; |
|
}; |
|
shouldYieldToHost = function () { |
|
return false; |
|
}; |
|
getCurrentTime = function () { |
|
return _currentTime === -1 ? 0 : _currentTime; |
|
}; |
|
} 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 messageKey = '__reactIdleCallback$' + Math.random().toString(36).slice(2); |
|
var idleTick = function (event) { |
|
if (event.source !== window || event.data !== messageKey) { |
|
return; |
|
} |
|
|
|
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; |
|
} |
|
} |
|
}; |
|
// Assumes that we have addEventListener in this environment. Might need |
|
// something better for old IE. |
|
window.addEventListener('message', idleTick, 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; |
|
window.postMessage(messageKey, '*'); |
|
} |
|
}; |
|
|
|
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. |
|
window.postMessage(messageKey, '*'); |
|
} 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_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) { |
|
return { |
|
$$typeof: REACT_LAZY_TYPE, |
|
_ctor: ctor, |
|
// React uses these fields to store the result. |
|
_status: -1, |
|
_result: null |
|
}; |
|
} |
|
|
|
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 useMutationEffect(create, inputs) { |
|
var dispatcher = resolveDispatcher(); |
|
return dispatcher.useMutationEffect(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; |
|
var name = void 0, |
|
propTypes = void 0; |
|
if (typeof type === 'function') { |
|
// Class or function component |
|
name = type.displayName || type.name; |
|
propTypes = type.propTypes; |
|
} else if (typeof type === 'object' && type !== null && type.$$typeof === REACT_FORWARD_REF_TYPE) { |
|
// ForwardRef |
|
var functionName = type.render.displayName || type.render.name || ''; |
|
name = type.displayName || (functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef'); |
|
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, |
|
|
|
__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals |
|
}; |
|
|
|
if (enableStableConcurrentModeAPIs) { |
|
React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE; |
|
React.Profiler = REACT_PROFILER_TYPE; |
|
} else { |
|
React.unstable_ConcurrentMode = REACT_CONCURRENT_MODE_TYPE; |
|
React.unstable_Profiler = REACT_PROFILER_TYPE; |
|
} |
|
|
|
if (enableHooks) { |
|
React.useCallback = useCallback; |
|
React.useContext = useContext; |
|
React.useEffect = useEffect; |
|
React.useImperativeMethods = useImperativeMethods; |
|
React.useLayoutEffect = useLayoutEffect; |
|
React.useMemo = useMemo; |
|
React.useMutationEffect = useMutationEffect; |
|
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; |
|
|
|
})));
|
|
|