This app provides monitoring and information features for the common freifunk user and the technical stuff of a freifunk community.
Code base is taken from a TUM Practical Course project and added here to see if Freifunk Altdorf can use it.
https://www.freifunk-altdorf.de
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1736 lines
55 KiB
1736 lines
55 KiB
/** @license React v16.3.1 |
|
* react.development.js |
|
* |
|
* Copyright (c) 2013-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
*/ |
|
|
|
'use 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'; |
|
|
|
/* |
|
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; |
|
}; |
|
|
|
// TODO: this is special because it gets imported during build. |
|
|
|
var ReactVersion = '16.3.1'; |
|
|
|
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol |
|
// nor polyfill, then a plain number is used for performance. |
|
var hasSymbol = typeof Symbol === 'function' && Symbol['for']; |
|
|
|
var REACT_ELEMENT_TYPE = hasSymbol ? Symbol['for']('react.element') : 0xeac7; |
|
var REACT_CALL_TYPE = hasSymbol ? Symbol['for']('react.call') : 0xeac8; |
|
var REACT_RETURN_TYPE = hasSymbol ? Symbol['for']('react.return') : 0xeac9; |
|
var REACT_PORTAL_TYPE = hasSymbol ? Symbol['for']('react.portal') : 0xeaca; |
|
var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol['for']('react.fragment') : 0xeacb; |
|
var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol['for']('react.strict_mode') : 0xeacc; |
|
var REACT_PROVIDER_TYPE = hasSymbol ? Symbol['for']('react.provider') : 0xeacd; |
|
var REACT_CONTEXT_TYPE = hasSymbol ? Symbol['for']('react.context') : 0xeace; |
|
var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol['for']('react.async_mode') : 0xeacf; |
|
var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol['for']('react.forward_ref') : 0xead0; |
|
|
|
var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; |
|
var FAUX_ITERATOR_SYMBOL = '@@iterator'; |
|
|
|
function getIteratorFn(maybeIterable) { |
|
if (maybeIterable === null || typeof maybeIterable === 'undefined') { |
|
return null; |
|
} |
|
var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; |
|
if (typeof maybeIterator === 'function') { |
|
return maybeIterator; |
|
} |
|
return null; |
|
} |
|
|
|
/** |
|
* WARNING: DO NOT manually require this module. |
|
* This is a replacement for `invariant(...)` used by the error code system |
|
* and will _only_ be required by the corresponding babel pass. |
|
* It always throws. |
|
*/ |
|
|
|
/** |
|
* Copyright (c) 2013-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
* |
|
*/ |
|
|
|
|
|
|
|
var emptyObject = {}; |
|
|
|
{ |
|
Object.freeze(emptyObject); |
|
} |
|
|
|
var emptyObject_1 = emptyObject; |
|
|
|
/** |
|
* Copyright (c) 2013-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
* |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Use invariant() to assert state which your program assumes to be true. |
|
* |
|
* 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(format) {}; |
|
|
|
{ |
|
validateFormat = function validateFormat(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; |
|
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; |
|
} |
|
} |
|
|
|
var invariant_1 = invariant; |
|
|
|
/** |
|
* 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('`warning(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; |
|
|
|
/** |
|
* Copyright (c) 2013-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
* |
|
* |
|
*/ |
|
|
|
function makeEmptyFunction(arg) { |
|
return function () { |
|
return arg; |
|
}; |
|
} |
|
|
|
/** |
|
* This function accepts and discards inputs; it has no side effects. This is |
|
* primarily useful idiomatically for overridable function endpoints which |
|
* always need to be callable, since JS lacks a null-call idiom ala Cocoa. |
|
*/ |
|
var emptyFunction = function emptyFunction() {}; |
|
|
|
emptyFunction.thatReturns = makeEmptyFunction; |
|
emptyFunction.thatReturnsFalse = makeEmptyFunction(false); |
|
emptyFunction.thatReturnsTrue = makeEmptyFunction(true); |
|
emptyFunction.thatReturnsNull = makeEmptyFunction(null); |
|
emptyFunction.thatReturnsThis = function () { |
|
return this; |
|
}; |
|
emptyFunction.thatReturnsArgument = function (arg) { |
|
return arg; |
|
}; |
|
|
|
var emptyFunction_1 = emptyFunction; |
|
|
|
/** |
|
* Copyright (c) 2014-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
* |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Similar to invariant but only logs a warning if the condition is not met. |
|
* This can be used to log issues in development environments in critical |
|
* paths. Removing the logging code for production environments will keep the |
|
* same logic and follow the same code paths. |
|
*/ |
|
|
|
var warning = emptyFunction_1; |
|
|
|
{ |
|
var printWarning$1 = function printWarning(format) { |
|
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { |
|
args[_key - 1] = arguments[_key]; |
|
} |
|
|
|
var argIndex = 0; |
|
var message = 'Warning: ' + format.replace(/%s/g, function () { |
|
return args[argIndex++]; |
|
}); |
|
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) {} |
|
}; |
|
|
|
warning = function warning(condition, format) { |
|
if (format === undefined) { |
|
throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); |
|
} |
|
|
|
if (format.indexOf('Failed Composite propType: ') === 0) { |
|
return; // Ignore CompositeComponent proptype check. |
|
} |
|
|
|
if (!condition) { |
|
for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { |
|
args[_key2 - 2] = arguments[_key2]; |
|
} |
|
|
|
printWarning$1.apply(undefined, [format].concat(args)); |
|
} |
|
}; |
|
} |
|
|
|
var warning_1 = warning; |
|
|
|
var 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; |
|
} |
|
warning_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'); |
|
} |
|
}; |
|
|
|
/** |
|
* Base class helpers for the updating state of a component. |
|
*/ |
|
function Component(props, context, updater) { |
|
this.props = props; |
|
this.context = context; |
|
this.refs = emptyObject_1; |
|
// 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_1(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; |
|
this.refs = emptyObject_1; |
|
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; |
|
} |
|
|
|
/** |
|
* 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 |
|
}; |
|
|
|
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; |
|
warning_1(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName); |
|
} |
|
}; |
|
warnAboutAccessingKey.isReactWarning = true; |
|
Object.defineProperty(props, 'key', { |
|
get: warnAboutAccessingKey, |
|
configurable: true |
|
}); |
|
} |
|
|
|
function defineRefPropWarningGetter(props, displayName) { |
|
var warnAboutAccessingRef = function () { |
|
if (!specialPropRefWarningShown) { |
|
specialPropRefWarningShown = true; |
|
warning_1(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName); |
|
} |
|
}; |
|
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) { |
|
if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) { |
|
var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type; |
|
if (key) { |
|
defineKeyPropWarningGetter(props, displayName); |
|
} |
|
if (ref) { |
|
defineRefPropWarningGetter(props, displayName); |
|
} |
|
} |
|
} |
|
} |
|
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) { |
|
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 valid component. |
|
* @final |
|
*/ |
|
function isValidElement(object) { |
|
return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; |
|
} |
|
|
|
var ReactDebugCurrentFrame = {}; |
|
|
|
{ |
|
// Component that is being worked on |
|
ReactDebugCurrentFrame.getCurrentStack = null; |
|
|
|
ReactDebugCurrentFrame.getStackAddendum = function () { |
|
var impl = ReactDebugCurrentFrame.getCurrentStack; |
|
if (impl) { |
|
return impl(); |
|
} |
|
return null; |
|
}; |
|
} |
|
|
|
var SEPARATOR = '.'; |
|
var SUBSEPARATOR = ':'; |
|
|
|
/** |
|
* 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) { |
|
warning_1(didWarnAboutMaps, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', ReactDebugCurrentFrame.getStackAddendum()); |
|
didWarnAboutMaps = 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_1(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum); |
|
} |
|
} |
|
|
|
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#react.children.foreach |
|
* |
|
* 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, emptyFunction_1.thatReturnsArgument); |
|
} 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#react.children.map |
|
* |
|
* 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#react.children.count |
|
* |
|
* @param {?*} children Children tree container. |
|
* @return {number} The number of children. |
|
*/ |
|
function countChildren(children, context) { |
|
return traverseAllChildren(children, emptyFunction_1.thatReturnsNull, null); |
|
} |
|
|
|
/** |
|
* Flatten a children object (typically specified as `props.children`) and |
|
* return an array with appropriately re-keyed children. |
|
* |
|
* See https://reactjs.org/docs/react-api.html#react.children.toarray |
|
*/ |
|
function toArray(children) { |
|
var result = []; |
|
mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction_1.thatReturnsArgument); |
|
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#react.children.only |
|
* |
|
* 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_1(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 { |
|
{ |
|
warning_1(calculateChangedBits === null || typeof calculateChangedBits === 'function', 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits); |
|
} |
|
} |
|
|
|
var context = { |
|
$$typeof: REACT_CONTEXT_TYPE, |
|
_calculateChangedBits: calculateChangedBits, |
|
_defaultValue: defaultValue, |
|
_currentValue: defaultValue, |
|
_changedBits: 0, |
|
// These are circular |
|
Provider: null, |
|
Consumer: null |
|
}; |
|
|
|
context.Provider = { |
|
$$typeof: REACT_PROVIDER_TYPE, |
|
_context: context |
|
}; |
|
context.Consumer = context; |
|
|
|
{ |
|
context._currentRenderer = null; |
|
} |
|
|
|
return context; |
|
} |
|
|
|
function forwardRef(render) { |
|
{ |
|
warning_1(typeof render === 'function', 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render); |
|
} |
|
|
|
return { |
|
$$typeof: REACT_FORWARD_REF_TYPE, |
|
render: render |
|
}; |
|
} |
|
|
|
var describeComponentFrame = function (name, source, ownerName) { |
|
return '\n in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : ''); |
|
}; |
|
|
|
function isValidElementType(type) { |
|
return typeof type === 'string' || typeof type === 'function' || |
|
// Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill. |
|
type === REACT_FRAGMENT_TYPE || type === REACT_ASYNC_MODE_TYPE || type === REACT_STRICT_MODE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE); |
|
} |
|
|
|
function getComponentName(fiber) { |
|
var type = fiber.type; |
|
|
|
if (typeof type === 'function') { |
|
return type.displayName || type.name; |
|
} |
|
if (typeof type === 'string') { |
|
return type; |
|
} |
|
switch (type) { |
|
case REACT_FRAGMENT_TYPE: |
|
return 'ReactFragment'; |
|
case REACT_PORTAL_TYPE: |
|
return 'ReactPortal'; |
|
case REACT_CALL_TYPE: |
|
return 'ReactCall'; |
|
case REACT_RETURN_TYPE: |
|
return 'ReactReturn'; |
|
} |
|
return null; |
|
} |
|
|
|
/** |
|
* 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 invariant$2 = invariant_1; |
|
var warning$2 = warning_1; |
|
var ReactPropTypesSecret = ReactPropTypesSecret_1; |
|
var loggedTypeFailures = {}; |
|
} |
|
|
|
/** |
|
* 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. |
|
invariant$2(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]); |
|
error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); |
|
} catch (ex) { |
|
error = ex; |
|
} |
|
warning$2(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error); |
|
if (error 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() : ''; |
|
|
|
warning$2(false, 'Failed %s type: %s%s', location, 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 currentlyValidatingElement = void 0; |
|
var propTypesMisspellWarningShown = void 0; |
|
|
|
var getDisplayName = function () {}; |
|
var getStackAddendum = function () {}; |
|
|
|
{ |
|
currentlyValidatingElement = null; |
|
|
|
propTypesMisspellWarningShown = false; |
|
|
|
getDisplayName = function (element) { |
|
if (element == null) { |
|
return '#empty'; |
|
} else if (typeof element === 'string' || typeof element === 'number') { |
|
return '#text'; |
|
} else if (typeof element.type === 'string') { |
|
return element.type; |
|
} else if (element.type === REACT_FRAGMENT_TYPE) { |
|
return 'React.Fragment'; |
|
} else { |
|
return element.type.displayName || element.type.name || 'Unknown'; |
|
} |
|
}; |
|
|
|
getStackAddendum = function () { |
|
var stack = ''; |
|
if (currentlyValidatingElement) { |
|
var name = getDisplayName(currentlyValidatingElement); |
|
var owner = currentlyValidatingElement._owner; |
|
stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner)); |
|
} |
|
stack += ReactDebugCurrentFrame.getStackAddendum() || ''; |
|
return stack; |
|
}; |
|
} |
|
|
|
function getDeclarationErrorAddendum() { |
|
if (ReactCurrentOwner.current) { |
|
var name = getComponentName(ReactCurrentOwner.current); |
|
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) + '.'; |
|
} |
|
|
|
currentlyValidatingElement = element; |
|
{ |
|
warning_1(false, 'Each child in an array or iterator should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, getStackAddendum()); |
|
} |
|
currentlyValidatingElement = 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 componentClass = element.type; |
|
if (typeof componentClass !== 'function') { |
|
return; |
|
} |
|
var name = componentClass.displayName || componentClass.name; |
|
var propTypes = componentClass.propTypes; |
|
if (propTypes) { |
|
currentlyValidatingElement = element; |
|
checkPropTypes_1(propTypes, element.props, 'prop', name, getStackAddendum); |
|
currentlyValidatingElement = null; |
|
} else if (componentClass.PropTypes !== undefined && !propTypesMisspellWarningShown) { |
|
propTypesMisspellWarningShown = true; |
|
warning_1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown'); |
|
} |
|
if (typeof componentClass.getDefaultProps === 'function') { |
|
warning_1(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.'); |
|
} |
|
} |
|
|
|
/** |
|
* Given a fragment, validate that it can only be provided with fragment props |
|
* @param {ReactElement} fragment |
|
*/ |
|
function validateFragmentProps(fragment) { |
|
currentlyValidatingElement = 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.%s', key, getStackAddendum()); |
|
break; |
|
} |
|
} |
|
|
|
if (fragment.ref !== null) { |
|
warning_1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.%s', getStackAddendum()); |
|
} |
|
|
|
currentlyValidatingElement = 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(); |
|
} |
|
|
|
info += getStackAddendum() || ''; |
|
|
|
var typeString = void 0; |
|
if (type === null) { |
|
typeString = 'null'; |
|
} else if (Array.isArray(type)) { |
|
typeString = 'array'; |
|
} 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, |
|
|
|
Fragment: REACT_FRAGMENT_TYPE, |
|
StrictMode: REACT_STRICT_MODE_TYPE, |
|
unstable_AsyncMode: REACT_ASYNC_MODE_TYPE, |
|
|
|
createElement: createElementWithValidation, |
|
cloneElement: cloneElementWithValidation, |
|
createFactory: createFactoryWithValidation, |
|
isValidElement: isValidElement, |
|
|
|
version: ReactVersion, |
|
|
|
__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: { |
|
ReactCurrentOwner: ReactCurrentOwner, |
|
// Used by renderers to avoid bundling object-assign twice in UMD bundles: |
|
assign: objectAssign |
|
} |
|
}; |
|
|
|
{ |
|
objectAssign(React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, { |
|
// These should not be included in production. |
|
ReactDebugCurrentFrame: ReactDebugCurrentFrame, |
|
// Shim for React DOM 16.0.0 which still destructured (but not used) this. |
|
// TODO: remove in React 17.0. |
|
ReactComponentTreeHook: {} |
|
}); |
|
} |
|
|
|
|
|
|
|
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['default'] : React$3; |
|
|
|
return react; |
|
|
|
})));
|
|
|