react-native/Libraries/Renderer/ReactNativeRenderer-prod.js

5829 lines
197 KiB
JavaScript

/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @noflow
* @providesModule ReactNativeRenderer-prod
* @preventMunge
*/
"use strict";
require("InitializeCore");
var invariant = require("fbjs/lib/invariant"),
emptyFunction = require("fbjs/lib/emptyFunction"),
RCTEventEmitter = require("RCTEventEmitter"),
UIManager = require("UIManager"),
React = require("react"),
ExceptionsManager = require("ExceptionsManager"),
TextInputState = require("TextInputState"),
deepDiffer = require("deepDiffer"),
flattenStyle = require("flattenStyle"),
emptyObject = require("fbjs/lib/emptyObject"),
shallowEqual = require("fbjs/lib/shallowEqual"),
ReactErrorUtils = {
_caughtError: null,
_hasCaughtError: !1,
_rethrowError: null,
_hasRethrowError: !1,
injection: {
injectErrorUtils: function(injectedErrorUtils) {
invariant(
"function" === typeof injectedErrorUtils.invokeGuardedCallback,
"Injected invokeGuardedCallback() must be a function."
);
invokeGuardedCallback = injectedErrorUtils.invokeGuardedCallback;
}
},
invokeGuardedCallback: function(name, func, context, a, b, c, d, e, f) {
invokeGuardedCallback.apply(ReactErrorUtils, arguments);
},
invokeGuardedCallbackAndCatchFirstError: function(
name,
func,
context,
a,
b,
c,
d,
e,
f
) {
ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);
if (ReactErrorUtils.hasCaughtError()) {
var error = ReactErrorUtils.clearCaughtError();
ReactErrorUtils._hasRethrowError ||
((ReactErrorUtils._hasRethrowError = !0),
(ReactErrorUtils._rethrowError = error));
}
},
rethrowCaughtError: function() {
return rethrowCaughtError.apply(ReactErrorUtils, arguments);
},
hasCaughtError: function() {
return ReactErrorUtils._hasCaughtError;
},
clearCaughtError: function() {
if (ReactErrorUtils._hasCaughtError) {
var error = ReactErrorUtils._caughtError;
ReactErrorUtils._caughtError = null;
ReactErrorUtils._hasCaughtError = !1;
return error;
}
invariant(
!1,
"clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue."
);
}
};
function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
ReactErrorUtils._hasCaughtError = !1;
ReactErrorUtils._caughtError = null;
var funcArgs = Array.prototype.slice.call(arguments, 3);
try {
func.apply(context, funcArgs);
} catch (error) {
(ReactErrorUtils._caughtError = error),
(ReactErrorUtils._hasCaughtError = !0);
}
}
function rethrowCaughtError() {
if (ReactErrorUtils._hasRethrowError) {
var error = ReactErrorUtils._rethrowError;
ReactErrorUtils._rethrowError = null;
ReactErrorUtils._hasRethrowError = !1;
throw error;
}
}
var eventPluginOrder = null,
namesToPlugins = {};
function recomputePluginOrdering() {
if (eventPluginOrder)
for (var pluginName in namesToPlugins) {
var pluginModule = namesToPlugins[pluginName],
pluginIndex = eventPluginOrder.indexOf(pluginName);
invariant(
-1 < pluginIndex,
"EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.",
pluginName
);
if (!plugins[pluginIndex]) {
invariant(
pluginModule.extractEvents,
"EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.",
pluginName
);
plugins[pluginIndex] = pluginModule;
pluginIndex = pluginModule.eventTypes;
for (var eventName in pluginIndex) {
var JSCompiler_inline_result = void 0;
var dispatchConfig = pluginIndex[eventName],
pluginModule$jscomp$0 = pluginModule,
eventName$jscomp$0 = eventName;
invariant(
!eventNameDispatchConfigs.hasOwnProperty(eventName$jscomp$0),
"EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.",
eventName$jscomp$0
);
eventNameDispatchConfigs[eventName$jscomp$0] = dispatchConfig;
var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
if (phasedRegistrationNames) {
for (JSCompiler_inline_result in phasedRegistrationNames)
phasedRegistrationNames.hasOwnProperty(
JSCompiler_inline_result
) &&
publishRegistrationName(
phasedRegistrationNames[JSCompiler_inline_result],
pluginModule$jscomp$0,
eventName$jscomp$0
);
JSCompiler_inline_result = !0;
} else
dispatchConfig.registrationName
? (publishRegistrationName(
dispatchConfig.registrationName,
pluginModule$jscomp$0,
eventName$jscomp$0
),
(JSCompiler_inline_result = !0))
: (JSCompiler_inline_result = !1);
invariant(
JSCompiler_inline_result,
"EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.",
eventName,
pluginName
);
}
}
}
}
function publishRegistrationName(registrationName, pluginModule) {
invariant(
!registrationNameModules[registrationName],
"EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.",
registrationName
);
registrationNameModules[registrationName] = pluginModule;
}
var plugins = [],
eventNameDispatchConfigs = {},
registrationNameModules = {},
getFiberCurrentPropsFromNode = null,
getInstanceFromNode = null,
getNodeFromInstance = null;
function isEndish(topLevelType) {
return (
"topMouseUp" === topLevelType ||
"topTouchEnd" === topLevelType ||
"topTouchCancel" === topLevelType
);
}
function isMoveish(topLevelType) {
return "topMouseMove" === topLevelType || "topTouchMove" === topLevelType;
}
function isStartish(topLevelType) {
return "topMouseDown" === topLevelType || "topTouchStart" === topLevelType;
}
function executeDispatch(event, simulated, listener, inst) {
simulated = event.type || "unknown-event";
event.currentTarget = getNodeFromInstance(inst);
ReactErrorUtils.invokeGuardedCallbackAndCatchFirstError(
simulated,
listener,
void 0,
event
);
event.currentTarget = null;
}
function executeDirectDispatch(event) {
var dispatchListener = event._dispatchListeners,
dispatchInstance = event._dispatchInstances;
invariant(
!Array.isArray(dispatchListener),
"executeDirectDispatch(...): Invalid `event`."
);
event.currentTarget = dispatchListener
? getNodeFromInstance(dispatchInstance)
: null;
dispatchListener = dispatchListener ? dispatchListener(event) : null;
event.currentTarget = null;
event._dispatchListeners = null;
event._dispatchInstances = null;
return dispatchListener;
}
function accumulateInto(current, next) {
invariant(
null != next,
"accumulateInto(...): Accumulated items must not be null or undefined."
);
if (null == current) return next;
if (Array.isArray(current)) {
if (Array.isArray(next)) return current.push.apply(current, next), current;
current.push(next);
return current;
}
return Array.isArray(next) ? [current].concat(next) : [current, next];
}
function forEachAccumulated(arr, cb, scope) {
Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
}
var eventQueue = null;
function executeDispatchesAndReleaseTopLevel(e) {
if (e) {
var dispatchListeners = e._dispatchListeners,
dispatchInstances = e._dispatchInstances;
if (Array.isArray(dispatchListeners))
for (
var i = 0;
i < dispatchListeners.length && !e.isPropagationStopped();
i++
)
executeDispatch(e, !1, dispatchListeners[i], dispatchInstances[i]);
else
dispatchListeners &&
executeDispatch(e, !1, dispatchListeners, dispatchInstances);
e._dispatchListeners = null;
e._dispatchInstances = null;
e.isPersistent() || e.constructor.release(e);
}
}
var injection = {
injectEventPluginOrder: function(injectedEventPluginOrder) {
invariant(
!eventPluginOrder,
"EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React."
);
eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);
recomputePluginOrdering();
},
injectEventPluginsByName: function(injectedNamesToPlugins) {
var isOrderingDirty = !1,
pluginName;
for (pluginName in injectedNamesToPlugins)
if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
var pluginModule = injectedNamesToPlugins[pluginName];
(namesToPlugins.hasOwnProperty(pluginName) &&
namesToPlugins[pluginName] === pluginModule) ||
(invariant(
!namesToPlugins[pluginName],
"EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.",
pluginName
),
(namesToPlugins[pluginName] = pluginModule),
(isOrderingDirty = !0));
}
isOrderingDirty && recomputePluginOrdering();
}
};
function getListener(inst, registrationName) {
var listener = inst.stateNode;
if (!listener) return null;
var props = getFiberCurrentPropsFromNode(listener);
if (!props) return null;
listener = props[registrationName];
a: switch (registrationName) {
case "onClick":
case "onClickCapture":
case "onDoubleClick":
case "onDoubleClickCapture":
case "onMouseDown":
case "onMouseDownCapture":
case "onMouseMove":
case "onMouseMoveCapture":
case "onMouseUp":
case "onMouseUpCapture":
(props = !props.disabled) ||
((inst = inst.type),
(props = !(
"button" === inst ||
"input" === inst ||
"select" === inst ||
"textarea" === inst
)));
inst = !props;
break a;
default:
inst = !1;
}
if (inst) return null;
invariant(
!listener || "function" === typeof listener,
"Expected `%s` listener to be a function, instead got a value of `%s` type.",
registrationName,
typeof listener
);
return listener;
}
function getParent(inst) {
do inst = inst["return"];
while (inst && 5 !== inst.tag);
return inst ? inst : null;
}
function traverseTwoPhase(inst, fn, arg) {
for (var path = []; inst; ) path.push(inst), (inst = getParent(inst));
for (inst = path.length; 0 < inst--; ) fn(path[inst], "captured", arg);
for (inst = 0; inst < path.length; inst++) fn(path[inst], "bubbled", arg);
}
function accumulateDirectionalDispatches(inst, phase, event) {
if (
(phase = getListener(
inst,
event.dispatchConfig.phasedRegistrationNames[phase]
))
)
(event._dispatchListeners = accumulateInto(
event._dispatchListeners,
phase
)),
(event._dispatchInstances = accumulateInto(
event._dispatchInstances,
inst
));
}
function accumulateTwoPhaseDispatchesSingle(event) {
event &&
event.dispatchConfig.phasedRegistrationNames &&
traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
}
function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
if (event && event.dispatchConfig.phasedRegistrationNames) {
var targetInst = event._targetInst;
targetInst = targetInst ? getParent(targetInst) : null;
traverseTwoPhase(targetInst, accumulateDirectionalDispatches, event);
}
}
function accumulateDirectDispatchesSingle(event) {
if (event && event.dispatchConfig.registrationName) {
var inst = event._targetInst;
if (inst && event && event.dispatchConfig.registrationName) {
var listener = getListener(inst, event.dispatchConfig.registrationName);
listener &&
((event._dispatchListeners = accumulateInto(
event._dispatchListeners,
listener
)),
(event._dispatchInstances = accumulateInto(
event._dispatchInstances,
inst
)));
}
}
}
var shouldBeReleasedProperties = "dispatchConfig _targetInst nativeEvent isDefaultPrevented isPropagationStopped _dispatchListeners _dispatchInstances".split(
" "
),
EventInterface = {
type: null,
target: null,
currentTarget: emptyFunction.thatReturnsNull,
eventPhase: null,
bubbles: null,
cancelable: null,
timeStamp: function(event) {
return event.timeStamp || Date.now();
},
defaultPrevented: null,
isTrusted: null
};
function SyntheticEvent(
dispatchConfig,
targetInst,
nativeEvent,
nativeEventTarget
) {
this.dispatchConfig = dispatchConfig;
this._targetInst = targetInst;
this.nativeEvent = nativeEvent;
dispatchConfig = this.constructor.Interface;
for (var propName in dispatchConfig)
dispatchConfig.hasOwnProperty(propName) &&
((targetInst = dispatchConfig[propName])
? (this[propName] = targetInst(nativeEvent))
: "target" === propName
? (this.target = nativeEventTarget)
: (this[propName] = nativeEvent[propName]));
this.isDefaultPrevented = (null != nativeEvent.defaultPrevented
? nativeEvent.defaultPrevented
: !1 === nativeEvent.returnValue)
? emptyFunction.thatReturnsTrue
: emptyFunction.thatReturnsFalse;
this.isPropagationStopped = emptyFunction.thatReturnsFalse;
return this;
}
Object.assign(SyntheticEvent.prototype, {
preventDefault: function() {
this.defaultPrevented = !0;
var event = this.nativeEvent;
event &&
(event.preventDefault
? event.preventDefault()
: "unknown" !== typeof event.returnValue && (event.returnValue = !1),
(this.isDefaultPrevented = emptyFunction.thatReturnsTrue));
},
stopPropagation: function() {
var event = this.nativeEvent;
event &&
(event.stopPropagation
? event.stopPropagation()
: "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0),
(this.isPropagationStopped = emptyFunction.thatReturnsTrue));
},
persist: function() {
this.isPersistent = emptyFunction.thatReturnsTrue;
},
isPersistent: emptyFunction.thatReturnsFalse,
destructor: function() {
var Interface = this.constructor.Interface,
propName;
for (propName in Interface) this[propName] = null;
for (
Interface = 0;
Interface < shouldBeReleasedProperties.length;
Interface++
)
this[shouldBeReleasedProperties[Interface]] = null;
}
});
SyntheticEvent.Interface = EventInterface;
SyntheticEvent.augmentClass = function(Class, Interface) {
function E() {}
E.prototype = this.prototype;
var prototype = new E();
Object.assign(prototype, Class.prototype);
Class.prototype = prototype;
Class.prototype.constructor = Class;
Class.Interface = Object.assign({}, this.Interface, Interface);
Class.augmentClass = this.augmentClass;
addEventPoolingTo(Class);
};
addEventPoolingTo(SyntheticEvent);
function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
if (this.eventPool.length) {
var instance = this.eventPool.pop();
this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
return instance;
}
return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
}
function releasePooledEvent(event) {
invariant(
event instanceof this,
"Trying to release an event instance into a pool of a different type."
);
event.destructor();
10 > this.eventPool.length && this.eventPool.push(event);
}
function addEventPoolingTo(EventConstructor) {
EventConstructor.eventPool = [];
EventConstructor.getPooled = getPooledEvent;
EventConstructor.release = releasePooledEvent;
}
function ResponderSyntheticEvent(
dispatchConfig,
dispatchMarker,
nativeEvent,
nativeEventTarget
) {
return SyntheticEvent.call(
this,
dispatchConfig,
dispatchMarker,
nativeEvent,
nativeEventTarget
);
}
SyntheticEvent.augmentClass(ResponderSyntheticEvent, {
touchHistory: function() {
return null;
}
});
var touchBank = [],
touchHistory = {
touchBank: touchBank,
numberActiveTouches: 0,
indexOfSingleActiveTouch: -1,
mostRecentTimeStamp: 0
};
function timestampForTouch(touch) {
return touch.timeStamp || touch.timestamp;
}
function getTouchIdentifier(_ref) {
_ref = _ref.identifier;
invariant(null != _ref, "Touch object is missing identifier.");
return _ref;
}
function recordTouchStart(touch) {
var identifier = getTouchIdentifier(touch),
touchRecord = touchBank[identifier];
touchRecord
? ((touchRecord.touchActive = !0),
(touchRecord.startPageX = touch.pageX),
(touchRecord.startPageY = touch.pageY),
(touchRecord.startTimeStamp = timestampForTouch(touch)),
(touchRecord.currentPageX = touch.pageX),
(touchRecord.currentPageY = touch.pageY),
(touchRecord.currentTimeStamp = timestampForTouch(touch)),
(touchRecord.previousPageX = touch.pageX),
(touchRecord.previousPageY = touch.pageY),
(touchRecord.previousTimeStamp = timestampForTouch(touch)))
: ((touchRecord = {
touchActive: !0,
startPageX: touch.pageX,
startPageY: touch.pageY,
startTimeStamp: timestampForTouch(touch),
currentPageX: touch.pageX,
currentPageY: touch.pageY,
currentTimeStamp: timestampForTouch(touch),
previousPageX: touch.pageX,
previousPageY: touch.pageY,
previousTimeStamp: timestampForTouch(touch)
}),
(touchBank[identifier] = touchRecord));
touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
}
function recordTouchMove(touch) {
var touchRecord = touchBank[getTouchIdentifier(touch)];
touchRecord
? ((touchRecord.touchActive = !0),
(touchRecord.previousPageX = touchRecord.currentPageX),
(touchRecord.previousPageY = touchRecord.currentPageY),
(touchRecord.previousTimeStamp = touchRecord.currentTimeStamp),
(touchRecord.currentPageX = touch.pageX),
(touchRecord.currentPageY = touch.pageY),
(touchRecord.currentTimeStamp = timestampForTouch(touch)),
(touchHistory.mostRecentTimeStamp = timestampForTouch(touch)))
: console.error(
"Cannot record touch move without a touch start.\nTouch Move: %s\n",
"Touch Bank: %s",
printTouch(touch),
printTouchBank()
);
}
function recordTouchEnd(touch) {
var touchRecord = touchBank[getTouchIdentifier(touch)];
touchRecord
? ((touchRecord.touchActive = !1),
(touchRecord.previousPageX = touchRecord.currentPageX),
(touchRecord.previousPageY = touchRecord.currentPageY),
(touchRecord.previousTimeStamp = touchRecord.currentTimeStamp),
(touchRecord.currentPageX = touch.pageX),
(touchRecord.currentPageY = touch.pageY),
(touchRecord.currentTimeStamp = timestampForTouch(touch)),
(touchHistory.mostRecentTimeStamp = timestampForTouch(touch)))
: console.error(
"Cannot record touch end without a touch start.\nTouch End: %s\n",
"Touch Bank: %s",
printTouch(touch),
printTouchBank()
);
}
function printTouch(touch) {
return JSON.stringify({
identifier: touch.identifier,
pageX: touch.pageX,
pageY: touch.pageY,
timestamp: timestampForTouch(touch)
});
}
function printTouchBank() {
var printed = JSON.stringify(touchBank.slice(0, 20));
20 < touchBank.length &&
(printed += " (original size: " + touchBank.length + ")");
return printed;
}
var ResponderTouchHistoryStore = {
recordTouchTrack: function(topLevelType, nativeEvent) {
if (isMoveish(topLevelType))
nativeEvent.changedTouches.forEach(recordTouchMove);
else if (isStartish(topLevelType))
nativeEvent.changedTouches.forEach(recordTouchStart),
(touchHistory.numberActiveTouches = nativeEvent.touches.length),
1 === touchHistory.numberActiveTouches &&
(touchHistory.indexOfSingleActiveTouch =
nativeEvent.touches[0].identifier);
else if (
isEndish(topLevelType) &&
(nativeEvent.changedTouches.forEach(recordTouchEnd),
(touchHistory.numberActiveTouches = nativeEvent.touches.length),
1 === touchHistory.numberActiveTouches)
)
for (topLevelType = 0; topLevelType < touchBank.length; topLevelType++)
if (
((nativeEvent = touchBank[topLevelType]),
null != nativeEvent && nativeEvent.touchActive)
) {
touchHistory.indexOfSingleActiveTouch = topLevelType;
break;
}
},
touchHistory: touchHistory
};
function accumulate(current, next) {
invariant(
null != next,
"accumulate(...): Accumulated items must be not be null or undefined."
);
return null == current
? next
: Array.isArray(current)
? current.concat(next)
: Array.isArray(next) ? [current].concat(next) : [current, next];
}
var responderInst = null,
trackedTouchCount = 0,
previousActiveTouches = 0;
function changeResponder(nextResponderInst, blockHostResponder) {
var oldResponderInst = responderInst;
responderInst = nextResponderInst;
if (null !== ResponderEventPlugin.GlobalResponderHandler)
ResponderEventPlugin.GlobalResponderHandler.onChange(
oldResponderInst,
nextResponderInst,
blockHostResponder
);
}
var eventTypes = {
startShouldSetResponder: {
phasedRegistrationNames: {
bubbled: "onStartShouldSetResponder",
captured: "onStartShouldSetResponderCapture"
}
},
scrollShouldSetResponder: {
phasedRegistrationNames: {
bubbled: "onScrollShouldSetResponder",
captured: "onScrollShouldSetResponderCapture"
}
},
selectionChangeShouldSetResponder: {
phasedRegistrationNames: {
bubbled: "onSelectionChangeShouldSetResponder",
captured: "onSelectionChangeShouldSetResponderCapture"
}
},
moveShouldSetResponder: {
phasedRegistrationNames: {
bubbled: "onMoveShouldSetResponder",
captured: "onMoveShouldSetResponderCapture"
}
},
responderStart: { registrationName: "onResponderStart" },
responderMove: { registrationName: "onResponderMove" },
responderEnd: { registrationName: "onResponderEnd" },
responderRelease: { registrationName: "onResponderRelease" },
responderTerminationRequest: {
registrationName: "onResponderTerminationRequest"
},
responderGrant: { registrationName: "onResponderGrant" },
responderReject: { registrationName: "onResponderReject" },
responderTerminate: { registrationName: "onResponderTerminate" }
},
ResponderEventPlugin = {
_getResponder: function() {
return responderInst;
},
eventTypes: eventTypes,
extractEvents: function(
topLevelType,
targetInst,
nativeEvent,
nativeEventTarget
) {
if (isStartish(topLevelType)) trackedTouchCount += 1;
else if (isEndish(topLevelType))
if (0 <= trackedTouchCount) --trackedTouchCount;
else
return (
console.error(
"Ended a touch event which was not counted in `trackedTouchCount`."
),
null
);
ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
if (
targetInst &&
(("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll) ||
(0 < trackedTouchCount && "topSelectionChange" === topLevelType) ||
isStartish(topLevelType) ||
isMoveish(topLevelType))
) {
var shouldSetEventType = isStartish(topLevelType)
? eventTypes.startShouldSetResponder
: isMoveish(topLevelType)
? eventTypes.moveShouldSetResponder
: "topSelectionChange" === topLevelType
? eventTypes.selectionChangeShouldSetResponder
: eventTypes.scrollShouldSetResponder;
if (responderInst)
b: {
var JSCompiler_temp = responderInst;
for (
var depthA = 0, tempA = JSCompiler_temp;
tempA;
tempA = getParent(tempA)
)
depthA++;
tempA = 0;
for (var tempB = targetInst; tempB; tempB = getParent(tempB))
tempA++;
for (; 0 < depthA - tempA; )
(JSCompiler_temp = getParent(JSCompiler_temp)), depthA--;
for (; 0 < tempA - depthA; )
(targetInst = getParent(targetInst)), tempA--;
for (; depthA--; ) {
if (
JSCompiler_temp === targetInst ||
JSCompiler_temp === targetInst.alternate
)
break b;
JSCompiler_temp = getParent(JSCompiler_temp);
targetInst = getParent(targetInst);
}
JSCompiler_temp = null;
}
else JSCompiler_temp = targetInst;
targetInst = JSCompiler_temp === responderInst;
JSCompiler_temp = ResponderSyntheticEvent.getPooled(
shouldSetEventType,
JSCompiler_temp,
nativeEvent,
nativeEventTarget
);
JSCompiler_temp.touchHistory = ResponderTouchHistoryStore.touchHistory;
targetInst
? forEachAccumulated(
JSCompiler_temp,
accumulateTwoPhaseDispatchesSingleSkipTarget
)
: forEachAccumulated(
JSCompiler_temp,
accumulateTwoPhaseDispatchesSingle
);
b: {
shouldSetEventType = JSCompiler_temp._dispatchListeners;
targetInst = JSCompiler_temp._dispatchInstances;
if (Array.isArray(shouldSetEventType))
for (
depthA = 0;
depthA < shouldSetEventType.length &&
!JSCompiler_temp.isPropagationStopped();
depthA++
) {
if (
shouldSetEventType[depthA](JSCompiler_temp, targetInst[depthA])
) {
shouldSetEventType = targetInst[depthA];
break b;
}
}
else if (
shouldSetEventType &&
shouldSetEventType(JSCompiler_temp, targetInst)
) {
shouldSetEventType = targetInst;
break b;
}
shouldSetEventType = null;
}
JSCompiler_temp._dispatchInstances = null;
JSCompiler_temp._dispatchListeners = null;
JSCompiler_temp.isPersistent() ||
JSCompiler_temp.constructor.release(JSCompiler_temp);
if (shouldSetEventType && shouldSetEventType !== responderInst)
if (
((JSCompiler_temp = ResponderSyntheticEvent.getPooled(
eventTypes.responderGrant,
shouldSetEventType,
nativeEvent,
nativeEventTarget
)),
(JSCompiler_temp.touchHistory =
ResponderTouchHistoryStore.touchHistory),
forEachAccumulated(
JSCompiler_temp,
accumulateDirectDispatchesSingle
),
(targetInst = !0 === executeDirectDispatch(JSCompiler_temp)),
responderInst)
)
if (
((depthA = ResponderSyntheticEvent.getPooled(
eventTypes.responderTerminationRequest,
responderInst,
nativeEvent,
nativeEventTarget
)),
(depthA.touchHistory = ResponderTouchHistoryStore.touchHistory),
forEachAccumulated(depthA, accumulateDirectDispatchesSingle),
(tempA =
!depthA._dispatchListeners || executeDirectDispatch(depthA)),
depthA.isPersistent() || depthA.constructor.release(depthA),
tempA)
) {
depthA = ResponderSyntheticEvent.getPooled(
eventTypes.responderTerminate,
responderInst,
nativeEvent,
nativeEventTarget
);
depthA.touchHistory = ResponderTouchHistoryStore.touchHistory;
forEachAccumulated(depthA, accumulateDirectDispatchesSingle);
var JSCompiler_temp$jscomp$0 = accumulate(
JSCompiler_temp$jscomp$0,
[JSCompiler_temp, depthA]
);
changeResponder(shouldSetEventType, targetInst);
} else
(shouldSetEventType = ResponderSyntheticEvent.getPooled(
eventTypes.responderReject,
shouldSetEventType,
nativeEvent,
nativeEventTarget
)),
(shouldSetEventType.touchHistory =
ResponderTouchHistoryStore.touchHistory),
forEachAccumulated(
shouldSetEventType,
accumulateDirectDispatchesSingle
),
(JSCompiler_temp$jscomp$0 = accumulate(
JSCompiler_temp$jscomp$0,
shouldSetEventType
));
else
(JSCompiler_temp$jscomp$0 = accumulate(
JSCompiler_temp$jscomp$0,
JSCompiler_temp
)),
changeResponder(shouldSetEventType, targetInst);
else JSCompiler_temp$jscomp$0 = null;
} else JSCompiler_temp$jscomp$0 = null;
shouldSetEventType = responderInst && isStartish(topLevelType);
JSCompiler_temp = responderInst && isMoveish(topLevelType);
targetInst = responderInst && isEndish(topLevelType);
if (
(shouldSetEventType = shouldSetEventType
? eventTypes.responderStart
: JSCompiler_temp
? eventTypes.responderMove
: targetInst ? eventTypes.responderEnd : null)
)
(shouldSetEventType = ResponderSyntheticEvent.getPooled(
shouldSetEventType,
responderInst,
nativeEvent,
nativeEventTarget
)),
(shouldSetEventType.touchHistory =
ResponderTouchHistoryStore.touchHistory),
forEachAccumulated(
shouldSetEventType,
accumulateDirectDispatchesSingle
),
(JSCompiler_temp$jscomp$0 = accumulate(
JSCompiler_temp$jscomp$0,
shouldSetEventType
));
shouldSetEventType = responderInst && "topTouchCancel" === topLevelType;
if (
(topLevelType =
responderInst && !shouldSetEventType && isEndish(topLevelType))
)
a: {
if ((topLevelType = nativeEvent.touches) && 0 !== topLevelType.length)
for (
JSCompiler_temp = 0;
JSCompiler_temp < topLevelType.length;
JSCompiler_temp++
)
if (
((targetInst = topLevelType[JSCompiler_temp].target),
null !== targetInst &&
void 0 !== targetInst &&
0 !== targetInst)
) {
depthA = getInstanceFromNode(targetInst);
b: {
for (targetInst = responderInst; depthA; ) {
if (
targetInst === depthA ||
targetInst === depthA.alternate
) {
targetInst = !0;
break b;
}
depthA = getParent(depthA);
}
targetInst = !1;
}
if (targetInst) {
topLevelType = !1;
break a;
}
}
topLevelType = !0;
}
if (
(topLevelType = shouldSetEventType
? eventTypes.responderTerminate
: topLevelType ? eventTypes.responderRelease : null)
)
(nativeEvent = ResponderSyntheticEvent.getPooled(
topLevelType,
responderInst,
nativeEvent,
nativeEventTarget
)),
(nativeEvent.touchHistory = ResponderTouchHistoryStore.touchHistory),
forEachAccumulated(nativeEvent, accumulateDirectDispatchesSingle),
(JSCompiler_temp$jscomp$0 = accumulate(
JSCompiler_temp$jscomp$0,
nativeEvent
)),
changeResponder(null);
nativeEvent = ResponderTouchHistoryStore.touchHistory.numberActiveTouches;
if (
ResponderEventPlugin.GlobalInteractionHandler &&
nativeEvent !== previousActiveTouches
)
ResponderEventPlugin.GlobalInteractionHandler.onChange(nativeEvent);
previousActiveTouches = nativeEvent;
return JSCompiler_temp$jscomp$0;
},
GlobalResponderHandler: null,
GlobalInteractionHandler: null,
injection: {
injectGlobalResponderHandler: function(GlobalResponderHandler) {
ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
},
injectGlobalInteractionHandler: function(GlobalInteractionHandler) {
ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;
}
}
},
customBubblingEventTypes = {},
customDirectEventTypes = {},
ReactNativeBridgeEventPlugin = {
eventTypes: {},
extractEvents: function(
topLevelType,
targetInst,
nativeEvent,
nativeEventTarget
) {
var bubbleDispatchConfig = customBubblingEventTypes[topLevelType],
directDispatchConfig = customDirectEventTypes[topLevelType];
invariant(
bubbleDispatchConfig || directDispatchConfig,
'Unsupported top level event type "%s" dispatched',
topLevelType
);
topLevelType = SyntheticEvent.getPooled(
bubbleDispatchConfig || directDispatchConfig,
targetInst,
nativeEvent,
nativeEventTarget
);
if (bubbleDispatchConfig)
forEachAccumulated(topLevelType, accumulateTwoPhaseDispatchesSingle);
else if (directDispatchConfig)
forEachAccumulated(topLevelType, accumulateDirectDispatchesSingle);
else return null;
return topLevelType;
},
processEventTypes: function(viewConfig) {
var bubblingEventTypes = viewConfig.bubblingEventTypes;
viewConfig = viewConfig.directEventTypes;
if (null != bubblingEventTypes)
for (var _topLevelType in bubblingEventTypes)
null == customBubblingEventTypes[_topLevelType] &&
(ReactNativeBridgeEventPlugin.eventTypes[
_topLevelType
] = customBubblingEventTypes[_topLevelType] =
bubblingEventTypes[_topLevelType]);
if (null != viewConfig)
for (var _topLevelType2 in viewConfig)
null == customDirectEventTypes[_topLevelType2] &&
(ReactNativeBridgeEventPlugin.eventTypes[
_topLevelType2
] = customDirectEventTypes[_topLevelType2] =
viewConfig[_topLevelType2]);
}
},
instanceCache = {},
instanceProps = {};
function uncacheFiberNode(tag) {
delete instanceCache[tag];
delete instanceProps[tag];
}
function getInstanceFromTag(tag) {
return instanceCache[tag] || null;
}
var ReactNativeComponentTree = Object.freeze({
precacheFiberNode: function(hostInst, tag) {
instanceCache[tag] = hostInst;
},
uncacheFiberNode: uncacheFiberNode,
getClosestInstanceFromNode: getInstanceFromTag,
getInstanceFromNode: getInstanceFromTag,
getNodeFromInstance: function(inst) {
inst = inst.stateNode._nativeTag;
invariant(inst, "All native instances should have a tag.");
return inst;
},
getFiberCurrentPropsFromNode: function(stateNode) {
return instanceProps[stateNode._nativeTag] || null;
},
updateFiberProps: function(tag, props) {
instanceProps[tag] = props;
}
}),
restoreTarget = null,
restoreQueue = null;
function restoreStateOfTarget(target) {
if ((target = getInstanceFromNode(target))) {
invariant(
null,
"Fiber needs to be injected to handle a fiber target for controlled events. This error is likely caused by a bug in React. Please file an issue."
);
var props = getFiberCurrentPropsFromNode(target.stateNode);
null.restoreControlledState(target.stateNode, target.type, props);
}
}
function fiberBatchedUpdates(fn, bookkeeping) {
return fn(bookkeeping);
}
var isNestingBatched = !1;
function batchedUpdates(fn, bookkeeping) {
if (isNestingBatched) return fiberBatchedUpdates(fn, bookkeeping);
isNestingBatched = !0;
try {
return fiberBatchedUpdates(fn, bookkeeping);
} finally {
if (
((isNestingBatched = !1),
restoreTarget &&
((bookkeeping = restoreTarget),
(fn = restoreQueue),
(restoreQueue = restoreTarget = null),
restoreStateOfTarget(bookkeeping),
fn))
)
for (bookkeeping = 0; bookkeeping < fn.length; bookkeeping++)
restoreStateOfTarget(fn[bookkeeping]);
}
}
function handleTopLevel(
topLevelType,
targetInst,
nativeEvent,
nativeEventTarget
) {
for (var events, i = 0; i < plugins.length; i++) {
var possiblePlugin = plugins[i];
possiblePlugin &&
(possiblePlugin = possiblePlugin.extractEvents(
topLevelType,
targetInst,
nativeEvent,
nativeEventTarget
)) &&
(events = accumulateInto(events, possiblePlugin));
}
events && (eventQueue = accumulateInto(eventQueue, events));
topLevelType = eventQueue;
eventQueue = null;
topLevelType &&
(forEachAccumulated(topLevelType, executeDispatchesAndReleaseTopLevel),
invariant(
!eventQueue,
"processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."
),
ReactErrorUtils.rethrowCaughtError());
}
var ReactNativeTagHandles = {
tagsStartAt: 1,
tagCount: 1,
allocateTag: function() {
for (; this.reactTagIsNativeTopRootID(ReactNativeTagHandles.tagCount); )
ReactNativeTagHandles.tagCount++;
var tag = ReactNativeTagHandles.tagCount;
ReactNativeTagHandles.tagCount++;
return tag;
},
assertRootTag: function(tag) {
invariant(
this.reactTagIsNativeTopRootID(tag),
"Expect a native root tag, instead got %s",
tag
);
},
reactTagIsNativeTopRootID: function(reactTag) {
return 1 === reactTag % 10;
}
},
EMPTY_NATIVE_EVENT = {};
function _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam) {
var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT,
inst = getInstanceFromTag(rootNodeID);
batchedUpdates(function() {
handleTopLevel(topLevelType, inst, nativeEvent, nativeEvent.target);
});
}
var ReactNativeEventEmitter = Object.freeze({
getListener: getListener,
registrationNames: registrationNameModules,
_receiveRootNodeIDEvent: _receiveRootNodeIDEvent,
receiveEvent: function(rootNodeID, topLevelType, nativeEventParam) {
_receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
},
receiveTouches: function(eventTopLevelType, touches, changedIndices) {
if (
"topTouchEnd" === eventTopLevelType ||
"topTouchCancel" === eventTopLevelType
) {
var JSCompiler_temp = [];
for (var i = 0; i < changedIndices.length; i++) {
var index = changedIndices[i];
JSCompiler_temp.push(touches[index]);
touches[index] = null;
}
for (i = changedIndices = 0; i < touches.length; i++)
(index = touches[i]),
null !== index && (touches[changedIndices++] = index);
touches.length = changedIndices;
} else
for (JSCompiler_temp = [], i = 0; i < changedIndices.length; i++)
JSCompiler_temp.push(touches[changedIndices[i]]);
for (
changedIndices = 0;
changedIndices < JSCompiler_temp.length;
changedIndices++
) {
i = JSCompiler_temp[changedIndices];
i.changedTouches = JSCompiler_temp;
i.touches = touches;
index = null;
var target = i.target;
null === target ||
void 0 === target ||
target < ReactNativeTagHandles.tagsStartAt ||
(index = target);
_receiveRootNodeIDEvent(index, eventTopLevelType, i);
}
},
handleTopLevel: handleTopLevel
});
RCTEventEmitter.register(ReactNativeEventEmitter);
injection.injectEventPluginOrder([
"ResponderEventPlugin",
"ReactNativeBridgeEventPlugin"
]);
getFiberCurrentPropsFromNode =
ReactNativeComponentTree.getFiberCurrentPropsFromNode;
getInstanceFromNode = ReactNativeComponentTree.getInstanceFromNode;
getNodeFromInstance = ReactNativeComponentTree.getNodeFromInstance;
ResponderEventPlugin.injection.injectGlobalResponderHandler({
onChange: function(from, to, blockNativeResponder) {
null !== to
? UIManager.setJSResponder(to.stateNode._nativeTag, blockNativeResponder)
: UIManager.clearJSResponder();
}
});
injection.injectEventPluginsByName({
ResponderEventPlugin: ResponderEventPlugin,
ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin
});
function defaultShowDialog() {
return !0;
}
var showDialog = defaultShowDialog,
hasSymbol = "function" === typeof Symbol && Symbol["for"],
REACT_ELEMENT_TYPE = hasSymbol ? Symbol["for"]("react.element") : 60103,
REACT_CALL_TYPE = hasSymbol ? Symbol["for"]("react.call") : 60104,
REACT_RETURN_TYPE = hasSymbol ? Symbol["for"]("react.return") : 60105,
REACT_PORTAL_TYPE = hasSymbol ? Symbol["for"]("react.portal") : 60106,
REACT_FRAGMENT_TYPE = hasSymbol ? Symbol["for"]("react.fragment") : 60107,
MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && Symbol.iterator;
function getIteratorFn(maybeIterable) {
if (null === maybeIterable || "undefined" === typeof maybeIterable)
return null;
maybeIterable =
(MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
maybeIterable["@@iterator"];
return "function" === typeof maybeIterable ? maybeIterable : null;
}
function createPortal(children, containerInfo, implementation) {
var key =
3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
return {
$$typeof: REACT_PORTAL_TYPE,
key: null == key ? null : "" + key,
children: children,
containerInfo: containerInfo,
implementation: implementation
};
}
var TouchHistoryMath = {
centroidDimension: function(
touchHistory,
touchesChangedAfter,
isXAxis,
ofCurrent
) {
var touchBank = touchHistory.touchBank,
total = 0,
count = 0;
touchHistory =
1 === touchHistory.numberActiveTouches
? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch]
: null;
if (null !== touchHistory)
touchHistory.touchActive &&
touchHistory.currentTimeStamp > touchesChangedAfter &&
((total +=
ofCurrent && isXAxis
? touchHistory.currentPageX
: ofCurrent && !isXAxis
? touchHistory.currentPageY
: !ofCurrent && isXAxis
? touchHistory.previousPageX
: touchHistory.previousPageY),
(count = 1));
else
for (
touchHistory = 0;
touchHistory < touchBank.length;
touchHistory++
) {
var touchTrack = touchBank[touchHistory];
null !== touchTrack &&
void 0 !== touchTrack &&
touchTrack.touchActive &&
touchTrack.currentTimeStamp >= touchesChangedAfter &&
((total +=
ofCurrent && isXAxis
? touchTrack.currentPageX
: ofCurrent && !isXAxis
? touchTrack.currentPageY
: !ofCurrent && isXAxis
? touchTrack.previousPageX
: touchTrack.previousPageY),
count++);
}
return 0 < count ? total / count : TouchHistoryMath.noCentroid;
},
currentCentroidXOfTouchesChangedAfter: function(
touchHistory,
touchesChangedAfter
) {
return TouchHistoryMath.centroidDimension(
touchHistory,
touchesChangedAfter,
!0,
!0
);
},
currentCentroidYOfTouchesChangedAfter: function(
touchHistory,
touchesChangedAfter
) {
return TouchHistoryMath.centroidDimension(
touchHistory,
touchesChangedAfter,
!1,
!0
);
},
previousCentroidXOfTouchesChangedAfter: function(
touchHistory,
touchesChangedAfter
) {
return TouchHistoryMath.centroidDimension(
touchHistory,
touchesChangedAfter,
!0,
!1
);
},
previousCentroidYOfTouchesChangedAfter: function(
touchHistory,
touchesChangedAfter
) {
return TouchHistoryMath.centroidDimension(
touchHistory,
touchesChangedAfter,
!1,
!1
);
},
currentCentroidX: function(touchHistory) {
return TouchHistoryMath.centroidDimension(touchHistory, 0, !0, !0);
},
currentCentroidY: function(touchHistory) {
return TouchHistoryMath.centroidDimension(touchHistory, 0, !1, !0);
},
noCentroid: -1
},
ReactCurrentOwner =
React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,
ReactGlobalSharedState = Object.freeze({
ReactCurrentOwner: ReactCurrentOwner,
ReactDebugCurrentFrame: null
}),
objects = {},
uniqueID = 1,
emptyObject$2 = {},
ReactNativePropRegistry = (function() {
function ReactNativePropRegistry() {
if (!(this instanceof ReactNativePropRegistry))
throw new TypeError("Cannot call a class as a function");
}
ReactNativePropRegistry.register = function(object) {
var id = ++uniqueID;
objects[id] = object;
return id;
};
ReactNativePropRegistry.getByID = function(id) {
if (!id) return emptyObject$2;
var object = objects[id];
return object
? object
: (console.warn("Invalid style with id `" + id + "`. Skipping ..."),
emptyObject$2);
};
return ReactNativePropRegistry;
})(),
emptyObject$1 = {},
removedKeys = null,
removedKeyCount = 0;
function resolveObject(idOrObject) {
return "number" === typeof idOrObject
? ReactNativePropRegistry.getByID(idOrObject)
: idOrObject;
}
function restoreDeletedValuesInNestedArray(
updatePayload,
node,
validAttributes
) {
if (Array.isArray(node))
for (var i = node.length; i-- && 0 < removedKeyCount; )
restoreDeletedValuesInNestedArray(
updatePayload,
node[i],
validAttributes
);
else if (node && 0 < removedKeyCount)
for (i in ((node = resolveObject(node)), removedKeys))
if (removedKeys[i]) {
var nextProp = node[i];
if (void 0 !== nextProp) {
var attributeConfig = validAttributes[i];
if (attributeConfig) {
"function" === typeof nextProp && (nextProp = !0);
"undefined" === typeof nextProp && (nextProp = null);
if ("object" !== typeof attributeConfig)
updatePayload[i] = nextProp;
else if (
"function" === typeof attributeConfig.diff ||
"function" === typeof attributeConfig.process
)
(nextProp =
"function" === typeof attributeConfig.process
? attributeConfig.process(nextProp)
: nextProp),
(updatePayload[i] = nextProp);
removedKeys[i] = !1;
removedKeyCount--;
}
}
}
}
function diffNestedProperty(
updatePayload,
prevProp,
nextProp,
validAttributes
) {
if (!updatePayload && prevProp === nextProp) return updatePayload;
if (!prevProp || !nextProp)
return nextProp
? addNestedProperty(updatePayload, nextProp, validAttributes)
: prevProp
? clearNestedProperty(updatePayload, prevProp, validAttributes)
: updatePayload;
if (!Array.isArray(prevProp) && !Array.isArray(nextProp))
return diffProperties(
updatePayload,
resolveObject(prevProp),
resolveObject(nextProp),
validAttributes
);
if (Array.isArray(prevProp) && Array.isArray(nextProp)) {
var minLength =
prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
i;
for (i = 0; i < minLength; i++)
updatePayload = diffNestedProperty(
updatePayload,
prevProp[i],
nextProp[i],
validAttributes
);
for (; i < prevProp.length; i++)
updatePayload = clearNestedProperty(
updatePayload,
prevProp[i],
validAttributes
);
for (; i < nextProp.length; i++)
updatePayload = addNestedProperty(
updatePayload,
nextProp[i],
validAttributes
);
return updatePayload;
}
return Array.isArray(prevProp)
? diffProperties(
updatePayload,
flattenStyle(prevProp),
resolveObject(nextProp),
validAttributes
)
: diffProperties(
updatePayload,
resolveObject(prevProp),
flattenStyle(nextProp),
validAttributes
);
}
function addNestedProperty(updatePayload, nextProp, validAttributes) {
if (!nextProp) return updatePayload;
if (!Array.isArray(nextProp))
return (
(nextProp = resolveObject(nextProp)),
diffProperties(updatePayload, emptyObject$1, nextProp, validAttributes)
);
for (var i = 0; i < nextProp.length; i++)
updatePayload = addNestedProperty(
updatePayload,
nextProp[i],
validAttributes
);
return updatePayload;
}
function clearNestedProperty(updatePayload, prevProp, validAttributes) {
if (!prevProp) return updatePayload;
if (!Array.isArray(prevProp))
return (
(prevProp = resolveObject(prevProp)),
diffProperties(updatePayload, prevProp, emptyObject$1, validAttributes)
);
for (var i = 0; i < prevProp.length; i++)
updatePayload = clearNestedProperty(
updatePayload,
prevProp[i],
validAttributes
);
return updatePayload;
}
function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
var attributeConfig, propKey;
for (propKey in nextProps)
if ((attributeConfig = validAttributes[propKey])) {
var prevProp = prevProps[propKey];
var nextProp = nextProps[propKey];
"function" === typeof nextProp &&
((nextProp = !0), "function" === typeof prevProp && (prevProp = !0));
"undefined" === typeof nextProp &&
((nextProp = null),
"undefined" === typeof prevProp && (prevProp = null));
removedKeys && (removedKeys[propKey] = !1);
if (updatePayload && void 0 !== updatePayload[propKey])
if ("object" !== typeof attributeConfig)
updatePayload[propKey] = nextProp;
else {
if (
"function" === typeof attributeConfig.diff ||
"function" === typeof attributeConfig.process
)
(attributeConfig =
"function" === typeof attributeConfig.process
? attributeConfig.process(nextProp)
: nextProp),
(updatePayload[propKey] = attributeConfig);
}
else if (prevProp !== nextProp)
if ("object" !== typeof attributeConfig)
("object" !== typeof nextProp ||
null === nextProp ||
deepDiffer(prevProp, nextProp)) &&
((updatePayload || (updatePayload = {}))[propKey] = nextProp);
else if (
"function" === typeof attributeConfig.diff ||
"function" === typeof attributeConfig.process
) {
if (
void 0 === prevProp ||
("function" === typeof attributeConfig.diff
? attributeConfig.diff(prevProp, nextProp)
: "object" !== typeof nextProp ||
null === nextProp ||
deepDiffer(prevProp, nextProp))
)
(attributeConfig =
"function" === typeof attributeConfig.process
? attributeConfig.process(nextProp)
: nextProp),
((updatePayload || (updatePayload = {}))[
propKey
] = attributeConfig);
} else
(removedKeys = null),
(removedKeyCount = 0),
(updatePayload = diffNestedProperty(
updatePayload,
prevProp,
nextProp,
attributeConfig
)),
0 < removedKeyCount &&
updatePayload &&
(restoreDeletedValuesInNestedArray(
updatePayload,
nextProp,
attributeConfig
),
(removedKeys = null));
}
for (propKey in prevProps)
void 0 === nextProps[propKey] &&
(!(attributeConfig = validAttributes[propKey]) ||
(updatePayload && void 0 !== updatePayload[propKey]) ||
((prevProp = prevProps[propKey]),
void 0 !== prevProp &&
("object" !== typeof attributeConfig ||
"function" === typeof attributeConfig.diff ||
"function" === typeof attributeConfig.process
? (((updatePayload || (updatePayload = {}))[propKey] = null),
removedKeys || (removedKeys = {}),
removedKeys[propKey] ||
((removedKeys[propKey] = !0), removedKeyCount++))
: (updatePayload = clearNestedProperty(
updatePayload,
prevProp,
attributeConfig
)))));
return updatePayload;
}
function mountSafeCallback(context, callback) {
return function() {
if (callback) {
if ("boolean" === typeof context.__isMounted) {
if (!context.__isMounted) return;
} else if (
"function" === typeof context.isMounted &&
!context.isMounted()
)
return;
return callback.apply(context, arguments);
}
};
}
function getComponentName(fiber) {
fiber = fiber.type;
return "string" === typeof fiber
? fiber
: "function" === typeof fiber ? fiber.displayName || fiber.name : null;
}
var debugRenderPhaseSideEffects = require("ReactFeatureFlags")
.debugRenderPhaseSideEffects;
function isFiberMountedImpl(fiber) {
var node = fiber;
if (fiber.alternate) for (; node["return"]; ) node = node["return"];
else {
if (0 !== (node.effectTag & 2)) return 1;
for (; node["return"]; )
if (((node = node["return"]), 0 !== (node.effectTag & 2))) return 1;
}
return 3 === node.tag ? 2 : 3;
}
function isMounted(component) {
return (component = component._reactInternalFiber)
? 2 === isFiberMountedImpl(component)
: !1;
}
function assertIsMounted(fiber) {
invariant(
2 === isFiberMountedImpl(fiber),
"Unable to find node on an unmounted component."
);
}
function findCurrentFiberUsingSlowPath(fiber) {
var alternate = fiber.alternate;
if (!alternate)
return (
(alternate = isFiberMountedImpl(fiber)),
invariant(
3 !== alternate,
"Unable to find node on an unmounted component."
),
1 === alternate ? null : fiber
);
for (var a = fiber, b = alternate; ; ) {
var parentA = a["return"],
parentB = parentA ? parentA.alternate : null;
if (!parentA || !parentB) break;
if (parentA.child === parentB.child) {
for (var child = parentA.child; child; ) {
if (child === a) return assertIsMounted(parentA), fiber;
if (child === b) return assertIsMounted(parentA), alternate;
child = child.sibling;
}
invariant(!1, "Unable to find node on an unmounted component.");
}
if (a["return"] !== b["return"]) (a = parentA), (b = parentB);
else {
child = !1;
for (var _child = parentA.child; _child; ) {
if (_child === a) {
child = !0;
a = parentA;
b = parentB;
break;
}
if (_child === b) {
child = !0;
b = parentA;
a = parentB;
break;
}
_child = _child.sibling;
}
if (!child) {
for (_child = parentB.child; _child; ) {
if (_child === a) {
child = !0;
a = parentB;
b = parentA;
break;
}
if (_child === b) {
child = !0;
b = parentB;
a = parentA;
break;
}
_child = _child.sibling;
}
invariant(
child,
"Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue."
);
}
}
invariant(
a.alternate === b,
"Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue."
);
}
invariant(3 === a.tag, "Unable to find node on an unmounted component.");
return a.stateNode.current === a ? fiber : alternate;
}
function findCurrentHostFiber(parent) {
parent = findCurrentFiberUsingSlowPath(parent);
if (!parent) return null;
for (var node = parent; ; ) {
if (5 === node.tag || 6 === node.tag) return node;
if (node.child) (node.child["return"] = node), (node = node.child);
else {
if (node === parent) break;
for (; !node.sibling; ) {
if (!node["return"] || node["return"] === parent) return null;
node = node["return"];
}
node.sibling["return"] = node["return"];
node = node.sibling;
}
}
return null;
}
function findCurrentHostFiberWithNoPortals(parent) {
parent = findCurrentFiberUsingSlowPath(parent);
if (!parent) return null;
for (var node = parent; ; ) {
if (5 === node.tag || 6 === node.tag) return node;
if (node.child && 4 !== node.tag)
(node.child["return"] = node), (node = node.child);
else {
if (node === parent) break;
for (; !node.sibling; ) {
if (!node["return"] || node["return"] === parent) return null;
node = node["return"];
}
node.sibling["return"] = node["return"];
node = node.sibling;
}
}
return null;
}
var valueStack = [],
index = -1;
function pop(cursor) {
0 > index ||
((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
}
function push(cursor, value) {
index++;
valueStack[index] = cursor.current;
cursor.current = value;
}
new Set();
var contextStackCursor = { current: emptyObject },
didPerformWorkStackCursor = { current: !1 },
previousContext = emptyObject;
function getUnmaskedContext(workInProgress) {
return isContextProvider(workInProgress)
? previousContext
: contextStackCursor.current;
}
function getMaskedContext(workInProgress, unmaskedContext) {
var contextTypes = workInProgress.type.contextTypes;
if (!contextTypes) return emptyObject;
var instance = workInProgress.stateNode;
if (
instance &&
instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext
)
return instance.__reactInternalMemoizedMaskedChildContext;
var context = {},
key;
for (key in contextTypes) context[key] = unmaskedContext[key];
instance &&
((workInProgress = workInProgress.stateNode),
(workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext),
(workInProgress.__reactInternalMemoizedMaskedChildContext = context));
return context;
}
function isContextProvider(fiber) {
return 2 === fiber.tag && null != fiber.type.childContextTypes;
}
function popContextProvider(fiber) {
isContextProvider(fiber) &&
(pop(didPerformWorkStackCursor, fiber), pop(contextStackCursor, fiber));
}
function pushTopLevelContextObject(fiber, context, didChange) {
invariant(
null == contextStackCursor.cursor,
"Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue."
);
push(contextStackCursor, context, fiber);
push(didPerformWorkStackCursor, didChange, fiber);
}
function processChildContext(fiber, parentContext) {
var instance = fiber.stateNode,
childContextTypes = fiber.type.childContextTypes;
if ("function" !== typeof instance.getChildContext) return parentContext;
instance = instance.getChildContext();
for (var contextKey in instance)
invariant(
contextKey in childContextTypes,
'%s.getChildContext(): key "%s" is not defined in childContextTypes.',
getComponentName(fiber) || "Unknown",
contextKey
);
return Object.assign({}, parentContext, instance);
}
function pushContextProvider(workInProgress) {
if (!isContextProvider(workInProgress)) return !1;
var instance = workInProgress.stateNode;
instance =
(instance && instance.__reactInternalMemoizedMergedChildContext) ||
emptyObject;
previousContext = contextStackCursor.current;
push(contextStackCursor, instance, workInProgress);
push(
didPerformWorkStackCursor,
didPerformWorkStackCursor.current,
workInProgress
);
return !0;
}
function invalidateContextProvider(workInProgress, didChange) {
var instance = workInProgress.stateNode;
invariant(
instance,
"Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue."
);
if (didChange) {
var mergedContext = processChildContext(workInProgress, previousContext);
instance.__reactInternalMemoizedMergedChildContext = mergedContext;
pop(didPerformWorkStackCursor, workInProgress);
pop(contextStackCursor, workInProgress);
push(contextStackCursor, mergedContext, workInProgress);
} else pop(didPerformWorkStackCursor, workInProgress);
push(didPerformWorkStackCursor, didChange, workInProgress);
}
function FiberNode(tag, pendingProps, key, internalContextTag) {
this.tag = tag;
this.key = key;
this.stateNode = this.type = null;
this.sibling = this.child = this["return"] = null;
this.index = 0;
this.ref = null;
this.pendingProps = pendingProps;
this.memoizedState = this.updateQueue = this.memoizedProps = null;
this.internalContextTag = internalContextTag;
this.effectTag = 0;
this.lastEffect = this.firstEffect = this.nextEffect = null;
this.expirationTime = 0;
this.alternate = null;
}
function createFiber(tag, pendingProps, key, internalContextTag) {
return new FiberNode(tag, pendingProps, key, internalContextTag);
}
function createWorkInProgress(current, pendingProps, expirationTime) {
var workInProgress = current.alternate;
null === workInProgress
? ((workInProgress = createFiber(
current.tag,
pendingProps,
current.key,
current.internalContextTag
)),
(workInProgress.type = current.type),
(workInProgress.stateNode = current.stateNode),
(workInProgress.alternate = current),
(current.alternate = workInProgress))
: ((workInProgress.pendingProps = pendingProps),
(workInProgress.effectTag = 0),
(workInProgress.nextEffect = null),
(workInProgress.firstEffect = null),
(workInProgress.lastEffect = null));
workInProgress.expirationTime = expirationTime;
workInProgress.child = current.child;
workInProgress.memoizedProps = current.memoizedProps;
workInProgress.memoizedState = current.memoizedState;
workInProgress.updateQueue = current.updateQueue;
workInProgress.sibling = current.sibling;
workInProgress.index = current.index;
workInProgress.ref = current.ref;
return workInProgress;
}
function createFiberFromElement(element, internalContextTag, expirationTime) {
var fiber = void 0,
type = element.type,
key = element.key;
element = element.props;
"function" === typeof type
? ((fiber =
type.prototype && type.prototype.isReactComponent
? createFiber(2, element, key, internalContextTag)
: createFiber(0, element, key, internalContextTag)),
(fiber.type = type))
: "string" === typeof type
? ((fiber = createFiber(5, element, key, internalContextTag)),
(fiber.type = type))
: "object" === typeof type &&
null !== type &&
"number" === typeof type.tag
? ((fiber = type), (fiber.pendingProps = element))
: invariant(
!1,
"Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s",
null == type ? type : typeof type,
""
);
fiber.expirationTime = expirationTime;
return fiber;
}
function createFiberFromFragment(
elements,
internalContextTag,
expirationTime,
key
) {
elements = createFiber(10, elements, key, internalContextTag);
elements.expirationTime = expirationTime;
return elements;
}
function createFiberFromText(content, internalContextTag, expirationTime) {
content = createFiber(6, content, null, internalContextTag);
content.expirationTime = expirationTime;
return content;
}
function createFiberFromCall(call, internalContextTag, expirationTime) {
internalContextTag = createFiber(7, call, call.key, internalContextTag);
internalContextTag.type = call.handler;
internalContextTag.expirationTime = expirationTime;
return internalContextTag;
}
function createFiberFromReturn(returnNode, internalContextTag, expirationTime) {
returnNode = createFiber(9, null, null, internalContextTag);
returnNode.expirationTime = expirationTime;
return returnNode;
}
function createFiberFromPortal(portal, internalContextTag, expirationTime) {
internalContextTag = createFiber(
4,
null !== portal.children ? portal.children : [],
portal.key,
internalContextTag
);
internalContextTag.expirationTime = expirationTime;
internalContextTag.stateNode = {
containerInfo: portal.containerInfo,
pendingChildren: null,
implementation: portal.implementation
};
return internalContextTag;
}
var onCommitFiberRoot = null,
onCommitFiberUnmount = null;
function catchErrors(fn) {
return function(arg) {
try {
return fn(arg);
} catch (err) {}
};
}
function injectInternals(internals) {
if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
if (hook.isDisabled || !hook.supportsFiber) return !0;
try {
var rendererID = hook.inject(internals);
onCommitFiberRoot = catchErrors(function(root) {
return hook.onCommitFiberRoot(rendererID, root);
});
onCommitFiberUnmount = catchErrors(function(fiber) {
return hook.onCommitFiberUnmount(rendererID, fiber);
});
} catch (err) {}
return !0;
}
function onCommitRoot(root) {
"function" === typeof onCommitFiberRoot && onCommitFiberRoot(root);
}
function onCommitUnmount(fiber) {
"function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(fiber);
}
function createUpdateQueue(baseState) {
return {
baseState: baseState,
expirationTime: 0,
first: null,
last: null,
callbackList: null,
hasForceUpdate: !1,
isInitialized: !1
};
}
function insertUpdateIntoQueue(queue, update) {
null === queue.last
? (queue.first = queue.last = update)
: ((queue.last.next = update), (queue.last = update));
if (
0 === queue.expirationTime ||
queue.expirationTime > update.expirationTime
)
queue.expirationTime = update.expirationTime;
}
function insertUpdateIntoFiber(fiber, update) {
var alternateFiber = fiber.alternate,
queue1 = fiber.updateQueue;
null === queue1 && (queue1 = fiber.updateQueue = createUpdateQueue(null));
null !== alternateFiber
? ((fiber = alternateFiber.updateQueue),
null === fiber &&
(fiber = alternateFiber.updateQueue = createUpdateQueue(null)))
: (fiber = null);
fiber = fiber !== queue1 ? fiber : null;
null === fiber
? insertUpdateIntoQueue(queue1, update)
: null === queue1.last || null === fiber.last
? (insertUpdateIntoQueue(queue1, update),
insertUpdateIntoQueue(fiber, update))
: (insertUpdateIntoQueue(queue1, update), (fiber.last = update));
}
function getStateFromUpdate(update, instance, prevState, props) {
update = update.partialState;
return "function" === typeof update
? (debugRenderPhaseSideEffects && update.call(instance, prevState, props),
update.call(instance, prevState, props))
: update;
}
function processUpdateQueue(
current,
workInProgress,
queue,
instance,
props,
renderExpirationTime
) {
null !== current &&
current.updateQueue === queue &&
(queue = workInProgress.updateQueue = {
baseState: queue.baseState,
expirationTime: queue.expirationTime,
first: queue.first,
last: queue.last,
isInitialized: queue.isInitialized,
callbackList: null,
hasForceUpdate: !1
});
queue.expirationTime = 0;
queue.isInitialized
? (current = queue.baseState)
: ((current = queue.baseState = workInProgress.memoizedState),
(queue.isInitialized = !0));
for (
var dontMutatePrevState = !0, update = queue.first, didSkip = !1;
null !== update;
) {
var updateExpirationTime = update.expirationTime;
if (updateExpirationTime > renderExpirationTime) {
var remainingExpirationTime = queue.expirationTime;
if (
0 === remainingExpirationTime ||
remainingExpirationTime > updateExpirationTime
)
queue.expirationTime = updateExpirationTime;
didSkip || ((didSkip = !0), (queue.baseState = current));
} else {
didSkip ||
((queue.first = update.next),
null === queue.first && (queue.last = null));
if (update.isReplace)
(current = getStateFromUpdate(update, instance, current, props)),
(dontMutatePrevState = !0);
else if (
(updateExpirationTime = getStateFromUpdate(
update,
instance,
current,
props
))
)
(current = dontMutatePrevState
? Object.assign({}, current, updateExpirationTime)
: Object.assign(current, updateExpirationTime)),
(dontMutatePrevState = !1);
update.isForced && (queue.hasForceUpdate = !0);
null !== update.callback &&
((updateExpirationTime = queue.callbackList),
null === updateExpirationTime &&
(updateExpirationTime = queue.callbackList = []),
updateExpirationTime.push(update));
}
update = update.next;
}
null !== queue.callbackList
? (workInProgress.effectTag |= 32)
: null !== queue.first ||
queue.hasForceUpdate ||
(workInProgress.updateQueue = null);
didSkip || (queue.baseState = current);
return current;
}
function commitCallbacks(queue, context) {
var callbackList = queue.callbackList;
if (null !== callbackList)
for (
queue.callbackList = null, queue = 0;
queue < callbackList.length;
queue++
) {
var update = callbackList[queue],
_callback = update.callback;
update.callback = null;
invariant(
"function" === typeof _callback,
"Invalid argument passed as callback. Expected a function. Instead received: %s",
_callback
);
_callback.call(context);
}
}
function ReactFiberClassComponent(
scheduleWork,
computeExpirationForFiber,
memoizeProps,
memoizeState
) {
function adoptClassInstance(workInProgress, instance) {
instance.updater = updater;
workInProgress.stateNode = instance;
instance._reactInternalFiber = workInProgress;
}
var updater = {
isMounted: isMounted,
enqueueSetState: function(instance, partialState, callback) {
instance = instance._reactInternalFiber;
callback = void 0 === callback ? null : callback;
var expirationTime = computeExpirationForFiber(instance);
insertUpdateIntoFiber(instance, {
expirationTime: expirationTime,
partialState: partialState,
callback: callback,
isReplace: !1,
isForced: !1,
nextCallback: null,
next: null
});
scheduleWork(instance, expirationTime);
},
enqueueReplaceState: function(instance, state, callback) {
instance = instance._reactInternalFiber;
callback = void 0 === callback ? null : callback;
var expirationTime = computeExpirationForFiber(instance);
insertUpdateIntoFiber(instance, {
expirationTime: expirationTime,
partialState: state,
callback: callback,
isReplace: !0,
isForced: !1,
nextCallback: null,
next: null
});
scheduleWork(instance, expirationTime);
},
enqueueForceUpdate: function(instance, callback) {
instance = instance._reactInternalFiber;
callback = void 0 === callback ? null : callback;
var expirationTime = computeExpirationForFiber(instance);
insertUpdateIntoFiber(instance, {
expirationTime: expirationTime,
partialState: null,
callback: callback,
isReplace: !1,
isForced: !0,
nextCallback: null,
next: null
});
scheduleWork(instance, expirationTime);
}
};
return {
adoptClassInstance: adoptClassInstance,
constructClassInstance: function(workInProgress, props) {
var ctor = workInProgress.type,
unmaskedContext = getUnmaskedContext(workInProgress),
needsContext =
2 === workInProgress.tag && null != workInProgress.type.contextTypes,
context = needsContext
? getMaskedContext(workInProgress, unmaskedContext)
: emptyObject;
props = new ctor(props, context);
adoptClassInstance(workInProgress, props);
needsContext &&
((workInProgress = workInProgress.stateNode),
(workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext),
(workInProgress.__reactInternalMemoizedMaskedChildContext = context));
return props;
},
mountClassInstance: function(workInProgress, renderExpirationTime) {
var current = workInProgress.alternate,
instance = workInProgress.stateNode,
state = instance.state || null,
props = workInProgress.pendingProps,
unmaskedContext = getUnmaskedContext(workInProgress);
instance.props = props;
instance.state = workInProgress.memoizedState = state;
instance.refs = emptyObject;
instance.context = getMaskedContext(workInProgress, unmaskedContext);
null != workInProgress.type &&
null != workInProgress.type.prototype &&
!0 === workInProgress.type.prototype.unstable_isAsyncReactComponent &&
(workInProgress.internalContextTag |= 1);
"function" === typeof instance.componentWillMount &&
((state = instance.state),
instance.componentWillMount(),
debugRenderPhaseSideEffects && instance.componentWillMount(),
state !== instance.state &&
updater.enqueueReplaceState(instance, instance.state, null),
(state = workInProgress.updateQueue),
null !== state &&
(instance.state = processUpdateQueue(
current,
workInProgress,
state,
instance,
props,
renderExpirationTime
)));
"function" === typeof instance.componentDidMount &&
(workInProgress.effectTag |= 4);
},
updateClassInstance: function(
current,
workInProgress,
renderExpirationTime
) {
var instance = workInProgress.stateNode;
instance.props = workInProgress.memoizedProps;
instance.state = workInProgress.memoizedState;
var oldProps = workInProgress.memoizedProps,
newProps = workInProgress.pendingProps,
oldContext = instance.context,
newUnmaskedContext = getUnmaskedContext(workInProgress);
newUnmaskedContext = getMaskedContext(workInProgress, newUnmaskedContext);
"function" !== typeof instance.componentWillReceiveProps ||
(oldProps === newProps && oldContext === newUnmaskedContext) ||
((oldContext = instance.state),
instance.componentWillReceiveProps(newProps, newUnmaskedContext),
debugRenderPhaseSideEffects &&
instance.componentWillReceiveProps(newProps, newUnmaskedContext),
instance.state !== oldContext &&
updater.enqueueReplaceState(instance, instance.state, null));
oldContext = workInProgress.memoizedState;
renderExpirationTime =
null !== workInProgress.updateQueue
? processUpdateQueue(
current,
workInProgress,
workInProgress.updateQueue,
instance,
newProps,
renderExpirationTime
)
: oldContext;
if (
!(
oldProps !== newProps ||
oldContext !== renderExpirationTime ||
didPerformWorkStackCursor.current ||
(null !== workInProgress.updateQueue &&
workInProgress.updateQueue.hasForceUpdate)
)
)
return (
"function" !== typeof instance.componentDidUpdate ||
(oldProps === current.memoizedProps &&
oldContext === current.memoizedState) ||
(workInProgress.effectTag |= 4),
!1
);
if (
null === oldProps ||
(null !== workInProgress.updateQueue &&
workInProgress.updateQueue.hasForceUpdate)
)
var shouldUpdate = !0;
else {
shouldUpdate = workInProgress.stateNode;
var type = workInProgress.type;
"function" === typeof shouldUpdate.shouldComponentUpdate
? ((type = shouldUpdate.shouldComponentUpdate(
newProps,
renderExpirationTime,
newUnmaskedContext
)),
debugRenderPhaseSideEffects &&
shouldUpdate.shouldComponentUpdate(
newProps,
renderExpirationTime,
newUnmaskedContext
),
(shouldUpdate = type))
: (shouldUpdate =
type.prototype && type.prototype.isPureReactComponent
? !shallowEqual(oldProps, newProps) ||
!shallowEqual(oldContext, renderExpirationTime)
: !0);
}
shouldUpdate
? ("function" === typeof instance.componentWillUpdate &&
(instance.componentWillUpdate(
newProps,
renderExpirationTime,
newUnmaskedContext
),
debugRenderPhaseSideEffects &&
instance.componentWillUpdate(
newProps,
renderExpirationTime,
newUnmaskedContext
)),
"function" === typeof instance.componentDidUpdate &&
(workInProgress.effectTag |= 4))
: ("function" !== typeof instance.componentDidUpdate ||
(oldProps === current.memoizedProps &&
oldContext === current.memoizedState) ||
(workInProgress.effectTag |= 4),
memoizeProps(workInProgress, newProps),
memoizeState(workInProgress, renderExpirationTime));
instance.props = newProps;
instance.state = renderExpirationTime;
instance.context = newUnmaskedContext;
return shouldUpdate;
}
};
}
var isArray$1 = Array.isArray;
function coerceRef(current, element) {
var mixedRef = element.ref;
if (null !== mixedRef && "function" !== typeof mixedRef) {
if (element._owner) {
element = element._owner;
var inst = void 0;
element &&
(invariant(
2 === element.tag,
"Stateless function components cannot have refs."
),
(inst = element.stateNode));
invariant(
inst,
"Missing owner for string ref %s. This error is likely caused by a bug in React. Please file an issue.",
mixedRef
);
var stringRef = "" + mixedRef;
if (
null !== current &&
null !== current.ref &&
current.ref._stringRef === stringRef
)
return current.ref;
current = function(value) {
var refs = inst.refs === emptyObject ? (inst.refs = {}) : inst.refs;
null === value ? delete refs[stringRef] : (refs[stringRef] = value);
};
current._stringRef = stringRef;
return current;
}
invariant(
"string" === typeof mixedRef,
"Expected ref to be a function or a string."
);
invariant(
element._owner,
"Element ref was specified as a string (%s) but no owner was set. You may have multiple copies of React loaded. (details: https://fb.me/react-refs-must-have-owner).",
mixedRef
);
}
return mixedRef;
}
function throwOnInvalidObjectType(returnFiber, newChild) {
"textarea" !== returnFiber.type &&
invariant(
!1,
"Objects are not valid as a React child (found: %s).%s",
"[object Object]" === Object.prototype.toString.call(newChild)
? "object with keys {" + Object.keys(newChild).join(", ") + "}"
: newChild,
""
);
}
function ChildReconciler(shouldTrackSideEffects) {
function deleteChild(returnFiber, childToDelete) {
if (shouldTrackSideEffects) {
var last = returnFiber.lastEffect;
null !== last
? ((last.nextEffect = childToDelete),
(returnFiber.lastEffect = childToDelete))
: (returnFiber.firstEffect = returnFiber.lastEffect = childToDelete);
childToDelete.nextEffect = null;
childToDelete.effectTag = 8;
}
}
function deleteRemainingChildren(returnFiber, currentFirstChild) {
if (!shouldTrackSideEffects) return null;
for (; null !== currentFirstChild; )
deleteChild(returnFiber, currentFirstChild),
(currentFirstChild = currentFirstChild.sibling);
return null;
}
function mapRemainingChildren(returnFiber, currentFirstChild) {
for (returnFiber = new Map(); null !== currentFirstChild; )
null !== currentFirstChild.key
? returnFiber.set(currentFirstChild.key, currentFirstChild)
: returnFiber.set(currentFirstChild.index, currentFirstChild),
(currentFirstChild = currentFirstChild.sibling);
return returnFiber;
}
function useFiber(fiber, pendingProps, expirationTime) {
fiber = createWorkInProgress(fiber, pendingProps, expirationTime);
fiber.index = 0;
fiber.sibling = null;
return fiber;
}
function placeChild(newFiber, lastPlacedIndex, newIndex) {
newFiber.index = newIndex;
if (!shouldTrackSideEffects) return lastPlacedIndex;
newIndex = newFiber.alternate;
if (null !== newIndex)
return (
(newIndex = newIndex.index),
newIndex < lastPlacedIndex
? ((newFiber.effectTag = 2), lastPlacedIndex)
: newIndex
);
newFiber.effectTag = 2;
return lastPlacedIndex;
}
function placeSingleChild(newFiber) {
shouldTrackSideEffects &&
null === newFiber.alternate &&
(newFiber.effectTag = 2);
return newFiber;
}
function updateTextNode(returnFiber, current, textContent, expirationTime) {
if (null === current || 6 !== current.tag)
return (
(current = createFiberFromText(
textContent,
returnFiber.internalContextTag,
expirationTime
)),
(current["return"] = returnFiber),
current
);
current = useFiber(current, textContent, expirationTime);
current["return"] = returnFiber;
return current;
}
function updateElement(returnFiber, current, element, expirationTime) {
if (null !== current && current.type === element.type)
return (
(expirationTime = useFiber(current, element.props, expirationTime)),
(expirationTime.ref = coerceRef(current, element)),
(expirationTime["return"] = returnFiber),
expirationTime
);
expirationTime = createFiberFromElement(
element,
returnFiber.internalContextTag,
expirationTime
);
expirationTime.ref = coerceRef(current, element);
expirationTime["return"] = returnFiber;
return expirationTime;
}
function updateCall(returnFiber, current, call, expirationTime) {
if (null === current || 7 !== current.tag)
return (
(current = createFiberFromCall(
call,
returnFiber.internalContextTag,
expirationTime
)),
(current["return"] = returnFiber),
current
);
current = useFiber(current, call, expirationTime);
current["return"] = returnFiber;
return current;
}
function updateReturn(returnFiber, current, returnNode, expirationTime) {
if (null === current || 9 !== current.tag)
return (
(current = createFiberFromReturn(
returnNode,
returnFiber.internalContextTag,
expirationTime
)),
(current.type = returnNode.value),
(current["return"] = returnFiber),
current
);
current = useFiber(current, null, expirationTime);
current.type = returnNode.value;
current["return"] = returnFiber;
return current;
}
function updatePortal(returnFiber, current, portal, expirationTime) {
if (
null === current ||
4 !== current.tag ||
current.stateNode.containerInfo !== portal.containerInfo ||
current.stateNode.implementation !== portal.implementation
)
return (
(current = createFiberFromPortal(
portal,
returnFiber.internalContextTag,
expirationTime
)),
(current["return"] = returnFiber),
current
);
current = useFiber(current, portal.children || [], expirationTime);
current["return"] = returnFiber;
return current;
}
function updateFragment(returnFiber, current, fragment, expirationTime, key) {
if (null === current || 10 !== current.tag)
return (
(current = createFiberFromFragment(
fragment,
returnFiber.internalContextTag,
expirationTime,
key
)),
(current["return"] = returnFiber),
current
);
current = useFiber(current, fragment, expirationTime);
current["return"] = returnFiber;
return current;
}
function createChild(returnFiber, newChild, expirationTime) {
if ("string" === typeof newChild || "number" === typeof newChild)
return (
(newChild = createFiberFromText(
"" + newChild,
returnFiber.internalContextTag,
expirationTime
)),
(newChild["return"] = returnFiber),
newChild
);
if ("object" === typeof newChild && null !== newChild) {
switch (newChild.$$typeof) {
case REACT_ELEMENT_TYPE:
if (newChild.type === REACT_FRAGMENT_TYPE)
return (
(newChild = createFiberFromFragment(
newChild.props.children,
returnFiber.internalContextTag,
expirationTime,
newChild.key
)),
(newChild["return"] = returnFiber),
newChild
);
expirationTime = createFiberFromElement(
newChild,
returnFiber.internalContextTag,
expirationTime
);
expirationTime.ref = coerceRef(null, newChild);
expirationTime["return"] = returnFiber;
return expirationTime;
case REACT_CALL_TYPE:
return (
(newChild = createFiberFromCall(
newChild,
returnFiber.internalContextTag,
expirationTime
)),
(newChild["return"] = returnFiber),
newChild
);
case REACT_RETURN_TYPE:
return (
(expirationTime = createFiberFromReturn(
newChild,
returnFiber.internalContextTag,
expirationTime
)),
(expirationTime.type = newChild.value),
(expirationTime["return"] = returnFiber),
expirationTime
);
case REACT_PORTAL_TYPE:
return (
(newChild = createFiberFromPortal(
newChild,
returnFiber.internalContextTag,
expirationTime
)),
(newChild["return"] = returnFiber),
newChild
);
}
if (isArray$1(newChild) || getIteratorFn(newChild))
return (
(newChild = createFiberFromFragment(
newChild,
returnFiber.internalContextTag,
expirationTime,
null
)),
(newChild["return"] = returnFiber),
newChild
);
throwOnInvalidObjectType(returnFiber, newChild);
}
return null;
}
function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
var key = null !== oldFiber ? oldFiber.key : null;
if ("string" === typeof newChild || "number" === typeof newChild)
return null !== key
? null
: updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
if ("object" === typeof newChild && null !== newChild) {
switch (newChild.$$typeof) {
case REACT_ELEMENT_TYPE:
return newChild.key === key
? newChild.type === REACT_FRAGMENT_TYPE
? updateFragment(
returnFiber,
oldFiber,
newChild.props.children,
expirationTime,
key
)
: updateElement(returnFiber, oldFiber, newChild, expirationTime)
: null;
case REACT_CALL_TYPE:
return newChild.key === key
? updateCall(returnFiber, oldFiber, newChild, expirationTime)
: null;
case REACT_RETURN_TYPE:
return null === key
? updateReturn(returnFiber, oldFiber, newChild, expirationTime)
: null;
case REACT_PORTAL_TYPE:
return newChild.key === key
? updatePortal(returnFiber, oldFiber, newChild, expirationTime)
: null;
}
if (isArray$1(newChild) || getIteratorFn(newChild))
return null !== key
? null
: updateFragment(
returnFiber,
oldFiber,
newChild,
expirationTime,
null
);
throwOnInvalidObjectType(returnFiber, newChild);
}
return null;
}
function updateFromMap(
existingChildren,
returnFiber,
newIdx,
newChild,
expirationTime
) {
if ("string" === typeof newChild || "number" === typeof newChild)
return (
(existingChildren = existingChildren.get(newIdx) || null),
updateTextNode(
returnFiber,
existingChildren,
"" + newChild,
expirationTime
)
);
if ("object" === typeof newChild && null !== newChild) {
switch (newChild.$$typeof) {
case REACT_ELEMENT_TYPE:
return (
(existingChildren =
existingChildren.get(
null === newChild.key ? newIdx : newChild.key
) || null),
newChild.type === REACT_FRAGMENT_TYPE
? updateFragment(
returnFiber,
existingChildren,
newChild.props.children,
expirationTime,
newChild.key
)
: updateElement(
returnFiber,
existingChildren,
newChild,
expirationTime
)
);
case REACT_CALL_TYPE:
return (
(existingChildren =
existingChildren.get(
null === newChild.key ? newIdx : newChild.key
) || null),
updateCall(returnFiber, existingChildren, newChild, expirationTime)
);
case REACT_RETURN_TYPE:
return (
(existingChildren = existingChildren.get(newIdx) || null),
updateReturn(
returnFiber,
existingChildren,
newChild,
expirationTime
)
);
case REACT_PORTAL_TYPE:
return (
(existingChildren =
existingChildren.get(
null === newChild.key ? newIdx : newChild.key
) || null),
updatePortal(
returnFiber,
existingChildren,
newChild,
expirationTime
)
);
}
if (isArray$1(newChild) || getIteratorFn(newChild))
return (
(existingChildren = existingChildren.get(newIdx) || null),
updateFragment(
returnFiber,
existingChildren,
newChild,
expirationTime,
null
)
);
throwOnInvalidObjectType(returnFiber, newChild);
}
return null;
}
function reconcileChildrenArray(
returnFiber,
currentFirstChild,
newChildren,
expirationTime
) {
for (
var resultingFirstChild = null,
previousNewFiber = null,
oldFiber = currentFirstChild,
newIdx = (currentFirstChild = 0),
nextOldFiber = null;
null !== oldFiber && newIdx < newChildren.length;
newIdx++
) {
oldFiber.index > newIdx
? ((nextOldFiber = oldFiber), (oldFiber = null))
: (nextOldFiber = oldFiber.sibling);
var newFiber = updateSlot(
returnFiber,
oldFiber,
newChildren[newIdx],
expirationTime
);
if (null === newFiber) {
null === oldFiber && (oldFiber = nextOldFiber);
break;
}
shouldTrackSideEffects &&
oldFiber &&
null === newFiber.alternate &&
deleteChild(returnFiber, oldFiber);
currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
null === previousNewFiber
? (resultingFirstChild = newFiber)
: (previousNewFiber.sibling = newFiber);
previousNewFiber = newFiber;
oldFiber = nextOldFiber;
}
if (newIdx === newChildren.length)
return (
deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild
);
if (null === oldFiber) {
for (; newIdx < newChildren.length; newIdx++)
if (
(oldFiber = createChild(
returnFiber,
newChildren[newIdx],
expirationTime
))
)
(currentFirstChild = placeChild(oldFiber, currentFirstChild, newIdx)),
null === previousNewFiber
? (resultingFirstChild = oldFiber)
: (previousNewFiber.sibling = oldFiber),
(previousNewFiber = oldFiber);
return resultingFirstChild;
}
for (
oldFiber = mapRemainingChildren(returnFiber, oldFiber);
newIdx < newChildren.length;
newIdx++
)
if (
(nextOldFiber = updateFromMap(
oldFiber,
returnFiber,
newIdx,
newChildren[newIdx],
expirationTime
))
) {
if (shouldTrackSideEffects && null !== nextOldFiber.alternate)
oldFiber["delete"](
null === nextOldFiber.key ? newIdx : nextOldFiber.key
);
currentFirstChild = placeChild(nextOldFiber, currentFirstChild, newIdx);
null === previousNewFiber
? (resultingFirstChild = nextOldFiber)
: (previousNewFiber.sibling = nextOldFiber);
previousNewFiber = nextOldFiber;
}
shouldTrackSideEffects &&
oldFiber.forEach(function(child) {
return deleteChild(returnFiber, child);
});
return resultingFirstChild;
}
function reconcileChildrenIterator(
returnFiber,
currentFirstChild,
newChildrenIterable,
expirationTime
) {
var iteratorFn = getIteratorFn(newChildrenIterable);
invariant(
"function" === typeof iteratorFn,
"An object is not an iterable. This error is likely caused by a bug in React. Please file an issue."
);
newChildrenIterable = iteratorFn.call(newChildrenIterable);
invariant(
null != newChildrenIterable,
"An iterable object provided no iterator."
);
for (
var previousNewFiber = (iteratorFn = null),
oldFiber = currentFirstChild,
newIdx = (currentFirstChild = 0),
nextOldFiber = null,
step = newChildrenIterable.next();
null !== oldFiber && !step.done;
newIdx++, step = newChildrenIterable.next()
) {
oldFiber.index > newIdx
? ((nextOldFiber = oldFiber), (oldFiber = null))
: (nextOldFiber = oldFiber.sibling);
var newFiber = updateSlot(
returnFiber,
oldFiber,
step.value,
expirationTime
);
if (null === newFiber) {
oldFiber || (oldFiber = nextOldFiber);
break;
}
shouldTrackSideEffects &&
oldFiber &&
null === newFiber.alternate &&
deleteChild(returnFiber, oldFiber);
currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
null === previousNewFiber
? (iteratorFn = newFiber)
: (previousNewFiber.sibling = newFiber);
previousNewFiber = newFiber;
oldFiber = nextOldFiber;
}
if (step.done)
return deleteRemainingChildren(returnFiber, oldFiber), iteratorFn;
if (null === oldFiber) {
for (; !step.done; newIdx++, step = newChildrenIterable.next())
(step = createChild(returnFiber, step.value, expirationTime)),
null !== step &&
((currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
null === previousNewFiber
? (iteratorFn = step)
: (previousNewFiber.sibling = step),
(previousNewFiber = step));
return iteratorFn;
}
for (
oldFiber = mapRemainingChildren(returnFiber, oldFiber);
!step.done;
newIdx++, step = newChildrenIterable.next()
)
if (
((step = updateFromMap(
oldFiber,
returnFiber,
newIdx,
step.value,
expirationTime
)),
null !== step)
) {
if (shouldTrackSideEffects && null !== step.alternate)
oldFiber["delete"](null === step.key ? newIdx : step.key);
currentFirstChild = placeChild(step, currentFirstChild, newIdx);
null === previousNewFiber
? (iteratorFn = step)
: (previousNewFiber.sibling = step);
previousNewFiber = step;
}
shouldTrackSideEffects &&
oldFiber.forEach(function(child) {
return deleteChild(returnFiber, child);
});
return iteratorFn;
}
return function(returnFiber, currentFirstChild, newChild, expirationTime) {
"object" === typeof newChild &&
null !== newChild &&
newChild.type === REACT_FRAGMENT_TYPE &&
null === newChild.key &&
(newChild = newChild.props.children);
var isObject = "object" === typeof newChild && null !== newChild;
if (isObject)
switch (newChild.$$typeof) {
case REACT_ELEMENT_TYPE:
a: {
var key = newChild.key;
for (isObject = currentFirstChild; null !== isObject; ) {
if (isObject.key === key)
if (
10 === isObject.tag
? newChild.type === REACT_FRAGMENT_TYPE
: isObject.type === newChild.type
) {
deleteRemainingChildren(returnFiber, isObject.sibling);
currentFirstChild = useFiber(
isObject,
newChild.type === REACT_FRAGMENT_TYPE
? newChild.props.children
: newChild.props,
expirationTime
);
currentFirstChild.ref = coerceRef(isObject, newChild);
currentFirstChild["return"] = returnFiber;
returnFiber = currentFirstChild;
break a;
} else {
deleteRemainingChildren(returnFiber, isObject);
break;
}
else deleteChild(returnFiber, isObject);
isObject = isObject.sibling;
}
newChild.type === REACT_FRAGMENT_TYPE
? ((currentFirstChild = createFiberFromFragment(
newChild.props.children,
returnFiber.internalContextTag,
expirationTime,
newChild.key
)),
(currentFirstChild["return"] = returnFiber),
(returnFiber = currentFirstChild))
: ((expirationTime = createFiberFromElement(
newChild,
returnFiber.internalContextTag,
expirationTime
)),
(expirationTime.ref = coerceRef(currentFirstChild, newChild)),
(expirationTime["return"] = returnFiber),
(returnFiber = expirationTime));
}
return placeSingleChild(returnFiber);
case REACT_CALL_TYPE:
a: {
for (isObject = newChild.key; null !== currentFirstChild; ) {
if (currentFirstChild.key === isObject)
if (7 === currentFirstChild.tag) {
deleteRemainingChildren(
returnFiber,
currentFirstChild.sibling
);
currentFirstChild = useFiber(
currentFirstChild,
newChild,
expirationTime
);
currentFirstChild["return"] = returnFiber;
returnFiber = currentFirstChild;
break a;
} else {
deleteRemainingChildren(returnFiber, currentFirstChild);
break;
}
else deleteChild(returnFiber, currentFirstChild);
currentFirstChild = currentFirstChild.sibling;
}
currentFirstChild = createFiberFromCall(
newChild,
returnFiber.internalContextTag,
expirationTime
);
currentFirstChild["return"] = returnFiber;
returnFiber = currentFirstChild;
}
return placeSingleChild(returnFiber);
case REACT_RETURN_TYPE:
a: {
if (null !== currentFirstChild)
if (9 === currentFirstChild.tag) {
deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
currentFirstChild = useFiber(
currentFirstChild,
null,
expirationTime
);
currentFirstChild.type = newChild.value;
currentFirstChild["return"] = returnFiber;
returnFiber = currentFirstChild;
break a;
} else deleteRemainingChildren(returnFiber, currentFirstChild);
currentFirstChild = createFiberFromReturn(
newChild,
returnFiber.internalContextTag,
expirationTime
);
currentFirstChild.type = newChild.value;
currentFirstChild["return"] = returnFiber;
returnFiber = currentFirstChild;
}
return placeSingleChild(returnFiber);
case REACT_PORTAL_TYPE:
a: {
for (isObject = newChild.key; null !== currentFirstChild; ) {
if (currentFirstChild.key === isObject)
if (
4 === currentFirstChild.tag &&
currentFirstChild.stateNode.containerInfo ===
newChild.containerInfo &&
currentFirstChild.stateNode.implementation ===
newChild.implementation
) {
deleteRemainingChildren(
returnFiber,
currentFirstChild.sibling
);
currentFirstChild = useFiber(
currentFirstChild,
newChild.children || [],
expirationTime
);
currentFirstChild["return"] = returnFiber;
returnFiber = currentFirstChild;
break a;
} else {
deleteRemainingChildren(returnFiber, currentFirstChild);
break;
}
else deleteChild(returnFiber, currentFirstChild);
currentFirstChild = currentFirstChild.sibling;
}
currentFirstChild = createFiberFromPortal(
newChild,
returnFiber.internalContextTag,
expirationTime
);
currentFirstChild["return"] = returnFiber;
returnFiber = currentFirstChild;
}
return placeSingleChild(returnFiber);
}
if ("string" === typeof newChild || "number" === typeof newChild)
return (
(newChild = "" + newChild),
null !== currentFirstChild && 6 === currentFirstChild.tag
? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling),
(currentFirstChild = useFiber(
currentFirstChild,
newChild,
expirationTime
)))
: (deleteRemainingChildren(returnFiber, currentFirstChild),
(currentFirstChild = createFiberFromText(
newChild,
returnFiber.internalContextTag,
expirationTime
))),
(currentFirstChild["return"] = returnFiber),
(returnFiber = currentFirstChild),
placeSingleChild(returnFiber)
);
if (isArray$1(newChild))
return reconcileChildrenArray(
returnFiber,
currentFirstChild,
newChild,
expirationTime
);
if (getIteratorFn(newChild))
return reconcileChildrenIterator(
returnFiber,
currentFirstChild,
newChild,
expirationTime
);
isObject && throwOnInvalidObjectType(returnFiber, newChild);
if ("undefined" === typeof newChild)
switch (returnFiber.tag) {
case 2:
case 1:
(expirationTime = returnFiber.type),
invariant(
!1,
"%s(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null.",
expirationTime.displayName || expirationTime.name || "Component"
);
}
return deleteRemainingChildren(returnFiber, currentFirstChild);
};
}
var reconcileChildFibers = ChildReconciler(!0),
mountChildFibers = ChildReconciler(!1);
function ReactFiberBeginWork(
config,
hostContext,
hydrationContext,
scheduleWork,
computeExpirationForFiber
) {
function reconcileChildren(current, workInProgress, nextChildren) {
var renderExpirationTime = workInProgress.expirationTime;
workInProgress.child =
null === current
? mountChildFibers(
workInProgress,
null,
nextChildren,
renderExpirationTime
)
: reconcileChildFibers(
workInProgress,
current.child,
nextChildren,
renderExpirationTime
);
}
function markRef(current, workInProgress) {
var ref = workInProgress.ref;
null === ref ||
(current && current.ref === ref) ||
(workInProgress.effectTag |= 128);
}
function finishClassComponent(
current,
workInProgress,
shouldUpdate,
hasContext
) {
markRef(current, workInProgress);
if (!shouldUpdate)
return (
hasContext && invalidateContextProvider(workInProgress, !1),
bailoutOnAlreadyFinishedWork(current, workInProgress)
);
shouldUpdate = workInProgress.stateNode;
ReactCurrentOwner.current = workInProgress;
debugRenderPhaseSideEffects && shouldUpdate.render();
var nextChildren = shouldUpdate.render();
workInProgress.effectTag |= 1;
reconcileChildren(current, workInProgress, nextChildren);
workInProgress.memoizedState = shouldUpdate.state;
workInProgress.memoizedProps = shouldUpdate.props;
hasContext && invalidateContextProvider(workInProgress, !0);
return workInProgress.child;
}
function pushHostRootContext(workInProgress) {
var root = workInProgress.stateNode;
root.pendingContext
? pushTopLevelContextObject(
workInProgress,
root.pendingContext,
root.pendingContext !== root.context
)
: root.context &&
pushTopLevelContextObject(workInProgress, root.context, !1);
pushHostContainer(workInProgress, root.containerInfo);
}
function bailoutOnAlreadyFinishedWork(current, workInProgress) {
invariant(
null === current || workInProgress.child === current.child,
"Resuming work not yet implemented."
);
if (null !== workInProgress.child) {
current = workInProgress.child;
var newChild = createWorkInProgress(
current,
current.pendingProps,
current.expirationTime
);
workInProgress.child = newChild;
for (newChild["return"] = workInProgress; null !== current.sibling; )
(current = current.sibling),
(newChild = newChild.sibling = createWorkInProgress(
current,
current.pendingProps,
current.expirationTime
)),
(newChild["return"] = workInProgress);
newChild.sibling = null;
}
return workInProgress.child;
}
function bailoutOnLowPriority(current, workInProgress) {
switch (workInProgress.tag) {
case 3:
pushHostRootContext(workInProgress);
break;
case 2:
pushContextProvider(workInProgress);
break;
case 4:
pushHostContainer(
workInProgress,
workInProgress.stateNode.containerInfo
);
}
return null;
}
var shouldSetTextContent = config.shouldSetTextContent,
useSyncScheduling = config.useSyncScheduling,
shouldDeprioritizeSubtree = config.shouldDeprioritizeSubtree,
pushHostContext = hostContext.pushHostContext,
pushHostContainer = hostContext.pushHostContainer,
enterHydrationState = hydrationContext.enterHydrationState,
resetHydrationState = hydrationContext.resetHydrationState,
tryToClaimNextHydratableInstance =
hydrationContext.tryToClaimNextHydratableInstance;
config = ReactFiberClassComponent(
scheduleWork,
computeExpirationForFiber,
function(workInProgress, nextProps) {
workInProgress.memoizedProps = nextProps;
},
function(workInProgress, nextState) {
workInProgress.memoizedState = nextState;
}
);
var adoptClassInstance = config.adoptClassInstance,
constructClassInstance = config.constructClassInstance,
mountClassInstance = config.mountClassInstance,
updateClassInstance = config.updateClassInstance;
return {
beginWork: function(current, workInProgress, renderExpirationTime) {
if (
0 === workInProgress.expirationTime ||
workInProgress.expirationTime > renderExpirationTime
)
return bailoutOnLowPriority(current, workInProgress);
switch (workInProgress.tag) {
case 0:
invariant(
null === current,
"An indeterminate component should never have mounted. This error is likely caused by a bug in React. Please file an issue."
);
var fn = workInProgress.type,
props = workInProgress.pendingProps,
unmaskedContext = getUnmaskedContext(workInProgress);
unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
fn = fn(props, unmaskedContext);
workInProgress.effectTag |= 1;
"object" === typeof fn &&
null !== fn &&
"function" === typeof fn.render
? ((workInProgress.tag = 2),
(props = pushContextProvider(workInProgress)),
adoptClassInstance(workInProgress, fn),
mountClassInstance(workInProgress, renderExpirationTime),
(current = finishClassComponent(
current,
workInProgress,
!0,
props
)))
: ((workInProgress.tag = 1),
reconcileChildren(current, workInProgress, fn),
(workInProgress.memoizedProps = props),
(current = workInProgress.child));
return current;
case 1:
return (
(props = workInProgress.type),
(renderExpirationTime = workInProgress.pendingProps),
didPerformWorkStackCursor.current ||
workInProgress.memoizedProps !== renderExpirationTime
? ((fn = getUnmaskedContext(workInProgress)),
(fn = getMaskedContext(workInProgress, fn)),
(props = props(renderExpirationTime, fn)),
(workInProgress.effectTag |= 1),
reconcileChildren(current, workInProgress, props),
(workInProgress.memoizedProps = renderExpirationTime),
(current = workInProgress.child))
: (current = bailoutOnAlreadyFinishedWork(
current,
workInProgress
)),
current
);
case 2:
return (
(props = pushContextProvider(workInProgress)),
(fn = void 0),
null === current
? workInProgress.stateNode
? invariant(!1, "Resuming work not yet implemented.")
: (constructClassInstance(
workInProgress,
workInProgress.pendingProps
),
mountClassInstance(workInProgress, renderExpirationTime),
(fn = !0))
: (fn = updateClassInstance(
current,
workInProgress,
renderExpirationTime
)),
finishClassComponent(current, workInProgress, fn, props)
);
case 3:
return (
pushHostRootContext(workInProgress),
(props = workInProgress.updateQueue),
null !== props
? ((fn = workInProgress.memoizedState),
(props = processUpdateQueue(
current,
workInProgress,
props,
null,
null,
renderExpirationTime
)),
fn === props
? (resetHydrationState(),
(current = bailoutOnAlreadyFinishedWork(
current,
workInProgress
)))
: ((fn = props.element),
(unmaskedContext = workInProgress.stateNode),
(null === current || null === current.child) &&
unmaskedContext.hydrate &&
enterHydrationState(workInProgress)
? ((workInProgress.effectTag |= 2),
(workInProgress.child = mountChildFibers(
workInProgress,
null,
fn,
renderExpirationTime
)))
: (resetHydrationState(),
reconcileChildren(current, workInProgress, fn)),
(workInProgress.memoizedState = props),
(current = workInProgress.child)))
: (resetHydrationState(),
(current = bailoutOnAlreadyFinishedWork(
current,
workInProgress
))),
current
);
case 5:
pushHostContext(workInProgress);
null === current && tryToClaimNextHydratableInstance(workInProgress);
props = workInProgress.type;
var memoizedProps = workInProgress.memoizedProps;
fn = workInProgress.pendingProps;
unmaskedContext = null !== current ? current.memoizedProps : null;
didPerformWorkStackCursor.current || memoizedProps !== fn
? ((memoizedProps = fn.children),
shouldSetTextContent(props, fn)
? (memoizedProps = null)
: unmaskedContext &&
shouldSetTextContent(props, unmaskedContext) &&
(workInProgress.effectTag |= 16),
markRef(current, workInProgress),
2147483647 !== renderExpirationTime &&
!useSyncScheduling &&
shouldDeprioritizeSubtree(props, fn)
? ((workInProgress.expirationTime = 2147483647),
(current = null))
: (reconcileChildren(current, workInProgress, memoizedProps),
(workInProgress.memoizedProps = fn),
(current = workInProgress.child)))
: (current = bailoutOnAlreadyFinishedWork(current, workInProgress));
return current;
case 6:
return (
null === current &&
tryToClaimNextHydratableInstance(workInProgress),
(workInProgress.memoizedProps = workInProgress.pendingProps),
null
);
case 8:
workInProgress.tag = 7;
case 7:
return (
(props = workInProgress.pendingProps),
didPerformWorkStackCursor.current ||
workInProgress.memoizedProps !== props ||
(props = workInProgress.memoizedProps),
(fn = props.children),
(workInProgress.stateNode =
null === current
? mountChildFibers(
workInProgress,
workInProgress.stateNode,
fn,
renderExpirationTime
)
: reconcileChildFibers(
workInProgress,
workInProgress.stateNode,
fn,
renderExpirationTime
)),
(workInProgress.memoizedProps = props),
workInProgress.stateNode
);
case 9:
return null;
case 4:
return (
pushHostContainer(
workInProgress,
workInProgress.stateNode.containerInfo
),
(props = workInProgress.pendingProps),
didPerformWorkStackCursor.current ||
workInProgress.memoizedProps !== props
? (null === current
? (workInProgress.child = reconcileChildFibers(
workInProgress,
null,
props,
renderExpirationTime
))
: reconcileChildren(current, workInProgress, props),
(workInProgress.memoizedProps = props),
(current = workInProgress.child))
: (current = bailoutOnAlreadyFinishedWork(
current,
workInProgress
)),
current
);
case 10:
return (
(renderExpirationTime = workInProgress.pendingProps),
didPerformWorkStackCursor.current ||
(null !== renderExpirationTime &&
workInProgress.memoizedProps !== renderExpirationTime)
? (reconcileChildren(
current,
workInProgress,
renderExpirationTime
),
(workInProgress.memoizedProps = renderExpirationTime),
(current = workInProgress.child))
: (current = bailoutOnAlreadyFinishedWork(
current,
workInProgress
)),
current
);
default:
invariant(
!1,
"Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue."
);
}
},
beginFailedWork: function(current, workInProgress, renderExpirationTime) {
switch (workInProgress.tag) {
case 2:
pushContextProvider(workInProgress);
break;
case 3:
pushHostRootContext(workInProgress);
break;
default:
invariant(
!1,
"Invalid type of work. This error is likely caused by a bug in React. Please file an issue."
);
}
workInProgress.effectTag |= 64;
null === current
? (workInProgress.child = null)
: workInProgress.child !== current.child &&
(workInProgress.child = current.child);
if (
0 === workInProgress.expirationTime ||
workInProgress.expirationTime > renderExpirationTime
)
return bailoutOnLowPriority(current, workInProgress);
workInProgress.firstEffect = null;
workInProgress.lastEffect = null;
workInProgress.child =
null === current
? mountChildFibers(workInProgress, null, null, renderExpirationTime)
: reconcileChildFibers(
workInProgress,
current.child,
null,
renderExpirationTime
);
2 === workInProgress.tag &&
((current = workInProgress.stateNode),
(workInProgress.memoizedProps = current.props),
(workInProgress.memoizedState = current.state));
return workInProgress.child;
}
};
}
function ReactFiberCompleteWork(config, hostContext, hydrationContext) {
function markUpdate(workInProgress) {
workInProgress.effectTag |= 4;
}
var createInstance = config.createInstance,
createTextInstance = config.createTextInstance,
appendInitialChild = config.appendInitialChild,
finalizeInitialChildren = config.finalizeInitialChildren,
prepareUpdate = config.prepareUpdate,
persistence = config.persistence,
getRootHostContainer = hostContext.getRootHostContainer,
popHostContext = hostContext.popHostContext,
getHostContext = hostContext.getHostContext,
popHostContainer = hostContext.popHostContainer,
prepareToHydrateHostInstance =
hydrationContext.prepareToHydrateHostInstance,
prepareToHydrateHostTextInstance =
hydrationContext.prepareToHydrateHostTextInstance,
popHydrationState = hydrationContext.popHydrationState,
updateHostContainer = void 0,
updateHostComponent = void 0,
updateHostText = void 0;
config.mutation
? ((updateHostContainer = function() {}),
(updateHostComponent = function(current, workInProgress, updatePayload) {
(workInProgress.updateQueue = updatePayload) &&
markUpdate(workInProgress);
}),
(updateHostText = function(current, workInProgress, oldText, newText) {
oldText !== newText && markUpdate(workInProgress);
}))
: persistence
? invariant(!1, "Persistent reconciler is disabled.")
: invariant(!1, "Noop reconciler is disabled.");
return {
completeWork: function(current, workInProgress, renderExpirationTime) {
var newProps = workInProgress.pendingProps;
switch (workInProgress.tag) {
case 1:
return null;
case 2:
return popContextProvider(workInProgress), null;
case 3:
popHostContainer(workInProgress);
pop(didPerformWorkStackCursor, workInProgress);
pop(contextStackCursor, workInProgress);
newProps = workInProgress.stateNode;
newProps.pendingContext &&
((newProps.context = newProps.pendingContext),
(newProps.pendingContext = null));
if (null === current || null === current.child)
popHydrationState(workInProgress), (workInProgress.effectTag &= -3);
updateHostContainer(workInProgress);
return null;
case 5:
popHostContext(workInProgress);
renderExpirationTime = getRootHostContainer();
var type = workInProgress.type;
if (null !== current && null != workInProgress.stateNode) {
var oldProps = current.memoizedProps,
instance = workInProgress.stateNode,
currentHostContext = getHostContext();
instance = prepareUpdate(
instance,
type,
oldProps,
newProps,
renderExpirationTime,
currentHostContext
);
updateHostComponent(
current,
workInProgress,
instance,
type,
oldProps,
newProps,
renderExpirationTime
);
current.ref !== workInProgress.ref &&
(workInProgress.effectTag |= 128);
} else {
if (!newProps)
return (
invariant(
null !== workInProgress.stateNode,
"We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
),
null
);
current = getHostContext();
if (popHydrationState(workInProgress))
prepareToHydrateHostInstance(
workInProgress,
renderExpirationTime,
current
) && markUpdate(workInProgress);
else {
current = createInstance(
type,
newProps,
renderExpirationTime,
current,
workInProgress
);
a: for (oldProps = workInProgress.child; null !== oldProps; ) {
if (5 === oldProps.tag || 6 === oldProps.tag)
appendInitialChild(current, oldProps.stateNode);
else if (4 !== oldProps.tag && null !== oldProps.child) {
oldProps.child["return"] = oldProps;
oldProps = oldProps.child;
continue;
}
if (oldProps === workInProgress) break;
for (; null === oldProps.sibling; ) {
if (
null === oldProps["return"] ||
oldProps["return"] === workInProgress
)
break a;
oldProps = oldProps["return"];
}
oldProps.sibling["return"] = oldProps["return"];
oldProps = oldProps.sibling;
}
finalizeInitialChildren(
current,
type,
newProps,
renderExpirationTime
) && markUpdate(workInProgress);
workInProgress.stateNode = current;
}
null !== workInProgress.ref && (workInProgress.effectTag |= 128);
}
return null;
case 6:
if (current && null != workInProgress.stateNode)
updateHostText(
current,
workInProgress,
current.memoizedProps,
newProps
);
else {
if ("string" !== typeof newProps)
return (
invariant(
null !== workInProgress.stateNode,
"We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
),
null
);
current = getRootHostContainer();
renderExpirationTime = getHostContext();
popHydrationState(workInProgress)
? prepareToHydrateHostTextInstance(workInProgress) &&
markUpdate(workInProgress)
: (workInProgress.stateNode = createTextInstance(
newProps,
current,
renderExpirationTime,
workInProgress
));
}
return null;
case 7:
newProps = workInProgress.memoizedProps;
invariant(
newProps,
"Should be resolved by now. This error is likely caused by a bug in React. Please file an issue."
);
workInProgress.tag = 8;
type = [];
a: for (
(oldProps = workInProgress.stateNode) &&
(oldProps["return"] = workInProgress);
null !== oldProps;
) {
if (5 === oldProps.tag || 6 === oldProps.tag || 4 === oldProps.tag)
invariant(!1, "A call cannot have host component children.");
else if (9 === oldProps.tag) type.push(oldProps.type);
else if (null !== oldProps.child) {
oldProps.child["return"] = oldProps;
oldProps = oldProps.child;
continue;
}
for (; null === oldProps.sibling; ) {
if (
null === oldProps["return"] ||
oldProps["return"] === workInProgress
)
break a;
oldProps = oldProps["return"];
}
oldProps.sibling["return"] = oldProps["return"];
oldProps = oldProps.sibling;
}
oldProps = newProps.handler;
newProps = oldProps(newProps.props, type);
workInProgress.child = reconcileChildFibers(
workInProgress,
null !== current ? current.child : null,
newProps,
renderExpirationTime
);
return workInProgress.child;
case 8:
return (workInProgress.tag = 7), null;
case 9:
return null;
case 10:
return null;
case 4:
return (
popHostContainer(workInProgress),
updateHostContainer(workInProgress),
null
);
case 0:
invariant(
!1,
"An indeterminate component should have become determinate before completing. This error is likely caused by a bug in React. Please file an issue."
);
default:
invariant(
!1,
"Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue."
);
}
}
};
}
function ReactFiberCommitWork(config, captureError) {
function safelyDetachRef(current) {
var ref = current.ref;
if (null !== ref)
try {
ref(null);
} catch (refError) {
captureError(current, refError);
}
}
function commitUnmount(current) {
"function" === typeof onCommitUnmount && onCommitUnmount(current);
switch (current.tag) {
case 2:
safelyDetachRef(current);
var instance = current.stateNode;
if ("function" === typeof instance.componentWillUnmount)
try {
(instance.props = current.memoizedProps),
(instance.state = current.memoizedState),
instance.componentWillUnmount();
} catch (unmountError) {
captureError(current, unmountError);
}
break;
case 5:
safelyDetachRef(current);
break;
case 7:
commitNestedUnmounts(current.stateNode);
break;
case 4:
mutation && unmountHostComponents(current);
}
}
function commitNestedUnmounts(root) {
for (var node = root; ; )
if (
(commitUnmount(node),
null === node.child || (mutation && 4 === node.tag))
) {
if (node === root) break;
for (; null === node.sibling; ) {
if (null === node["return"] || node["return"] === root) return;
node = node["return"];
}
node.sibling["return"] = node["return"];
node = node.sibling;
} else (node.child["return"] = node), (node = node.child);
}
function isHostParent(fiber) {
return 5 === fiber.tag || 3 === fiber.tag || 4 === fiber.tag;
}
function unmountHostComponents(current) {
for (
var node = current,
currentParentIsValid = !1,
currentParent = void 0,
currentParentIsContainer = void 0;
;
) {
if (!currentParentIsValid) {
currentParentIsValid = node["return"];
a: for (;;) {
invariant(
null !== currentParentIsValid,
"Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."
);
switch (currentParentIsValid.tag) {
case 5:
currentParent = currentParentIsValid.stateNode;
currentParentIsContainer = !1;
break a;
case 3:
currentParent = currentParentIsValid.stateNode.containerInfo;
currentParentIsContainer = !0;
break a;
case 4:
currentParent = currentParentIsValid.stateNode.containerInfo;
currentParentIsContainer = !0;
break a;
}
currentParentIsValid = currentParentIsValid["return"];
}
currentParentIsValid = !0;
}
if (5 === node.tag || 6 === node.tag)
commitNestedUnmounts(node),
currentParentIsContainer
? removeChildFromContainer(currentParent, node.stateNode)
: removeChild(currentParent, node.stateNode);
else if (
(4 === node.tag
? (currentParent = node.stateNode.containerInfo)
: commitUnmount(node),
null !== node.child)
) {
node.child["return"] = node;
node = node.child;
continue;
}
if (node === current) break;
for (; null === node.sibling; ) {
if (null === node["return"] || node["return"] === current) return;
node = node["return"];
4 === node.tag && (currentParentIsValid = !1);
}
node.sibling["return"] = node["return"];
node = node.sibling;
}
}
var getPublicInstance = config.getPublicInstance,
mutation = config.mutation;
config = config.persistence;
mutation ||
(config
? invariant(!1, "Persistent reconciler is disabled.")
: invariant(!1, "Noop reconciler is disabled."));
var commitMount = mutation.commitMount,
commitUpdate = mutation.commitUpdate,
resetTextContent = mutation.resetTextContent,
commitTextUpdate = mutation.commitTextUpdate,
appendChild = mutation.appendChild,
appendChildToContainer = mutation.appendChildToContainer,
insertBefore = mutation.insertBefore,
insertInContainerBefore = mutation.insertInContainerBefore,
removeChild = mutation.removeChild,
removeChildFromContainer = mutation.removeChildFromContainer;
return {
commitResetTextContent: function(current) {
resetTextContent(current.stateNode);
},
commitPlacement: function(finishedWork) {
a: {
for (var parent = finishedWork["return"]; null !== parent; ) {
if (isHostParent(parent)) {
var parentFiber = parent;
break a;
}
parent = parent["return"];
}
invariant(
!1,
"Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."
);
parentFiber = void 0;
}
var isContainer = (parent = void 0);
switch (parentFiber.tag) {
case 5:
parent = parentFiber.stateNode;
isContainer = !1;
break;
case 3:
parent = parentFiber.stateNode.containerInfo;
isContainer = !0;
break;
case 4:
parent = parentFiber.stateNode.containerInfo;
isContainer = !0;
break;
default:
invariant(
!1,
"Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue."
);
}
parentFiber.effectTag & 16 &&
(resetTextContent(parent), (parentFiber.effectTag &= -17));
a: b: for (parentFiber = finishedWork; ; ) {
for (; null === parentFiber.sibling; ) {
if (
null === parentFiber["return"] ||
isHostParent(parentFiber["return"])
) {
parentFiber = null;
break a;
}
parentFiber = parentFiber["return"];
}
parentFiber.sibling["return"] = parentFiber["return"];
for (
parentFiber = parentFiber.sibling;
5 !== parentFiber.tag && 6 !== parentFiber.tag;
) {
if (parentFiber.effectTag & 2) continue b;
if (null === parentFiber.child || 4 === parentFiber.tag) continue b;
else
(parentFiber.child["return"] = parentFiber),
(parentFiber = parentFiber.child);
}
if (!(parentFiber.effectTag & 2)) {
parentFiber = parentFiber.stateNode;
break a;
}
}
for (var node = finishedWork; ; ) {
if (5 === node.tag || 6 === node.tag)
parentFiber
? isContainer
? insertInContainerBefore(parent, node.stateNode, parentFiber)
: insertBefore(parent, node.stateNode, parentFiber)
: isContainer
? appendChildToContainer(parent, node.stateNode)
: appendChild(parent, node.stateNode);
else if (4 !== node.tag && null !== node.child) {
node.child["return"] = node;
node = node.child;
continue;
}
if (node === finishedWork) break;
for (; null === node.sibling; ) {
if (null === node["return"] || node["return"] === finishedWork)
return;
node = node["return"];
}
node.sibling["return"] = node["return"];
node = node.sibling;
}
},
commitDeletion: function(current) {
unmountHostComponents(current);
current["return"] = null;
current.child = null;
current.alternate &&
((current.alternate.child = null),
(current.alternate["return"] = null));
},
commitWork: function(current, finishedWork) {
switch (finishedWork.tag) {
case 2:
break;
case 5:
var instance = finishedWork.stateNode;
if (null != instance) {
var newProps = finishedWork.memoizedProps;
current = null !== current ? current.memoizedProps : newProps;
var type = finishedWork.type,
updatePayload = finishedWork.updateQueue;
finishedWork.updateQueue = null;
null !== updatePayload &&
commitUpdate(
instance,
updatePayload,
type,
current,
newProps,
finishedWork
);
}
break;
case 6:
invariant(
null !== finishedWork.stateNode,
"This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue."
);
instance = finishedWork.memoizedProps;
commitTextUpdate(
finishedWork.stateNode,
null !== current ? current.memoizedProps : instance,
instance
);
break;
case 3:
break;
default:
invariant(
!1,
"This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."
);
}
},
commitLifeCycles: function(current, finishedWork) {
switch (finishedWork.tag) {
case 2:
var instance = finishedWork.stateNode;
if (finishedWork.effectTag & 4)
if (null === current)
(instance.props = finishedWork.memoizedProps),
(instance.state = finishedWork.memoizedState),
instance.componentDidMount();
else {
var prevProps = current.memoizedProps;
current = current.memoizedState;
instance.props = finishedWork.memoizedProps;
instance.state = finishedWork.memoizedState;
instance.componentDidUpdate(prevProps, current);
}
finishedWork = finishedWork.updateQueue;
null !== finishedWork && commitCallbacks(finishedWork, instance);
break;
case 3:
instance = finishedWork.updateQueue;
null !== instance &&
commitCallbacks(
instance,
null !== finishedWork.child ? finishedWork.child.stateNode : null
);
break;
case 5:
instance = finishedWork.stateNode;
null === current &&
finishedWork.effectTag & 4 &&
commitMount(
instance,
finishedWork.type,
finishedWork.memoizedProps,
finishedWork
);
break;
case 6:
break;
case 4:
break;
default:
invariant(
!1,
"This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."
);
}
},
commitAttachRef: function(finishedWork) {
var ref = finishedWork.ref;
if (null !== ref) {
var instance = finishedWork.stateNode;
switch (finishedWork.tag) {
case 5:
ref(getPublicInstance(instance));
break;
default:
ref(instance);
}
}
},
commitDetachRef: function(current) {
current = current.ref;
null !== current && current(null);
}
};
}
var NO_CONTEXT = {};
function ReactFiberHostContext(config) {
function requiredContext(c) {
invariant(
c !== NO_CONTEXT,
"Expected host context to exist. This error is likely caused by a bug in React. Please file an issue."
);
return c;
}
var getChildHostContext = config.getChildHostContext,
getRootHostContext = config.getRootHostContext,
contextStackCursor = { current: NO_CONTEXT },
contextFiberStackCursor = { current: NO_CONTEXT },
rootInstanceStackCursor = { current: NO_CONTEXT };
return {
getHostContext: function() {
return requiredContext(contextStackCursor.current);
},
getRootHostContainer: function() {
return requiredContext(rootInstanceStackCursor.current);
},
popHostContainer: function(fiber) {
pop(contextStackCursor, fiber);
pop(contextFiberStackCursor, fiber);
pop(rootInstanceStackCursor, fiber);
},
popHostContext: function(fiber) {
contextFiberStackCursor.current === fiber &&
(pop(contextStackCursor, fiber), pop(contextFiberStackCursor, fiber));
},
pushHostContainer: function(fiber, nextRootInstance) {
push(rootInstanceStackCursor, nextRootInstance, fiber);
nextRootInstance = getRootHostContext(nextRootInstance);
push(contextFiberStackCursor, fiber, fiber);
push(contextStackCursor, nextRootInstance, fiber);
},
pushHostContext: function(fiber) {
var rootInstance = requiredContext(rootInstanceStackCursor.current),
context = requiredContext(contextStackCursor.current);
rootInstance = getChildHostContext(context, fiber.type, rootInstance);
context !== rootInstance &&
(push(contextFiberStackCursor, fiber, fiber),
push(contextStackCursor, rootInstance, fiber));
},
resetHostContainer: function() {
contextStackCursor.current = NO_CONTEXT;
rootInstanceStackCursor.current = NO_CONTEXT;
}
};
}
function ReactFiberHydrationContext(config) {
function deleteHydratableInstance(returnFiber, instance) {
var fiber = createFiber(5, null, null, 0);
fiber.type = "DELETED";
fiber.stateNode = instance;
fiber["return"] = returnFiber;
fiber.effectTag = 8;
null !== returnFiber.lastEffect
? ((returnFiber.lastEffect.nextEffect = fiber),
(returnFiber.lastEffect = fiber))
: (returnFiber.firstEffect = returnFiber.lastEffect = fiber);
}
function tryHydrate(fiber, nextInstance) {
switch (fiber.tag) {
case 5:
return (
(nextInstance = canHydrateInstance(
nextInstance,
fiber.type,
fiber.pendingProps
)),
null !== nextInstance ? ((fiber.stateNode = nextInstance), !0) : !1
);
case 6:
return (
(nextInstance = canHydrateTextInstance(
nextInstance,
fiber.pendingProps
)),
null !== nextInstance ? ((fiber.stateNode = nextInstance), !0) : !1
);
default:
return !1;
}
}
function popToNextHostParent(fiber) {
for (
fiber = fiber["return"];
null !== fiber && 5 !== fiber.tag && 3 !== fiber.tag;
)
fiber = fiber["return"];
hydrationParentFiber = fiber;
}
var shouldSetTextContent = config.shouldSetTextContent;
config = config.hydration;
if (!config)
return {
enterHydrationState: function() {
return !1;
},
resetHydrationState: function() {},
tryToClaimNextHydratableInstance: function() {},
prepareToHydrateHostInstance: function() {
invariant(
!1,
"Expected prepareToHydrateHostInstance() to never be called. This error is likely caused by a bug in React. Please file an issue."
);
},
prepareToHydrateHostTextInstance: function() {
invariant(
!1,
"Expected prepareToHydrateHostTextInstance() to never be called. This error is likely caused by a bug in React. Please file an issue."
);
},
popHydrationState: function() {
return !1;
}
};
var canHydrateInstance = config.canHydrateInstance,
canHydrateTextInstance = config.canHydrateTextInstance,
getNextHydratableSibling = config.getNextHydratableSibling,
getFirstHydratableChild = config.getFirstHydratableChild,
hydrateInstance = config.hydrateInstance,
hydrateTextInstance = config.hydrateTextInstance,
hydrationParentFiber = null,
nextHydratableInstance = null,
isHydrating = !1;
return {
enterHydrationState: function(fiber) {
nextHydratableInstance = getFirstHydratableChild(
fiber.stateNode.containerInfo
);
hydrationParentFiber = fiber;
return (isHydrating = !0);
},
resetHydrationState: function() {
nextHydratableInstance = hydrationParentFiber = null;
isHydrating = !1;
},
tryToClaimNextHydratableInstance: function(fiber) {
if (isHydrating) {
var nextInstance = nextHydratableInstance;
if (nextInstance) {
if (!tryHydrate(fiber, nextInstance)) {
nextInstance = getNextHydratableSibling(nextInstance);
if (!nextInstance || !tryHydrate(fiber, nextInstance)) {
fiber.effectTag |= 2;
isHydrating = !1;
hydrationParentFiber = fiber;
return;
}
deleteHydratableInstance(
hydrationParentFiber,
nextHydratableInstance
);
}
hydrationParentFiber = fiber;
nextHydratableInstance = getFirstHydratableChild(nextInstance);
} else
(fiber.effectTag |= 2),
(isHydrating = !1),
(hydrationParentFiber = fiber);
}
},
prepareToHydrateHostInstance: function(
fiber,
rootContainerInstance,
hostContext
) {
rootContainerInstance = hydrateInstance(
fiber.stateNode,
fiber.type,
fiber.memoizedProps,
rootContainerInstance,
hostContext,
fiber
);
fiber.updateQueue = rootContainerInstance;
return null !== rootContainerInstance ? !0 : !1;
},
prepareToHydrateHostTextInstance: function(fiber) {
return hydrateTextInstance(fiber.stateNode, fiber.memoizedProps, fiber);
},
popHydrationState: function(fiber) {
if (fiber !== hydrationParentFiber) return !1;
if (!isHydrating)
return popToNextHostParent(fiber), (isHydrating = !0), !1;
var type = fiber.type;
if (
5 !== fiber.tag ||
("head" !== type &&
"body" !== type &&
!shouldSetTextContent(type, fiber.memoizedProps))
)
for (type = nextHydratableInstance; type; )
deleteHydratableInstance(fiber, type),
(type = getNextHydratableSibling(type));
popToNextHostParent(fiber);
nextHydratableInstance = hydrationParentFiber
? getNextHydratableSibling(fiber.stateNode)
: null;
return !0;
}
};
}
function ReactFiberScheduler(config) {
function completeUnitOfWork(workInProgress$jscomp$0) {
for (;;) {
var next = completeWork(
workInProgress$jscomp$0.alternate,
workInProgress$jscomp$0,
nextRenderExpirationTime
),
returnFiber = workInProgress$jscomp$0["return"],
siblingFiber = workInProgress$jscomp$0.sibling;
var workInProgress = workInProgress$jscomp$0;
if (
2147483647 === nextRenderExpirationTime ||
2147483647 !== workInProgress.expirationTime
) {
if (2 !== workInProgress.tag && 3 !== workInProgress.tag)
var newExpirationTime = 0;
else
(newExpirationTime = workInProgress.updateQueue),
(newExpirationTime =
null === newExpirationTime
? 0
: newExpirationTime.expirationTime);
for (var child = workInProgress.child; null !== child; )
0 !== child.expirationTime &&
(0 === newExpirationTime ||
newExpirationTime > child.expirationTime) &&
(newExpirationTime = child.expirationTime),
(child = child.sibling);
workInProgress.expirationTime = newExpirationTime;
}
if (null !== next) return next;
null !== returnFiber &&
(null === returnFiber.firstEffect &&
(returnFiber.firstEffect = workInProgress$jscomp$0.firstEffect),
null !== workInProgress$jscomp$0.lastEffect &&
(null !== returnFiber.lastEffect &&
(returnFiber.lastEffect.nextEffect =
workInProgress$jscomp$0.firstEffect),
(returnFiber.lastEffect = workInProgress$jscomp$0.lastEffect)),
1 < workInProgress$jscomp$0.effectTag &&
(null !== returnFiber.lastEffect
? (returnFiber.lastEffect.nextEffect = workInProgress$jscomp$0)
: (returnFiber.firstEffect = workInProgress$jscomp$0),
(returnFiber.lastEffect = workInProgress$jscomp$0)));
if (null !== siblingFiber) return siblingFiber;
if (null !== returnFiber) workInProgress$jscomp$0 = returnFiber;
else {
workInProgress$jscomp$0.stateNode.isReadyForCommit = !0;
break;
}
}
return null;
}
function performUnitOfWork(workInProgress) {
var next = beginWork(
workInProgress.alternate,
workInProgress,
nextRenderExpirationTime
);
null === next && (next = completeUnitOfWork(workInProgress));
ReactCurrentOwner.current = null;
return next;
}
function performFailedUnitOfWork(workInProgress) {
var next = beginFailedWork(
workInProgress.alternate,
workInProgress,
nextRenderExpirationTime
);
null === next && (next = completeUnitOfWork(workInProgress));
ReactCurrentOwner.current = null;
return next;
}
function workLoop(expirationTime) {
if (null !== capturedErrors) {
if (
!(
0 === nextRenderExpirationTime ||
nextRenderExpirationTime > expirationTime
)
)
if (nextRenderExpirationTime <= mostRecentCurrentTime)
for (; null !== nextUnitOfWork; )
nextUnitOfWork = hasCapturedError(nextUnitOfWork)
? performFailedUnitOfWork(nextUnitOfWork)
: performUnitOfWork(nextUnitOfWork);
else
for (; null !== nextUnitOfWork && !shouldYield(); )
nextUnitOfWork = hasCapturedError(nextUnitOfWork)
? performFailedUnitOfWork(nextUnitOfWork)
: performUnitOfWork(nextUnitOfWork);
} else if (
!(
0 === nextRenderExpirationTime ||
nextRenderExpirationTime > expirationTime
)
)
if (nextRenderExpirationTime <= mostRecentCurrentTime)
for (; null !== nextUnitOfWork; )
nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
else
for (; null !== nextUnitOfWork && !shouldYield(); )
nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
}
function renderRoot(root, expirationTime) {
invariant(
!isWorking,
"renderRoot was called recursively. This error is likely caused by a bug in React. Please file an issue."
);
isWorking = !0;
root.isReadyForCommit = !1;
if (
root !== nextRoot ||
expirationTime !== nextRenderExpirationTime ||
null === nextUnitOfWork
) {
for (; -1 < index; ) (valueStack[index] = null), index--;
previousContext = emptyObject;
contextStackCursor.current = emptyObject;
didPerformWorkStackCursor.current = !1;
resetHostContainer();
nextRoot = root;
nextRenderExpirationTime = expirationTime;
nextUnitOfWork = createWorkInProgress(
nextRoot.current,
null,
expirationTime
);
}
var didError = !1,
error = null;
try {
workLoop(expirationTime);
} catch (e) {
(didError = !0), (error = e);
}
for (; didError; ) {
if (didFatal) {
firstUncaughtError = error;
break;
}
var failedWork = nextUnitOfWork;
if (null === failedWork) didFatal = !0;
else {
var boundary = captureError(failedWork, error);
invariant(
null !== boundary,
"Should have found an error boundary. This error is likely caused by a bug in React. Please file an issue."
);
if (!didFatal) {
try {
didError = boundary;
error = expirationTime;
for (boundary = didError; null !== failedWork; ) {
switch (failedWork.tag) {
case 2:
popContextProvider(failedWork);
break;
case 5:
popHostContext(failedWork);
break;
case 3:
popHostContainer(failedWork);
break;
case 4:
popHostContainer(failedWork);
}
if (failedWork === boundary || failedWork.alternate === boundary)
break;
failedWork = failedWork["return"];
}
nextUnitOfWork = performFailedUnitOfWork(didError);
workLoop(error);
} catch (e) {
didError = !0;
error = e;
continue;
}
break;
}
}
}
expirationTime = firstUncaughtError;
didFatal = isWorking = !1;
firstUncaughtError = null;
null !== expirationTime && onUncaughtError(expirationTime);
return root.isReadyForCommit ? root.current.alternate : null;
}
function captureError(failedWork, error$jscomp$0) {
var boundary = (ReactCurrentOwner.current = null),
errorBoundaryFound = !1,
willRetry = !1,
errorBoundaryName = null;
if (3 === failedWork.tag)
(boundary = failedWork), isFailedBoundary(failedWork) && (didFatal = !0);
else
for (
var node = failedWork["return"];
null !== node && null === boundary;
) {
2 === node.tag
? "function" === typeof node.stateNode.componentDidCatch &&
((errorBoundaryFound = !0),
(errorBoundaryName = getComponentName(node)),
(boundary = node),
(willRetry = !0))
: 3 === node.tag && (boundary = node);
if (isFailedBoundary(node)) {
if (
isUnmounting ||
(null !== commitPhaseBoundaries &&
(commitPhaseBoundaries.has(node) ||
(null !== node.alternate &&
commitPhaseBoundaries.has(node.alternate))))
)
return null;
boundary = null;
willRetry = !1;
}
node = node["return"];
}
if (null !== boundary) {
null === failedBoundaries && (failedBoundaries = new Set());
failedBoundaries.add(boundary);
var info = "";
node = failedWork;
do {
a: switch (node.tag) {
case 0:
case 1:
case 2:
case 5:
var owner = node._debugOwner,
source = node._debugSource;
var JSCompiler_inline_result = getComponentName(node);
var ownerName = null;
owner && (ownerName = getComponentName(owner));
owner = source;
JSCompiler_inline_result =
"\n in " +
(JSCompiler_inline_result || "Unknown") +
(owner
? " (at " +
owner.fileName.replace(/^.*[\\\/]/, "") +
":" +
owner.lineNumber +
")"
: ownerName ? " (created by " + ownerName + ")" : "");
break a;
default:
JSCompiler_inline_result = "";
}
info += JSCompiler_inline_result;
node = node["return"];
} while (node);
node = info;
failedWork = getComponentName(failedWork);
null === capturedErrors && (capturedErrors = new Map());
error$jscomp$0 = {
componentName: failedWork,
componentStack: node,
error: error$jscomp$0,
errorBoundary: errorBoundaryFound ? boundary.stateNode : null,
errorBoundaryFound: errorBoundaryFound,
errorBoundaryName: errorBoundaryName,
willRetry: willRetry
};
capturedErrors.set(boundary, error$jscomp$0);
try {
if (!1 !== showDialog(error$jscomp$0)) {
var error = error$jscomp$0.error;
(error && error.suppressReactErrorLogging) || console.error(error);
}
} catch (e) {
(e && e.suppressReactErrorLogging) || console.error(e);
}
isCommitting
? (null === commitPhaseBoundaries &&
(commitPhaseBoundaries = new Set()),
commitPhaseBoundaries.add(boundary))
: scheduleErrorRecovery(boundary);
return boundary;
}
null === firstUncaughtError && (firstUncaughtError = error$jscomp$0);
return null;
}
function hasCapturedError(fiber) {
return (
null !== capturedErrors &&
(capturedErrors.has(fiber) ||
(null !== fiber.alternate && capturedErrors.has(fiber.alternate)))
);
}
function isFailedBoundary(fiber) {
return (
null !== failedBoundaries &&
(failedBoundaries.has(fiber) ||
(null !== fiber.alternate && failedBoundaries.has(fiber.alternate)))
);
}
function computeAsyncExpiration() {
return 20 * ((((recalculateCurrentTime() + 100) / 20) | 0) + 1);
}
function computeExpirationForFiber(fiber) {
return 0 !== expirationContext
? expirationContext
: isWorking
? isCommitting ? 1 : nextRenderExpirationTime
: !useSyncScheduling || fiber.internalContextTag & 1
? computeAsyncExpiration()
: 1;
}
function scheduleWork(fiber, expirationTime) {
return scheduleWorkImpl(fiber, expirationTime, !1);
}
function scheduleWorkImpl(fiber, expirationTime) {
for (; null !== fiber; ) {
if (0 === fiber.expirationTime || fiber.expirationTime > expirationTime)
fiber.expirationTime = expirationTime;
null !== fiber.alternate &&
(0 === fiber.alternate.expirationTime ||
fiber.alternate.expirationTime > expirationTime) &&
(fiber.alternate.expirationTime = expirationTime);
if (null === fiber["return"])
if (3 === fiber.tag) {
var root = fiber.stateNode;
!isWorking &&
root === nextRoot &&
expirationTime < nextRenderExpirationTime &&
((nextUnitOfWork = nextRoot = null),
(nextRenderExpirationTime = 0));
requestWork(root, expirationTime);
!isWorking &&
root === nextRoot &&
expirationTime < nextRenderExpirationTime &&
((nextUnitOfWork = nextRoot = null),
(nextRenderExpirationTime = 0));
} else break;
fiber = fiber["return"];
}
}
function scheduleErrorRecovery(fiber) {
scheduleWorkImpl(fiber, 1, !0);
}
function recalculateCurrentTime() {
return (mostRecentCurrentTime = (((now() - startTime) / 10) | 0) + 2);
}
function scheduleCallbackWithExpiration(expirationTime) {
if (0 !== callbackExpirationTime) {
if (expirationTime > callbackExpirationTime) return;
cancelDeferredCallback(callbackID);
}
var currentMs = now() - startTime;
callbackExpirationTime = expirationTime;
callbackID = scheduleDeferredCallback(performAsyncWork, {
timeout: 10 * (expirationTime - 2) - currentMs
});
}
function requestWork(root, expirationTime) {
nestedUpdateCount > NESTED_UPDATE_LIMIT &&
invariant(
!1,
"Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops."
);
if (null === root.nextScheduledRoot)
(root.remainingExpirationTime = expirationTime),
null === lastScheduledRoot
? ((firstScheduledRoot = lastScheduledRoot = root),
(root.nextScheduledRoot = root))
: ((lastScheduledRoot = lastScheduledRoot.nextScheduledRoot = root),
(lastScheduledRoot.nextScheduledRoot = firstScheduledRoot));
else {
var remainingExpirationTime = root.remainingExpirationTime;
if (
0 === remainingExpirationTime ||
expirationTime < remainingExpirationTime
)
root.remainingExpirationTime = expirationTime;
}
isRendering ||
(isBatchingUpdates
? isUnbatchingUpdates &&
((nextFlushedRoot = root),
(nextFlushedExpirationTime = 1),
performWorkOnRoot(root, 1, recalculateCurrentTime()))
: 1 === expirationTime
? performWork(1, null)
: scheduleCallbackWithExpiration(expirationTime));
}
function findHighestPriorityRoot() {
var highestPriorityWork = 0,
highestPriorityRoot = null;
if (null !== lastScheduledRoot)
for (
var previousScheduledRoot = lastScheduledRoot,
root = firstScheduledRoot;
null !== root;
) {
var remainingExpirationTime = root.remainingExpirationTime;
if (0 === remainingExpirationTime) {
invariant(
null !== previousScheduledRoot && null !== lastScheduledRoot,
"Should have a previous and last root. This error is likely caused by a bug in React. Please file an issue."
);
if (root === root.nextScheduledRoot) {
firstScheduledRoot = lastScheduledRoot = root.nextScheduledRoot = null;
break;
} else if (root === firstScheduledRoot)
(firstScheduledRoot = remainingExpirationTime =
root.nextScheduledRoot),
(lastScheduledRoot.nextScheduledRoot = remainingExpirationTime),
(root.nextScheduledRoot = null);
else if (root === lastScheduledRoot) {
lastScheduledRoot = previousScheduledRoot;
lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;
root.nextScheduledRoot = null;
break;
} else
(previousScheduledRoot.nextScheduledRoot = root.nextScheduledRoot),
(root.nextScheduledRoot = null);
root = previousScheduledRoot.nextScheduledRoot;
} else {
if (
0 === highestPriorityWork ||
remainingExpirationTime < highestPriorityWork
)
(highestPriorityWork = remainingExpirationTime),
(highestPriorityRoot = root);
if (root === lastScheduledRoot) break;
previousScheduledRoot = root;
root = root.nextScheduledRoot;
}
}
previousScheduledRoot = nextFlushedRoot;
null !== previousScheduledRoot &&
previousScheduledRoot === highestPriorityRoot
? nestedUpdateCount++
: (nestedUpdateCount = 0);
nextFlushedRoot = highestPriorityRoot;
nextFlushedExpirationTime = highestPriorityWork;
}
function performAsyncWork(dl) {
performWork(0, dl);
}
function performWork(minExpirationTime, dl) {
deadline = dl;
for (
findHighestPriorityRoot();
null !== nextFlushedRoot &&
0 !== nextFlushedExpirationTime &&
(0 === minExpirationTime ||
nextFlushedExpirationTime <= minExpirationTime) &&
!deadlineDidExpire;
)
performWorkOnRoot(
nextFlushedRoot,
nextFlushedExpirationTime,
recalculateCurrentTime()
),
findHighestPriorityRoot();
null !== deadline && ((callbackExpirationTime = 0), (callbackID = -1));
0 !== nextFlushedExpirationTime &&
scheduleCallbackWithExpiration(nextFlushedExpirationTime);
deadline = null;
deadlineDidExpire = !1;
nestedUpdateCount = 0;
finishRendering();
}
function finishRendering() {
if (null !== completedBatches) {
var batches = completedBatches;
completedBatches = null;
for (var i = 0; i < batches.length; i++) {
var batch = batches[i];
try {
batch._onComplete();
} catch (error) {
hasUnhandledError ||
((hasUnhandledError = !0), (unhandledError = error));
}
}
}
if (hasUnhandledError)
throw ((batches = unhandledError),
(unhandledError = null),
(hasUnhandledError = !1),
batches);
}
function performWorkOnRoot(root, expirationTime, currentTime) {
invariant(
!isRendering,
"performWorkOnRoot was called recursively. This error is likely caused by a bug in React. Please file an issue."
);
isRendering = !0;
expirationTime <= currentTime
? ((currentTime = root.finishedWork),
null !== currentTime
? completeRoot(root, currentTime, expirationTime)
: ((root.finishedWork = null),
(currentTime = renderRoot(root, expirationTime)),
null !== currentTime &&
completeRoot(root, currentTime, expirationTime)))
: ((currentTime = root.finishedWork),
null !== currentTime
? completeRoot(root, currentTime, expirationTime)
: ((root.finishedWork = null),
(currentTime = renderRoot(root, expirationTime)),
null !== currentTime &&
(shouldYield()
? (root.finishedWork = currentTime)
: completeRoot(root, currentTime, expirationTime))));
isRendering = !1;
}
function completeRoot(root, finishedWork, expirationTime) {
var firstBatch = root.firstBatch;
if (
null !== firstBatch &&
firstBatch._expirationTime <= expirationTime &&
(null === completedBatches
? (completedBatches = [firstBatch])
: completedBatches.push(firstBatch),
firstBatch._defer)
) {
root.finishedWork = finishedWork;
root.remainingExpirationTime = 0;
return;
}
root.finishedWork = null;
isCommitting = isWorking = !0;
expirationTime = finishedWork.stateNode;
invariant(
expirationTime.current !== finishedWork,
"Cannot commit the same tree as before. This is probably a bug related to the return field. This error is likely caused by a bug in React. Please file an issue."
);
expirationTime.isReadyForCommit = !1;
ReactCurrentOwner.current = null;
1 < finishedWork.effectTag
? null !== finishedWork.lastEffect
? ((finishedWork.lastEffect.nextEffect = finishedWork),
(firstBatch = finishedWork.firstEffect))
: (firstBatch = finishedWork)
: (firstBatch = finishedWork.firstEffect);
prepareForCommit();
for (nextEffect = firstBatch; null !== nextEffect; ) {
var didError = !1,
_error = void 0;
try {
for (; null !== nextEffect; ) {
var effectTag = nextEffect.effectTag;
effectTag & 16 && commitResetTextContent(nextEffect);
if (effectTag & 128) {
var current = nextEffect.alternate;
null !== current && commitDetachRef(current);
}
switch (effectTag & -242) {
case 2:
commitPlacement(nextEffect);
nextEffect.effectTag &= -3;
break;
case 6:
commitPlacement(nextEffect);
nextEffect.effectTag &= -3;
commitWork(nextEffect.alternate, nextEffect);
break;
case 4:
commitWork(nextEffect.alternate, nextEffect);
break;
case 8:
(isUnmounting = !0),
commitDeletion(nextEffect),
(isUnmounting = !1);
}
nextEffect = nextEffect.nextEffect;
}
} catch (e) {
(didError = !0), (_error = e);
}
didError &&
(invariant(
null !== nextEffect,
"Should have next effect. This error is likely caused by a bug in React. Please file an issue."
),
captureError(nextEffect, _error),
null !== nextEffect && (nextEffect = nextEffect.nextEffect));
}
resetAfterCommit();
expirationTime.current = finishedWork;
for (nextEffect = firstBatch; null !== nextEffect; ) {
effectTag = !1;
current = void 0;
try {
for (; null !== nextEffect; ) {
var effectTag$jscomp$0 = nextEffect.effectTag;
effectTag$jscomp$0 & 36 &&
commitLifeCycles(nextEffect.alternate, nextEffect);
effectTag$jscomp$0 & 128 && commitAttachRef(nextEffect);
if (effectTag$jscomp$0 & 64)
switch (((firstBatch = nextEffect),
(didError = void 0),
null !== capturedErrors &&
((didError = capturedErrors.get(firstBatch)),
capturedErrors["delete"](firstBatch),
null == didError &&
null !== firstBatch.alternate &&
((firstBatch = firstBatch.alternate),
(didError = capturedErrors.get(firstBatch)),
capturedErrors["delete"](firstBatch))),
invariant(
null != didError,
"No error for given unit of work. This error is likely caused by a bug in React. Please file an issue."
),
firstBatch.tag)) {
case 2:
firstBatch.stateNode.componentDidCatch(didError.error, {
componentStack: didError.componentStack
});
break;
case 3:
null === firstUncaughtError &&
(firstUncaughtError = didError.error);
break;
default:
invariant(
!1,
"Invalid type of work. This error is likely caused by a bug in React. Please file an issue."
);
}
var next = nextEffect.nextEffect;
nextEffect.nextEffect = null;
nextEffect = next;
}
} catch (e) {
(effectTag = !0), (current = e);
}
effectTag &&
(invariant(
null !== nextEffect,
"Should have next effect. This error is likely caused by a bug in React. Please file an issue."
),
captureError(nextEffect, current),
null !== nextEffect && (nextEffect = nextEffect.nextEffect));
}
isWorking = isCommitting = !1;
"function" === typeof onCommitRoot && onCommitRoot(finishedWork.stateNode);
commitPhaseBoundaries &&
(commitPhaseBoundaries.forEach(scheduleErrorRecovery),
(commitPhaseBoundaries = null));
null !== firstUncaughtError &&
((finishedWork = firstUncaughtError),
(firstUncaughtError = null),
onUncaughtError(finishedWork));
finishedWork = expirationTime.current.expirationTime;
0 === finishedWork && (failedBoundaries = capturedErrors = null);
root.remainingExpirationTime = finishedWork;
}
function shouldYield() {
return null === deadline ||
deadline.timeRemaining() > timeHeuristicForUnitOfWork
? !1
: (deadlineDidExpire = !0);
}
function onUncaughtError(error) {
invariant(
null !== nextFlushedRoot,
"Should be working on a root. This error is likely caused by a bug in React. Please file an issue."
);
nextFlushedRoot.remainingExpirationTime = 0;
hasUnhandledError || ((hasUnhandledError = !0), (unhandledError = error));
}
var hostContext = ReactFiberHostContext(config),
hydrationContext = ReactFiberHydrationContext(config),
popHostContainer = hostContext.popHostContainer,
popHostContext = hostContext.popHostContext,
resetHostContainer = hostContext.resetHostContainer,
_ReactFiberBeginWork = ReactFiberBeginWork(
config,
hostContext,
hydrationContext,
scheduleWork,
computeExpirationForFiber
),
beginWork = _ReactFiberBeginWork.beginWork,
beginFailedWork = _ReactFiberBeginWork.beginFailedWork,
completeWork = ReactFiberCompleteWork(config, hostContext, hydrationContext)
.completeWork;
hostContext = ReactFiberCommitWork(config, captureError);
var commitResetTextContent = hostContext.commitResetTextContent,
commitPlacement = hostContext.commitPlacement,
commitDeletion = hostContext.commitDeletion,
commitWork = hostContext.commitWork,
commitLifeCycles = hostContext.commitLifeCycles,
commitAttachRef = hostContext.commitAttachRef,
commitDetachRef = hostContext.commitDetachRef,
now = config.now,
scheduleDeferredCallback = config.scheduleDeferredCallback,
cancelDeferredCallback = config.cancelDeferredCallback,
useSyncScheduling = config.useSyncScheduling,
prepareForCommit = config.prepareForCommit,
resetAfterCommit = config.resetAfterCommit,
startTime = now(),
mostRecentCurrentTime = 2,
lastUniqueAsyncExpiration = 0,
expirationContext = 0,
isWorking = !1,
nextUnitOfWork = null,
nextRoot = null,
nextRenderExpirationTime = 0,
nextEffect = null,
capturedErrors = null,
failedBoundaries = null,
commitPhaseBoundaries = null,
firstUncaughtError = null,
didFatal = !1,
isCommitting = !1,
isUnmounting = !1,
firstScheduledRoot = null,
lastScheduledRoot = null,
callbackExpirationTime = 0,
callbackID = -1,
isRendering = !1,
nextFlushedRoot = null,
nextFlushedExpirationTime = 0,
deadlineDidExpire = !1,
hasUnhandledError = !1,
unhandledError = null,
deadline = null,
isBatchingUpdates = !1,
isUnbatchingUpdates = !1,
completedBatches = null,
NESTED_UPDATE_LIMIT = 1e3,
nestedUpdateCount = 0,
timeHeuristicForUnitOfWork = 1;
return {
computeAsyncExpiration: computeAsyncExpiration,
computeExpirationForFiber: computeExpirationForFiber,
scheduleWork: scheduleWork,
requestWork: requestWork,
flushRoot: function(root, expirationTime) {
invariant(
!isRendering,
"work.commit(): Cannot commit while already rendering. This likely means you attempted to commit from inside a lifecycle method."
);
performWorkOnRoot(root, expirationTime, expirationTime);
finishRendering();
},
batchedUpdates: function(fn, a) {
var previousIsBatchingUpdates = isBatchingUpdates;
isBatchingUpdates = !0;
try {
return fn(a);
} finally {
(isBatchingUpdates = previousIsBatchingUpdates) ||
isRendering ||
performWork(1, null);
}
},
unbatchedUpdates: function(fn) {
if (isBatchingUpdates && !isUnbatchingUpdates) {
isUnbatchingUpdates = !0;
try {
return fn();
} finally {
isUnbatchingUpdates = !1;
}
}
return fn();
},
flushSync: function(fn) {
var previousIsBatchingUpdates = isBatchingUpdates;
isBatchingUpdates = !0;
try {
a: {
var previousExpirationContext = expirationContext;
expirationContext = 1;
try {
var JSCompiler_inline_result = fn();
break a;
} finally {
expirationContext = previousExpirationContext;
}
JSCompiler_inline_result = void 0;
}
return JSCompiler_inline_result;
} finally {
(isBatchingUpdates = previousIsBatchingUpdates),
invariant(
!isRendering,
"flushSync was called from inside a lifecycle method. It cannot be called when React is already rendering."
),
performWork(1, null);
}
},
deferredUpdates: function(fn) {
var previousExpirationContext = expirationContext;
expirationContext = computeAsyncExpiration();
try {
return fn();
} finally {
expirationContext = previousExpirationContext;
}
},
computeUniqueAsyncExpiration: function() {
var result = computeAsyncExpiration();
result <= lastUniqueAsyncExpiration &&
(result = lastUniqueAsyncExpiration + 1);
return (lastUniqueAsyncExpiration = result);
}
};
}
function ReactFiberReconciler$1(config) {
function updateContainerAtExpirationTime(
element,
container,
parentComponent,
expirationTime,
callback
) {
var current = container.current;
if (parentComponent) {
parentComponent = parentComponent._reactInternalFiber;
var parentContext;
b: {
invariant(
2 === isFiberMountedImpl(parentComponent) &&
2 === parentComponent.tag,
"Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue."
);
for (parentContext = parentComponent; 3 !== parentContext.tag; ) {
if (isContextProvider(parentContext)) {
parentContext =
parentContext.stateNode.__reactInternalMemoizedMergedChildContext;
break b;
}
parentContext = parentContext["return"];
invariant(
parentContext,
"Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue."
);
}
parentContext = parentContext.stateNode.context;
}
parentComponent = isContextProvider(parentComponent)
? processChildContext(parentComponent, parentContext)
: parentContext;
} else parentComponent = emptyObject;
null === container.context
? (container.context = parentComponent)
: (container.pendingContext = parentComponent);
container = callback;
insertUpdateIntoFiber(current, {
expirationTime: expirationTime,
partialState: { element: element },
callback: void 0 === container ? null : container,
isReplace: !1,
isForced: !1,
next: null
});
scheduleWork(current, expirationTime);
return expirationTime;
}
function findHostInstance(fiber) {
fiber = findCurrentHostFiber(fiber);
return null === fiber ? null : fiber.stateNode;
}
var getPublicInstance = config.getPublicInstance;
config = ReactFiberScheduler(config);
var computeAsyncExpiration = config.computeAsyncExpiration,
computeExpirationForFiber = config.computeExpirationForFiber,
scheduleWork = config.scheduleWork;
return {
createContainer: function(containerInfo, hydrate) {
var uninitializedFiber = createFiber(3, null, 0);
containerInfo = {
current: uninitializedFiber,
containerInfo: containerInfo,
pendingChildren: null,
remainingExpirationTime: 0,
isReadyForCommit: !1,
finishedWork: null,
context: null,
pendingContext: null,
hydrate: hydrate,
firstBatch: null,
nextScheduledRoot: null
};
return (uninitializedFiber.stateNode = containerInfo);
},
updateContainer: function(element, container, parentComponent, callback) {
var current = container.current;
current =
null != element &&
null != element.type &&
null != element.type.prototype &&
!0 === element.type.prototype.unstable_isAsyncReactComponent
? computeAsyncExpiration()
: computeExpirationForFiber(current);
return updateContainerAtExpirationTime(
element,
container,
parentComponent,
current,
callback
);
},
updateContainerAtExpirationTime: updateContainerAtExpirationTime,
flushRoot: config.flushRoot,
requestWork: config.requestWork,
computeUniqueAsyncExpiration: config.computeUniqueAsyncExpiration,
batchedUpdates: config.batchedUpdates,
unbatchedUpdates: config.unbatchedUpdates,
deferredUpdates: config.deferredUpdates,
flushSync: config.flushSync,
getPublicRootInstance: function(container) {
container = container.current;
if (!container.child) return null;
switch (container.child.tag) {
case 5:
return getPublicInstance(container.child.stateNode);
default:
return container.child.stateNode;
}
},
findHostInstance: findHostInstance,
findHostInstanceWithNoPortals: function(fiber) {
fiber = findCurrentHostFiberWithNoPortals(fiber);
return null === fiber ? null : fiber.stateNode;
},
injectIntoDevTools: function(devToolsConfig) {
var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
return injectInternals(
Object.assign({}, devToolsConfig, {
findHostInstanceByFiber: function(fiber) {
return findHostInstance(fiber);
},
findFiberByHostInstance: function(instance) {
return findFiberByHostInstance
? findFiberByHostInstance(instance)
: null;
}
})
);
}
};
}
var ReactFiberReconciler$2 = Object.freeze({ default: ReactFiberReconciler$1 }),
ReactFiberReconciler$3 =
(ReactFiberReconciler$2 && ReactFiberReconciler$1) ||
ReactFiberReconciler$2,
reactReconciler = ReactFiberReconciler$3["default"]
? ReactFiberReconciler$3["default"]
: ReactFiberReconciler$3,
viewConfigCallbacks = new Map(),
viewConfigs = new Map(),
ReactNativeFiberHostComponent = (function() {
function ReactNativeFiberHostComponent(tag, viewConfig) {
if (!(this instanceof ReactNativeFiberHostComponent))
throw new TypeError("Cannot call a class as a function");
this._nativeTag = tag;
this._children = [];
this.viewConfig = viewConfig;
}
ReactNativeFiberHostComponent.prototype.blur = function() {
TextInputState.blurTextInput(this._nativeTag);
};
ReactNativeFiberHostComponent.prototype.focus = function() {
TextInputState.focusTextInput(this._nativeTag);
};
ReactNativeFiberHostComponent.prototype.measure = function(callback) {
UIManager.measure(this._nativeTag, mountSafeCallback(this, callback));
};
ReactNativeFiberHostComponent.prototype.measureInWindow = function(
callback
) {
UIManager.measureInWindow(
this._nativeTag,
mountSafeCallback(this, callback)
);
};
ReactNativeFiberHostComponent.prototype.measureLayout = function(
relativeToNativeNode,
onSuccess,
onFail
) {
UIManager.measureLayout(
this._nativeTag,
relativeToNativeNode,
mountSafeCallback(this, onFail),
mountSafeCallback(this, onSuccess)
);
};
ReactNativeFiberHostComponent.prototype.setNativeProps = function(
nativeProps
) {
nativeProps = diffProperties(
null,
emptyObject$1,
nativeProps,
this.viewConfig.validAttributes
);
null != nativeProps &&
UIManager.updateView(
this._nativeTag,
this.viewConfig.uiViewClassName,
nativeProps
);
};
return ReactNativeFiberHostComponent;
})(),
now =
"object" === typeof performance && "function" === typeof performance.now
? function() {
return performance.now();
}
: function() {
return Date.now();
},
scheduledCallback = null,
frameDeadline = 0,
frameDeadlineObject = {
timeRemaining: function() {
return frameDeadline - now();
}
};
function setTimeoutCallback() {
frameDeadline = now() + 5;
var callback = scheduledCallback;
scheduledCallback = null;
null !== callback && callback(frameDeadlineObject);
}
function recursivelyUncacheFiberNode(node) {
"number" === typeof node
? uncacheFiberNode(node)
: (uncacheFiberNode(node._nativeTag),
node._children.forEach(recursivelyUncacheFiberNode));
}
var NativeRenderer = reactReconciler({
appendInitialChild: function(parentInstance, child) {
parentInstance._children.push(child);
},
createInstance: function(
type,
props,
rootContainerInstance,
hostContext,
internalInstanceHandle
) {
hostContext = ReactNativeTagHandles.allocateTag();
if (viewConfigs.has(type)) var viewConfig = viewConfigs.get(type);
else
(viewConfig = viewConfigCallbacks.get(type)),
invariant(
"function" === typeof viewConfig,
"View config not found for name %s",
type
),
viewConfigCallbacks.set(type, null),
(viewConfig = viewConfig()),
viewConfigs.set(type, viewConfig);
invariant(viewConfig, "View config not found for name %s", type);
type = viewConfig;
viewConfig = diffProperties(
null,
emptyObject$1,
props,
type.validAttributes
);
UIManager.createView(
hostContext,
type.uiViewClassName,
rootContainerInstance,
viewConfig
);
rootContainerInstance = new ReactNativeFiberHostComponent(
hostContext,
type
);
instanceCache[hostContext] = internalInstanceHandle;
instanceProps[hostContext] = props;
return rootContainerInstance;
},
createTextInstance: function(
text,
rootContainerInstance,
hostContext,
internalInstanceHandle
) {
hostContext = ReactNativeTagHandles.allocateTag();
UIManager.createView(hostContext, "RCTRawText", rootContainerInstance, {
text: text
});
instanceCache[hostContext] = internalInstanceHandle;
return hostContext;
},
finalizeInitialChildren: function(parentInstance) {
if (0 === parentInstance._children.length) return !1;
var nativeTags = parentInstance._children.map(function(child) {
return "number" === typeof child ? child : child._nativeTag;
});
UIManager.setChildren(parentInstance._nativeTag, nativeTags);
return !1;
},
getRootHostContext: function() {
return emptyObject;
},
getChildHostContext: function() {
return emptyObject;
},
getPublicInstance: function(instance) {
return instance;
},
now: now,
prepareForCommit: function() {},
prepareUpdate: function() {
return emptyObject;
},
resetAfterCommit: function() {},
scheduleDeferredCallback: function(callback) {
scheduledCallback = callback;
return setTimeout(setTimeoutCallback, 1);
},
cancelDeferredCallback: function(callbackID) {
scheduledCallback = null;
clearTimeout(callbackID);
},
shouldDeprioritizeSubtree: function() {
return !1;
},
shouldSetTextContent: function() {
return !1;
},
useSyncScheduling: !0,
mutation: {
appendChild: function(parentInstance, child) {
var childTag = "number" === typeof child ? child : child._nativeTag,
children = parentInstance._children,
index = children.indexOf(child);
0 <= index
? (children.splice(index, 1),
children.push(child),
UIManager.manageChildren(
parentInstance._nativeTag,
[index],
[children.length - 1],
[],
[],
[]
))
: (children.push(child),
UIManager.manageChildren(
parentInstance._nativeTag,
[],
[],
[childTag],
[children.length - 1],
[]
));
},
appendChildToContainer: function(parentInstance, child) {
UIManager.setChildren(parentInstance, [
"number" === typeof child ? child : child._nativeTag
]);
},
commitTextUpdate: function(textInstance, oldText, newText) {
UIManager.updateView(textInstance, "RCTRawText", { text: newText });
},
commitMount: function() {},
commitUpdate: function(
instance,
updatePayloadTODO,
type,
oldProps,
newProps
) {
updatePayloadTODO = instance.viewConfig;
instanceProps[instance._nativeTag] = newProps;
oldProps = diffProperties(
null,
oldProps,
newProps,
updatePayloadTODO.validAttributes
);
null != oldProps &&
UIManager.updateView(
instance._nativeTag,
updatePayloadTODO.uiViewClassName,
oldProps
);
},
insertBefore: function(parentInstance, child, beforeChild) {
var children = parentInstance._children,
index = children.indexOf(child);
0 <= index
? (children.splice(index, 1),
(beforeChild = children.indexOf(beforeChild)),
children.splice(beforeChild, 0, child),
UIManager.manageChildren(
parentInstance._nativeTag,
[index],
[beforeChild],
[],
[],
[]
))
: ((index = children.indexOf(beforeChild)),
children.splice(index, 0, child),
UIManager.manageChildren(
parentInstance._nativeTag,
[],
[],
["number" === typeof child ? child : child._nativeTag],
[index],
[]
));
},
insertInContainerBefore: function(parentInstance) {
invariant(
"number" !== typeof parentInstance,
"Container does not support insertBefore operation"
);
},
removeChild: function(parentInstance, child) {
recursivelyUncacheFiberNode(child);
var children = parentInstance._children;
child = children.indexOf(child);
children.splice(child, 1);
UIManager.manageChildren(
parentInstance._nativeTag,
[],
[],
[],
[],
[child]
);
},
removeChildFromContainer: function(parentInstance, child) {
recursivelyUncacheFiberNode(child);
UIManager.manageChildren(parentInstance, [], [], [], [], [0]);
},
resetTextContent: function() {}
}
});
function findNodeHandle(componentOrHandle) {
if (null == componentOrHandle) return null;
if ("number" === typeof componentOrHandle) return componentOrHandle;
var internalInstance = componentOrHandle._reactInternalFiber;
if (internalInstance)
return NativeRenderer.findHostInstance(internalInstance);
if (componentOrHandle) return componentOrHandle;
invariant(
("object" === typeof componentOrHandle &&
"_nativeTag" in componentOrHandle) ||
(null != componentOrHandle.render &&
"function" === typeof componentOrHandle.render),
"findNodeHandle(...): Argument is not a component (type: %s, keys: %s)",
typeof componentOrHandle,
Object.keys(componentOrHandle)
);
invariant(
!1,
"findNodeHandle(...): Unable to find node handle for unmounted component."
);
}
function findNumericNodeHandleFiber(componentOrHandle) {
componentOrHandle = findNodeHandle(componentOrHandle);
return null == componentOrHandle || "number" === typeof componentOrHandle
? componentOrHandle
: componentOrHandle._nativeTag;
}
function _inherits(subClass, superClass) {
if ("function" !== typeof superClass && null !== superClass)
throw new TypeError(
"Super expression must either be null or a function, not " +
typeof superClass
);
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
enumerable: !1,
writable: !0,
configurable: !0
}
});
superClass &&
(Object.setPrototypeOf
? Object.setPrototypeOf(subClass, superClass)
: (subClass.__proto__ = superClass));
}
var ReactNativeComponent = (function(_React$Component) {
function ReactNativeComponent() {
if (!(this instanceof ReactNativeComponent))
throw new TypeError("Cannot call a class as a function");
var call = _React$Component.apply(this, arguments);
if (!this)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called"
);
return !call || ("object" !== typeof call && "function" !== typeof call)
? this
: call;
}
_inherits(ReactNativeComponent, _React$Component);
ReactNativeComponent.prototype.blur = function() {
TextInputState.blurTextInput(findNumericNodeHandleFiber(this));
};
ReactNativeComponent.prototype.focus = function() {
TextInputState.focusTextInput(findNumericNodeHandleFiber(this));
};
ReactNativeComponent.prototype.measure = function(callback) {
UIManager.measure(
findNumericNodeHandleFiber(this),
mountSafeCallback(this, callback)
);
};
ReactNativeComponent.prototype.measureInWindow = function(callback) {
UIManager.measureInWindow(
findNumericNodeHandleFiber(this),
mountSafeCallback(this, callback)
);
};
ReactNativeComponent.prototype.measureLayout = function(
relativeToNativeNode,
onSuccess,
onFail
) {
UIManager.measureLayout(
findNumericNodeHandleFiber(this),
relativeToNativeNode,
mountSafeCallback(this, onFail),
mountSafeCallback(this, onSuccess)
);
};
ReactNativeComponent.prototype.setNativeProps = function(nativeProps) {
var maybeInstance = void 0;
try {
maybeInstance = findNodeHandle(this);
} catch (error) {}
if (null != maybeInstance) {
var viewConfig = maybeInstance.viewConfig;
nativeProps = diffProperties(
null,
emptyObject$1,
nativeProps,
viewConfig.validAttributes
);
null != nativeProps &&
UIManager.updateView(
maybeInstance._nativeTag,
viewConfig.uiViewClassName,
nativeProps
);
}
};
return ReactNativeComponent;
})(React.Component),
getInspectorDataForViewTag = void 0;
getInspectorDataForViewTag = function() {
invariant(!1, "getInspectorDataForViewTag() is not available in production");
};
fiberBatchedUpdates = NativeRenderer.batchedUpdates;
var roots = new Map();
function fn$jscomp$inline_616(capturedError) {
var componentStack = capturedError.componentStack,
error = capturedError.error;
if (error instanceof Error) {
capturedError = error.message;
var name = error.name;
try {
error.message =
(capturedError ? name + ": " + capturedError : name) +
"\n\nThis error is located at:" +
componentStack;
} catch (e) {}
} else
error =
"string" === typeof error
? Error(error + "\n\nThis error is located at:" + componentStack)
: Error("Unspecified error at:" + componentStack);
ExceptionsManager.handleException(error, !1);
return !1;
}
invariant(
showDialog === defaultShowDialog,
"The custom dialog was already injected."
);
invariant(
"function" === typeof fn$jscomp$inline_616,
"Injected showDialog() must be a function."
);
showDialog = fn$jscomp$inline_616;
var ReactNativeRenderer = {
NativeComponent: ReactNativeComponent,
findNodeHandle: findNumericNodeHandleFiber,
render: function(element, containerTag, callback) {
var root = roots.get(containerTag);
root ||
((root = NativeRenderer.createContainer(containerTag, !1)),
roots.set(containerTag, root));
NativeRenderer.updateContainer(element, root, null, callback);
return NativeRenderer.getPublicRootInstance(root);
},
unmountComponentAtNode: function(containerTag) {
var root = roots.get(containerTag);
root &&
NativeRenderer.updateContainer(null, root, null, function() {
roots["delete"](containerTag);
});
},
unmountComponentAtNodeAndRemoveContainer: function(containerTag) {
ReactNativeRenderer.unmountComponentAtNode(containerTag);
UIManager.removeRootView(containerTag);
},
createPortal: function(children, containerTag) {
return createPortal(
children,
containerTag,
null,
2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null
);
},
unstable_batchedUpdates: batchedUpdates,
flushSync: NativeRenderer.flushSync,
__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
NativeMethodsMixin: {
measure: function(callback) {
UIManager.measure(
findNumericNodeHandleFiber(this),
mountSafeCallback(this, callback)
);
},
measureInWindow: function(callback) {
UIManager.measureInWindow(
findNumericNodeHandleFiber(this),
mountSafeCallback(this, callback)
);
},
measureLayout: function(relativeToNativeNode, onSuccess, onFail) {
UIManager.measureLayout(
findNumericNodeHandleFiber(this),
relativeToNativeNode,
mountSafeCallback(this, onFail),
mountSafeCallback(this, onSuccess)
);
},
setNativeProps: function(nativeProps) {
var maybeInstance = void 0;
try {
maybeInstance = findNodeHandle(this);
} catch (error) {}
if (null != maybeInstance) {
var viewConfig = maybeInstance.viewConfig;
nativeProps = diffProperties(
null,
emptyObject$1,
nativeProps,
viewConfig.validAttributes
);
null != nativeProps &&
UIManager.updateView(
maybeInstance._nativeTag,
viewConfig.uiViewClassName,
nativeProps
);
}
},
focus: function() {
TextInputState.focusTextInput(findNumericNodeHandleFiber(this));
},
blur: function() {
TextInputState.blurTextInput(findNumericNodeHandleFiber(this));
}
},
ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin,
ReactGlobalSharedState: ReactGlobalSharedState,
ReactNativeComponentTree: ReactNativeComponentTree,
ReactNativePropRegistry: ReactNativePropRegistry,
TouchHistoryMath: TouchHistoryMath,
createReactNativeComponentClass: function(name, callback) {
invariant(
!viewConfigCallbacks.has(name),
"Tried to register two views with the same name %s",
name
);
viewConfigCallbacks.set(name, callback);
return name;
},
takeSnapshot: function(view, options) {
"number" !== typeof view &&
"window" !== view &&
(view = findNumericNodeHandleFiber(view) || "window");
return UIManager.__takeSnapshot(view, options);
}
}
};
NativeRenderer.injectIntoDevTools({
findFiberByHostInstance: getInstanceFromTag,
getInspectorDataForViewTag: getInspectorDataForViewTag,
bundleType: 0,
version: "16.2.0",
rendererPackageName: "react-native-renderer"
});
var ReactNativeRenderer$2 = Object.freeze({ default: ReactNativeRenderer }),
ReactNativeRenderer$3 =
(ReactNativeRenderer$2 && ReactNativeRenderer) || ReactNativeRenderer$2;
module.exports = ReactNativeRenderer$3["default"]
? ReactNativeRenderer$3["default"]
: ReactNativeRenderer$3;