mirror of
https://github.com/WordPress/WordPress.git
synced 2024-12-25 10:38:11 +01:00
4f86a03258
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages. - Upgrades React from 16.5.2 to 16.6.3. - Adds a missing `wp-date` dependency to the editor script. - Updates changed dependencies in `script-loader.php`. - Fixes undefined notices in some blocks. - Removes incorrect `gutenberg` textdomain. Merges [43891], [43903], and [43919] to trunk. Props atimmer, aduth, youknowriad, danielbachhuber. See #45145. Built from https://develop.svn.wordpress.org/trunk@44262 git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
3030 lines
96 KiB
JavaScript
3030 lines
96 KiB
JavaScript
/** @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;
|
||
|
||
})));
|