react-native
Version:
A framework for building native apps using React
1,497 lines (1,493 loc) • 361 kB
JavaScript
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @noflow
* @nolint
* @preventMunge
* @generated SignedSource<<e8da88ae248e2c108d8595c48ad070ca>>
*
* This file was sync'd from the facebook/react repository.
*/
"use strict";
require("react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore");
var ReactNativePrivateInterface = require("react-native/Libraries/ReactPrivate/ReactNativePrivateInterface"),
React = require("react"),
Scheduler = require("scheduler"),
isArrayImpl = Array.isArray,
ReactSharedInternals =
React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
assign = Object.assign,
prefix,
suffix;
function describeBuiltInComponentFrame(name) {
if (void 0 === prefix)
try {
throw Error();
} catch (x) {
var match = x.stack.trim().match(/\n( *(at )?)/);
prefix = (match && match[1]) || "";
suffix =
-1 < x.stack.indexOf("\n at")
? " (<anonymous>)"
: -1 < x.stack.indexOf("@")
? "@unknown:0:0"
: "";
}
return "\n" + prefix + name + suffix;
}
var reentry = !1;
function describeNativeComponentFrame(fn, construct) {
if (!fn || reentry) return "";
reentry = !0;
var previousPrepareStackTrace = Error.prepareStackTrace;
Error.prepareStackTrace = void 0;
try {
var RunInRootFrame = {
DetermineComponentFrameRoot: function () {
try {
if (construct) {
var Fake = function () {
throw Error();
};
Object.defineProperty(Fake.prototype, "props", {
set: function () {
throw Error();
}
});
if ("object" === typeof Reflect && Reflect.construct) {
try {
Reflect.construct(Fake, []);
} catch (x) {
var control = x;
}
Reflect.construct(fn, [], Fake);
} else {
try {
Fake.call();
} catch (x$1) {
control = x$1;
}
fn.call(Fake.prototype);
}
} else {
try {
throw Error();
} catch (x$2) {
control = x$2;
}
(Fake = fn()) &&
"function" === typeof Fake.catch &&
Fake.catch(function () {});
}
} catch (sample) {
if (sample && control && "string" === typeof sample.stack)
return [sample.stack, control.stack];
}
return [null, null];
}
};
RunInRootFrame.DetermineComponentFrameRoot.displayName =
"DetermineComponentFrameRoot";
var namePropDescriptor = Object.getOwnPropertyDescriptor(
RunInRootFrame.DetermineComponentFrameRoot,
"name"
);
namePropDescriptor &&
namePropDescriptor.configurable &&
Object.defineProperty(
RunInRootFrame.DetermineComponentFrameRoot,
"name",
{ value: "DetermineComponentFrameRoot" }
);
var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
sampleStack = _RunInRootFrame$Deter[0],
controlStack = _RunInRootFrame$Deter[1];
if (sampleStack && controlStack) {
var sampleLines = sampleStack.split("\n"),
controlLines = controlStack.split("\n");
for (
namePropDescriptor = RunInRootFrame = 0;
RunInRootFrame < sampleLines.length &&
!sampleLines[RunInRootFrame].includes("DetermineComponentFrameRoot");
)
RunInRootFrame++;
for (
;
namePropDescriptor < controlLines.length &&
!controlLines[namePropDescriptor].includes(
"DetermineComponentFrameRoot"
);
)
namePropDescriptor++;
if (
RunInRootFrame === sampleLines.length ||
namePropDescriptor === controlLines.length
)
for (
RunInRootFrame = sampleLines.length - 1,
namePropDescriptor = controlLines.length - 1;
1 <= RunInRootFrame &&
0 <= namePropDescriptor &&
sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor];
)
namePropDescriptor--;
for (
;
1 <= RunInRootFrame && 0 <= namePropDescriptor;
RunInRootFrame--, namePropDescriptor--
)
if (sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
if (1 !== RunInRootFrame || 1 !== namePropDescriptor) {
do
if (
(RunInRootFrame--,
namePropDescriptor--,
0 > namePropDescriptor ||
sampleLines[RunInRootFrame] !==
controlLines[namePropDescriptor])
) {
var frame =
"\n" +
sampleLines[RunInRootFrame].replace(" at new ", " at ");
fn.displayName &&
frame.includes("<anonymous>") &&
(frame = frame.replace("<anonymous>", fn.displayName));
return frame;
}
while (1 <= RunInRootFrame && 0 <= namePropDescriptor);
}
break;
}
}
} finally {
(reentry = !1), (Error.prepareStackTrace = previousPrepareStackTrace);
}
return (previousPrepareStackTrace = fn ? fn.displayName || fn.name : "")
? describeBuiltInComponentFrame(previousPrepareStackTrace)
: "";
}
function describeFiber(fiber, childFiber) {
switch (fiber.tag) {
case 26:
case 27:
case 5:
return describeBuiltInComponentFrame(fiber.type);
case 16:
return describeBuiltInComponentFrame("Lazy");
case 13:
return fiber.child !== childFiber && null !== childFiber
? describeBuiltInComponentFrame("Suspense Fallback")
: describeBuiltInComponentFrame("Suspense");
case 19:
return describeBuiltInComponentFrame("SuspenseList");
case 0:
case 15:
return describeNativeComponentFrame(fiber.type, !1);
case 11:
return describeNativeComponentFrame(fiber.type.render, !1);
case 1:
return describeNativeComponentFrame(fiber.type, !0);
case 31:
return describeBuiltInComponentFrame("Activity");
default:
return "";
}
}
function getStackByFiberInDevAndProd(workInProgress) {
try {
var info = "",
previous = null;
do
(info += describeFiber(workInProgress, previous)),
(previous = workInProgress),
(workInProgress = workInProgress.return);
while (workInProgress);
return info;
} catch (x) {
return "\nError generating stack: " + x.message + "\n" + x.stack;
}
}
var REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
REACT_PORTAL_TYPE = Symbol.for("react.portal"),
REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
REACT_CONTEXT_TYPE = Symbol.for("react.context"),
REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
REACT_MEMO_TYPE = Symbol.for("react.memo"),
REACT_LAZY_TYPE = Symbol.for("react.lazy");
Symbol.for("react.scope");
var REACT_ACTIVITY_TYPE = Symbol.for("react.activity");
Symbol.for("react.legacy_hidden");
Symbol.for("react.tracing_marker");
var REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");
Symbol.for("react.view_transition");
var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
function getIteratorFn(maybeIterable) {
if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
maybeIterable =
(MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
maybeIterable["@@iterator"];
return "function" === typeof maybeIterable ? maybeIterable : null;
}
var REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
function getComponentNameFromType(type) {
if (null == type) return null;
if ("function" === typeof type)
return type.$$typeof === REACT_CLIENT_REFERENCE
? null
: type.displayName || type.name || null;
if ("string" === typeof type) return type;
switch (type) {
case REACT_FRAGMENT_TYPE:
return "Fragment";
case REACT_PROFILER_TYPE:
return "Profiler";
case REACT_STRICT_MODE_TYPE:
return "StrictMode";
case REACT_SUSPENSE_TYPE:
return "Suspense";
case REACT_SUSPENSE_LIST_TYPE:
return "SuspenseList";
case REACT_ACTIVITY_TYPE:
return "Activity";
}
if ("object" === typeof type)
switch (type.$$typeof) {
case REACT_PORTAL_TYPE:
return "Portal";
case REACT_CONTEXT_TYPE:
return type.displayName || "Context";
case REACT_CONSUMER_TYPE:
return (type._context.displayName || "Context") + ".Consumer";
case REACT_FORWARD_REF_TYPE:
var innerType = type.render;
type = type.displayName;
type ||
((type = innerType.displayName || innerType.name || ""),
(type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
return type;
case REACT_MEMO_TYPE:
return (
(innerType = type.displayName || null),
null !== innerType
? innerType
: getComponentNameFromType(type.type) || "Memo"
);
case REACT_LAZY_TYPE:
innerType = type._payload;
type = type._init;
try {
return getComponentNameFromType(type(innerType));
} catch (x) {}
}
return null;
}
var hasError = !1,
caughtError = null,
getFiberCurrentPropsFromNode$1 = null,
getInstanceFromNode$1 = null,
getNodeFromInstance$1 = null;
function executeDispatch(event, listener, inst) {
event.currentTarget = getNodeFromInstance$1(inst);
try {
listener(event);
} catch (error) {
hasError || ((hasError = !0), (caughtError = error));
}
event.currentTarget = null;
}
function executeDirectDispatch(event) {
var dispatchListener = event._dispatchListeners,
dispatchInstance = event._dispatchInstances;
if (isArrayImpl(dispatchListener)) throw Error("Invalid `event`.");
event.currentTarget = dispatchListener
? getNodeFromInstance$1(dispatchInstance)
: null;
dispatchListener = dispatchListener ? dispatchListener(event) : null;
event.currentTarget = null;
event._dispatchListeners = null;
event._dispatchInstances = null;
return dispatchListener;
}
function functionThatReturnsTrue() {
return !0;
}
function functionThatReturnsFalse() {
return !1;
}
function SyntheticEvent(
dispatchConfig,
targetInst,
nativeEvent,
nativeEventTarget
) {
this.dispatchConfig = dispatchConfig;
this._targetInst = targetInst;
this.nativeEvent = nativeEvent;
this._dispatchInstances = this._dispatchListeners = null;
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
)
? functionThatReturnsTrue
: functionThatReturnsFalse;
this.isPropagationStopped = functionThatReturnsFalse;
return this;
}
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 = functionThatReturnsTrue));
},
stopPropagation: function () {
var event = this.nativeEvent;
event &&
(event.stopPropagation
? event.stopPropagation()
: "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0),
(this.isPropagationStopped = functionThatReturnsTrue));
},
persist: function () {
this.isPersistent = functionThatReturnsTrue;
},
isPersistent: functionThatReturnsFalse,
destructor: function () {
var Interface = this.constructor.Interface,
propName;
for (propName in Interface) this[propName] = null;
this.nativeEvent = this._targetInst = this.dispatchConfig = null;
this.isPropagationStopped = this.isDefaultPrevented =
functionThatReturnsFalse;
this._dispatchInstances = this._dispatchListeners = null;
}
});
SyntheticEvent.Interface = {
type: null,
target: null,
currentTarget: function () {
return null;
},
eventPhase: null,
bubbles: null,
cancelable: null,
timeStamp: function (event) {
return event.timeStamp || Date.now();
},
defaultPrevented: null,
isTrusted: null
};
SyntheticEvent.extend = function (Interface) {
function E() {}
function Class() {
return Super.apply(this, arguments);
}
var Super = this;
E.prototype = Super.prototype;
var prototype = new E();
assign(prototype, Class.prototype);
Class.prototype = prototype;
Class.prototype.constructor = Class;
Class.Interface = assign({}, Super.Interface, Interface);
Class.extend = Super.extend;
addEventPoolingTo(Class);
return Class;
};
addEventPoolingTo(SyntheticEvent);
function createOrGetPooledEvent(
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) {
if (!(event instanceof this))
throw Error(
"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.getPooled = createOrGetPooledEvent;
EventConstructor.eventPool = [];
EventConstructor.release = releasePooledEvent;
}
var ResponderSyntheticEvent = SyntheticEvent.extend({
touchHistory: function () {
return null;
}
});
function isStartish(topLevelType) {
return "topTouchStart" === topLevelType;
}
function isMoveish(topLevelType) {
return "topTouchMove" === topLevelType;
}
var startDependencies = ["topTouchStart"],
moveDependencies = ["topTouchMove"],
endDependencies = ["topTouchCancel", "topTouchEnd"],
touchBank = [],
touchHistory = {
touchBank: touchBank,
numberActiveTouches: 0,
indexOfSingleActiveTouch: -1,
mostRecentTimeStamp: 0
};
function timestampForTouch(touch) {
return touch.timeStamp || touch.timestamp;
}
function getTouchIdentifier(_ref) {
_ref = _ref.identifier;
if (null == _ref) throw Error("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)));
}
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)));
}
var instrumentationCallback,
ResponderTouchHistoryStore = {
instrument: function (callback) {
instrumentationCallback = callback;
},
recordTouchTrack: function (topLevelType, nativeEvent) {
null != instrumentationCallback &&
instrumentationCallback(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 (
"topTouchEnd" === topLevelType ||
"topTouchCancel" === topLevelType
)
if (
(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) {
if (null == next)
throw Error("Accumulated items must not be null or undefined.");
return null == current
? next
: isArrayImpl(current)
? current.concat(next)
: isArrayImpl(next)
? [current].concat(next)
: [current, next];
}
function accumulateInto(current, next) {
if (null == next)
throw Error("Accumulated items must not be null or undefined.");
if (null == current) return next;
if (isArrayImpl(current)) {
if (isArrayImpl(next)) return current.push.apply(current, next), current;
current.push(next);
return current;
}
return isArrayImpl(next) ? [current].concat(next) : [current, next];
}
function forEachAccumulated(arr, cb, scope) {
Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
}
var responderInst = null,
trackedTouchCount = 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"
},
dependencies: startDependencies
},
scrollShouldSetResponder: {
phasedRegistrationNames: {
bubbled: "onScrollShouldSetResponder",
captured: "onScrollShouldSetResponderCapture"
},
dependencies: ["topScroll"]
},
selectionChangeShouldSetResponder: {
phasedRegistrationNames: {
bubbled: "onSelectionChangeShouldSetResponder",
captured: "onSelectionChangeShouldSetResponderCapture"
},
dependencies: ["topSelectionChange"]
},
moveShouldSetResponder: {
phasedRegistrationNames: {
bubbled: "onMoveShouldSetResponder",
captured: "onMoveShouldSetResponderCapture"
},
dependencies: moveDependencies
},
responderStart: {
registrationName: "onResponderStart",
dependencies: startDependencies
},
responderMove: {
registrationName: "onResponderMove",
dependencies: moveDependencies
},
responderEnd: {
registrationName: "onResponderEnd",
dependencies: endDependencies
},
responderRelease: {
registrationName: "onResponderRelease",
dependencies: endDependencies
},
responderTerminationRequest: {
registrationName: "onResponderTerminationRequest",
dependencies: []
},
responderGrant: { registrationName: "onResponderGrant", dependencies: [] },
responderReject: { registrationName: "onResponderReject", dependencies: [] },
responderTerminate: {
registrationName: "onResponderTerminate",
dependencies: []
}
};
function getParent$1(inst) {
do inst = inst.return;
while (inst && 5 !== inst.tag);
return inst ? inst : null;
}
function traverseTwoPhase$1(inst, fn, arg) {
for (var path = []; inst; ) path.push(inst), (inst = getParent$1(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 getListener$1(inst, registrationName) {
inst = inst.stateNode;
if (null === inst) return null;
inst = getFiberCurrentPropsFromNode$1(inst);
if (null === inst) return null;
if ((inst = inst[registrationName]) && "function" !== typeof inst)
throw Error(
"Expected `" +
registrationName +
"` listener to be a function, instead got a value of `" +
typeof inst +
"` type."
);
return inst;
}
function accumulateDirectionalDispatches$1(inst, phase, event) {
if (
(phase = getListener$1(
inst,
event.dispatchConfig.phasedRegistrationNames[phase]
))
)
(event._dispatchListeners = accumulateInto(
event._dispatchListeners,
phase
)),
(event._dispatchInstances = accumulateInto(
event._dispatchInstances,
inst
));
}
function accumulateDirectDispatchesSingle$1(event) {
if (event && event.dispatchConfig.registrationName) {
var inst = event._targetInst;
if (inst && event && event.dispatchConfig.registrationName) {
var listener = getListener$1(inst, event.dispatchConfig.registrationName);
listener &&
((event._dispatchListeners = accumulateInto(
event._dispatchListeners,
listener
)),
(event._dispatchInstances = accumulateInto(
event._dispatchInstances,
inst
)));
}
}
}
function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
if (event && event.dispatchConfig.phasedRegistrationNames) {
var targetInst = event._targetInst;
targetInst = targetInst ? getParent$1(targetInst) : null;
traverseTwoPhase$1(targetInst, accumulateDirectionalDispatches$1, event);
}
}
function accumulateTwoPhaseDispatchesSingle$1(event) {
event &&
event.dispatchConfig.phasedRegistrationNames &&
traverseTwoPhase$1(
event._targetInst,
accumulateDirectionalDispatches$1,
event
);
}
var ResponderEventPlugin = {
_getResponder: function () {
return responderInst;
},
eventTypes: eventTypes,
extractEvents: function (
topLevelType,
targetInst,
nativeEvent,
nativeEventTarget
) {
if (isStartish(topLevelType)) trackedTouchCount += 1;
else if (
"topTouchEnd" === topLevelType ||
"topTouchCancel" === topLevelType
)
if (0 <= trackedTouchCount) --trackedTouchCount;
else return 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$1(tempA)
)
depthA++;
tempA = 0;
for (var tempB = targetInst; tempB; tempB = getParent$1(tempB))
tempA++;
for (; 0 < depthA - tempA; )
(JSCompiler_temp = getParent$1(JSCompiler_temp)), depthA--;
for (; 0 < tempA - depthA; )
(targetInst = getParent$1(targetInst)), tempA--;
for (; depthA--; ) {
if (
JSCompiler_temp === targetInst ||
JSCompiler_temp === targetInst.alternate
)
break b;
JSCompiler_temp = getParent$1(JSCompiler_temp);
targetInst = getParent$1(targetInst);
}
JSCompiler_temp = null;
}
else JSCompiler_temp = targetInst;
targetInst = JSCompiler_temp;
JSCompiler_temp = targetInst === responderInst;
shouldSetEventType = ResponderSyntheticEvent.getPooled(
shouldSetEventType,
targetInst,
nativeEvent,
nativeEventTarget
);
shouldSetEventType.touchHistory =
ResponderTouchHistoryStore.touchHistory;
JSCompiler_temp
? forEachAccumulated(
shouldSetEventType,
accumulateTwoPhaseDispatchesSingleSkipTarget
)
: forEachAccumulated(
shouldSetEventType,
accumulateTwoPhaseDispatchesSingle$1
);
b: {
JSCompiler_temp = shouldSetEventType._dispatchListeners;
targetInst = shouldSetEventType._dispatchInstances;
if (isArrayImpl(JSCompiler_temp))
for (
depthA = 0;
depthA < JSCompiler_temp.length &&
!shouldSetEventType.isPropagationStopped();
depthA++
) {
if (
JSCompiler_temp[depthA](shouldSetEventType, targetInst[depthA])
) {
JSCompiler_temp = targetInst[depthA];
break b;
}
}
else if (
JSCompiler_temp &&
JSCompiler_temp(shouldSetEventType, targetInst)
) {
JSCompiler_temp = targetInst;
break b;
}
JSCompiler_temp = null;
}
shouldSetEventType._dispatchInstances = null;
shouldSetEventType._dispatchListeners = null;
shouldSetEventType.isPersistent() ||
shouldSetEventType.constructor.release(shouldSetEventType);
if (JSCompiler_temp && JSCompiler_temp !== responderInst)
if (
((shouldSetEventType = ResponderSyntheticEvent.getPooled(
eventTypes.responderGrant,
JSCompiler_temp,
nativeEvent,
nativeEventTarget
)),
(shouldSetEventType.touchHistory =
ResponderTouchHistoryStore.touchHistory),
forEachAccumulated(
shouldSetEventType,
accumulateDirectDispatchesSingle$1
),
(targetInst = !0 === executeDirectDispatch(shouldSetEventType)),
responderInst)
)
if (
((depthA = ResponderSyntheticEvent.getPooled(
eventTypes.responderTerminationRequest,
responderInst,
nativeEvent,
nativeEventTarget
)),
(depthA.touchHistory = ResponderTouchHistoryStore.touchHistory),
forEachAccumulated(depthA, accumulateDirectDispatchesSingle$1),
(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$1);
var JSCompiler_temp$jscomp$0 = accumulate(
JSCompiler_temp$jscomp$0,
[shouldSetEventType, depthA]
);
changeResponder(JSCompiler_temp, targetInst);
} else
(shouldSetEventType = ResponderSyntheticEvent.getPooled(
eventTypes.responderReject,
JSCompiler_temp,
nativeEvent,
nativeEventTarget
)),
(shouldSetEventType.touchHistory =
ResponderTouchHistoryStore.touchHistory),
forEachAccumulated(
shouldSetEventType,
accumulateDirectDispatchesSingle$1
),
(JSCompiler_temp$jscomp$0 = accumulate(
JSCompiler_temp$jscomp$0,
shouldSetEventType
));
else
(JSCompiler_temp$jscomp$0 = accumulate(
JSCompiler_temp$jscomp$0,
shouldSetEventType
)),
changeResponder(JSCompiler_temp, targetInst);
else JSCompiler_temp$jscomp$0 = null;
} else JSCompiler_temp$jscomp$0 = null;
shouldSetEventType = responderInst && isStartish(topLevelType);
JSCompiler_temp = responderInst && isMoveish(topLevelType);
targetInst =
responderInst &&
("topTouchEnd" === topLevelType || "topTouchCancel" === 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$1
),
(JSCompiler_temp$jscomp$0 = accumulate(
JSCompiler_temp$jscomp$0,
shouldSetEventType
));
shouldSetEventType = responderInst && "topTouchCancel" === topLevelType;
if (
(topLevelType =
responderInst &&
!shouldSetEventType &&
("topTouchEnd" === topLevelType || "topTouchCancel" === 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$1(targetInst);
b: {
for (targetInst = responderInst; depthA; ) {
if (
targetInst === depthA ||
targetInst === depthA.alternate
) {
targetInst = !0;
break b;
}
depthA = getParent$1(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$1),
(JSCompiler_temp$jscomp$0 = accumulate(
JSCompiler_temp$jscomp$0,
nativeEvent
)),
changeResponder(null);
return JSCompiler_temp$jscomp$0;
},
GlobalResponderHandler: null,
injection: {
injectGlobalResponderHandler: function (GlobalResponderHandler) {
ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
}
}
},
eventPluginOrder = null,
namesToPlugins = {};
function recomputePluginOrdering() {
if (eventPluginOrder)
for (var pluginName in namesToPlugins) {
var pluginModule = namesToPlugins[pluginName],
pluginIndex = eventPluginOrder.indexOf(pluginName);
if (-1 >= pluginIndex)
throw Error(
"EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `" +
(pluginName + "`.")
);
if (!plugins[pluginIndex]) {
if (!pluginModule.extractEvents)
throw Error(
"EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `" +
(pluginName + "` does not.")
);
plugins[pluginIndex] = pluginModule;
pluginIndex = pluginModule.eventTypes;
for (var eventName in pluginIndex) {
var JSCompiler_inline_result = void 0;
var dispatchConfig = pluginIndex[eventName];
if (eventNameDispatchConfigs.hasOwnProperty(eventName))
throw Error(
"EventPluginRegistry: More than one plugin attempted to publish the same event name, `" +
(eventName + "`.")
);
eventNameDispatchConfigs[eventName] = dispatchConfig;
var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
if (phasedRegistrationNames) {
for (JSCompiler_inline_result in phasedRegistrationNames)
phasedRegistrationNames.hasOwnProperty(
JSCompiler_inline_result
) &&
publishRegistrationName(
phasedRegistrationNames[JSCompiler_inline_result],
pluginModule
);
JSCompiler_inline_result = !0;
} else
dispatchConfig.registrationName
? (publishRegistrationName(
dispatchConfig.registrationName,
pluginModule
),
(JSCompiler_inline_result = !0))
: (JSCompiler_inline_result = !1);
if (!JSCompiler_inline_result)
throw Error(
"EventPluginRegistry: Failed to publish event `" +
eventName +
"` for plugin `" +
pluginName +
"`."
);
}
}
}
}
function publishRegistrationName(registrationName, pluginModule) {
if (registrationNameModules[registrationName])
throw Error(
"EventPluginRegistry: More than one plugin attempted to publish the same registration name, `" +
(registrationName + "`.")
);
registrationNameModules[registrationName] = pluginModule;
}
var plugins = [],
eventNameDispatchConfigs = {},
registrationNameModules = {};
function getListener(inst, registrationName) {
inst = inst.stateNode;
if (null === inst) return null;
inst = getFiberCurrentPropsFromNode$1(inst);
if (null === inst) return null;
if ((inst = inst[registrationName]) && "function" !== typeof inst)
throw Error(
"Expected `" +
registrationName +
"` listener to be a function, instead got a value of `" +
typeof inst +
"` type."
);
return inst;
}
var customBubblingEventTypes =
ReactNativePrivateInterface.ReactNativeViewConfigRegistry
.customBubblingEventTypes,
customDirectEventTypes =
ReactNativePrivateInterface.ReactNativeViewConfigRegistry
.customDirectEventTypes;
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 traverseTwoPhase(inst, fn, arg, skipBubbling) {
for (var path = []; inst; ) {
path.push(inst);
do inst = inst.return;
while (inst && 5 !== inst.tag);
inst = inst ? inst : null;
}
for (inst = path.length; 0 < inst--; ) fn(path[inst], "captured", arg);
if (skipBubbling) fn(path[0], "bubbled", arg);
else
for (inst = 0; inst < path.length; inst++) fn(path[inst], "bubbled", arg);
}
function accumulateTwoPhaseDispatchesSingle(event) {
event &&
event.dispatchConfig.phasedRegistrationNames &&
traverseTwoPhase(
event._targetInst,
accumulateDirectionalDispatches,
event,
!1
);
}
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
)));
}
}
}
if (eventPluginOrder)
throw Error(
"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([
"ResponderEventPlugin",
"ReactNativeBridgeEventPlugin"
]);
recomputePluginOrdering();
var injectedNamesToPlugins$jscomp$inline_277 = {
ResponderEventPlugin: ResponderEventPlugin,
ReactNativeBridgeEventPlugin: {
eventTypes: {},
extractEvents: function (
topLevelType,
targetInst,
nativeEvent,
nativeEventTarget
) {
if (null == targetInst) return null;
var bubbleDispatchConfig = customBubblingEventTypes[topLevelType],
directDispatchConfig = customDirectEventTypes[topLevelType];
if (!bubbleDispatchConfig && !directDispatchConfig)
throw Error(
'Unsupported top level event type "' + topLevelType + '" dispatched'
);
topLevelType = SyntheticEvent.getPooled(
bubbleDispatchConfig || directDispatchConfig,
targetInst,
nativeEvent,
nativeEventTarget
);
if (bubbleDispatchConfig)
null != topLevelType &&
null != topLevelType.dispatchConfig.phasedRegistrationNames &&
topLevelType.dispatchConfig.phasedRegistrationNames.skipBubbling
? topLevelType &&
topLevelType.dispatchConfig.phasedRegistrationNames &&
traverseTwoPhase(
topLevelType._targetInst,
accumulateDirectionalDispatches,
topLevelType,
!0
)
: forEachAccumulated(
topLevelType,
accumulateTwoPhaseDispatchesSingle
);
else if (directDispatchConfig)
forEachAccumulated(topLevelType, accumulateDirectDispatchesSingle);
else return null;
return topLevelType;
}
}
},
isOrderingDirty$jscomp$inline_278 = !1,
pluginName$jscomp$inline_279;
for (pluginName$jscomp$inline_279 in injectedNamesToPlugins$jscomp$inline_277)
if (
injectedNamesToPlugins$jscomp$inline_277.hasOwnProperty(
pluginName$jscomp$inline_279
)
) {
var pluginModule$jscomp$inline_280 =
injectedNamesToPlugins$jscomp$inline_277[pluginName$jscomp$inline_279];
if (
!namesToPlugins.hasOwnProperty(pluginName$jscomp$inline_279) ||
namesToPlugins[pluginName$jscomp$inline_279] !==
pluginModule$jscomp$inline_280
) {
if (namesToPlugins[pluginName$jscomp$inline_279])
throw Error(
"EventPluginRegistry: Cannot inject two different event plugins using the same name, `" +
(pluginName$jscomp$inline_279 + "`.")
);
namesToPlugins[pluginName$jscomp$inline_279] =
pluginModule$jscomp$inline_280;
isOrderingDirty$jscomp$inline_278 = !0;
}
}
isOrderingDirty$jscomp$inline_278 && recomputePluginOrdering();
function batchedUpdatesImpl(fn, bookkeeping) {
return fn(bookkeeping);
}
var isInsideEventHandler = !1;
function batchedUpdates$1(fn, bookkeeping) {
if (isInsideEventHandler) return fn(bookkeeping);
isInsideEventHandler = !0;
try {
return batchedUpdatesImpl(fn, bookkeeping);
} finally {
isInsideEventHandler = !1;
}
}
var eventQueue = null;
function executeDispatchesAndReleaseTopLevel(e) {
if (e) {
var dispatchListeners = e._dispatchListeners,
dispatchInstances = e._dispatchInstances;
if (isArrayImpl(dispatchListeners))
for (
var i = 0;
i < dispatchListeners.length && !e.isPropagationStopped();
i++
)
executeDispatch(e, dispatchListeners[i], dispatchInstances[i]);
else
dispatchListeners &&
executeDispatch(e, dispatchListeners, dispatchInstances);
e._dispatchListeners = null;
e._dispatchInstances = null;
e.isPersistent() || e.constructor.release(e);
}
}
function dispatchEvent(target, topLevelType, nativeEvent) {
var eventTarget = null;
if (null != target) {
var stateNode = target.stateNode;
null != stateNode && (eventTarget = getPublicInstance(stateNode));
}
batchedUpdates$1(function () {
var event = { eventName: topLevelType, nativeEvent: nativeEvent };
ReactNativePrivateInterface.RawEventEmitter.emit(topLevelType, event);
ReactNativePrivateInterface.RawEventEmitter.emit("*", event);
event = eventTarget;
for (
var events = null, legacyPlugins = plugins, i = 0;
i < legacyPlugins.length;
i++
) {
var possiblePlugin = legacyPlugins[i];
possiblePlugin &&
(possiblePlugin = possiblePlugin.extractEvents(
topLevelType,
target,
nativeEvent,
event
)) &&
(events = accumulateInto(events, possiblePlugin));
}
event = events;
null !== event && (eventQueue = accumulateInto(eventQueue, event));
event = eventQueue;
eventQueue = null;
if (event) {
forEachAccumulated(event, executeDispatchesAndReleaseTopLevel);
if (eventQueue)
throw Error(
"processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."
);
if (hasError)
throw (
((event = caughtError), (hasError = !1), (caughtError = null), event)
);
}
});
}
var scheduleCallback$3 = Scheduler.unstable_scheduleCallback,
cancelCallback$1 = Scheduler.unstable_cancelCallback,
shouldYield = Scheduler.unstable_shouldYield,
requestPaint = Scheduler.unstable_requestPaint,
now = Scheduler.unstable_now,
ImmediatePriority = Scheduler.unstable_ImmediatePriority,
UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
NormalPriority$1 = Scheduler.unstable_NormalPriority,
IdlePriority = Scheduler.unstable_IdlePriority,
log$1 = Scheduler.log,
unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue,
rendererID = null,
injectedHook = null;
function setIsStrictModeForDevtools(newIsStrictMode) {
"function" === typeof log$1 && unstable_setDisableYieldValue(newIsStrictMode);
if (injectedHook && "function" === typeof injectedHook.setStrictMode)
try {
injectedHook.setStrictMode(rendererID, newIsStrictMode);
} catch (err) {}
}
var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
log = Math.log,
LN2 = Math.LN2;
function clz32Fallback(x) {
x >>>= 0;
return 0 === x ? 32 : (31 - ((log(x) / LN2) | 0)) | 0;
}
var nextTransitionUpdateLane = 256,
nextTransitionDeferredLane = 262144,
nextRetryLane = 4194304;
function getHighestPriorityLanes(lanes) {
var pendingSyncLanes = lanes & 42;
if (0 !== pendingSyncLanes) return pendingSyncLanes;
switch (lanes & -lanes) {
case 1:
return 1;
case 2:
return 2;
case 4:
return 4;
case 8:
return 8;
case 16:
return 16;
case 32:
return 32;
case 64:
return 64;
case 128:
return 128;
case 256:
case 512:
case 1024:
case 2048:
case 4096:
case 8192:
case 16384:
case 32768:
case 65536:
case 131072:
return lanes & 261888;
case 262144:
case 524288:
case 1048576:
case 2097152:
return lanes & 3932160;
case 4194304:
case 8388608:
case 16777216:
case 33554432:
return lanes & 62914560;
case 67108864:
return 67108864;
case 134217728:
return 134217728;
case 268435456:
return 268435456;
case 536870912:
return 536870912;
case 1073741824:
return 0;
default:
return lanes;
}
}
function getNextLanes(root, wipLanes, rootHasPendingCommit) {
var pendingLanes = root.pendingLanes;
if (0 === pendingLanes) return 0;
var nextLanes = 0,
suspendedLanes = root.suspendedLanes,
pingedLanes = root.pingedLanes;
root = root.warmLanes;
var nonIdlePendingLanes = pendingLanes & 134217727;
0 !== nonIdlePendingLanes
? ((pendingLanes = nonIdlePendingLanes & ~suspendedLanes),
0 !== pendingLanes
? (nextLanes = getHighestPriorityLanes(pendingLanes))
: ((pingedLanes &= nonIdlePendingLanes),
0 !== pingedLanes
? (nextLanes = getHighestPriorityLanes(pingedLanes))
: rootHasPendingCommit ||
((rootHasPendingCommit = nonIdlePendingLanes & ~root),
0 !== rootHasPendingCommit &&
(nextLanes = getHighestPriorityLanes(rootHasPendingCommit)))))
: ((nonIdlePendingLanes = pendingLanes & ~suspendedLanes),
0 !== nonIdlePendingLanes
? (nextLanes = getHighestPriorityLanes(nonIdlePendingLanes))
: 0 !== pingedLanes
? (nextLanes = getHighestPriorityLanes(pingedLanes))
: rootHasPendingCommit ||
((rootHasPendingCommit = pendingLanes & ~root),
0 !== rootHasPendingCommit &&
(nextLanes = getHighestPriorityLanes(rootHasPendingCommit))));
return 0 === nextLanes
? 0
: 0 !== wipLanes &&
wipLanes !== nextLanes &&
0 === (wipLanes & suspendedLanes) &&
((suspendedLanes = nextLanes & -nextLanes),
(rootHasPendingCommit = wipLanes & -wipLanes),
suspendedLanes >= rootHasPendingCommit ||
(32 === suspendedLanes && 0 !== (rootHasPendingCommit & 4194048)))
? wipLanes
: nextLanes;
}
function checkIfRootIsPrerendering(root, renderLanes) {
return (
0 ===
(root.pendingLanes &
~(root.suspendedLanes & ~root.pingedLanes) &
renderLanes)
);
}
function computeExpirationTime(lane, currentTime) {
switch (lane) {
case 1:
case 2:
case 4:
case 8:
case 64:
return currentTime + 250;
case 16:
case 32:
case 128:
case 256:
case 512:
case 1024:
case 2048:
case 4096:
case 8192:
case 16384:
case 32768:
case 65536:
case 131072:
case 262144:
case 524288:
case 1048576:
case 2097152:
return currentTime + 5e3;
case 4194304:
case 8388608:
case 16777216:
case 33554432:
return -1;
case 67108864:
case 134217728:
case 268435456:
case 536870912:
case 1073741824:
return -1;
default:
return -1;
}
}
function claimNextRetryLane() {
var lane = nextRetryLane;
nextRetryLane <<= 1;
0 === (nextRetryLane & 62