mirror of
https://github.com/facebook/react.git
synced 2025-11-01 09:12:30 +00:00
Remove propTypes checks for legacy context (#28324)
Part of https://github.com/facebook/react/pull/28207, this is easy to
land in isolation.
The approach I'm taking is slightly different — instead of leaving
validation on for legacy context, I disable the validation (it's
DEV-only) and leave just the parts that drive the runtime logic. I.e.
`contexTypes` and `childContextTypes` *values* are now ignored, the keys
are used just like before.
DiffTrain build for [64e755d737](https://github.com/facebook/react/commit/64e755d7374d753c75dc16ba1a4a09ce7b8689dd)
This commit is contained in:
gaearon
@@ -1 +1 @@
|
||||
5d445b50a670d6cdc52943ca4e5ab3422792c57c
|
||||
64e755d7374d753c75dc16ba1a4a09ce7b8689dd
|
||||
|
||||
@@ -618,4 +618,4 @@ exports.useSyncExternalStore = function (
|
||||
exports.useTransition = function () {
|
||||
return ReactCurrentDispatcher.current.useTransition();
|
||||
};
|
||||
exports.version = "18.3.0-www-classic-a886996f";
|
||||
exports.version = "18.3.0-www-classic-e7aae6cc";
|
||||
|
||||
@@ -66,7 +66,7 @@ if (__DEV__) {
|
||||
return self;
|
||||
}
|
||||
|
||||
var ReactVersion = "18.3.0-www-classic-a35bff2f";
|
||||
var ReactVersion = "18.3.0-www-classic-67fbc8af";
|
||||
|
||||
var LegacyRoot = 0;
|
||||
var ConcurrentRoot = 1;
|
||||
@@ -3033,453 +3033,6 @@ if (__DEV__) {
|
||||
}
|
||||
var NotPendingTransition = null;
|
||||
|
||||
var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher;
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name, ownerFn) {
|
||||
{
|
||||
if (prefix === undefined) {
|
||||
// Extract the VM specific prefix used by each line.
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
} // We use the prefix to ensure our stacks line up with native stack frames.
|
||||
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
}
|
||||
var reentry = false;
|
||||
var componentFrameCache;
|
||||
|
||||
{
|
||||
var PossiblyWeakMap$2 = typeof WeakMap === "function" ? WeakMap : Map;
|
||||
componentFrameCache = new PossiblyWeakMap$2();
|
||||
}
|
||||
/**
|
||||
* Leverages native browser/VM stack frames to get proper details (e.g.
|
||||
* filename, line + col number) for a single component in a component stack. We
|
||||
* do this by:
|
||||
* (1) throwing and catching an error in the function - this will be our
|
||||
* control error.
|
||||
* (2) calling the component which will eventually throw an error that we'll
|
||||
* catch - this will be our sample error.
|
||||
* (3) diffing the control and sample error stacks to find the stack frame
|
||||
* which represents our component.
|
||||
*/
|
||||
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
// If something asked for a stack inside a fake render, it should get ignored.
|
||||
if (!fn || reentry) {
|
||||
return "";
|
||||
}
|
||||
|
||||
{
|
||||
var frame = componentFrameCache.get(fn);
|
||||
|
||||
if (frame !== undefined) {
|
||||
return frame;
|
||||
}
|
||||
}
|
||||
|
||||
reentry = true;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
|
||||
|
||||
Error.prepareStackTrace = undefined;
|
||||
var previousDispatcher;
|
||||
|
||||
{
|
||||
previousDispatcher = ReactCurrentDispatcher$2.current; // Set the dispatcher in DEV because this might be call in the render function
|
||||
// for warnings.
|
||||
|
||||
ReactCurrentDispatcher$2.current = null;
|
||||
disableLogs();
|
||||
}
|
||||
/**
|
||||
* Finding a common stack frame between sample and control errors can be
|
||||
* tricky given the different types and levels of stack trace truncation from
|
||||
* different JS VMs. So instead we'll attempt to control what that common
|
||||
* frame should be through this object method:
|
||||
* Having both the sample and control errors be in the function under the
|
||||
* `DescribeNativeComponentFrameRoot` property, + setting the `name` and
|
||||
* `displayName` properties of the function ensures that a stack
|
||||
* frame exists that has the method name `DescribeNativeComponentFrameRoot` in
|
||||
* it for both control and sample stacks.
|
||||
*/
|
||||
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
var control;
|
||||
|
||||
try {
|
||||
// This should throw.
|
||||
if (construct) {
|
||||
// Something should be setting the props in the constructor.
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
// We use a throwing setter instead of frozen or non-writable props
|
||||
// because that won't throw in a non-strict mode function.
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
|
||||
if (typeof Reflect === "object" && Reflect.construct) {
|
||||
// We construct a different control for this case to include any extra
|
||||
// frames added by the construct call.
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
control = x;
|
||||
}
|
||||
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // $FlowFixMe[prop-missing] found when upgrading Flow
|
||||
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // TODO(luna): This will currently only throw if the function component
|
||||
// tries to access React/ReactDOM/props. We should probably make this throw
|
||||
// in simple components too
|
||||
|
||||
var maybePromise = fn(); // If the function component returns a promise, it's likely an async
|
||||
// component, which we don't yet support. Attach a noop catch handler to
|
||||
// silence the error.
|
||||
// TODO: Implement component stacks for async client components?
|
||||
|
||||
if (maybePromise && typeof maybePromise.catch === "function") {
|
||||
maybePromise.catch(function () {});
|
||||
}
|
||||
}
|
||||
} catch (sample) {
|
||||
// This is inlined manually because closure doesn't do it for us.
|
||||
if (sample && control && typeof sample.stack === "string") {
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
}
|
||||
|
||||
return [null, null];
|
||||
}
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
); // Before ES6, the `name` property was not configurable.
|
||||
|
||||
if (namePropDescriptor && namePropDescriptor.configurable) {
|
||||
// V8 utilizes a function's `name` property when generating a stack trace.
|
||||
Object.defineProperty(
|
||||
RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
|
||||
// is set to `false`.
|
||||
// $FlowFixMe[cannot-write]
|
||||
"name",
|
||||
{
|
||||
value: "DetermineComponentFrameRoot"
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
var _RunInRootFrame$Deter =
|
||||
RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
|
||||
if (sampleStack && controlStack) {
|
||||
// This extracts the first frame from the sample that isn't also in the control.
|
||||
// Skipping one frame that we assume is the frame that calls the two.
|
||||
var sampleLines = sampleStack.split("\n");
|
||||
var controlLines = controlStack.split("\n");
|
||||
var s = 0;
|
||||
var c = 0;
|
||||
|
||||
while (
|
||||
s < sampleLines.length &&
|
||||
!sampleLines[s].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
s++;
|
||||
}
|
||||
|
||||
while (
|
||||
c < controlLines.length &&
|
||||
!controlLines[c].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
c++;
|
||||
} // We couldn't find our intentionally injected common root frame, attempt
|
||||
// to find another common root frame by search from the bottom of the
|
||||
// control stack...
|
||||
|
||||
if (s === sampleLines.length || c === controlLines.length) {
|
||||
s = sampleLines.length - 1;
|
||||
c = controlLines.length - 1;
|
||||
|
||||
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
|
||||
// We expect at least one stack frame to be shared.
|
||||
// Typically this will be the root most one. However, stack frames may be
|
||||
// cut off due to maximum stack limits. In this case, one maybe cut off
|
||||
// earlier than the other. We assume that the sample is longer or the same
|
||||
// and there for cut off earlier. So we should find the root most frame in
|
||||
// the sample somewhere in the control.
|
||||
c--;
|
||||
}
|
||||
}
|
||||
|
||||
for (; s >= 1 && c >= 0; s--, c--) {
|
||||
// Next we find the first one that isn't the same which should be the
|
||||
// frame that called our sample function and the control.
|
||||
if (sampleLines[s] !== controlLines[c]) {
|
||||
// In V8, the first line is describing the message but other VMs don't.
|
||||
// If we're about to return the first line, and the control is also on the same
|
||||
// line, that's a pretty good indicator that our sample threw at same line as
|
||||
// the control. I.e. before we entered the sample frame. So we ignore this result.
|
||||
// This can happen if you passed a class to function component, or non-function.
|
||||
if (s !== 1 || c !== 1) {
|
||||
do {
|
||||
s--;
|
||||
c--; // We may still have similar intermediate frames from the construct call.
|
||||
// The next one that isn't the same should be our match though.
|
||||
|
||||
if (c < 0 || sampleLines[s] !== controlLines[c]) {
|
||||
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
|
||||
var _frame =
|
||||
"\n" + sampleLines[s].replace(" at new ", " at "); // If our component frame is labeled "<anonymous>"
|
||||
// but we have a user-provided "displayName"
|
||||
// splice it in to make the stack more readable.
|
||||
|
||||
if (fn.displayName && _frame.includes("<anonymous>")) {
|
||||
_frame = _frame.replace("<anonymous>", fn.displayName);
|
||||
}
|
||||
|
||||
if (true) {
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, _frame);
|
||||
}
|
||||
} // Return the line we found.
|
||||
|
||||
return _frame;
|
||||
}
|
||||
} while (s >= 1 && c >= 0);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
reentry = false;
|
||||
|
||||
{
|
||||
ReactCurrentDispatcher$2.current = previousDispatcher;
|
||||
reenableLogs();
|
||||
}
|
||||
|
||||
Error.prepareStackTrace = previousPrepareStackTrace;
|
||||
} // Fallback to just using the name if we couldn't make it throw.
|
||||
|
||||
var name = fn ? fn.displayName || fn.name : "";
|
||||
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
|
||||
|
||||
{
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, syntheticFrame);
|
||||
}
|
||||
}
|
||||
|
||||
return syntheticFrame;
|
||||
}
|
||||
|
||||
function describeClassComponentFrame(ctor, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(ctor, true);
|
||||
}
|
||||
}
|
||||
function describeFunctionComponentFrame(fn, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(fn, false);
|
||||
}
|
||||
}
|
||||
|
||||
function shouldConstruct$1(Component) {
|
||||
var prototype = Component.prototype;
|
||||
return !!(prototype && prototype.isReactComponent);
|
||||
}
|
||||
|
||||
function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
|
||||
if (type == null) {
|
||||
return "";
|
||||
}
|
||||
|
||||
if (typeof type === "function") {
|
||||
{
|
||||
return describeNativeComponentFrame(type, shouldConstruct$1(type));
|
||||
}
|
||||
}
|
||||
|
||||
if (typeof type === "string") {
|
||||
return describeBuiltInComponentFrame(type);
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return describeBuiltInComponentFrame("Suspense");
|
||||
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return describeBuiltInComponentFrame("SuspenseList");
|
||||
}
|
||||
|
||||
if (typeof type === "object") {
|
||||
switch (type.$$typeof) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
return describeFunctionComponentFrame(type.render);
|
||||
|
||||
case REACT_MEMO_TYPE:
|
||||
// Memo may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(type.type, ownerFn);
|
||||
|
||||
case REACT_LAZY_TYPE: {
|
||||
var lazyComponent = type;
|
||||
var payload = lazyComponent._payload;
|
||||
var init = lazyComponent._init;
|
||||
|
||||
try {
|
||||
// Lazy may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(
|
||||
init(payload),
|
||||
ownerFn
|
||||
);
|
||||
} catch (x) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
// $FlowFixMe[method-unbinding]
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var valueStack = [];
|
||||
var fiberStack;
|
||||
|
||||
@@ -3602,11 +3155,6 @@ if (__DEV__) {
|
||||
|
||||
for (var key in contextTypes) {
|
||||
context[key] = unmaskedContext[key];
|
||||
}
|
||||
|
||||
{
|
||||
var name = getComponentNameFromFiber(workInProgress) || "Unknown";
|
||||
checkPropTypes(contextTypes, context, "context", name);
|
||||
} // Cache unmasked context so we can avoid recreating masked context unless necessary.
|
||||
// Context is created before the class component is instantiated so check for instance.
|
||||
|
||||
@@ -3698,16 +3246,6 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
var name = getComponentNameFromFiber(fiber) || "Unknown";
|
||||
checkPropTypes(
|
||||
childContextTypes,
|
||||
childContext,
|
||||
"child context",
|
||||
name
|
||||
);
|
||||
}
|
||||
|
||||
return assign({}, parentContext, childContext);
|
||||
}
|
||||
}
|
||||
@@ -3916,9 +3454,9 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
}
|
||||
var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe[incompatible-type]: Flow cannot handle polymorphic WeakMaps
|
||||
var PossiblyWeakMap$2 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe[incompatible-type]: Flow cannot handle polymorphic WeakMaps
|
||||
|
||||
var wakeableIDs = new PossiblyWeakMap$1();
|
||||
var wakeableIDs = new PossiblyWeakMap$2();
|
||||
var wakeableID = 0;
|
||||
|
||||
function getWakeableID(wakeable) {
|
||||
@@ -5599,6 +5137,453 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher;
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name, ownerFn) {
|
||||
{
|
||||
if (prefix === undefined) {
|
||||
// Extract the VM specific prefix used by each line.
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
} // We use the prefix to ensure our stacks line up with native stack frames.
|
||||
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
}
|
||||
var reentry = false;
|
||||
var componentFrameCache;
|
||||
|
||||
{
|
||||
var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map;
|
||||
componentFrameCache = new PossiblyWeakMap$1();
|
||||
}
|
||||
/**
|
||||
* Leverages native browser/VM stack frames to get proper details (e.g.
|
||||
* filename, line + col number) for a single component in a component stack. We
|
||||
* do this by:
|
||||
* (1) throwing and catching an error in the function - this will be our
|
||||
* control error.
|
||||
* (2) calling the component which will eventually throw an error that we'll
|
||||
* catch - this will be our sample error.
|
||||
* (3) diffing the control and sample error stacks to find the stack frame
|
||||
* which represents our component.
|
||||
*/
|
||||
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
// If something asked for a stack inside a fake render, it should get ignored.
|
||||
if (!fn || reentry) {
|
||||
return "";
|
||||
}
|
||||
|
||||
{
|
||||
var frame = componentFrameCache.get(fn);
|
||||
|
||||
if (frame !== undefined) {
|
||||
return frame;
|
||||
}
|
||||
}
|
||||
|
||||
reentry = true;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
|
||||
|
||||
Error.prepareStackTrace = undefined;
|
||||
var previousDispatcher;
|
||||
|
||||
{
|
||||
previousDispatcher = ReactCurrentDispatcher$2.current; // Set the dispatcher in DEV because this might be call in the render function
|
||||
// for warnings.
|
||||
|
||||
ReactCurrentDispatcher$2.current = null;
|
||||
disableLogs();
|
||||
}
|
||||
/**
|
||||
* Finding a common stack frame between sample and control errors can be
|
||||
* tricky given the different types and levels of stack trace truncation from
|
||||
* different JS VMs. So instead we'll attempt to control what that common
|
||||
* frame should be through this object method:
|
||||
* Having both the sample and control errors be in the function under the
|
||||
* `DescribeNativeComponentFrameRoot` property, + setting the `name` and
|
||||
* `displayName` properties of the function ensures that a stack
|
||||
* frame exists that has the method name `DescribeNativeComponentFrameRoot` in
|
||||
* it for both control and sample stacks.
|
||||
*/
|
||||
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
var control;
|
||||
|
||||
try {
|
||||
// This should throw.
|
||||
if (construct) {
|
||||
// Something should be setting the props in the constructor.
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
// We use a throwing setter instead of frozen or non-writable props
|
||||
// because that won't throw in a non-strict mode function.
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
|
||||
if (typeof Reflect === "object" && Reflect.construct) {
|
||||
// We construct a different control for this case to include any extra
|
||||
// frames added by the construct call.
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
control = x;
|
||||
}
|
||||
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // $FlowFixMe[prop-missing] found when upgrading Flow
|
||||
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // TODO(luna): This will currently only throw if the function component
|
||||
// tries to access React/ReactDOM/props. We should probably make this throw
|
||||
// in simple components too
|
||||
|
||||
var maybePromise = fn(); // If the function component returns a promise, it's likely an async
|
||||
// component, which we don't yet support. Attach a noop catch handler to
|
||||
// silence the error.
|
||||
// TODO: Implement component stacks for async client components?
|
||||
|
||||
if (maybePromise && typeof maybePromise.catch === "function") {
|
||||
maybePromise.catch(function () {});
|
||||
}
|
||||
}
|
||||
} catch (sample) {
|
||||
// This is inlined manually because closure doesn't do it for us.
|
||||
if (sample && control && typeof sample.stack === "string") {
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
}
|
||||
|
||||
return [null, null];
|
||||
}
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
); // Before ES6, the `name` property was not configurable.
|
||||
|
||||
if (namePropDescriptor && namePropDescriptor.configurable) {
|
||||
// V8 utilizes a function's `name` property when generating a stack trace.
|
||||
Object.defineProperty(
|
||||
RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
|
||||
// is set to `false`.
|
||||
// $FlowFixMe[cannot-write]
|
||||
"name",
|
||||
{
|
||||
value: "DetermineComponentFrameRoot"
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
var _RunInRootFrame$Deter =
|
||||
RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
|
||||
if (sampleStack && controlStack) {
|
||||
// This extracts the first frame from the sample that isn't also in the control.
|
||||
// Skipping one frame that we assume is the frame that calls the two.
|
||||
var sampleLines = sampleStack.split("\n");
|
||||
var controlLines = controlStack.split("\n");
|
||||
var s = 0;
|
||||
var c = 0;
|
||||
|
||||
while (
|
||||
s < sampleLines.length &&
|
||||
!sampleLines[s].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
s++;
|
||||
}
|
||||
|
||||
while (
|
||||
c < controlLines.length &&
|
||||
!controlLines[c].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
c++;
|
||||
} // We couldn't find our intentionally injected common root frame, attempt
|
||||
// to find another common root frame by search from the bottom of the
|
||||
// control stack...
|
||||
|
||||
if (s === sampleLines.length || c === controlLines.length) {
|
||||
s = sampleLines.length - 1;
|
||||
c = controlLines.length - 1;
|
||||
|
||||
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
|
||||
// We expect at least one stack frame to be shared.
|
||||
// Typically this will be the root most one. However, stack frames may be
|
||||
// cut off due to maximum stack limits. In this case, one maybe cut off
|
||||
// earlier than the other. We assume that the sample is longer or the same
|
||||
// and there for cut off earlier. So we should find the root most frame in
|
||||
// the sample somewhere in the control.
|
||||
c--;
|
||||
}
|
||||
}
|
||||
|
||||
for (; s >= 1 && c >= 0; s--, c--) {
|
||||
// Next we find the first one that isn't the same which should be the
|
||||
// frame that called our sample function and the control.
|
||||
if (sampleLines[s] !== controlLines[c]) {
|
||||
// In V8, the first line is describing the message but other VMs don't.
|
||||
// If we're about to return the first line, and the control is also on the same
|
||||
// line, that's a pretty good indicator that our sample threw at same line as
|
||||
// the control. I.e. before we entered the sample frame. So we ignore this result.
|
||||
// This can happen if you passed a class to function component, or non-function.
|
||||
if (s !== 1 || c !== 1) {
|
||||
do {
|
||||
s--;
|
||||
c--; // We may still have similar intermediate frames from the construct call.
|
||||
// The next one that isn't the same should be our match though.
|
||||
|
||||
if (c < 0 || sampleLines[s] !== controlLines[c]) {
|
||||
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
|
||||
var _frame =
|
||||
"\n" + sampleLines[s].replace(" at new ", " at "); // If our component frame is labeled "<anonymous>"
|
||||
// but we have a user-provided "displayName"
|
||||
// splice it in to make the stack more readable.
|
||||
|
||||
if (fn.displayName && _frame.includes("<anonymous>")) {
|
||||
_frame = _frame.replace("<anonymous>", fn.displayName);
|
||||
}
|
||||
|
||||
if (true) {
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, _frame);
|
||||
}
|
||||
} // Return the line we found.
|
||||
|
||||
return _frame;
|
||||
}
|
||||
} while (s >= 1 && c >= 0);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
reentry = false;
|
||||
|
||||
{
|
||||
ReactCurrentDispatcher$2.current = previousDispatcher;
|
||||
reenableLogs();
|
||||
}
|
||||
|
||||
Error.prepareStackTrace = previousPrepareStackTrace;
|
||||
} // Fallback to just using the name if we couldn't make it throw.
|
||||
|
||||
var name = fn ? fn.displayName || fn.name : "";
|
||||
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
|
||||
|
||||
{
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, syntheticFrame);
|
||||
}
|
||||
}
|
||||
|
||||
return syntheticFrame;
|
||||
}
|
||||
|
||||
function describeClassComponentFrame(ctor, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(ctor, true);
|
||||
}
|
||||
}
|
||||
function describeFunctionComponentFrame(fn, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(fn, false);
|
||||
}
|
||||
}
|
||||
|
||||
function shouldConstruct$1(Component) {
|
||||
var prototype = Component.prototype;
|
||||
return !!(prototype && prototype.isReactComponent);
|
||||
}
|
||||
|
||||
function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
|
||||
if (type == null) {
|
||||
return "";
|
||||
}
|
||||
|
||||
if (typeof type === "function") {
|
||||
{
|
||||
return describeNativeComponentFrame(type, shouldConstruct$1(type));
|
||||
}
|
||||
}
|
||||
|
||||
if (typeof type === "string") {
|
||||
return describeBuiltInComponentFrame(type);
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return describeBuiltInComponentFrame("Suspense");
|
||||
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return describeBuiltInComponentFrame("SuspenseList");
|
||||
}
|
||||
|
||||
if (typeof type === "object") {
|
||||
switch (type.$$typeof) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
return describeFunctionComponentFrame(type.render);
|
||||
|
||||
case REACT_MEMO_TYPE:
|
||||
// Memo may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(type.type, ownerFn);
|
||||
|
||||
case REACT_LAZY_TYPE: {
|
||||
var lazyComponent = type;
|
||||
var payload = lazyComponent._payload;
|
||||
var init = lazyComponent._init;
|
||||
|
||||
try {
|
||||
// Lazy may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(
|
||||
init(payload),
|
||||
ownerFn
|
||||
);
|
||||
} catch (x) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
// $FlowFixMe[method-unbinding]
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs equality by iterating through keys on an object and returning false
|
||||
* when any key has values which are not strictly equal between the arguments.
|
||||
|
||||
@@ -66,7 +66,7 @@ if (__DEV__) {
|
||||
return self;
|
||||
}
|
||||
|
||||
var ReactVersion = "18.3.0-www-modern-57608326";
|
||||
var ReactVersion = "18.3.0-www-modern-f7b80cf4";
|
||||
|
||||
var LegacyRoot = 0;
|
||||
var ConcurrentRoot = 1;
|
||||
@@ -3030,453 +3030,6 @@ if (__DEV__) {
|
||||
}
|
||||
var NotPendingTransition = null;
|
||||
|
||||
var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher;
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name, ownerFn) {
|
||||
{
|
||||
if (prefix === undefined) {
|
||||
// Extract the VM specific prefix used by each line.
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
} // We use the prefix to ensure our stacks line up with native stack frames.
|
||||
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
}
|
||||
var reentry = false;
|
||||
var componentFrameCache;
|
||||
|
||||
{
|
||||
var PossiblyWeakMap$2 = typeof WeakMap === "function" ? WeakMap : Map;
|
||||
componentFrameCache = new PossiblyWeakMap$2();
|
||||
}
|
||||
/**
|
||||
* Leverages native browser/VM stack frames to get proper details (e.g.
|
||||
* filename, line + col number) for a single component in a component stack. We
|
||||
* do this by:
|
||||
* (1) throwing and catching an error in the function - this will be our
|
||||
* control error.
|
||||
* (2) calling the component which will eventually throw an error that we'll
|
||||
* catch - this will be our sample error.
|
||||
* (3) diffing the control and sample error stacks to find the stack frame
|
||||
* which represents our component.
|
||||
*/
|
||||
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
// If something asked for a stack inside a fake render, it should get ignored.
|
||||
if (!fn || reentry) {
|
||||
return "";
|
||||
}
|
||||
|
||||
{
|
||||
var frame = componentFrameCache.get(fn);
|
||||
|
||||
if (frame !== undefined) {
|
||||
return frame;
|
||||
}
|
||||
}
|
||||
|
||||
reentry = true;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
|
||||
|
||||
Error.prepareStackTrace = undefined;
|
||||
var previousDispatcher;
|
||||
|
||||
{
|
||||
previousDispatcher = ReactCurrentDispatcher$2.current; // Set the dispatcher in DEV because this might be call in the render function
|
||||
// for warnings.
|
||||
|
||||
ReactCurrentDispatcher$2.current = null;
|
||||
disableLogs();
|
||||
}
|
||||
/**
|
||||
* Finding a common stack frame between sample and control errors can be
|
||||
* tricky given the different types and levels of stack trace truncation from
|
||||
* different JS VMs. So instead we'll attempt to control what that common
|
||||
* frame should be through this object method:
|
||||
* Having both the sample and control errors be in the function under the
|
||||
* `DescribeNativeComponentFrameRoot` property, + setting the `name` and
|
||||
* `displayName` properties of the function ensures that a stack
|
||||
* frame exists that has the method name `DescribeNativeComponentFrameRoot` in
|
||||
* it for both control and sample stacks.
|
||||
*/
|
||||
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
var control;
|
||||
|
||||
try {
|
||||
// This should throw.
|
||||
if (construct) {
|
||||
// Something should be setting the props in the constructor.
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
// We use a throwing setter instead of frozen or non-writable props
|
||||
// because that won't throw in a non-strict mode function.
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
|
||||
if (typeof Reflect === "object" && Reflect.construct) {
|
||||
// We construct a different control for this case to include any extra
|
||||
// frames added by the construct call.
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
control = x;
|
||||
}
|
||||
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // $FlowFixMe[prop-missing] found when upgrading Flow
|
||||
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // TODO(luna): This will currently only throw if the function component
|
||||
// tries to access React/ReactDOM/props. We should probably make this throw
|
||||
// in simple components too
|
||||
|
||||
var maybePromise = fn(); // If the function component returns a promise, it's likely an async
|
||||
// component, which we don't yet support. Attach a noop catch handler to
|
||||
// silence the error.
|
||||
// TODO: Implement component stacks for async client components?
|
||||
|
||||
if (maybePromise && typeof maybePromise.catch === "function") {
|
||||
maybePromise.catch(function () {});
|
||||
}
|
||||
}
|
||||
} catch (sample) {
|
||||
// This is inlined manually because closure doesn't do it for us.
|
||||
if (sample && control && typeof sample.stack === "string") {
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
}
|
||||
|
||||
return [null, null];
|
||||
}
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
); // Before ES6, the `name` property was not configurable.
|
||||
|
||||
if (namePropDescriptor && namePropDescriptor.configurable) {
|
||||
// V8 utilizes a function's `name` property when generating a stack trace.
|
||||
Object.defineProperty(
|
||||
RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
|
||||
// is set to `false`.
|
||||
// $FlowFixMe[cannot-write]
|
||||
"name",
|
||||
{
|
||||
value: "DetermineComponentFrameRoot"
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
var _RunInRootFrame$Deter =
|
||||
RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
|
||||
if (sampleStack && controlStack) {
|
||||
// This extracts the first frame from the sample that isn't also in the control.
|
||||
// Skipping one frame that we assume is the frame that calls the two.
|
||||
var sampleLines = sampleStack.split("\n");
|
||||
var controlLines = controlStack.split("\n");
|
||||
var s = 0;
|
||||
var c = 0;
|
||||
|
||||
while (
|
||||
s < sampleLines.length &&
|
||||
!sampleLines[s].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
s++;
|
||||
}
|
||||
|
||||
while (
|
||||
c < controlLines.length &&
|
||||
!controlLines[c].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
c++;
|
||||
} // We couldn't find our intentionally injected common root frame, attempt
|
||||
// to find another common root frame by search from the bottom of the
|
||||
// control stack...
|
||||
|
||||
if (s === sampleLines.length || c === controlLines.length) {
|
||||
s = sampleLines.length - 1;
|
||||
c = controlLines.length - 1;
|
||||
|
||||
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
|
||||
// We expect at least one stack frame to be shared.
|
||||
// Typically this will be the root most one. However, stack frames may be
|
||||
// cut off due to maximum stack limits. In this case, one maybe cut off
|
||||
// earlier than the other. We assume that the sample is longer or the same
|
||||
// and there for cut off earlier. So we should find the root most frame in
|
||||
// the sample somewhere in the control.
|
||||
c--;
|
||||
}
|
||||
}
|
||||
|
||||
for (; s >= 1 && c >= 0; s--, c--) {
|
||||
// Next we find the first one that isn't the same which should be the
|
||||
// frame that called our sample function and the control.
|
||||
if (sampleLines[s] !== controlLines[c]) {
|
||||
// In V8, the first line is describing the message but other VMs don't.
|
||||
// If we're about to return the first line, and the control is also on the same
|
||||
// line, that's a pretty good indicator that our sample threw at same line as
|
||||
// the control. I.e. before we entered the sample frame. So we ignore this result.
|
||||
// This can happen if you passed a class to function component, or non-function.
|
||||
if (s !== 1 || c !== 1) {
|
||||
do {
|
||||
s--;
|
||||
c--; // We may still have similar intermediate frames from the construct call.
|
||||
// The next one that isn't the same should be our match though.
|
||||
|
||||
if (c < 0 || sampleLines[s] !== controlLines[c]) {
|
||||
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
|
||||
var _frame =
|
||||
"\n" + sampleLines[s].replace(" at new ", " at "); // If our component frame is labeled "<anonymous>"
|
||||
// but we have a user-provided "displayName"
|
||||
// splice it in to make the stack more readable.
|
||||
|
||||
if (fn.displayName && _frame.includes("<anonymous>")) {
|
||||
_frame = _frame.replace("<anonymous>", fn.displayName);
|
||||
}
|
||||
|
||||
if (true) {
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, _frame);
|
||||
}
|
||||
} // Return the line we found.
|
||||
|
||||
return _frame;
|
||||
}
|
||||
} while (s >= 1 && c >= 0);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
reentry = false;
|
||||
|
||||
{
|
||||
ReactCurrentDispatcher$2.current = previousDispatcher;
|
||||
reenableLogs();
|
||||
}
|
||||
|
||||
Error.prepareStackTrace = previousPrepareStackTrace;
|
||||
} // Fallback to just using the name if we couldn't make it throw.
|
||||
|
||||
var name = fn ? fn.displayName || fn.name : "";
|
||||
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
|
||||
|
||||
{
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, syntheticFrame);
|
||||
}
|
||||
}
|
||||
|
||||
return syntheticFrame;
|
||||
}
|
||||
|
||||
function describeClassComponentFrame(ctor, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(ctor, true);
|
||||
}
|
||||
}
|
||||
function describeFunctionComponentFrame(fn, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(fn, false);
|
||||
}
|
||||
}
|
||||
|
||||
function shouldConstruct$1(Component) {
|
||||
var prototype = Component.prototype;
|
||||
return !!(prototype && prototype.isReactComponent);
|
||||
}
|
||||
|
||||
function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
|
||||
if (type == null) {
|
||||
return "";
|
||||
}
|
||||
|
||||
if (typeof type === "function") {
|
||||
{
|
||||
return describeNativeComponentFrame(type, shouldConstruct$1(type));
|
||||
}
|
||||
}
|
||||
|
||||
if (typeof type === "string") {
|
||||
return describeBuiltInComponentFrame(type);
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return describeBuiltInComponentFrame("Suspense");
|
||||
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return describeBuiltInComponentFrame("SuspenseList");
|
||||
}
|
||||
|
||||
if (typeof type === "object") {
|
||||
switch (type.$$typeof) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
return describeFunctionComponentFrame(type.render);
|
||||
|
||||
case REACT_MEMO_TYPE:
|
||||
// Memo may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(type.type, ownerFn);
|
||||
|
||||
case REACT_LAZY_TYPE: {
|
||||
var lazyComponent = type;
|
||||
var payload = lazyComponent._payload;
|
||||
var init = lazyComponent._init;
|
||||
|
||||
try {
|
||||
// Lazy may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(
|
||||
init(payload),
|
||||
ownerFn
|
||||
);
|
||||
} catch (x) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
// $FlowFixMe[method-unbinding]
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var valueStack = [];
|
||||
var fiberStack;
|
||||
|
||||
@@ -3666,9 +3219,9 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
}
|
||||
var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe[incompatible-type]: Flow cannot handle polymorphic WeakMaps
|
||||
var PossiblyWeakMap$2 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe[incompatible-type]: Flow cannot handle polymorphic WeakMaps
|
||||
|
||||
var wakeableIDs = new PossiblyWeakMap$1();
|
||||
var wakeableIDs = new PossiblyWeakMap$2();
|
||||
var wakeableID = 0;
|
||||
|
||||
function getWakeableID(wakeable) {
|
||||
@@ -5349,6 +4902,453 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher;
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name, ownerFn) {
|
||||
{
|
||||
if (prefix === undefined) {
|
||||
// Extract the VM specific prefix used by each line.
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
} // We use the prefix to ensure our stacks line up with native stack frames.
|
||||
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
}
|
||||
var reentry = false;
|
||||
var componentFrameCache;
|
||||
|
||||
{
|
||||
var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map;
|
||||
componentFrameCache = new PossiblyWeakMap$1();
|
||||
}
|
||||
/**
|
||||
* Leverages native browser/VM stack frames to get proper details (e.g.
|
||||
* filename, line + col number) for a single component in a component stack. We
|
||||
* do this by:
|
||||
* (1) throwing and catching an error in the function - this will be our
|
||||
* control error.
|
||||
* (2) calling the component which will eventually throw an error that we'll
|
||||
* catch - this will be our sample error.
|
||||
* (3) diffing the control and sample error stacks to find the stack frame
|
||||
* which represents our component.
|
||||
*/
|
||||
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
// If something asked for a stack inside a fake render, it should get ignored.
|
||||
if (!fn || reentry) {
|
||||
return "";
|
||||
}
|
||||
|
||||
{
|
||||
var frame = componentFrameCache.get(fn);
|
||||
|
||||
if (frame !== undefined) {
|
||||
return frame;
|
||||
}
|
||||
}
|
||||
|
||||
reentry = true;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
|
||||
|
||||
Error.prepareStackTrace = undefined;
|
||||
var previousDispatcher;
|
||||
|
||||
{
|
||||
previousDispatcher = ReactCurrentDispatcher$2.current; // Set the dispatcher in DEV because this might be call in the render function
|
||||
// for warnings.
|
||||
|
||||
ReactCurrentDispatcher$2.current = null;
|
||||
disableLogs();
|
||||
}
|
||||
/**
|
||||
* Finding a common stack frame between sample and control errors can be
|
||||
* tricky given the different types and levels of stack trace truncation from
|
||||
* different JS VMs. So instead we'll attempt to control what that common
|
||||
* frame should be through this object method:
|
||||
* Having both the sample and control errors be in the function under the
|
||||
* `DescribeNativeComponentFrameRoot` property, + setting the `name` and
|
||||
* `displayName` properties of the function ensures that a stack
|
||||
* frame exists that has the method name `DescribeNativeComponentFrameRoot` in
|
||||
* it for both control and sample stacks.
|
||||
*/
|
||||
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
var control;
|
||||
|
||||
try {
|
||||
// This should throw.
|
||||
if (construct) {
|
||||
// Something should be setting the props in the constructor.
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
// We use a throwing setter instead of frozen or non-writable props
|
||||
// because that won't throw in a non-strict mode function.
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
|
||||
if (typeof Reflect === "object" && Reflect.construct) {
|
||||
// We construct a different control for this case to include any extra
|
||||
// frames added by the construct call.
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
control = x;
|
||||
}
|
||||
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // $FlowFixMe[prop-missing] found when upgrading Flow
|
||||
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // TODO(luna): This will currently only throw if the function component
|
||||
// tries to access React/ReactDOM/props. We should probably make this throw
|
||||
// in simple components too
|
||||
|
||||
var maybePromise = fn(); // If the function component returns a promise, it's likely an async
|
||||
// component, which we don't yet support. Attach a noop catch handler to
|
||||
// silence the error.
|
||||
// TODO: Implement component stacks for async client components?
|
||||
|
||||
if (maybePromise && typeof maybePromise.catch === "function") {
|
||||
maybePromise.catch(function () {});
|
||||
}
|
||||
}
|
||||
} catch (sample) {
|
||||
// This is inlined manually because closure doesn't do it for us.
|
||||
if (sample && control && typeof sample.stack === "string") {
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
}
|
||||
|
||||
return [null, null];
|
||||
}
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
); // Before ES6, the `name` property was not configurable.
|
||||
|
||||
if (namePropDescriptor && namePropDescriptor.configurable) {
|
||||
// V8 utilizes a function's `name` property when generating a stack trace.
|
||||
Object.defineProperty(
|
||||
RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
|
||||
// is set to `false`.
|
||||
// $FlowFixMe[cannot-write]
|
||||
"name",
|
||||
{
|
||||
value: "DetermineComponentFrameRoot"
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
var _RunInRootFrame$Deter =
|
||||
RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
|
||||
if (sampleStack && controlStack) {
|
||||
// This extracts the first frame from the sample that isn't also in the control.
|
||||
// Skipping one frame that we assume is the frame that calls the two.
|
||||
var sampleLines = sampleStack.split("\n");
|
||||
var controlLines = controlStack.split("\n");
|
||||
var s = 0;
|
||||
var c = 0;
|
||||
|
||||
while (
|
||||
s < sampleLines.length &&
|
||||
!sampleLines[s].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
s++;
|
||||
}
|
||||
|
||||
while (
|
||||
c < controlLines.length &&
|
||||
!controlLines[c].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
c++;
|
||||
} // We couldn't find our intentionally injected common root frame, attempt
|
||||
// to find another common root frame by search from the bottom of the
|
||||
// control stack...
|
||||
|
||||
if (s === sampleLines.length || c === controlLines.length) {
|
||||
s = sampleLines.length - 1;
|
||||
c = controlLines.length - 1;
|
||||
|
||||
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
|
||||
// We expect at least one stack frame to be shared.
|
||||
// Typically this will be the root most one. However, stack frames may be
|
||||
// cut off due to maximum stack limits. In this case, one maybe cut off
|
||||
// earlier than the other. We assume that the sample is longer or the same
|
||||
// and there for cut off earlier. So we should find the root most frame in
|
||||
// the sample somewhere in the control.
|
||||
c--;
|
||||
}
|
||||
}
|
||||
|
||||
for (; s >= 1 && c >= 0; s--, c--) {
|
||||
// Next we find the first one that isn't the same which should be the
|
||||
// frame that called our sample function and the control.
|
||||
if (sampleLines[s] !== controlLines[c]) {
|
||||
// In V8, the first line is describing the message but other VMs don't.
|
||||
// If we're about to return the first line, and the control is also on the same
|
||||
// line, that's a pretty good indicator that our sample threw at same line as
|
||||
// the control. I.e. before we entered the sample frame. So we ignore this result.
|
||||
// This can happen if you passed a class to function component, or non-function.
|
||||
if (s !== 1 || c !== 1) {
|
||||
do {
|
||||
s--;
|
||||
c--; // We may still have similar intermediate frames from the construct call.
|
||||
// The next one that isn't the same should be our match though.
|
||||
|
||||
if (c < 0 || sampleLines[s] !== controlLines[c]) {
|
||||
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
|
||||
var _frame =
|
||||
"\n" + sampleLines[s].replace(" at new ", " at "); // If our component frame is labeled "<anonymous>"
|
||||
// but we have a user-provided "displayName"
|
||||
// splice it in to make the stack more readable.
|
||||
|
||||
if (fn.displayName && _frame.includes("<anonymous>")) {
|
||||
_frame = _frame.replace("<anonymous>", fn.displayName);
|
||||
}
|
||||
|
||||
if (true) {
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, _frame);
|
||||
}
|
||||
} // Return the line we found.
|
||||
|
||||
return _frame;
|
||||
}
|
||||
} while (s >= 1 && c >= 0);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
reentry = false;
|
||||
|
||||
{
|
||||
ReactCurrentDispatcher$2.current = previousDispatcher;
|
||||
reenableLogs();
|
||||
}
|
||||
|
||||
Error.prepareStackTrace = previousPrepareStackTrace;
|
||||
} // Fallback to just using the name if we couldn't make it throw.
|
||||
|
||||
var name = fn ? fn.displayName || fn.name : "";
|
||||
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
|
||||
|
||||
{
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, syntheticFrame);
|
||||
}
|
||||
}
|
||||
|
||||
return syntheticFrame;
|
||||
}
|
||||
|
||||
function describeClassComponentFrame(ctor, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(ctor, true);
|
||||
}
|
||||
}
|
||||
function describeFunctionComponentFrame(fn, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(fn, false);
|
||||
}
|
||||
}
|
||||
|
||||
function shouldConstruct$1(Component) {
|
||||
var prototype = Component.prototype;
|
||||
return !!(prototype && prototype.isReactComponent);
|
||||
}
|
||||
|
||||
function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
|
||||
if (type == null) {
|
||||
return "";
|
||||
}
|
||||
|
||||
if (typeof type === "function") {
|
||||
{
|
||||
return describeNativeComponentFrame(type, shouldConstruct$1(type));
|
||||
}
|
||||
}
|
||||
|
||||
if (typeof type === "string") {
|
||||
return describeBuiltInComponentFrame(type);
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return describeBuiltInComponentFrame("Suspense");
|
||||
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return describeBuiltInComponentFrame("SuspenseList");
|
||||
}
|
||||
|
||||
if (typeof type === "object") {
|
||||
switch (type.$$typeof) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
return describeFunctionComponentFrame(type.render);
|
||||
|
||||
case REACT_MEMO_TYPE:
|
||||
// Memo may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(type.type, ownerFn);
|
||||
|
||||
case REACT_LAZY_TYPE: {
|
||||
var lazyComponent = type;
|
||||
var payload = lazyComponent._payload;
|
||||
var init = lazyComponent._init;
|
||||
|
||||
try {
|
||||
// Lazy may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(
|
||||
init(payload),
|
||||
ownerFn
|
||||
);
|
||||
} catch (x) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
// $FlowFixMe[method-unbinding]
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs equality by iterating through keys on an object and returning false
|
||||
* when any key has values which are not strictly equal between the arguments.
|
||||
|
||||
@@ -827,151 +827,7 @@ function shouldSetTextContent(type, props) {
|
||||
"string" === typeof props.children || "number" === typeof props.children
|
||||
);
|
||||
}
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name) {
|
||||
if (void 0 === prefix)
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
var reentry = !1;
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
if (!fn || reentry) return "";
|
||||
reentry = !0;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace;
|
||||
Error.prepareStackTrace = void 0;
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
try {
|
||||
if (construct) {
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
};
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
if ("object" === typeof Reflect && Reflect.construct) {
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
var control = x;
|
||||
}
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x$10) {
|
||||
control = x$10;
|
||||
}
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x$11) {
|
||||
control = x$11;
|
||||
}
|
||||
(Fake = fn()) &&
|
||||
"function" === typeof Fake.catch &&
|
||||
Fake.catch(function () {});
|
||||
}
|
||||
} catch (sample) {
|
||||
if (sample && control && "string" === typeof sample.stack)
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
return [null, null];
|
||||
}
|
||||
};
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
);
|
||||
namePropDescriptor &&
|
||||
namePropDescriptor.configurable &&
|
||||
Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, "name", {
|
||||
value: "DetermineComponentFrameRoot"
|
||||
});
|
||||
try {
|
||||
var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
if (sampleStack && controlStack) {
|
||||
var sampleLines = sampleStack.split("\n"),
|
||||
controlLines = controlStack.split("\n");
|
||||
for (
|
||||
namePropDescriptor = RunInRootFrame = 0;
|
||||
RunInRootFrame < sampleLines.length &&
|
||||
!sampleLines[RunInRootFrame].includes("DetermineComponentFrameRoot");
|
||||
|
||||
)
|
||||
RunInRootFrame++;
|
||||
for (
|
||||
;
|
||||
namePropDescriptor < controlLines.length &&
|
||||
!controlLines[namePropDescriptor].includes(
|
||||
"DetermineComponentFrameRoot"
|
||||
);
|
||||
|
||||
)
|
||||
namePropDescriptor++;
|
||||
if (
|
||||
RunInRootFrame === sampleLines.length ||
|
||||
namePropDescriptor === controlLines.length
|
||||
)
|
||||
for (
|
||||
RunInRootFrame = sampleLines.length - 1,
|
||||
namePropDescriptor = controlLines.length - 1;
|
||||
1 <= RunInRootFrame &&
|
||||
0 <= namePropDescriptor &&
|
||||
sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor];
|
||||
|
||||
)
|
||||
namePropDescriptor--;
|
||||
for (
|
||||
;
|
||||
1 <= RunInRootFrame && 0 <= namePropDescriptor;
|
||||
RunInRootFrame--, namePropDescriptor--
|
||||
)
|
||||
if (sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
|
||||
if (1 !== RunInRootFrame || 1 !== namePropDescriptor) {
|
||||
do
|
||||
if (
|
||||
(RunInRootFrame--,
|
||||
namePropDescriptor--,
|
||||
0 > namePropDescriptor ||
|
||||
sampleLines[RunInRootFrame] !==
|
||||
controlLines[namePropDescriptor])
|
||||
) {
|
||||
var frame =
|
||||
"\n" +
|
||||
sampleLines[RunInRootFrame].replace(" at new ", " at ");
|
||||
fn.displayName &&
|
||||
frame.includes("<anonymous>") &&
|
||||
(frame = frame.replace("<anonymous>", fn.displayName));
|
||||
return frame;
|
||||
}
|
||||
while (1 <= RunInRootFrame && 0 <= namePropDescriptor);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
(reentry = !1), (Error.prepareStackTrace = previousPrepareStackTrace);
|
||||
}
|
||||
return (previousPrepareStackTrace = fn ? fn.displayName || fn.name : "")
|
||||
? describeBuiltInComponentFrame(previousPrepareStackTrace)
|
||||
: "";
|
||||
}
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty,
|
||||
valueStack = [],
|
||||
var valueStack = [],
|
||||
index = -1;
|
||||
function createCursor(defaultValue) {
|
||||
return { current: defaultValue };
|
||||
@@ -1210,35 +1066,35 @@ function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
|
||||
var didPerformSomeWork = !1;
|
||||
for (var root = firstScheduledRoot; null !== root; ) {
|
||||
if (!onlyLegacy || 0 === root.tag) {
|
||||
var workInProgressRootRenderLanes$13 = workInProgressRootRenderLanes,
|
||||
var workInProgressRootRenderLanes$11 = workInProgressRootRenderLanes,
|
||||
nextLanes = getNextLanes(
|
||||
root,
|
||||
root === workInProgressRoot ? workInProgressRootRenderLanes$13 : 0
|
||||
root === workInProgressRoot ? workInProgressRootRenderLanes$11 : 0
|
||||
);
|
||||
if (0 !== (nextLanes & 3))
|
||||
try {
|
||||
didPerformSomeWork = !0;
|
||||
workInProgressRootRenderLanes$13 = root;
|
||||
workInProgressRootRenderLanes$11 = root;
|
||||
if (0 !== (executionContext & 6))
|
||||
throw Error(formatProdErrorMessage(327));
|
||||
if (!flushPassiveEffects()) {
|
||||
var exitStatus = renderRootSync(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
nextLanes
|
||||
);
|
||||
if (
|
||||
0 !== workInProgressRootRenderLanes$13.tag &&
|
||||
0 !== workInProgressRootRenderLanes$11.tag &&
|
||||
2 === exitStatus
|
||||
) {
|
||||
var originallyAttemptedLanes = nextLanes,
|
||||
errorRetryLanes = getLanesToRetrySynchronouslyOnError(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
originallyAttemptedLanes
|
||||
);
|
||||
0 !== errorRetryLanes &&
|
||||
((nextLanes = errorRetryLanes),
|
||||
(exitStatus = recoverFromConcurrentError(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
originallyAttemptedLanes,
|
||||
errorRetryLanes
|
||||
)));
|
||||
@@ -1246,34 +1102,34 @@ function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
|
||||
if (1 === exitStatus)
|
||||
throw (
|
||||
((originallyAttemptedLanes = workInProgressRootFatalError),
|
||||
prepareFreshStack(workInProgressRootRenderLanes$13, 0),
|
||||
prepareFreshStack(workInProgressRootRenderLanes$11, 0),
|
||||
markRootSuspended(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
nextLanes,
|
||||
0
|
||||
),
|
||||
ensureRootIsScheduled(workInProgressRootRenderLanes$13),
|
||||
ensureRootIsScheduled(workInProgressRootRenderLanes$11),
|
||||
originallyAttemptedLanes)
|
||||
);
|
||||
6 === exitStatus
|
||||
? markRootSuspended(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
nextLanes,
|
||||
workInProgressDeferredLane
|
||||
)
|
||||
: ((workInProgressRootRenderLanes$13.finishedWork =
|
||||
workInProgressRootRenderLanes$13.current.alternate),
|
||||
(workInProgressRootRenderLanes$13.finishedLanes =
|
||||
: ((workInProgressRootRenderLanes$11.finishedWork =
|
||||
workInProgressRootRenderLanes$11.current.alternate),
|
||||
(workInProgressRootRenderLanes$11.finishedLanes =
|
||||
nextLanes),
|
||||
commitRoot(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
workInProgressRootRecoverableErrors,
|
||||
workInProgressTransitions,
|
||||
workInProgressRootDidIncludeRecursiveRenderUpdate,
|
||||
workInProgressDeferredLane
|
||||
));
|
||||
}
|
||||
ensureRootIsScheduled(workInProgressRootRenderLanes$13);
|
||||
ensureRootIsScheduled(workInProgressRootRenderLanes$11);
|
||||
} catch (error) {
|
||||
null === errors ? (errors = [error]) : errors.push(error);
|
||||
}
|
||||
@@ -1700,6 +1556,150 @@ function commitCallbacks(updateQueue, context) {
|
||||
)
|
||||
callCallback(callbacks[updateQueue], context);
|
||||
}
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name) {
|
||||
if (void 0 === prefix)
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
var reentry = !1;
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
if (!fn || reentry) return "";
|
||||
reentry = !0;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace;
|
||||
Error.prepareStackTrace = void 0;
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
try {
|
||||
if (construct) {
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
};
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
if ("object" === typeof Reflect && Reflect.construct) {
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
var control = x;
|
||||
}
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x$17) {
|
||||
control = x$17;
|
||||
}
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x$18) {
|
||||
control = x$18;
|
||||
}
|
||||
(Fake = fn()) &&
|
||||
"function" === typeof Fake.catch &&
|
||||
Fake.catch(function () {});
|
||||
}
|
||||
} catch (sample) {
|
||||
if (sample && control && "string" === typeof sample.stack)
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
return [null, null];
|
||||
}
|
||||
};
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
);
|
||||
namePropDescriptor &&
|
||||
namePropDescriptor.configurable &&
|
||||
Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, "name", {
|
||||
value: "DetermineComponentFrameRoot"
|
||||
});
|
||||
try {
|
||||
var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
if (sampleStack && controlStack) {
|
||||
var sampleLines = sampleStack.split("\n"),
|
||||
controlLines = controlStack.split("\n");
|
||||
for (
|
||||
namePropDescriptor = RunInRootFrame = 0;
|
||||
RunInRootFrame < sampleLines.length &&
|
||||
!sampleLines[RunInRootFrame].includes("DetermineComponentFrameRoot");
|
||||
|
||||
)
|
||||
RunInRootFrame++;
|
||||
for (
|
||||
;
|
||||
namePropDescriptor < controlLines.length &&
|
||||
!controlLines[namePropDescriptor].includes(
|
||||
"DetermineComponentFrameRoot"
|
||||
);
|
||||
|
||||
)
|
||||
namePropDescriptor++;
|
||||
if (
|
||||
RunInRootFrame === sampleLines.length ||
|
||||
namePropDescriptor === controlLines.length
|
||||
)
|
||||
for (
|
||||
RunInRootFrame = sampleLines.length - 1,
|
||||
namePropDescriptor = controlLines.length - 1;
|
||||
1 <= RunInRootFrame &&
|
||||
0 <= namePropDescriptor &&
|
||||
sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor];
|
||||
|
||||
)
|
||||
namePropDescriptor--;
|
||||
for (
|
||||
;
|
||||
1 <= RunInRootFrame && 0 <= namePropDescriptor;
|
||||
RunInRootFrame--, namePropDescriptor--
|
||||
)
|
||||
if (sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
|
||||
if (1 !== RunInRootFrame || 1 !== namePropDescriptor) {
|
||||
do
|
||||
if (
|
||||
(RunInRootFrame--,
|
||||
namePropDescriptor--,
|
||||
0 > namePropDescriptor ||
|
||||
sampleLines[RunInRootFrame] !==
|
||||
controlLines[namePropDescriptor])
|
||||
) {
|
||||
var frame =
|
||||
"\n" +
|
||||
sampleLines[RunInRootFrame].replace(" at new ", " at ");
|
||||
fn.displayName &&
|
||||
frame.includes("<anonymous>") &&
|
||||
(frame = frame.replace("<anonymous>", fn.displayName));
|
||||
return frame;
|
||||
}
|
||||
while (1 <= RunInRootFrame && 0 <= namePropDescriptor);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
(reentry = !1), (Error.prepareStackTrace = previousPrepareStackTrace);
|
||||
}
|
||||
return (previousPrepareStackTrace = fn ? fn.displayName || fn.name : "")
|
||||
? describeBuiltInComponentFrame(previousPrepareStackTrace)
|
||||
: "";
|
||||
}
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
function shallowEqual(objA, objB) {
|
||||
if (objectIs(objA, objB)) return !0;
|
||||
if (
|
||||
@@ -10587,7 +10587,7 @@ var slice = Array.prototype.slice,
|
||||
return null;
|
||||
},
|
||||
bundleType: 0,
|
||||
version: "18.3.0-www-classic-467be9af",
|
||||
version: "18.3.0-www-classic-82c2613b",
|
||||
rendererPackageName: "react-art"
|
||||
};
|
||||
var internals$jscomp$inline_1323 = {
|
||||
@@ -10618,7 +10618,7 @@ var internals$jscomp$inline_1323 = {
|
||||
scheduleRoot: null,
|
||||
setRefreshHandler: null,
|
||||
getCurrentFiber: null,
|
||||
reconcilerVersion: "18.3.0-www-classic-467be9af"
|
||||
reconcilerVersion: "18.3.0-www-classic-82c2613b"
|
||||
};
|
||||
if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
|
||||
var hook$jscomp$inline_1324 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
|
||||
|
||||
@@ -701,151 +701,7 @@ function shouldSetTextContent(type, props) {
|
||||
"string" === typeof props.children || "number" === typeof props.children
|
||||
);
|
||||
}
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name) {
|
||||
if (void 0 === prefix)
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
var reentry = !1;
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
if (!fn || reentry) return "";
|
||||
reentry = !0;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace;
|
||||
Error.prepareStackTrace = void 0;
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
try {
|
||||
if (construct) {
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
};
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
if ("object" === typeof Reflect && Reflect.construct) {
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
var control = x;
|
||||
}
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x$10) {
|
||||
control = x$10;
|
||||
}
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x$11) {
|
||||
control = x$11;
|
||||
}
|
||||
(Fake = fn()) &&
|
||||
"function" === typeof Fake.catch &&
|
||||
Fake.catch(function () {});
|
||||
}
|
||||
} catch (sample) {
|
||||
if (sample && control && "string" === typeof sample.stack)
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
return [null, null];
|
||||
}
|
||||
};
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
);
|
||||
namePropDescriptor &&
|
||||
namePropDescriptor.configurable &&
|
||||
Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, "name", {
|
||||
value: "DetermineComponentFrameRoot"
|
||||
});
|
||||
try {
|
||||
var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
if (sampleStack && controlStack) {
|
||||
var sampleLines = sampleStack.split("\n"),
|
||||
controlLines = controlStack.split("\n");
|
||||
for (
|
||||
namePropDescriptor = RunInRootFrame = 0;
|
||||
RunInRootFrame < sampleLines.length &&
|
||||
!sampleLines[RunInRootFrame].includes("DetermineComponentFrameRoot");
|
||||
|
||||
)
|
||||
RunInRootFrame++;
|
||||
for (
|
||||
;
|
||||
namePropDescriptor < controlLines.length &&
|
||||
!controlLines[namePropDescriptor].includes(
|
||||
"DetermineComponentFrameRoot"
|
||||
);
|
||||
|
||||
)
|
||||
namePropDescriptor++;
|
||||
if (
|
||||
RunInRootFrame === sampleLines.length ||
|
||||
namePropDescriptor === controlLines.length
|
||||
)
|
||||
for (
|
||||
RunInRootFrame = sampleLines.length - 1,
|
||||
namePropDescriptor = controlLines.length - 1;
|
||||
1 <= RunInRootFrame &&
|
||||
0 <= namePropDescriptor &&
|
||||
sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor];
|
||||
|
||||
)
|
||||
namePropDescriptor--;
|
||||
for (
|
||||
;
|
||||
1 <= RunInRootFrame && 0 <= namePropDescriptor;
|
||||
RunInRootFrame--, namePropDescriptor--
|
||||
)
|
||||
if (sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
|
||||
if (1 !== RunInRootFrame || 1 !== namePropDescriptor) {
|
||||
do
|
||||
if (
|
||||
(RunInRootFrame--,
|
||||
namePropDescriptor--,
|
||||
0 > namePropDescriptor ||
|
||||
sampleLines[RunInRootFrame] !==
|
||||
controlLines[namePropDescriptor])
|
||||
) {
|
||||
var frame =
|
||||
"\n" +
|
||||
sampleLines[RunInRootFrame].replace(" at new ", " at ");
|
||||
fn.displayName &&
|
||||
frame.includes("<anonymous>") &&
|
||||
(frame = frame.replace("<anonymous>", fn.displayName));
|
||||
return frame;
|
||||
}
|
||||
while (1 <= RunInRootFrame && 0 <= namePropDescriptor);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
(reentry = !1), (Error.prepareStackTrace = previousPrepareStackTrace);
|
||||
}
|
||||
return (previousPrepareStackTrace = fn ? fn.displayName || fn.name : "")
|
||||
? describeBuiltInComponentFrame(previousPrepareStackTrace)
|
||||
: "";
|
||||
}
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty,
|
||||
valueStack = [],
|
||||
var valueStack = [],
|
||||
index = -1;
|
||||
function createCursor(defaultValue) {
|
||||
return { current: defaultValue };
|
||||
@@ -1006,35 +862,35 @@ function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
|
||||
var didPerformSomeWork = !1;
|
||||
for (var root = firstScheduledRoot; null !== root; ) {
|
||||
if (!onlyLegacy || 0 === root.tag) {
|
||||
var workInProgressRootRenderLanes$13 = workInProgressRootRenderLanes,
|
||||
var workInProgressRootRenderLanes$11 = workInProgressRootRenderLanes,
|
||||
nextLanes = getNextLanes(
|
||||
root,
|
||||
root === workInProgressRoot ? workInProgressRootRenderLanes$13 : 0
|
||||
root === workInProgressRoot ? workInProgressRootRenderLanes$11 : 0
|
||||
);
|
||||
if (0 !== (nextLanes & 3))
|
||||
try {
|
||||
didPerformSomeWork = !0;
|
||||
workInProgressRootRenderLanes$13 = root;
|
||||
workInProgressRootRenderLanes$11 = root;
|
||||
if (0 !== (executionContext & 6))
|
||||
throw Error(formatProdErrorMessage(327));
|
||||
if (!flushPassiveEffects()) {
|
||||
var exitStatus = renderRootSync(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
nextLanes
|
||||
);
|
||||
if (
|
||||
0 !== workInProgressRootRenderLanes$13.tag &&
|
||||
0 !== workInProgressRootRenderLanes$11.tag &&
|
||||
2 === exitStatus
|
||||
) {
|
||||
var originallyAttemptedLanes = nextLanes,
|
||||
errorRetryLanes = getLanesToRetrySynchronouslyOnError(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
originallyAttemptedLanes
|
||||
);
|
||||
0 !== errorRetryLanes &&
|
||||
((nextLanes = errorRetryLanes),
|
||||
(exitStatus = recoverFromConcurrentError(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
originallyAttemptedLanes,
|
||||
errorRetryLanes
|
||||
)));
|
||||
@@ -1042,34 +898,34 @@ function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
|
||||
if (1 === exitStatus)
|
||||
throw (
|
||||
((originallyAttemptedLanes = workInProgressRootFatalError),
|
||||
prepareFreshStack(workInProgressRootRenderLanes$13, 0),
|
||||
prepareFreshStack(workInProgressRootRenderLanes$11, 0),
|
||||
markRootSuspended(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
nextLanes,
|
||||
0
|
||||
),
|
||||
ensureRootIsScheduled(workInProgressRootRenderLanes$13),
|
||||
ensureRootIsScheduled(workInProgressRootRenderLanes$11),
|
||||
originallyAttemptedLanes)
|
||||
);
|
||||
6 === exitStatus
|
||||
? markRootSuspended(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
nextLanes,
|
||||
workInProgressDeferredLane
|
||||
)
|
||||
: ((workInProgressRootRenderLanes$13.finishedWork =
|
||||
workInProgressRootRenderLanes$13.current.alternate),
|
||||
(workInProgressRootRenderLanes$13.finishedLanes =
|
||||
: ((workInProgressRootRenderLanes$11.finishedWork =
|
||||
workInProgressRootRenderLanes$11.current.alternate),
|
||||
(workInProgressRootRenderLanes$11.finishedLanes =
|
||||
nextLanes),
|
||||
commitRoot(
|
||||
workInProgressRootRenderLanes$13,
|
||||
workInProgressRootRenderLanes$11,
|
||||
workInProgressRootRecoverableErrors,
|
||||
workInProgressTransitions,
|
||||
workInProgressRootDidIncludeRecursiveRenderUpdate,
|
||||
workInProgressDeferredLane
|
||||
));
|
||||
}
|
||||
ensureRootIsScheduled(workInProgressRootRenderLanes$13);
|
||||
ensureRootIsScheduled(workInProgressRootRenderLanes$11);
|
||||
} catch (error) {
|
||||
null === errors ? (errors = [error]) : errors.push(error);
|
||||
}
|
||||
@@ -1496,6 +1352,150 @@ function commitCallbacks(updateQueue, context) {
|
||||
)
|
||||
callCallback(callbacks[updateQueue], context);
|
||||
}
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name) {
|
||||
if (void 0 === prefix)
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
var reentry = !1;
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
if (!fn || reentry) return "";
|
||||
reentry = !0;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace;
|
||||
Error.prepareStackTrace = void 0;
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
try {
|
||||
if (construct) {
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
};
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
if ("object" === typeof Reflect && Reflect.construct) {
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
var control = x;
|
||||
}
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x$17) {
|
||||
control = x$17;
|
||||
}
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x$18) {
|
||||
control = x$18;
|
||||
}
|
||||
(Fake = fn()) &&
|
||||
"function" === typeof Fake.catch &&
|
||||
Fake.catch(function () {});
|
||||
}
|
||||
} catch (sample) {
|
||||
if (sample && control && "string" === typeof sample.stack)
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
return [null, null];
|
||||
}
|
||||
};
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
);
|
||||
namePropDescriptor &&
|
||||
namePropDescriptor.configurable &&
|
||||
Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, "name", {
|
||||
value: "DetermineComponentFrameRoot"
|
||||
});
|
||||
try {
|
||||
var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
if (sampleStack && controlStack) {
|
||||
var sampleLines = sampleStack.split("\n"),
|
||||
controlLines = controlStack.split("\n");
|
||||
for (
|
||||
namePropDescriptor = RunInRootFrame = 0;
|
||||
RunInRootFrame < sampleLines.length &&
|
||||
!sampleLines[RunInRootFrame].includes("DetermineComponentFrameRoot");
|
||||
|
||||
)
|
||||
RunInRootFrame++;
|
||||
for (
|
||||
;
|
||||
namePropDescriptor < controlLines.length &&
|
||||
!controlLines[namePropDescriptor].includes(
|
||||
"DetermineComponentFrameRoot"
|
||||
);
|
||||
|
||||
)
|
||||
namePropDescriptor++;
|
||||
if (
|
||||
RunInRootFrame === sampleLines.length ||
|
||||
namePropDescriptor === controlLines.length
|
||||
)
|
||||
for (
|
||||
RunInRootFrame = sampleLines.length - 1,
|
||||
namePropDescriptor = controlLines.length - 1;
|
||||
1 <= RunInRootFrame &&
|
||||
0 <= namePropDescriptor &&
|
||||
sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor];
|
||||
|
||||
)
|
||||
namePropDescriptor--;
|
||||
for (
|
||||
;
|
||||
1 <= RunInRootFrame && 0 <= namePropDescriptor;
|
||||
RunInRootFrame--, namePropDescriptor--
|
||||
)
|
||||
if (sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
|
||||
if (1 !== RunInRootFrame || 1 !== namePropDescriptor) {
|
||||
do
|
||||
if (
|
||||
(RunInRootFrame--,
|
||||
namePropDescriptor--,
|
||||
0 > namePropDescriptor ||
|
||||
sampleLines[RunInRootFrame] !==
|
||||
controlLines[namePropDescriptor])
|
||||
) {
|
||||
var frame =
|
||||
"\n" +
|
||||
sampleLines[RunInRootFrame].replace(" at new ", " at ");
|
||||
fn.displayName &&
|
||||
frame.includes("<anonymous>") &&
|
||||
(frame = frame.replace("<anonymous>", fn.displayName));
|
||||
return frame;
|
||||
}
|
||||
while (1 <= RunInRootFrame && 0 <= namePropDescriptor);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
(reentry = !1), (Error.prepareStackTrace = previousPrepareStackTrace);
|
||||
}
|
||||
return (previousPrepareStackTrace = fn ? fn.displayName || fn.name : "")
|
||||
? describeBuiltInComponentFrame(previousPrepareStackTrace)
|
||||
: "";
|
||||
}
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
function shallowEqual(objA, objB) {
|
||||
if (objectIs(objA, objB)) return !0;
|
||||
if (
|
||||
@@ -10242,7 +10242,7 @@ var slice = Array.prototype.slice,
|
||||
return null;
|
||||
},
|
||||
bundleType: 0,
|
||||
version: "18.3.0-www-modern-c2fc2707",
|
||||
version: "18.3.0-www-modern-95350842",
|
||||
rendererPackageName: "react-art"
|
||||
};
|
||||
var internals$jscomp$inline_1303 = {
|
||||
@@ -10273,7 +10273,7 @@ var internals$jscomp$inline_1303 = {
|
||||
scheduleRoot: null,
|
||||
setRefreshHandler: null,
|
||||
getCurrentFiber: null,
|
||||
reconcilerVersion: "18.3.0-www-modern-c2fc2707"
|
||||
reconcilerVersion: "18.3.0-www-modern-95350842"
|
||||
};
|
||||
if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
|
||||
var hook$jscomp$inline_1304 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
|
||||
|
||||
@@ -7448,111 +7448,6 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var warnedAboutMissingGetChildContext;
|
||||
|
||||
{
|
||||
@@ -7624,11 +7519,6 @@ if (__DEV__) {
|
||||
|
||||
for (var key in contextTypes) {
|
||||
context[key] = unmaskedContext[key];
|
||||
}
|
||||
|
||||
{
|
||||
var name = getComponentNameFromFiber(workInProgress) || "Unknown";
|
||||
checkPropTypes(contextTypes, context, "context", name);
|
||||
} // Cache unmasked context so we can avoid recreating masked context unless necessary.
|
||||
// Context is created before the class component is instantiated so check for instance.
|
||||
|
||||
@@ -7720,16 +7610,6 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
var name = getComponentNameFromFiber(fiber) || "Unknown";
|
||||
checkPropTypes(
|
||||
childContextTypes,
|
||||
childContext,
|
||||
"child context",
|
||||
name
|
||||
);
|
||||
}
|
||||
|
||||
return assign({}, parentContext, childContext);
|
||||
}
|
||||
}
|
||||
@@ -10418,6 +10298,111 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs equality by iterating through keys on an object and returning false
|
||||
* when any key has values which are not strictly equal between the arguments.
|
||||
@@ -36032,7 +36017,7 @@ if (__DEV__) {
|
||||
return root;
|
||||
}
|
||||
|
||||
var ReactVersion = "18.3.0-www-classic-a49769f2";
|
||||
var ReactVersion = "18.3.0-www-classic-fb240cfb";
|
||||
|
||||
function createPortal$1(
|
||||
children,
|
||||
|
||||
@@ -7631,111 +7631,6 @@ if (__DEV__) {
|
||||
return false;
|
||||
}
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var emptyContextObject = {};
|
||||
|
||||
{
|
||||
@@ -10354,6 +10249,111 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs equality by iterating through keys on an object and returning false
|
||||
* when any key has values which are not strictly equal between the arguments.
|
||||
@@ -35853,7 +35853,7 @@ if (__DEV__) {
|
||||
return root;
|
||||
}
|
||||
|
||||
var ReactVersion = "18.3.0-www-modern-673db17c";
|
||||
var ReactVersion = "18.3.0-www-modern-b0d7b4a2";
|
||||
|
||||
function createPortal$1(
|
||||
children,
|
||||
|
||||
@@ -17453,7 +17453,7 @@ Internals.Events = [
|
||||
var devToolsConfig$jscomp$inline_1869 = {
|
||||
findFiberByHostInstance: getClosestInstanceFromNode,
|
||||
bundleType: 0,
|
||||
version: "18.3.0-www-modern-57608326",
|
||||
version: "18.3.0-www-modern-f7b80cf4",
|
||||
rendererPackageName: "react-dom"
|
||||
};
|
||||
(function (internals) {
|
||||
@@ -17498,7 +17498,7 @@ var devToolsConfig$jscomp$inline_1869 = {
|
||||
scheduleRoot: null,
|
||||
setRefreshHandler: null,
|
||||
getCurrentFiber: null,
|
||||
reconcilerVersion: "18.3.0-www-modern-57608326"
|
||||
reconcilerVersion: "18.3.0-www-modern-f7b80cf4"
|
||||
});
|
||||
exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
|
||||
exports.createPortal = function (children, container) {
|
||||
@@ -17756,7 +17756,7 @@ exports.useFormState = function (action, initialState, permalink) {
|
||||
exports.useFormStatus = function () {
|
||||
return ReactCurrentDispatcher$2.current.useHostTransitionStatus();
|
||||
};
|
||||
exports.version = "18.3.0-www-modern-57608326";
|
||||
exports.version = "18.3.0-www-modern-f7b80cf4";
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
|
||||
"function" ===
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
|
||||
|
||||
@@ -7585,111 +7585,6 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var warnedAboutMissingGetChildContext;
|
||||
|
||||
{
|
||||
@@ -7761,11 +7656,6 @@ if (__DEV__) {
|
||||
|
||||
for (var key in contextTypes) {
|
||||
context[key] = unmaskedContext[key];
|
||||
}
|
||||
|
||||
{
|
||||
var name = getComponentNameFromFiber(workInProgress) || "Unknown";
|
||||
checkPropTypes(contextTypes, context, "context", name);
|
||||
} // Cache unmasked context so we can avoid recreating masked context unless necessary.
|
||||
// Context is created before the class component is instantiated so check for instance.
|
||||
|
||||
@@ -7857,16 +7747,6 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
var name = getComponentNameFromFiber(fiber) || "Unknown";
|
||||
checkPropTypes(
|
||||
childContextTypes,
|
||||
childContext,
|
||||
"child context",
|
||||
name
|
||||
);
|
||||
}
|
||||
|
||||
return assign({}, parentContext, childContext);
|
||||
}
|
||||
}
|
||||
@@ -10555,6 +10435,111 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs equality by iterating through keys on an object and returning false
|
||||
* when any key has values which are not strictly equal between the arguments.
|
||||
@@ -36656,7 +36641,7 @@ if (__DEV__) {
|
||||
return root;
|
||||
}
|
||||
|
||||
var ReactVersion = "18.3.0-www-classic-a886996f";
|
||||
var ReactVersion = "18.3.0-www-classic-e7aae6cc";
|
||||
|
||||
function createPortal$1(
|
||||
children,
|
||||
|
||||
@@ -7768,111 +7768,6 @@ if (__DEV__) {
|
||||
return false;
|
||||
}
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var emptyContextObject = {};
|
||||
|
||||
{
|
||||
@@ -10491,6 +10386,111 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs equality by iterating through keys on an object and returning false
|
||||
* when any key has values which are not strictly equal between the arguments.
|
||||
@@ -36477,7 +36477,7 @@ if (__DEV__) {
|
||||
return root;
|
||||
}
|
||||
|
||||
var ReactVersion = "18.3.0-www-modern-5da31c9b";
|
||||
var ReactVersion = "18.3.0-www-modern-6eadd94f";
|
||||
|
||||
function createPortal$1(
|
||||
children,
|
||||
|
||||
@@ -2219,453 +2219,6 @@ if (__DEV__) {
|
||||
}
|
||||
var NotPendingTransition = null;
|
||||
|
||||
var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher;
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name, ownerFn) {
|
||||
{
|
||||
if (prefix === undefined) {
|
||||
// Extract the VM specific prefix used by each line.
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
} // We use the prefix to ensure our stacks line up with native stack frames.
|
||||
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
}
|
||||
var reentry = false;
|
||||
var componentFrameCache;
|
||||
|
||||
{
|
||||
var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map;
|
||||
componentFrameCache = new PossiblyWeakMap$1();
|
||||
}
|
||||
/**
|
||||
* Leverages native browser/VM stack frames to get proper details (e.g.
|
||||
* filename, line + col number) for a single component in a component stack. We
|
||||
* do this by:
|
||||
* (1) throwing and catching an error in the function - this will be our
|
||||
* control error.
|
||||
* (2) calling the component which will eventually throw an error that we'll
|
||||
* catch - this will be our sample error.
|
||||
* (3) diffing the control and sample error stacks to find the stack frame
|
||||
* which represents our component.
|
||||
*/
|
||||
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
// If something asked for a stack inside a fake render, it should get ignored.
|
||||
if (!fn || reentry) {
|
||||
return "";
|
||||
}
|
||||
|
||||
{
|
||||
var frame = componentFrameCache.get(fn);
|
||||
|
||||
if (frame !== undefined) {
|
||||
return frame;
|
||||
}
|
||||
}
|
||||
|
||||
reentry = true;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
|
||||
|
||||
Error.prepareStackTrace = undefined;
|
||||
var previousDispatcher;
|
||||
|
||||
{
|
||||
previousDispatcher = ReactCurrentDispatcher$2.current; // Set the dispatcher in DEV because this might be call in the render function
|
||||
// for warnings.
|
||||
|
||||
ReactCurrentDispatcher$2.current = null;
|
||||
disableLogs();
|
||||
}
|
||||
/**
|
||||
* Finding a common stack frame between sample and control errors can be
|
||||
* tricky given the different types and levels of stack trace truncation from
|
||||
* different JS VMs. So instead we'll attempt to control what that common
|
||||
* frame should be through this object method:
|
||||
* Having both the sample and control errors be in the function under the
|
||||
* `DescribeNativeComponentFrameRoot` property, + setting the `name` and
|
||||
* `displayName` properties of the function ensures that a stack
|
||||
* frame exists that has the method name `DescribeNativeComponentFrameRoot` in
|
||||
* it for both control and sample stacks.
|
||||
*/
|
||||
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
var control;
|
||||
|
||||
try {
|
||||
// This should throw.
|
||||
if (construct) {
|
||||
// Something should be setting the props in the constructor.
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
// We use a throwing setter instead of frozen or non-writable props
|
||||
// because that won't throw in a non-strict mode function.
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
|
||||
if (typeof Reflect === "object" && Reflect.construct) {
|
||||
// We construct a different control for this case to include any extra
|
||||
// frames added by the construct call.
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
control = x;
|
||||
}
|
||||
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // $FlowFixMe[prop-missing] found when upgrading Flow
|
||||
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // TODO(luna): This will currently only throw if the function component
|
||||
// tries to access React/ReactDOM/props. We should probably make this throw
|
||||
// in simple components too
|
||||
|
||||
var maybePromise = fn(); // If the function component returns a promise, it's likely an async
|
||||
// component, which we don't yet support. Attach a noop catch handler to
|
||||
// silence the error.
|
||||
// TODO: Implement component stacks for async client components?
|
||||
|
||||
if (maybePromise && typeof maybePromise.catch === "function") {
|
||||
maybePromise.catch(function () {});
|
||||
}
|
||||
}
|
||||
} catch (sample) {
|
||||
// This is inlined manually because closure doesn't do it for us.
|
||||
if (sample && control && typeof sample.stack === "string") {
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
}
|
||||
|
||||
return [null, null];
|
||||
}
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
); // Before ES6, the `name` property was not configurable.
|
||||
|
||||
if (namePropDescriptor && namePropDescriptor.configurable) {
|
||||
// V8 utilizes a function's `name` property when generating a stack trace.
|
||||
Object.defineProperty(
|
||||
RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
|
||||
// is set to `false`.
|
||||
// $FlowFixMe[cannot-write]
|
||||
"name",
|
||||
{
|
||||
value: "DetermineComponentFrameRoot"
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
var _RunInRootFrame$Deter =
|
||||
RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
|
||||
if (sampleStack && controlStack) {
|
||||
// This extracts the first frame from the sample that isn't also in the control.
|
||||
// Skipping one frame that we assume is the frame that calls the two.
|
||||
var sampleLines = sampleStack.split("\n");
|
||||
var controlLines = controlStack.split("\n");
|
||||
var s = 0;
|
||||
var c = 0;
|
||||
|
||||
while (
|
||||
s < sampleLines.length &&
|
||||
!sampleLines[s].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
s++;
|
||||
}
|
||||
|
||||
while (
|
||||
c < controlLines.length &&
|
||||
!controlLines[c].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
c++;
|
||||
} // We couldn't find our intentionally injected common root frame, attempt
|
||||
// to find another common root frame by search from the bottom of the
|
||||
// control stack...
|
||||
|
||||
if (s === sampleLines.length || c === controlLines.length) {
|
||||
s = sampleLines.length - 1;
|
||||
c = controlLines.length - 1;
|
||||
|
||||
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
|
||||
// We expect at least one stack frame to be shared.
|
||||
// Typically this will be the root most one. However, stack frames may be
|
||||
// cut off due to maximum stack limits. In this case, one maybe cut off
|
||||
// earlier than the other. We assume that the sample is longer or the same
|
||||
// and there for cut off earlier. So we should find the root most frame in
|
||||
// the sample somewhere in the control.
|
||||
c--;
|
||||
}
|
||||
}
|
||||
|
||||
for (; s >= 1 && c >= 0; s--, c--) {
|
||||
// Next we find the first one that isn't the same which should be the
|
||||
// frame that called our sample function and the control.
|
||||
if (sampleLines[s] !== controlLines[c]) {
|
||||
// In V8, the first line is describing the message but other VMs don't.
|
||||
// If we're about to return the first line, and the control is also on the same
|
||||
// line, that's a pretty good indicator that our sample threw at same line as
|
||||
// the control. I.e. before we entered the sample frame. So we ignore this result.
|
||||
// This can happen if you passed a class to function component, or non-function.
|
||||
if (s !== 1 || c !== 1) {
|
||||
do {
|
||||
s--;
|
||||
c--; // We may still have similar intermediate frames from the construct call.
|
||||
// The next one that isn't the same should be our match though.
|
||||
|
||||
if (c < 0 || sampleLines[s] !== controlLines[c]) {
|
||||
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
|
||||
var _frame =
|
||||
"\n" + sampleLines[s].replace(" at new ", " at "); // If our component frame is labeled "<anonymous>"
|
||||
// but we have a user-provided "displayName"
|
||||
// splice it in to make the stack more readable.
|
||||
|
||||
if (fn.displayName && _frame.includes("<anonymous>")) {
|
||||
_frame = _frame.replace("<anonymous>", fn.displayName);
|
||||
}
|
||||
|
||||
if (true) {
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, _frame);
|
||||
}
|
||||
} // Return the line we found.
|
||||
|
||||
return _frame;
|
||||
}
|
||||
} while (s >= 1 && c >= 0);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
reentry = false;
|
||||
|
||||
{
|
||||
ReactCurrentDispatcher$2.current = previousDispatcher;
|
||||
reenableLogs();
|
||||
}
|
||||
|
||||
Error.prepareStackTrace = previousPrepareStackTrace;
|
||||
} // Fallback to just using the name if we couldn't make it throw.
|
||||
|
||||
var name = fn ? fn.displayName || fn.name : "";
|
||||
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
|
||||
|
||||
{
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, syntheticFrame);
|
||||
}
|
||||
}
|
||||
|
||||
return syntheticFrame;
|
||||
}
|
||||
|
||||
function describeClassComponentFrame(ctor, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(ctor, true);
|
||||
}
|
||||
}
|
||||
function describeFunctionComponentFrame(fn, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(fn, false);
|
||||
}
|
||||
}
|
||||
|
||||
function shouldConstruct$1(Component) {
|
||||
var prototype = Component.prototype;
|
||||
return !!(prototype && prototype.isReactComponent);
|
||||
}
|
||||
|
||||
function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
|
||||
if (type == null) {
|
||||
return "";
|
||||
}
|
||||
|
||||
if (typeof type === "function") {
|
||||
{
|
||||
return describeNativeComponentFrame(type, shouldConstruct$1(type));
|
||||
}
|
||||
}
|
||||
|
||||
if (typeof type === "string") {
|
||||
return describeBuiltInComponentFrame(type);
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return describeBuiltInComponentFrame("Suspense");
|
||||
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return describeBuiltInComponentFrame("SuspenseList");
|
||||
}
|
||||
|
||||
if (typeof type === "object") {
|
||||
switch (type.$$typeof) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
return describeFunctionComponentFrame(type.render);
|
||||
|
||||
case REACT_MEMO_TYPE:
|
||||
// Memo may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(type.type, ownerFn);
|
||||
|
||||
case REACT_LAZY_TYPE: {
|
||||
var lazyComponent = type;
|
||||
var payload = lazyComponent._payload;
|
||||
var init = lazyComponent._init;
|
||||
|
||||
try {
|
||||
// Lazy may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(
|
||||
init(payload),
|
||||
ownerFn
|
||||
);
|
||||
} catch (x) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
// $FlowFixMe[method-unbinding]
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var valueStack = [];
|
||||
var fiberStack;
|
||||
|
||||
@@ -2788,11 +2341,6 @@ if (__DEV__) {
|
||||
|
||||
for (var key in contextTypes) {
|
||||
context[key] = unmaskedContext[key];
|
||||
}
|
||||
|
||||
{
|
||||
var name = getComponentNameFromFiber(workInProgress) || "Unknown";
|
||||
checkPropTypes(contextTypes, context, "context", name);
|
||||
} // Cache unmasked context so we can avoid recreating masked context unless necessary.
|
||||
// Context is created before the class component is instantiated so check for instance.
|
||||
|
||||
@@ -2884,16 +2432,6 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
var name = getComponentNameFromFiber(fiber) || "Unknown";
|
||||
checkPropTypes(
|
||||
childContextTypes,
|
||||
childContext,
|
||||
"child context",
|
||||
name
|
||||
);
|
||||
}
|
||||
|
||||
return assign({}, parentContext, childContext);
|
||||
}
|
||||
}
|
||||
@@ -4531,6 +4069,453 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher;
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name, ownerFn) {
|
||||
{
|
||||
if (prefix === undefined) {
|
||||
// Extract the VM specific prefix used by each line.
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
} // We use the prefix to ensure our stacks line up with native stack frames.
|
||||
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
}
|
||||
var reentry = false;
|
||||
var componentFrameCache;
|
||||
|
||||
{
|
||||
var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map;
|
||||
componentFrameCache = new PossiblyWeakMap$1();
|
||||
}
|
||||
/**
|
||||
* Leverages native browser/VM stack frames to get proper details (e.g.
|
||||
* filename, line + col number) for a single component in a component stack. We
|
||||
* do this by:
|
||||
* (1) throwing and catching an error in the function - this will be our
|
||||
* control error.
|
||||
* (2) calling the component which will eventually throw an error that we'll
|
||||
* catch - this will be our sample error.
|
||||
* (3) diffing the control and sample error stacks to find the stack frame
|
||||
* which represents our component.
|
||||
*/
|
||||
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
// If something asked for a stack inside a fake render, it should get ignored.
|
||||
if (!fn || reentry) {
|
||||
return "";
|
||||
}
|
||||
|
||||
{
|
||||
var frame = componentFrameCache.get(fn);
|
||||
|
||||
if (frame !== undefined) {
|
||||
return frame;
|
||||
}
|
||||
}
|
||||
|
||||
reentry = true;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
|
||||
|
||||
Error.prepareStackTrace = undefined;
|
||||
var previousDispatcher;
|
||||
|
||||
{
|
||||
previousDispatcher = ReactCurrentDispatcher$2.current; // Set the dispatcher in DEV because this might be call in the render function
|
||||
// for warnings.
|
||||
|
||||
ReactCurrentDispatcher$2.current = null;
|
||||
disableLogs();
|
||||
}
|
||||
/**
|
||||
* Finding a common stack frame between sample and control errors can be
|
||||
* tricky given the different types and levels of stack trace truncation from
|
||||
* different JS VMs. So instead we'll attempt to control what that common
|
||||
* frame should be through this object method:
|
||||
* Having both the sample and control errors be in the function under the
|
||||
* `DescribeNativeComponentFrameRoot` property, + setting the `name` and
|
||||
* `displayName` properties of the function ensures that a stack
|
||||
* frame exists that has the method name `DescribeNativeComponentFrameRoot` in
|
||||
* it for both control and sample stacks.
|
||||
*/
|
||||
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
var control;
|
||||
|
||||
try {
|
||||
// This should throw.
|
||||
if (construct) {
|
||||
// Something should be setting the props in the constructor.
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
// We use a throwing setter instead of frozen or non-writable props
|
||||
// because that won't throw in a non-strict mode function.
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
|
||||
if (typeof Reflect === "object" && Reflect.construct) {
|
||||
// We construct a different control for this case to include any extra
|
||||
// frames added by the construct call.
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
control = x;
|
||||
}
|
||||
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // $FlowFixMe[prop-missing] found when upgrading Flow
|
||||
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // TODO(luna): This will currently only throw if the function component
|
||||
// tries to access React/ReactDOM/props. We should probably make this throw
|
||||
// in simple components too
|
||||
|
||||
var maybePromise = fn(); // If the function component returns a promise, it's likely an async
|
||||
// component, which we don't yet support. Attach a noop catch handler to
|
||||
// silence the error.
|
||||
// TODO: Implement component stacks for async client components?
|
||||
|
||||
if (maybePromise && typeof maybePromise.catch === "function") {
|
||||
maybePromise.catch(function () {});
|
||||
}
|
||||
}
|
||||
} catch (sample) {
|
||||
// This is inlined manually because closure doesn't do it for us.
|
||||
if (sample && control && typeof sample.stack === "string") {
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
}
|
||||
|
||||
return [null, null];
|
||||
}
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
); // Before ES6, the `name` property was not configurable.
|
||||
|
||||
if (namePropDescriptor && namePropDescriptor.configurable) {
|
||||
// V8 utilizes a function's `name` property when generating a stack trace.
|
||||
Object.defineProperty(
|
||||
RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
|
||||
// is set to `false`.
|
||||
// $FlowFixMe[cannot-write]
|
||||
"name",
|
||||
{
|
||||
value: "DetermineComponentFrameRoot"
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
var _RunInRootFrame$Deter =
|
||||
RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
|
||||
if (sampleStack && controlStack) {
|
||||
// This extracts the first frame from the sample that isn't also in the control.
|
||||
// Skipping one frame that we assume is the frame that calls the two.
|
||||
var sampleLines = sampleStack.split("\n");
|
||||
var controlLines = controlStack.split("\n");
|
||||
var s = 0;
|
||||
var c = 0;
|
||||
|
||||
while (
|
||||
s < sampleLines.length &&
|
||||
!sampleLines[s].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
s++;
|
||||
}
|
||||
|
||||
while (
|
||||
c < controlLines.length &&
|
||||
!controlLines[c].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
c++;
|
||||
} // We couldn't find our intentionally injected common root frame, attempt
|
||||
// to find another common root frame by search from the bottom of the
|
||||
// control stack...
|
||||
|
||||
if (s === sampleLines.length || c === controlLines.length) {
|
||||
s = sampleLines.length - 1;
|
||||
c = controlLines.length - 1;
|
||||
|
||||
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
|
||||
// We expect at least one stack frame to be shared.
|
||||
// Typically this will be the root most one. However, stack frames may be
|
||||
// cut off due to maximum stack limits. In this case, one maybe cut off
|
||||
// earlier than the other. We assume that the sample is longer or the same
|
||||
// and there for cut off earlier. So we should find the root most frame in
|
||||
// the sample somewhere in the control.
|
||||
c--;
|
||||
}
|
||||
}
|
||||
|
||||
for (; s >= 1 && c >= 0; s--, c--) {
|
||||
// Next we find the first one that isn't the same which should be the
|
||||
// frame that called our sample function and the control.
|
||||
if (sampleLines[s] !== controlLines[c]) {
|
||||
// In V8, the first line is describing the message but other VMs don't.
|
||||
// If we're about to return the first line, and the control is also on the same
|
||||
// line, that's a pretty good indicator that our sample threw at same line as
|
||||
// the control. I.e. before we entered the sample frame. So we ignore this result.
|
||||
// This can happen if you passed a class to function component, or non-function.
|
||||
if (s !== 1 || c !== 1) {
|
||||
do {
|
||||
s--;
|
||||
c--; // We may still have similar intermediate frames from the construct call.
|
||||
// The next one that isn't the same should be our match though.
|
||||
|
||||
if (c < 0 || sampleLines[s] !== controlLines[c]) {
|
||||
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
|
||||
var _frame =
|
||||
"\n" + sampleLines[s].replace(" at new ", " at "); // If our component frame is labeled "<anonymous>"
|
||||
// but we have a user-provided "displayName"
|
||||
// splice it in to make the stack more readable.
|
||||
|
||||
if (fn.displayName && _frame.includes("<anonymous>")) {
|
||||
_frame = _frame.replace("<anonymous>", fn.displayName);
|
||||
}
|
||||
|
||||
if (true) {
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, _frame);
|
||||
}
|
||||
} // Return the line we found.
|
||||
|
||||
return _frame;
|
||||
}
|
||||
} while (s >= 1 && c >= 0);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
reentry = false;
|
||||
|
||||
{
|
||||
ReactCurrentDispatcher$2.current = previousDispatcher;
|
||||
reenableLogs();
|
||||
}
|
||||
|
||||
Error.prepareStackTrace = previousPrepareStackTrace;
|
||||
} // Fallback to just using the name if we couldn't make it throw.
|
||||
|
||||
var name = fn ? fn.displayName || fn.name : "";
|
||||
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
|
||||
|
||||
{
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, syntheticFrame);
|
||||
}
|
||||
}
|
||||
|
||||
return syntheticFrame;
|
||||
}
|
||||
|
||||
function describeClassComponentFrame(ctor, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(ctor, true);
|
||||
}
|
||||
}
|
||||
function describeFunctionComponentFrame(fn, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(fn, false);
|
||||
}
|
||||
}
|
||||
|
||||
function shouldConstruct$1(Component) {
|
||||
var prototype = Component.prototype;
|
||||
return !!(prototype && prototype.isReactComponent);
|
||||
}
|
||||
|
||||
function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
|
||||
if (type == null) {
|
||||
return "";
|
||||
}
|
||||
|
||||
if (typeof type === "function") {
|
||||
{
|
||||
return describeNativeComponentFrame(type, shouldConstruct$1(type));
|
||||
}
|
||||
}
|
||||
|
||||
if (typeof type === "string") {
|
||||
return describeBuiltInComponentFrame(type);
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return describeBuiltInComponentFrame("Suspense");
|
||||
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return describeBuiltInComponentFrame("SuspenseList");
|
||||
}
|
||||
|
||||
if (typeof type === "object") {
|
||||
switch (type.$$typeof) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
return describeFunctionComponentFrame(type.render);
|
||||
|
||||
case REACT_MEMO_TYPE:
|
||||
// Memo may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(type.type, ownerFn);
|
||||
|
||||
case REACT_LAZY_TYPE: {
|
||||
var lazyComponent = type;
|
||||
var payload = lazyComponent._payload;
|
||||
var init = lazyComponent._init;
|
||||
|
||||
try {
|
||||
// Lazy may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(
|
||||
init(payload),
|
||||
ownerFn
|
||||
);
|
||||
} catch (x) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
// $FlowFixMe[method-unbinding]
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs equality by iterating through keys on an object and returning false
|
||||
* when any key has values which are not strictly equal between the arguments.
|
||||
@@ -26312,7 +26297,7 @@ if (__DEV__) {
|
||||
return root;
|
||||
}
|
||||
|
||||
var ReactVersion = "18.3.0-www-classic-a44f76ff";
|
||||
var ReactVersion = "18.3.0-www-classic-2ab113e0";
|
||||
|
||||
// Might add PROFILE later.
|
||||
|
||||
|
||||
@@ -2219,453 +2219,6 @@ if (__DEV__) {
|
||||
}
|
||||
var NotPendingTransition = null;
|
||||
|
||||
var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher;
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name, ownerFn) {
|
||||
{
|
||||
if (prefix === undefined) {
|
||||
// Extract the VM specific prefix used by each line.
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
} // We use the prefix to ensure our stacks line up with native stack frames.
|
||||
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
}
|
||||
var reentry = false;
|
||||
var componentFrameCache;
|
||||
|
||||
{
|
||||
var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map;
|
||||
componentFrameCache = new PossiblyWeakMap$1();
|
||||
}
|
||||
/**
|
||||
* Leverages native browser/VM stack frames to get proper details (e.g.
|
||||
* filename, line + col number) for a single component in a component stack. We
|
||||
* do this by:
|
||||
* (1) throwing and catching an error in the function - this will be our
|
||||
* control error.
|
||||
* (2) calling the component which will eventually throw an error that we'll
|
||||
* catch - this will be our sample error.
|
||||
* (3) diffing the control and sample error stacks to find the stack frame
|
||||
* which represents our component.
|
||||
*/
|
||||
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
// If something asked for a stack inside a fake render, it should get ignored.
|
||||
if (!fn || reentry) {
|
||||
return "";
|
||||
}
|
||||
|
||||
{
|
||||
var frame = componentFrameCache.get(fn);
|
||||
|
||||
if (frame !== undefined) {
|
||||
return frame;
|
||||
}
|
||||
}
|
||||
|
||||
reentry = true;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
|
||||
|
||||
Error.prepareStackTrace = undefined;
|
||||
var previousDispatcher;
|
||||
|
||||
{
|
||||
previousDispatcher = ReactCurrentDispatcher$2.current; // Set the dispatcher in DEV because this might be call in the render function
|
||||
// for warnings.
|
||||
|
||||
ReactCurrentDispatcher$2.current = null;
|
||||
disableLogs();
|
||||
}
|
||||
/**
|
||||
* Finding a common stack frame between sample and control errors can be
|
||||
* tricky given the different types and levels of stack trace truncation from
|
||||
* different JS VMs. So instead we'll attempt to control what that common
|
||||
* frame should be through this object method:
|
||||
* Having both the sample and control errors be in the function under the
|
||||
* `DescribeNativeComponentFrameRoot` property, + setting the `name` and
|
||||
* `displayName` properties of the function ensures that a stack
|
||||
* frame exists that has the method name `DescribeNativeComponentFrameRoot` in
|
||||
* it for both control and sample stacks.
|
||||
*/
|
||||
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
var control;
|
||||
|
||||
try {
|
||||
// This should throw.
|
||||
if (construct) {
|
||||
// Something should be setting the props in the constructor.
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
// We use a throwing setter instead of frozen or non-writable props
|
||||
// because that won't throw in a non-strict mode function.
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
|
||||
if (typeof Reflect === "object" && Reflect.construct) {
|
||||
// We construct a different control for this case to include any extra
|
||||
// frames added by the construct call.
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
control = x;
|
||||
}
|
||||
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // $FlowFixMe[prop-missing] found when upgrading Flow
|
||||
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // TODO(luna): This will currently only throw if the function component
|
||||
// tries to access React/ReactDOM/props. We should probably make this throw
|
||||
// in simple components too
|
||||
|
||||
var maybePromise = fn(); // If the function component returns a promise, it's likely an async
|
||||
// component, which we don't yet support. Attach a noop catch handler to
|
||||
// silence the error.
|
||||
// TODO: Implement component stacks for async client components?
|
||||
|
||||
if (maybePromise && typeof maybePromise.catch === "function") {
|
||||
maybePromise.catch(function () {});
|
||||
}
|
||||
}
|
||||
} catch (sample) {
|
||||
// This is inlined manually because closure doesn't do it for us.
|
||||
if (sample && control && typeof sample.stack === "string") {
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
}
|
||||
|
||||
return [null, null];
|
||||
}
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
); // Before ES6, the `name` property was not configurable.
|
||||
|
||||
if (namePropDescriptor && namePropDescriptor.configurable) {
|
||||
// V8 utilizes a function's `name` property when generating a stack trace.
|
||||
Object.defineProperty(
|
||||
RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
|
||||
// is set to `false`.
|
||||
// $FlowFixMe[cannot-write]
|
||||
"name",
|
||||
{
|
||||
value: "DetermineComponentFrameRoot"
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
var _RunInRootFrame$Deter =
|
||||
RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
|
||||
if (sampleStack && controlStack) {
|
||||
// This extracts the first frame from the sample that isn't also in the control.
|
||||
// Skipping one frame that we assume is the frame that calls the two.
|
||||
var sampleLines = sampleStack.split("\n");
|
||||
var controlLines = controlStack.split("\n");
|
||||
var s = 0;
|
||||
var c = 0;
|
||||
|
||||
while (
|
||||
s < sampleLines.length &&
|
||||
!sampleLines[s].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
s++;
|
||||
}
|
||||
|
||||
while (
|
||||
c < controlLines.length &&
|
||||
!controlLines[c].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
c++;
|
||||
} // We couldn't find our intentionally injected common root frame, attempt
|
||||
// to find another common root frame by search from the bottom of the
|
||||
// control stack...
|
||||
|
||||
if (s === sampleLines.length || c === controlLines.length) {
|
||||
s = sampleLines.length - 1;
|
||||
c = controlLines.length - 1;
|
||||
|
||||
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
|
||||
// We expect at least one stack frame to be shared.
|
||||
// Typically this will be the root most one. However, stack frames may be
|
||||
// cut off due to maximum stack limits. In this case, one maybe cut off
|
||||
// earlier than the other. We assume that the sample is longer or the same
|
||||
// and there for cut off earlier. So we should find the root most frame in
|
||||
// the sample somewhere in the control.
|
||||
c--;
|
||||
}
|
||||
}
|
||||
|
||||
for (; s >= 1 && c >= 0; s--, c--) {
|
||||
// Next we find the first one that isn't the same which should be the
|
||||
// frame that called our sample function and the control.
|
||||
if (sampleLines[s] !== controlLines[c]) {
|
||||
// In V8, the first line is describing the message but other VMs don't.
|
||||
// If we're about to return the first line, and the control is also on the same
|
||||
// line, that's a pretty good indicator that our sample threw at same line as
|
||||
// the control. I.e. before we entered the sample frame. So we ignore this result.
|
||||
// This can happen if you passed a class to function component, or non-function.
|
||||
if (s !== 1 || c !== 1) {
|
||||
do {
|
||||
s--;
|
||||
c--; // We may still have similar intermediate frames from the construct call.
|
||||
// The next one that isn't the same should be our match though.
|
||||
|
||||
if (c < 0 || sampleLines[s] !== controlLines[c]) {
|
||||
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
|
||||
var _frame =
|
||||
"\n" + sampleLines[s].replace(" at new ", " at "); // If our component frame is labeled "<anonymous>"
|
||||
// but we have a user-provided "displayName"
|
||||
// splice it in to make the stack more readable.
|
||||
|
||||
if (fn.displayName && _frame.includes("<anonymous>")) {
|
||||
_frame = _frame.replace("<anonymous>", fn.displayName);
|
||||
}
|
||||
|
||||
if (true) {
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, _frame);
|
||||
}
|
||||
} // Return the line we found.
|
||||
|
||||
return _frame;
|
||||
}
|
||||
} while (s >= 1 && c >= 0);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
reentry = false;
|
||||
|
||||
{
|
||||
ReactCurrentDispatcher$2.current = previousDispatcher;
|
||||
reenableLogs();
|
||||
}
|
||||
|
||||
Error.prepareStackTrace = previousPrepareStackTrace;
|
||||
} // Fallback to just using the name if we couldn't make it throw.
|
||||
|
||||
var name = fn ? fn.displayName || fn.name : "";
|
||||
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
|
||||
|
||||
{
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, syntheticFrame);
|
||||
}
|
||||
}
|
||||
|
||||
return syntheticFrame;
|
||||
}
|
||||
|
||||
function describeClassComponentFrame(ctor, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(ctor, true);
|
||||
}
|
||||
}
|
||||
function describeFunctionComponentFrame(fn, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(fn, false);
|
||||
}
|
||||
}
|
||||
|
||||
function shouldConstruct$1(Component) {
|
||||
var prototype = Component.prototype;
|
||||
return !!(prototype && prototype.isReactComponent);
|
||||
}
|
||||
|
||||
function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
|
||||
if (type == null) {
|
||||
return "";
|
||||
}
|
||||
|
||||
if (typeof type === "function") {
|
||||
{
|
||||
return describeNativeComponentFrame(type, shouldConstruct$1(type));
|
||||
}
|
||||
}
|
||||
|
||||
if (typeof type === "string") {
|
||||
return describeBuiltInComponentFrame(type);
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return describeBuiltInComponentFrame("Suspense");
|
||||
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return describeBuiltInComponentFrame("SuspenseList");
|
||||
}
|
||||
|
||||
if (typeof type === "object") {
|
||||
switch (type.$$typeof) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
return describeFunctionComponentFrame(type.render);
|
||||
|
||||
case REACT_MEMO_TYPE:
|
||||
// Memo may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(type.type, ownerFn);
|
||||
|
||||
case REACT_LAZY_TYPE: {
|
||||
var lazyComponent = type;
|
||||
var payload = lazyComponent._payload;
|
||||
var init = lazyComponent._init;
|
||||
|
||||
try {
|
||||
// Lazy may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(
|
||||
init(payload),
|
||||
ownerFn
|
||||
);
|
||||
} catch (x) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
// $FlowFixMe[method-unbinding]
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var valueStack = [];
|
||||
var fiberStack;
|
||||
|
||||
@@ -2788,11 +2341,6 @@ if (__DEV__) {
|
||||
|
||||
for (var key in contextTypes) {
|
||||
context[key] = unmaskedContext[key];
|
||||
}
|
||||
|
||||
{
|
||||
var name = getComponentNameFromFiber(workInProgress) || "Unknown";
|
||||
checkPropTypes(contextTypes, context, "context", name);
|
||||
} // Cache unmasked context so we can avoid recreating masked context unless necessary.
|
||||
// Context is created before the class component is instantiated so check for instance.
|
||||
|
||||
@@ -2884,16 +2432,6 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
var name = getComponentNameFromFiber(fiber) || "Unknown";
|
||||
checkPropTypes(
|
||||
childContextTypes,
|
||||
childContext,
|
||||
"child context",
|
||||
name
|
||||
);
|
||||
}
|
||||
|
||||
return assign({}, parentContext, childContext);
|
||||
}
|
||||
}
|
||||
@@ -4531,6 +4069,453 @@ if (__DEV__) {
|
||||
}
|
||||
}
|
||||
|
||||
var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher;
|
||||
var prefix;
|
||||
function describeBuiltInComponentFrame(name, ownerFn) {
|
||||
{
|
||||
if (prefix === undefined) {
|
||||
// Extract the VM specific prefix used by each line.
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
var match = x.stack.trim().match(/\n( *(at )?)/);
|
||||
prefix = (match && match[1]) || "";
|
||||
}
|
||||
} // We use the prefix to ensure our stacks line up with native stack frames.
|
||||
|
||||
return "\n" + prefix + name;
|
||||
}
|
||||
}
|
||||
var reentry = false;
|
||||
var componentFrameCache;
|
||||
|
||||
{
|
||||
var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map;
|
||||
componentFrameCache = new PossiblyWeakMap$1();
|
||||
}
|
||||
/**
|
||||
* Leverages native browser/VM stack frames to get proper details (e.g.
|
||||
* filename, line + col number) for a single component in a component stack. We
|
||||
* do this by:
|
||||
* (1) throwing and catching an error in the function - this will be our
|
||||
* control error.
|
||||
* (2) calling the component which will eventually throw an error that we'll
|
||||
* catch - this will be our sample error.
|
||||
* (3) diffing the control and sample error stacks to find the stack frame
|
||||
* which represents our component.
|
||||
*/
|
||||
|
||||
function describeNativeComponentFrame(fn, construct) {
|
||||
// If something asked for a stack inside a fake render, it should get ignored.
|
||||
if (!fn || reentry) {
|
||||
return "";
|
||||
}
|
||||
|
||||
{
|
||||
var frame = componentFrameCache.get(fn);
|
||||
|
||||
if (frame !== undefined) {
|
||||
return frame;
|
||||
}
|
||||
}
|
||||
|
||||
reentry = true;
|
||||
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
|
||||
|
||||
Error.prepareStackTrace = undefined;
|
||||
var previousDispatcher;
|
||||
|
||||
{
|
||||
previousDispatcher = ReactCurrentDispatcher$2.current; // Set the dispatcher in DEV because this might be call in the render function
|
||||
// for warnings.
|
||||
|
||||
ReactCurrentDispatcher$2.current = null;
|
||||
disableLogs();
|
||||
}
|
||||
/**
|
||||
* Finding a common stack frame between sample and control errors can be
|
||||
* tricky given the different types and levels of stack trace truncation from
|
||||
* different JS VMs. So instead we'll attempt to control what that common
|
||||
* frame should be through this object method:
|
||||
* Having both the sample and control errors be in the function under the
|
||||
* `DescribeNativeComponentFrameRoot` property, + setting the `name` and
|
||||
* `displayName` properties of the function ensures that a stack
|
||||
* frame exists that has the method name `DescribeNativeComponentFrameRoot` in
|
||||
* it for both control and sample stacks.
|
||||
*/
|
||||
|
||||
var RunInRootFrame = {
|
||||
DetermineComponentFrameRoot: function () {
|
||||
var control;
|
||||
|
||||
try {
|
||||
// This should throw.
|
||||
if (construct) {
|
||||
// Something should be setting the props in the constructor.
|
||||
var Fake = function () {
|
||||
throw Error();
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
Object.defineProperty(Fake.prototype, "props", {
|
||||
set: function () {
|
||||
// We use a throwing setter instead of frozen or non-writable props
|
||||
// because that won't throw in a non-strict mode function.
|
||||
throw Error();
|
||||
}
|
||||
});
|
||||
|
||||
if (typeof Reflect === "object" && Reflect.construct) {
|
||||
// We construct a different control for this case to include any extra
|
||||
// frames added by the construct call.
|
||||
try {
|
||||
Reflect.construct(Fake, []);
|
||||
} catch (x) {
|
||||
control = x;
|
||||
}
|
||||
|
||||
Reflect.construct(fn, [], Fake);
|
||||
} else {
|
||||
try {
|
||||
Fake.call();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // $FlowFixMe[prop-missing] found when upgrading Flow
|
||||
|
||||
fn.call(Fake.prototype);
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
throw Error();
|
||||
} catch (x) {
|
||||
control = x;
|
||||
} // TODO(luna): This will currently only throw if the function component
|
||||
// tries to access React/ReactDOM/props. We should probably make this throw
|
||||
// in simple components too
|
||||
|
||||
var maybePromise = fn(); // If the function component returns a promise, it's likely an async
|
||||
// component, which we don't yet support. Attach a noop catch handler to
|
||||
// silence the error.
|
||||
// TODO: Implement component stacks for async client components?
|
||||
|
||||
if (maybePromise && typeof maybePromise.catch === "function") {
|
||||
maybePromise.catch(function () {});
|
||||
}
|
||||
}
|
||||
} catch (sample) {
|
||||
// This is inlined manually because closure doesn't do it for us.
|
||||
if (sample && control && typeof sample.stack === "string") {
|
||||
return [sample.stack, control.stack];
|
||||
}
|
||||
}
|
||||
|
||||
return [null, null];
|
||||
}
|
||||
}; // $FlowFixMe[prop-missing]
|
||||
|
||||
RunInRootFrame.DetermineComponentFrameRoot.displayName =
|
||||
"DetermineComponentFrameRoot";
|
||||
var namePropDescriptor = Object.getOwnPropertyDescriptor(
|
||||
RunInRootFrame.DetermineComponentFrameRoot,
|
||||
"name"
|
||||
); // Before ES6, the `name` property was not configurable.
|
||||
|
||||
if (namePropDescriptor && namePropDescriptor.configurable) {
|
||||
// V8 utilizes a function's `name` property when generating a stack trace.
|
||||
Object.defineProperty(
|
||||
RunInRootFrame.DetermineComponentFrameRoot, // Configurable properties can be updated even if its writable descriptor
|
||||
// is set to `false`.
|
||||
// $FlowFixMe[cannot-write]
|
||||
"name",
|
||||
{
|
||||
value: "DetermineComponentFrameRoot"
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
var _RunInRootFrame$Deter =
|
||||
RunInRootFrame.DetermineComponentFrameRoot(),
|
||||
sampleStack = _RunInRootFrame$Deter[0],
|
||||
controlStack = _RunInRootFrame$Deter[1];
|
||||
|
||||
if (sampleStack && controlStack) {
|
||||
// This extracts the first frame from the sample that isn't also in the control.
|
||||
// Skipping one frame that we assume is the frame that calls the two.
|
||||
var sampleLines = sampleStack.split("\n");
|
||||
var controlLines = controlStack.split("\n");
|
||||
var s = 0;
|
||||
var c = 0;
|
||||
|
||||
while (
|
||||
s < sampleLines.length &&
|
||||
!sampleLines[s].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
s++;
|
||||
}
|
||||
|
||||
while (
|
||||
c < controlLines.length &&
|
||||
!controlLines[c].includes("DetermineComponentFrameRoot")
|
||||
) {
|
||||
c++;
|
||||
} // We couldn't find our intentionally injected common root frame, attempt
|
||||
// to find another common root frame by search from the bottom of the
|
||||
// control stack...
|
||||
|
||||
if (s === sampleLines.length || c === controlLines.length) {
|
||||
s = sampleLines.length - 1;
|
||||
c = controlLines.length - 1;
|
||||
|
||||
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
|
||||
// We expect at least one stack frame to be shared.
|
||||
// Typically this will be the root most one. However, stack frames may be
|
||||
// cut off due to maximum stack limits. In this case, one maybe cut off
|
||||
// earlier than the other. We assume that the sample is longer or the same
|
||||
// and there for cut off earlier. So we should find the root most frame in
|
||||
// the sample somewhere in the control.
|
||||
c--;
|
||||
}
|
||||
}
|
||||
|
||||
for (; s >= 1 && c >= 0; s--, c--) {
|
||||
// Next we find the first one that isn't the same which should be the
|
||||
// frame that called our sample function and the control.
|
||||
if (sampleLines[s] !== controlLines[c]) {
|
||||
// In V8, the first line is describing the message but other VMs don't.
|
||||
// If we're about to return the first line, and the control is also on the same
|
||||
// line, that's a pretty good indicator that our sample threw at same line as
|
||||
// the control. I.e. before we entered the sample frame. So we ignore this result.
|
||||
// This can happen if you passed a class to function component, or non-function.
|
||||
if (s !== 1 || c !== 1) {
|
||||
do {
|
||||
s--;
|
||||
c--; // We may still have similar intermediate frames from the construct call.
|
||||
// The next one that isn't the same should be our match though.
|
||||
|
||||
if (c < 0 || sampleLines[s] !== controlLines[c]) {
|
||||
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
|
||||
var _frame =
|
||||
"\n" + sampleLines[s].replace(" at new ", " at "); // If our component frame is labeled "<anonymous>"
|
||||
// but we have a user-provided "displayName"
|
||||
// splice it in to make the stack more readable.
|
||||
|
||||
if (fn.displayName && _frame.includes("<anonymous>")) {
|
||||
_frame = _frame.replace("<anonymous>", fn.displayName);
|
||||
}
|
||||
|
||||
if (true) {
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, _frame);
|
||||
}
|
||||
} // Return the line we found.
|
||||
|
||||
return _frame;
|
||||
}
|
||||
} while (s >= 1 && c >= 0);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
reentry = false;
|
||||
|
||||
{
|
||||
ReactCurrentDispatcher$2.current = previousDispatcher;
|
||||
reenableLogs();
|
||||
}
|
||||
|
||||
Error.prepareStackTrace = previousPrepareStackTrace;
|
||||
} // Fallback to just using the name if we couldn't make it throw.
|
||||
|
||||
var name = fn ? fn.displayName || fn.name : "";
|
||||
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
|
||||
|
||||
{
|
||||
if (typeof fn === "function") {
|
||||
componentFrameCache.set(fn, syntheticFrame);
|
||||
}
|
||||
}
|
||||
|
||||
return syntheticFrame;
|
||||
}
|
||||
|
||||
function describeClassComponentFrame(ctor, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(ctor, true);
|
||||
}
|
||||
}
|
||||
function describeFunctionComponentFrame(fn, ownerFn) {
|
||||
{
|
||||
return describeNativeComponentFrame(fn, false);
|
||||
}
|
||||
}
|
||||
|
||||
function shouldConstruct$1(Component) {
|
||||
var prototype = Component.prototype;
|
||||
return !!(prototype && prototype.isReactComponent);
|
||||
}
|
||||
|
||||
function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
|
||||
if (type == null) {
|
||||
return "";
|
||||
}
|
||||
|
||||
if (typeof type === "function") {
|
||||
{
|
||||
return describeNativeComponentFrame(type, shouldConstruct$1(type));
|
||||
}
|
||||
}
|
||||
|
||||
if (typeof type === "string") {
|
||||
return describeBuiltInComponentFrame(type);
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return describeBuiltInComponentFrame("Suspense");
|
||||
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return describeBuiltInComponentFrame("SuspenseList");
|
||||
}
|
||||
|
||||
if (typeof type === "object") {
|
||||
switch (type.$$typeof) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
return describeFunctionComponentFrame(type.render);
|
||||
|
||||
case REACT_MEMO_TYPE:
|
||||
// Memo may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(type.type, ownerFn);
|
||||
|
||||
case REACT_LAZY_TYPE: {
|
||||
var lazyComponent = type;
|
||||
var payload = lazyComponent._payload;
|
||||
var init = lazyComponent._init;
|
||||
|
||||
try {
|
||||
// Lazy may contain any component type so we recursively resolve it.
|
||||
return describeUnknownElementTypeFrameInDEV(
|
||||
init(payload),
|
||||
ownerFn
|
||||
);
|
||||
} catch (x) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
// $FlowFixMe[method-unbinding]
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
|
||||
var loggedTypeFailures = {};
|
||||
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
|
||||
|
||||
function setCurrentlyValidatingElement(element) {
|
||||
{
|
||||
if (element) {
|
||||
var owner = element._owner;
|
||||
var stack = describeUnknownElementTypeFrameInDEV(
|
||||
element.type,
|
||||
owner ? owner.type : null
|
||||
);
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
|
||||
} else {
|
||||
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function checkPropTypes(
|
||||
typeSpecs,
|
||||
values,
|
||||
location,
|
||||
componentName,
|
||||
element
|
||||
) {
|
||||
{
|
||||
// $FlowFixMe[incompatible-use] This is okay but Flow doesn't know it.
|
||||
var has = Function.call.bind(hasOwnProperty);
|
||||
|
||||
for (var typeSpecName in typeSpecs) {
|
||||
if (has(typeSpecs, typeSpecName)) {
|
||||
var error$1 = void 0; // 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") {
|
||||
// eslint-disable-next-line react-internal/prod-error-codes
|
||||
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] +
|
||||
"`." +
|
||||
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
|
||||
);
|
||||
err.name = "Invariant Violation";
|
||||
throw err;
|
||||
}
|
||||
|
||||
error$1 = typeSpecs[typeSpecName](
|
||||
values,
|
||||
typeSpecName,
|
||||
componentName,
|
||||
location,
|
||||
null,
|
||||
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
|
||||
);
|
||||
} catch (ex) {
|
||||
error$1 = ex;
|
||||
}
|
||||
|
||||
if (error$1 && !(error$1 instanceof Error)) {
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
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$1
|
||||
);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
|
||||
if (
|
||||
error$1 instanceof Error &&
|
||||
!(error$1.message in loggedTypeFailures)
|
||||
) {
|
||||
// Only monitor this failure once because there tends to be a lot of the
|
||||
// same error.
|
||||
loggedTypeFailures[error$1.message] = true;
|
||||
setCurrentlyValidatingElement(element);
|
||||
|
||||
error("Failed %s type: %s", location, error$1.message);
|
||||
|
||||
setCurrentlyValidatingElement(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs equality by iterating through keys on an object and returning false
|
||||
* when any key has values which are not strictly equal between the arguments.
|
||||
@@ -26312,7 +26297,7 @@ if (__DEV__) {
|
||||
return root;
|
||||
}
|
||||
|
||||
var ReactVersion = "18.3.0-www-modern-b84a23a6";
|
||||
var ReactVersion = "18.3.0-www-modern-0a08dcb6";
|
||||
|
||||
// Might add PROFILE later.
|
||||
|
||||
|
||||
Reference in New Issue
Block a user