diff options
Diffstat (limited to 'node_modules/react/umd/react.development.js')
| -rw-r--r-- | node_modules/react/umd/react.development.js | 1689 |
1 files changed, 1354 insertions, 335 deletions
diff --git a/node_modules/react/umd/react.development.js b/node_modules/react/umd/react.development.js index 654f3a82b..c06ed7edd 100644 --- a/node_modules/react/umd/react.development.js +++ b/node_modules/react/umd/react.development.js @@ -1,7 +1,7 @@ -/** @license React v16.2.0 +/** @license React v16.5.2 * react.development.js * - * Copyright (c) 2013-present, Facebook, Inc. + * 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. @@ -15,6 +15,81 @@ (global.React = factory()); }(this, (function () { 'use strict'; +// TODO: this is special because it gets imported during build. + +var ReactVersion = '16.5.2'; + +// 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_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf; +var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0; +var REACT_PLACEHOLDER_TYPE = hasSymbol ? Symbol.for('react.placeholder') : 0xead1; + +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; +} + +// Exports ReactDOM.createRoot + + +// Experimental error-boundary API that can recover from errors within a single +// render phase + +// Suspense +var enableSuspense = 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: + + +// Warn about legacy context API + + +// 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 + /* object-assign (c) Sindre Sorhus @@ -106,69 +181,6 @@ var objectAssign = shouldUseNative() ? Object.assign : function (target, source) return to; }; -// TODO: this is special because it gets imported during build. - -var ReactVersion = '16.2.0'; - -// The Symbol used to tag the ReactElement-like types. If there is no native Symbol -// nor polyfill, then a plain number is used for performance. -var hasSymbol = typeof Symbol === 'function' && Symbol['for']; - -var REACT_ELEMENT_TYPE = hasSymbol ? Symbol['for']('react.element') : 0xeac7; -var REACT_CALL_TYPE = hasSymbol ? Symbol['for']('react.call') : 0xeac8; -var REACT_RETURN_TYPE = hasSymbol ? Symbol['for']('react.return') : 0xeac9; -var REACT_PORTAL_TYPE = hasSymbol ? Symbol['for']('react.portal') : 0xeaca; -var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol['for']('react.fragment') : 0xeacb; - -var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; -var FAUX_ITERATOR_SYMBOL = '@@iterator'; - -function getIteratorFn(maybeIterable) { - if (maybeIterable === null || typeof maybeIterable === 'undefined') { - return null; - } - var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; - if (typeof maybeIterator === 'function') { - return maybeIterator; - } - return null; -} - -/** - * WARNING: DO NOT manually require this module. - * This is a replacement for `invariant(...)` used by the error code system - * and will _only_ be required by the corresponding babel pass. - * It always throws. - */ - -/** - * 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 emptyObject = {}; - -{ - Object.freeze(emptyObject); -} - -var emptyObject_1 = emptyObject; - -/** - * 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. - * - */ - - - /** * Use invariant() to assert state which your program assumes to be true. * @@ -180,10 +192,10 @@ var emptyObject_1 = emptyObject; * will remain to ensure logic does not differ in production. */ -var validateFormat = function validateFormat(format) {}; +var validateFormat = function () {}; { - validateFormat = function validateFormat(format) { + validateFormat = function (format) { if (format === undefined) { throw new Error('invariant requires an error message argument'); } @@ -194,7 +206,7 @@ function invariant(condition, format, a, b, c, d, e, f) { validateFormat(format); if (!condition) { - var error; + 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 { @@ -211,7 +223,8 @@ function invariant(condition, format, a, b, c, d, e, f) { } } -var invariant_1 = invariant; +// Relying on the `invariant()` implementation lets us +// preserve the format and params in the www builds. /** * Forked from fbjs/warning: @@ -252,7 +265,7 @@ var lowPriorityWarning = function () {}; lowPriorityWarning = function (condition, format) { if (format === undefined) { - throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); + 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++) { @@ -267,114 +280,105 @@ var lowPriorityWarning = function () {}; var lowPriorityWarning$1 = lowPriorityWarning; /** - * 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. - * - * - */ - -function makeEmptyFunction(arg) { - return function () { - return arg; - }; -} - -/** - * This function accepts and discards inputs; it has no side effects. This is - * primarily useful idiomatically for overridable function endpoints which - * always need to be callable, since JS lacks a null-call idiom ala Cocoa. - */ -var emptyFunction = function emptyFunction() {}; - -emptyFunction.thatReturns = makeEmptyFunction; -emptyFunction.thatReturnsFalse = makeEmptyFunction(false); -emptyFunction.thatReturnsTrue = makeEmptyFunction(true); -emptyFunction.thatReturnsNull = makeEmptyFunction(null); -emptyFunction.thatReturnsThis = function () { - return this; -}; -emptyFunction.thatReturnsArgument = function (arg) { - return arg; -}; - -var emptyFunction_1 = emptyFunction; - -/** - * Copyright (c) 2014-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. - * - */ - - - - - -/** * 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 = emptyFunction_1; +var warningWithoutStack = function () {}; { - var printWarning$1 = function printWarning(format) { - for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { - args[_key - 1] = arguments[_key]; + 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]; } - var argIndex = 0; - var message = 'Warning: ' + format.replace(/%s/g, function () { - return args[argIndex++]; - }); + 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') { - console.error(message); + var _args$map = args.map(function (item) { + return '' + item; + }), + a = _args$map[0], + b = _args$map[1], + c = _args$map[2], + d = _args$map[3], + e = _args$map[4], + f = _args$map[5], + g = _args$map[6], + h = _args$map[7]; + + var message = 'Warning: ' + format; + + // We intentionally don't use spread (or .apply) because it breaks IE9: + // https://github.com/facebook/react/issues/13610 + switch (args.length) { + case 0: + console.error(message); + break; + case 1: + console.error(message, a); + break; + case 2: + console.error(message, a, b); + break; + case 3: + console.error(message, a, b, c); + break; + case 4: + console.error(message, a, b, c, d); + break; + case 5: + console.error(message, a, b, c, d, e); + break; + case 6: + console.error(message, a, b, c, d, e, f); + break; + case 7: + console.error(message, a, b, c, d, e, f, g); + break; + case 8: + console.error(message, a, b, c, d, e, f, g, h); + break; + default: + throw new Error('warningWithoutStack() currently supports at most 8 arguments.'); + } } 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); + var argIndex = 0; + var _message = 'Warning: ' + format.replace(/%s/g, function () { + return args[argIndex++]; + }); + throw new Error(_message); } catch (x) {} }; - - warning = function warning(condition, format) { - if (format === undefined) { - throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); - } - - if (format.indexOf('Failed Composite propType: ') === 0) { - return; // Ignore CompositeComponent proptype check. - } - - 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$1.apply(undefined, [format].concat(args)); - } - }; } -var warning_1 = warning; +var warningWithoutStack$1 = warningWithoutStack; var didWarnStateUpdateForUnmountedComponent = {}; function warnNoop(publicInstance, callerName) { { - var constructor = publicInstance.constructor; - var componentName = constructor && (constructor.displayName || constructor.name) || 'ReactClass'; + var _constructor = publicInstance.constructor; + var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass'; var warningKey = componentName + '.' + callerName; if (didWarnStateUpdateForUnmountedComponent[warningKey]) { return; } - warning_1(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op.\n\nPlease check the code for the %s component.', callerName, callerName, componentName); + 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; } } @@ -447,13 +451,19 @@ var ReactNoopUpdateQueue = { } }; +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; - this.refs = emptyObject_1; + // 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; @@ -487,7 +497,7 @@ Component.prototype.isReactComponent = {}; * @protected */ Component.prototype.setState = function (partialState, callback) { - !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant_1(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0; + !(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'); }; @@ -534,46 +544,795 @@ Component.prototype.forceUpdate = function (callback) { } } +function ComponentDummy() {} +ComponentDummy.prototype = Component.prototype; + /** - * Base class helpers for the updating state of a component. + * Convenience component with default shallow equality check for sCU. */ function PureComponent(props, context, updater) { - // Duplicated from Component. this.props = props; this.context = context; - this.refs = emptyObject_1; - // We initialize the default updater but the real one gets injected by the - // renderer. + // If a component has string refs, we will assign a different object later. + this.refs = emptyObject; this.updater = updater || ReactNoopUpdateQueue; } -function ComponentDummy() {} -ComponentDummy.prototype = Component.prototype; var pureComponentPrototype = PureComponent.prototype = new ComponentDummy(); pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods. objectAssign(pureComponentPrototype, Component.prototype); pureComponentPrototype.isPureReactComponent = true; -function AsyncComponent(props, context, updater) { - // Duplicated from Component. - this.props = props; - this.context = context; - this.refs = emptyObject_1; - // We initialize the default updater but the real one gets injected by the - // renderer. - this.updater = updater || ReactNoopUpdateQueue; +// an immutable object with a single mutable value +function createRef() { + var refObject = { + current: null + }; + { + Object.seal(refObject); + } + return refObject; } -var asyncComponentPrototype = AsyncComponent.prototype = new ComponentDummy(); -asyncComponentPrototype.constructor = AsyncComponent; -// Avoid an extra prototype jump for these methods. -objectAssign(asyncComponentPrototype, Component.prototype); -asyncComponentPrototype.unstable_isAsyncReactComponent = true; -asyncComponentPrototype.render = function () { - return this.props.children; +/* eslint-disable no-var */ + +// TODO: Currently there's only a single priority level, Deferred. Will add +// additional priorities. +var DEFERRED_TIMEOUT = 5000; + +// Callbacks are stored as a circular, doubly linked list. +var firstCallbackNode = null; + +var isPerformingWork = false; + +var isHostCallbackScheduled = false; + +var hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function'; + +var timeRemaining; +if (hasNativePerformanceNow) { + timeRemaining = function () { + // We assume that if we have a performance timer that the rAF callback + // gets a performance timer value. Not sure if this is always true. + var remaining = getFrameDeadline() - performance.now(); + return remaining > 0 ? remaining : 0; + }; +} else { + timeRemaining = function () { + // Fallback to Date.now() + var remaining = getFrameDeadline() - Date.now(); + return remaining > 0 ? remaining : 0; + }; +} + +var deadlineObject = { + timeRemaining: timeRemaining, + didTimeout: false }; +function ensureHostCallbackIsScheduled() { + if (isPerformingWork) { + // Don't schedule work yet; wait until the next time we yield. + return; + } + // Schedule the host callback using the earliest timeout in the list. + var timesOutAt = firstCallbackNode.timesOutAt; + if (!isHostCallbackScheduled) { + isHostCallbackScheduled = true; + } else { + // Cancel the existing host callback. + cancelCallback(); + } + requestCallback(flushWork, timesOutAt); +} + +function flushFirstCallback(node) { + 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 previous = firstCallbackNode.previous; + firstCallbackNode = previous.next = next; + next.previous = previous; + } + + flushedNode.next = flushedNode.previous = null; + + // Now it's safe to call the callback. + var callback = flushedNode.callback; + callback(deadlineObject); +} + +function flushWork(didTimeout) { + isPerformingWork = true; + deadlineObject.didTimeout = didTimeout; + try { + if (didTimeout) { + // Flush all the timed out 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.timesOutAt <= currentTime) { + do { + flushFirstCallback(); + } while (firstCallbackNode !== null && firstCallbackNode.timesOutAt <= currentTime); + continue; + } + break; + } + } else { + // Keep flushing callbacks until we run out of time in the frame. + if (firstCallbackNode !== null) { + do { + flushFirstCallback(); + } while (firstCallbackNode !== null && getFrameDeadline() - getCurrentTime() > 0); + } + } + } finally { + isPerformingWork = false; + if (firstCallbackNode !== null) { + // There's still work remaining. Request another callback. + ensureHostCallbackIsScheduled(firstCallbackNode); + } else { + isHostCallbackScheduled = false; + } + } +} + +function unstable_scheduleWork(callback, options) { + var currentTime = getCurrentTime(); + + var timesOutAt; + if (options !== undefined && options !== null && options.timeout !== null && options.timeout !== undefined) { + // Check for an explicit timeout + timesOutAt = currentTime + options.timeout; + } else { + // Compute an absolute timeout using the default constant. + timesOutAt = currentTime + DEFERRED_TIMEOUT; + } + + var newNode = { + callback: callback, + timesOutAt: timesOutAt, + next: null, + previous: null + }; + + // Insert the new callback into the list, sorted by its timeout. + if (firstCallbackNode === null) { + // This is the first callback in the list. + firstCallbackNode = newNode.next = newNode.previous = newNode; + ensureHostCallbackIsScheduled(firstCallbackNode); + } else { + var next = null; + var node = firstCallbackNode; + do { + if (node.timesOutAt > timesOutAt) { + // The new callback times out before this one. + next = node; + break; + } + node = node.next; + } while (node !== firstCallbackNode); + + if (next === null) { + // No callback with a later timeout was found, which means the new + // callback has the latest timeout in the list. + next = firstCallbackNode; + } else if (next === firstCallbackNode) { + // The new callback has the earliest timeout in the entire list. + firstCallbackNode = newNode; + ensureHostCallbackIsScheduled(firstCallbackNode); + } + + var previous = next.previous; + previous.next = next.previous = newNode; + newNode.next = next; + newNode.previous = previous; + } + + return newNode; +} + +function unstable_cancelScheduledWork(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; +} + +// 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 requestCallback; +var cancelCallback; +var getFrameDeadline; + +if (typeof window === 'undefined') { + // If this accidentally gets imported in a non-browser environment, fallback + // to a naive implementation. + var timeoutID = -1; + requestCallback = function (callback, absoluteTimeout) { + timeoutID = setTimeout(callback, 0, true); + }; + cancelCallback = function () { + clearTimeout(timeoutID); + }; + getFrameDeadline = function () { + return 0; + }; +} else if (window._schedMock) { + // Dynamic injection, only for testing purposes. + var impl = window._schedMock; + requestCallback = impl[0]; + cancelCallback = impl[1]; + getFrameDeadline = impl[2]; +} else { + if (typeof console !== 'undefined') { + 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 scheduledCallback = null; + var isIdleScheduled = false; + var timeoutTime = -1; + + var isAnimationFrameScheduled = false; + + var isPerformingIdleWork = 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; + + getFrameDeadline = function () { + return frameDeadline; + }; + + // 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; + } + + isIdleScheduled = false; + + 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 (timeoutTime !== -1 && timeoutTime <= 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. + return; + } + } + + timeoutTime = -1; + var callback = scheduledCallback; + scheduledCallback = null; + if (callback !== null) { + isPerformingIdleWork = true; + try { + callback(didTimeout); + } finally { + isPerformingIdleWork = 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) { + isAnimationFrameScheduled = false; + 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 we get lower than that, 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 (!isIdleScheduled) { + isIdleScheduled = true; + window.postMessage(messageKey, '*'); + } + }; + + requestCallback = function (callback, absoluteTimeout) { + scheduledCallback = callback; + timeoutTime = absoluteTimeout; + if (isPerformingIdleWork) { + // If we're already performing idle work, an error must have been thrown. + // 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); + } + }; + + cancelCallback = function () { + scheduledCallback = null; + isIdleScheduled = 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. * @@ -585,9 +1344,203 @@ var ReactCurrentOwner = { * @internal * @type {ReactComponent} */ - current: null + 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 refineResolvedThenable(thenable) { + return thenable._reactStatus === Resolved ? thenable._reactResult : null; +} + +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_ASYNC_MODE_TYPE: + return 'AsyncMode'; + 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_PLACEHOLDER_TYPE: + return 'Placeholder'; + } + 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: + var renderFn = type.render; + var functionName = renderFn.displayName || renderFn.name || ''; + return type.displayName || (functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef'); + } + if (typeof type.then === 'function') { + var thenable = type; + var resolvedThenable = refineResolvedThenable(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, { + Schedule: { + unstable_cancelScheduledWork: unstable_cancelScheduledWork, + unstable_now: getCurrentTime, + unstable_scheduleWork: unstable_scheduleWork + }, + ScheduleTracing: { + __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 = { @@ -597,8 +1550,8 @@ var RESERVED_PROPS = { __source: true }; -var specialPropKeyWarningShown; -var specialPropRefWarningShown; +var specialPropKeyWarningShown = void 0; +var specialPropRefWarningShown = void 0; function hasValidRef(config) { { @@ -628,7 +1581,7 @@ function defineKeyPropWarningGetter(props, displayName) { var warnAboutAccessingKey = function () { if (!specialPropKeyWarningShown) { specialPropKeyWarningShown = true; - warning_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); + 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; @@ -642,7 +1595,7 @@ function defineRefPropWarningGetter(props, displayName) { var warnAboutAccessingRef = function () { if (!specialPropRefWarningShown) { specialPropRefWarningShown = true; - warning_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); + 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; @@ -674,7 +1627,7 @@ function defineRefPropWarningGetter(props, displayName) { */ var ReactElement = function (type, key, ref, self, source, owner, props) { var element = { - // This tag allow us to uniquely identify this as a React 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 @@ -733,7 +1686,7 @@ var ReactElement = function (type, key, ref, self, source, owner, props) { * See https://reactjs.org/docs/react-api.html#createelement */ function createElement(type, config, children) { - var propName; + var propName = void 0; // Reserved names are extracted var props = {}; @@ -790,14 +1743,12 @@ function createElement(type, config, children) { } { if (key || ref) { - if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) { - var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type; - if (key) { - defineKeyPropWarningGetter(props, displayName); - } - if (ref) { - defineRefPropWarningGetter(props, displayName); - } + var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type; + if (key) { + defineKeyPropWarningGetter(props, displayName); + } + if (ref) { + defineRefPropWarningGetter(props, displayName); } } } @@ -821,7 +1772,9 @@ function cloneAndReplaceKey(oldElement, newKey) { * See https://reactjs.org/docs/react-api.html#cloneelement */ function cloneElement(element, config, children) { - var propName; + !!(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); @@ -850,7 +1803,7 @@ function cloneElement(element, config, children) { } // Remaining properties override existing props - var defaultProps; + var defaultProps = void 0; if (element.type && element.type.defaultProps) { defaultProps = element.type.defaultProps; } @@ -886,28 +1839,13 @@ function cloneElement(element, config, children) { * 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 valid component. + * @return {boolean} True if `object` is a ReactElement. * @final */ function isValidElement(object) { return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; } -var ReactDebugCurrentFrame = {}; - -{ - // Component that is being worked on - ReactDebugCurrentFrame.getCurrentStack = null; - - ReactDebugCurrentFrame.getStackAddendum = function () { - var impl = ReactDebugCurrentFrame.getCurrentStack; - if (impl) { - return impl(); - } - return null; - }; -} - var SEPARATOR = '.'; var SUBSEPARATOR = ':'; @@ -1004,8 +1942,6 @@ function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) case 'object': switch (children.$$typeof) { case REACT_ELEMENT_TYPE: - case REACT_CALL_TYPE: - case REACT_RETURN_TYPE: case REACT_PORTAL_TYPE: invokeCallback = true; } @@ -1020,8 +1956,8 @@ function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) return 1; } - var child; - var nextName; + 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; @@ -1037,13 +1973,13 @@ function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) { // Warn about using Maps as children if (iteratorFn === children.entries) { - warning_1(didWarnAboutMaps, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', ReactDebugCurrentFrame.getStackAddendum()); + !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; + var step = void 0; var ii = 0; while (!(step = iterator.next()).done) { child = step.value; @@ -1056,7 +1992,7 @@ function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum(); } var childrenString = '' + children; - invariant_1(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum); + 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); } } @@ -1115,7 +2051,7 @@ function forEachSingleChild(bookKeeping, child, name) { /** * Iterates through children that are typically specified as `props.children`. * - * See https://reactjs.org/docs/react-api.html#react.children.foreach + * See https://reactjs.org/docs/react-api.html#reactchildrenforeach * * The provided forEachFunc(child, index) will be called for each * leaf child. @@ -1142,7 +2078,9 @@ function mapSingleChildIntoContext(bookKeeping, child, childKey) { var mappedChild = func.call(context, child, bookKeeping.count++); if (Array.isArray(mappedChild)) { - mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction_1.thatReturnsArgument); + mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, function (c) { + return c; + }); } else if (mappedChild != null) { if (isValidElement(mappedChild)) { mappedChild = cloneAndReplaceKey(mappedChild, @@ -1167,7 +2105,7 @@ function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) { /** * Maps children that are typically specified as `props.children`. * - * See https://reactjs.org/docs/react-api.html#react.children.map + * See https://reactjs.org/docs/react-api.html#reactchildrenmap * * The provided mapFunction(child, key, index) will be called for each * leaf child. @@ -1190,24 +2128,28 @@ function mapChildren(children, func, context) { * Count the number of children that are typically specified as * `props.children`. * - * See https://reactjs.org/docs/react-api.html#react.children.count + * See https://reactjs.org/docs/react-api.html#reactchildrencount * * @param {?*} children Children tree container. * @return {number} The number of children. */ -function countChildren(children, context) { - return traverseAllChildren(children, emptyFunction_1.thatReturnsNull, null); +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#react.children.toarray + * See https://reactjs.org/docs/react-api.html#reactchildrentoarray */ function toArray(children) { var result = []; - mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction_1.thatReturnsArgument); + mapIntoWithKeyPrefixInternal(children, result, null, function (child) { + return child; + }); return result; } @@ -1215,7 +2157,7 @@ function toArray(children) { * 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#react.children.only + * 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 @@ -1226,24 +2168,99 @@ function toArray(children) { * structure. */ function onlyChild(children) { - !isValidElement(children) ? invariant_1(false, 'React.Children.only expected to receive a single React element child.') : void 0; + !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0; return children; } -var describeComponentFrame = function (name, source, ownerName) { - return '\n in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : ''); -}; +function readContext(context, observedBits) { + var dispatcher = ReactCurrentOwner.currentDispatcher; + !(dispatcher !== null) ? invariant(false, 'Context.unstable_read(): Context can only be read while React is rendering, e.g. inside the render method or getDerivedStateFromProps.') : void 0; + return dispatcher.readContext(context, observedBits); +} -function getComponentName(fiber) { - var type = fiber.type; +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; + } + } - if (typeof type === 'string') { - return type; + 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, + // These are circular + Provider: null, + Consumer: null, + unstable_read: null + }; + + context.Provider = { + $$typeof: REACT_PROVIDER_TYPE, + _context: context + }; + context.Consumer = context; + context.unstable_read = readContext.bind(null, context); + + { + context._currentRenderer = null; + context._currentRenderer2 = null; } - if (typeof type === 'function') { - return type.displayName || type.name; + + return context; +} + +function lazy(ctor) { + var thenable = null; + return { + then: function (resolve, reject) { + if (thenable === null) { + // Lazily create thenable by wrapping in an extra thenable. + thenable = ctor(); + ctor = null; + } + return thenable.then(resolve, reject); + }, + + // React uses these fields to store the result. + _reactStatus: -1, + _reactResult: null + }; +} + +function forwardRef(render) { + { + 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 null; + + 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_ASYNC_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_PLACEHOLDER_TYPE || typeof type === 'object' && type !== null && (typeof type.then === 'function' || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE); } /** @@ -1268,11 +2285,24 @@ var ReactPropTypesSecret_1 = ReactPropTypesSecret$1; +var printWarning$1 = function() {}; + { - var invariant$2 = invariant_1; - var warning$2 = warning_1; 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) {} + }; } /** @@ -1297,12 +2327,29 @@ function checkPropTypes(typeSpecs, values, location, componentName, getStack) { try { // This is intentionally an invariant that gets caught. It's the same // behavior as without this statement except with a better message. - invariant$2(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]); + 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; } - warning$2(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error); + 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. @@ -1310,7 +2357,9 @@ function checkPropTypes(typeSpecs, values, location, componentName, getStack) { var stack = getStack ? getStack() : ''; - warning$2(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : ''); + printWarning$1( + 'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '') + ); } } } @@ -1326,42 +2375,15 @@ var checkPropTypes_1 = checkPropTypes; * that support it. */ -{ - var currentlyValidatingElement = null; - - var propTypesMisspellWarningShown = false; - - var getDisplayName = function (element) { - if (element == null) { - return '#empty'; - } else if (typeof element === 'string' || typeof element === 'number') { - return '#text'; - } else if (typeof element.type === 'string') { - return element.type; - } else if (element.type === REACT_FRAGMENT_TYPE) { - return 'React.Fragment'; - } else { - return element.type.displayName || element.type.name || 'Unknown'; - } - }; - - var getStackAddendum = function () { - var stack = ''; - if (currentlyValidatingElement) { - var name = getDisplayName(currentlyValidatingElement); - var owner = currentlyValidatingElement._owner; - stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner)); - } - stack += ReactDebugCurrentFrame.getStackAddendum() || ''; - return stack; - }; +var propTypesMisspellWarningShown = void 0; - var VALID_FRAGMENT_PROPS = new Map([['children', true], ['key', true]]); +{ + propTypesMisspellWarningShown = false; } function getDeclarationErrorAddendum() { if (ReactCurrentOwner.current) { - var name = getComponentName(ReactCurrentOwner.current); + var name = getComponentName(ReactCurrentOwner.current.type); if (name) { return '\n\nCheck the render method of `' + name + '`.'; } @@ -1427,14 +2449,14 @@ function validateExplicitKey(element, parentType) { 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) + '.'; + childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '.'; } - currentlyValidatingElement = element; + 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.%s', currentComponentErrorInfo, childOwner, getStackAddendum()); + 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); } - currentlyValidatingElement = null; + setCurrentlyValidatingElement(null); } /** @@ -1469,7 +2491,7 @@ function validateChildKeys(node, parentType) { // but now we print a separate warning for them later. if (iteratorFn !== node.entries) { var iterator = iteratorFn.call(node); - var step; + var step = void 0; while (!(step = iterator.next()).done) { if (isValidElement(step.value)) { validateExplicitKey(step.value, parentType); @@ -1487,22 +2509,31 @@ function validateChildKeys(node, parentType) { * @param {ReactElement} element */ function validatePropTypes(element) { - var componentClass = element.type; - if (typeof componentClass !== 'function') { + var type = element.type; + var name = void 0, + propTypes = void 0; + if (typeof type === 'function') { + // Class or functional 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; } - var name = componentClass.displayName || componentClass.name; - var propTypes = componentClass.propTypes; if (propTypes) { - currentlyValidatingElement = element; - checkPropTypes_1(propTypes, element.props, 'prop', name, getStackAddendum); - currentlyValidatingElement = null; - } else if (componentClass.PropTypes !== undefined && !propTypesMisspellWarningShown) { + setCurrentlyValidatingElement(element); + checkPropTypes_1(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum); + setCurrentlyValidatingElement(null); + } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) { propTypesMisspellWarningShown = true; - warning_1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown'); + warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown'); } - if (typeof componentClass.getDefaultProps === 'function') { - warning_1(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.'); + 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; } } @@ -1511,45 +2542,27 @@ function validatePropTypes(element) { * @param {ReactElement} fragment */ function validateFragmentProps(fragment) { - currentlyValidatingElement = fragment; - - var _iteratorNormalCompletion = true; - var _didIteratorError = false; - var _iteratorError = undefined; - - try { - for (var _iterator = Object.keys(fragment.props)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { - var key = _step.value; - - if (!VALID_FRAGMENT_PROPS.has(key)) { - warning_1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.%s', key, getStackAddendum()); - break; - } - } - } catch (err) { - _didIteratorError = true; - _iteratorError = err; - } finally { - try { - if (!_iteratorNormalCompletion && _iterator['return']) { - _iterator['return'](); - } - } finally { - if (_didIteratorError) { - throw _iteratorError; - } + 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`.%s', getStackAddendum()); + warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.'); } - currentlyValidatingElement = null; + setCurrentlyValidatingElement(null); } function createElementWithValidation(type, props, children) { - var validType = typeof type === 'string' || typeof type === 'function' || typeof type === 'symbol' || typeof type === 'number'; + 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) { @@ -1565,9 +2578,19 @@ function createElementWithValidation(type, props, children) { info += getDeclarationErrorAddendum(); } - info += getStackAddendum() || ''; + 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', type == null ? type : typeof type, info); + 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); @@ -1589,7 +2612,7 @@ function createElementWithValidation(type, props, children) { } } - if (typeof type === 'symbol' && type === REACT_FRAGMENT_TYPE) { + if (type === REACT_FRAGMENT_TYPE) { validateFragmentProps(element); } else { validatePropTypes(element); @@ -1600,9 +2623,8 @@ function createElementWithValidation(type, props, children) { function createFactoryWithValidation(type) { var validatedFactory = createElementWithValidation.bind(null, type); - // Legacy hook TODO: Warn if this is accessed validatedFactory.type = type; - + // Legacy hook: remove it { Object.defineProperty(validatedFactory, 'type', { enumerable: false, @@ -1637,11 +2659,17 @@ var React = { only: onlyChild }, + createRef: createRef, Component: Component, PureComponent: PureComponent, - unstable_AsyncComponent: AsyncComponent, + + createContext: createContext, + forwardRef: forwardRef, Fragment: REACT_FRAGMENT_TYPE, + StrictMode: REACT_STRICT_MODE_TYPE, + unstable_AsyncMode: REACT_ASYNC_MODE_TYPE, + unstable_Profiler: REACT_PROFILER_TYPE, createElement: createElementWithValidation, cloneElement: cloneElementWithValidation, @@ -1650,21 +2678,12 @@ var React = { version: ReactVersion, - __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: { - ReactCurrentOwner: ReactCurrentOwner, - // Used by renderers to avoid bundling object-assign twice in UMD bundles: - assign: objectAssign - } + __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals }; -{ - objectAssign(React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, { - // 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: {} - }); +if (enableSuspense) { + React.Placeholder = REACT_PLACEHOLDER_TYPE; + React.lazy = lazy; } @@ -1677,7 +2696,7 @@ 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['default'] : React$3; +var react = React$3.default || React$3; return react; |