481 lines
19 KiB
JavaScript
481 lines
19 KiB
JavaScript
// Module ID: 5011
|
|
// Function ID: 42780
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: []
|
|
// Exports: default
|
|
|
|
// Module 5011 (_isNativeReflectConstruct)
|
|
let DeviceEventEmitter;
|
|
let Platform;
|
|
let UIManager;
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
function hasUnresolvedRefs(simultaneousHandlers) {
|
|
function extract(simultaneousHandlers) {
|
|
if (Array.isArray(simultaneousHandlers)) {
|
|
let someResult = simultaneousHandlers.some((current) => {
|
|
let tmp = current;
|
|
if (current) {
|
|
tmp = null === current.current;
|
|
}
|
|
return tmp;
|
|
});
|
|
} else {
|
|
someResult = simultaneousHandlers;
|
|
if (simultaneousHandlers) {
|
|
someResult = null === simultaneousHandlers.current;
|
|
}
|
|
}
|
|
return someResult;
|
|
}
|
|
return extract(simultaneousHandlers.simultaneousHandlers) || extract(simultaneousHandlers.waitFor);
|
|
}
|
|
let closure_3 = importDefault(dependencyMap[0]);
|
|
let closure_4 = importDefault(dependencyMap[1]);
|
|
let closure_5 = importDefault(dependencyMap[2]);
|
|
let closure_6 = importDefault(dependencyMap[3]);
|
|
let closure_7 = importDefault(dependencyMap[4]);
|
|
let closure_8 = importDefault(dependencyMap[5]);
|
|
const importDefaultResult = importDefault(dependencyMap[6]);
|
|
let closure_9 = importAll(dependencyMap[7]);
|
|
({ Platform, UIManager, DeviceEventEmitter } = arg1(dependencyMap[8]));
|
|
const jsx = arg1(dependencyMap[9]).jsx;
|
|
arg1(dependencyMap[10]).customDirectEventTypes.topGestureHandlerEvent = { registrationName: "onGestureHandlerEvent" };
|
|
let obj = arg1(dependencyMap[11]);
|
|
let isFabricResult = obj.isFabric();
|
|
if (isFabricResult) {
|
|
obj = {};
|
|
obj = { registrationName: "onGestureHandlerEvent" };
|
|
obj.topOnGestureHandlerEvent = obj;
|
|
const obj1 = { registrationName: "onGestureHandlerStateChange" };
|
|
obj.topOnGestureHandlerStateChange = obj1;
|
|
isFabricResult = obj;
|
|
}
|
|
const merged = Object.assign({ onGestureHandlerEvent: { registrationName: "onGestureHandlerEvent" }, onGestureHandlerStateChange: { registrationName: "onGestureHandlerStateChange" } }, isFabricResult);
|
|
UIManager.genericDirectEventTypes = Object.assign({}, UIManager.genericDirectEventTypes, merged);
|
|
let viewManagerConfig;
|
|
if (null != UIManager.getViewManagerConfig) {
|
|
viewManagerConfig = UIManager.getViewManagerConfig("getConstants");
|
|
}
|
|
if (viewManagerConfig) {
|
|
const _Object = Object;
|
|
viewManagerConfig.genericDirectEventTypes = Object.assign({}, viewManagerConfig.genericDirectEventTypes, merged);
|
|
}
|
|
let fn = UIManager.setJSResponder;
|
|
if (undefined === fn) {
|
|
fn = () => {
|
|
|
|
};
|
|
}
|
|
let fn2 = UIManager.clearJSResponder;
|
|
if (undefined === fn2) {
|
|
fn2 = () => {
|
|
|
|
};
|
|
}
|
|
UIManager.setJSResponder = (arg0, arg1) => {
|
|
importDefault(dependencyMap[12]).handleSetJSResponder(arg0, arg1);
|
|
fn(arg0, arg1);
|
|
};
|
|
UIManager.clearJSResponder = () => {
|
|
const result = importDefault(dependencyMap[12]).handleClearJSResponder();
|
|
fn2();
|
|
};
|
|
const tmp3 = arg1(dependencyMap[8]);
|
|
const importDefaultResultResult = importDefaultResult({}, arg1(dependencyMap[13]).State.UNDETERMINED, undefined);
|
|
const importDefaultResultResult1 = importDefaultResult(importDefaultResult({}, arg1(dependencyMap[13]).State.UNDETERMINED, undefined), arg1(dependencyMap[13]).State.BEGAN, "onBegan");
|
|
const importDefaultResultResult2 = importDefaultResult(importDefaultResult(importDefaultResult({}, arg1(dependencyMap[13]).State.UNDETERMINED, undefined), arg1(dependencyMap[13]).State.BEGAN, "onBegan"), arg1(dependencyMap[13]).State.FAILED, "onFailed");
|
|
const importDefaultResultResult3 = importDefaultResult(importDefaultResult(importDefaultResult(importDefaultResult({}, arg1(dependencyMap[13]).State.UNDETERMINED, undefined), arg1(dependencyMap[13]).State.BEGAN, "onBegan"), arg1(dependencyMap[13]).State.FAILED, "onFailed"), arg1(dependencyMap[13]).State.CANCELLED, "onCancelled");
|
|
let closure_12 = importDefaultResult(importDefaultResult(importDefaultResult(importDefaultResult(importDefaultResult(importDefaultResult({}, arg1(dependencyMap[13]).State.UNDETERMINED, undefined), arg1(dependencyMap[13]).State.BEGAN, "onBegan"), arg1(dependencyMap[13]).State.FAILED, "onFailed"), arg1(dependencyMap[13]).State.CANCELLED, "onCancelled"), arg1(dependencyMap[13]).State.ACTIVE, "onActivated"), arg1(dependencyMap[13]).State.END, "onEnded");
|
|
|
|
export default function createHandler(name) {
|
|
let customNativeProps;
|
|
name = name.name;
|
|
const arg1 = name;
|
|
let allowedProps = name.allowedProps;
|
|
if (undefined === allowedProps) {
|
|
allowedProps = [];
|
|
}
|
|
const importDefault = allowedProps;
|
|
let config = name.config;
|
|
if (undefined === config) {
|
|
config = {};
|
|
}
|
|
const dependencyMap = config;
|
|
({ transformProps: closure_3, customNativeProps } = name);
|
|
if (undefined === customNativeProps) {
|
|
customNativeProps = [];
|
|
}
|
|
let closure_4 = customNativeProps;
|
|
const tmp = (Component) => {
|
|
class Handler {
|
|
constructor(arg0) {
|
|
self = this;
|
|
tmp = closure_4(this, Handler);
|
|
items = [];
|
|
items[0] = Component;
|
|
obj = closure_7(Handler);
|
|
tmp2 = closure_6;
|
|
if (closure_13()) {
|
|
tmp4 = globalThis;
|
|
_Reflect = Reflect;
|
|
tmp5 = closure_7;
|
|
constructResult = Reflect.construct(obj, items, closure_7(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items);
|
|
}
|
|
tmp2Result = tmp2(self, constructResult);
|
|
Handler = tmp2Result;
|
|
tmp2Result.handlerTag = -1;
|
|
tmp2Result.onGestureHandlerEvent = (nativeEvent) => {
|
|
if (nativeEvent.nativeEvent.handlerTag === tmp2Result.handlerTag) {
|
|
if ("function" === typeof tmp2Result.props.onGestureEvent) {
|
|
if (null != tmp2Result.props.onGestureEvent) {
|
|
const props2 = tmp2Result.props;
|
|
props2.onGestureEvent(nativeEvent);
|
|
}
|
|
}
|
|
} else if (null != tmp2Result.props.onGestureHandlerEvent) {
|
|
const props = tmp2Result.props;
|
|
const result = props.onGestureHandlerEvent(nativeEvent);
|
|
}
|
|
};
|
|
tmp2Result.onGestureHandlerStateChange = (nativeEvent) => {
|
|
if (nativeEvent.nativeEvent.handlerTag === tmp2Result.handlerTag) {
|
|
if ("function" === typeof tmp2Result.props.onHandlerStateChange) {
|
|
if (null != tmp2Result.props.onHandlerStateChange) {
|
|
const props = tmp2Result.props;
|
|
props.onHandlerStateChange(nativeEvent);
|
|
}
|
|
}
|
|
let tmp10 = tmp9;
|
|
if (closure_12[nativeEvent.nativeEvent.state]) {
|
|
tmp10 = tmp2Result.props[tmp9];
|
|
}
|
|
let tmp12 = tmp10;
|
|
if (tmp10) {
|
|
tmp12 = "function" === typeof tmp10;
|
|
}
|
|
if (tmp12) {
|
|
tmp10(nativeEvent);
|
|
}
|
|
} else if (null != tmp2Result.props.onGestureHandlerStateChange) {
|
|
const props2 = tmp2Result.props;
|
|
const result = props2.onGestureHandlerStateChange(nativeEvent);
|
|
}
|
|
};
|
|
tmp2Result.refHandler = (viewNode) => {
|
|
tmp2Result.viewNode = viewNode;
|
|
const Children = React.Children;
|
|
const onlyResult = Children.only(tmp2Result.props.children);
|
|
if (obj.isReact19()) {
|
|
const props = onlyResult.props;
|
|
let ref;
|
|
if (null != props) {
|
|
ref = props.ref;
|
|
}
|
|
} else if (null != onlyResult) {
|
|
ref = onlyResult.ref;
|
|
}
|
|
if (ref) {
|
|
if ("function" === typeof ref) {
|
|
ref(viewNode);
|
|
} else {
|
|
ref.current = viewNode;
|
|
}
|
|
}
|
|
};
|
|
tmp2Result.createGestureHandler = (config) => {
|
|
tmp2Result.handlerTag = tmp2Result(closure_2[14]).getNextHandlerTag();
|
|
tmp2Result.config = config;
|
|
const obj = tmp2Result(closure_2[14]);
|
|
callback(closure_2[12]).createGestureHandler(tmp2Result, tmp2Result.handlerTag, config);
|
|
};
|
|
tmp2Result.attachGestureHandler = (viewTag) => {
|
|
tmp2Result.viewTag = viewTag;
|
|
let obj = tmp2Result(closure_2[15]);
|
|
obj = { onGestureEvent: tmp2Result.onGestureHandlerEvent, onGestureStateChange: tmp2Result.onGestureHandlerStateChange };
|
|
const result = obj.registerOldGestureHandler(tmp2Result.handlerTag, obj);
|
|
const props = tmp2Result.props;
|
|
let onGestureEvent;
|
|
if (null != props) {
|
|
onGestureEvent = props.onGestureEvent;
|
|
}
|
|
let tmp3 = onGestureEvent;
|
|
if (onGestureEvent) {
|
|
let tmp4 = "current" in onGestureEvent;
|
|
if (!tmp4) {
|
|
tmp4 = "workletEventHandler" in onGestureEvent;
|
|
}
|
|
tmp3 = tmp4;
|
|
}
|
|
const props2 = tmp2Result.props;
|
|
if (!tmp3) {
|
|
if (!onHandlerStateChange) {
|
|
if (onGestureEvent) {
|
|
if ("__isNative" in onGestureEvent) {
|
|
let REANIMATED_WORKLET = tmp2Result(closure_2[16]).ActionType.NATIVE_ANIMATED_EVENT;
|
|
}
|
|
}
|
|
REANIMATED_WORKLET = tmp2Result(closure_2[16]).ActionType.JS_FUNCTION_OLD_API;
|
|
}
|
|
callback(closure_2[12]).attachGestureHandler(tmp2Result.handlerTag, viewTag, REANIMATED_WORKLET);
|
|
const obj3 = callback(closure_2[12]);
|
|
const result1 = tmp2Result(closure_2[17]).scheduleFlushOperations();
|
|
const obj4 = tmp2Result(closure_2[17]);
|
|
tmp2Result(closure_2[18]).ghQueueMicrotask(() => {
|
|
const MountRegistry = callback(closure_2[19]).MountRegistry;
|
|
const result = MountRegistry.gestureHandlerWillMount(callback);
|
|
});
|
|
}
|
|
REANIMATED_WORKLET = tmp2Result(closure_2[16]).ActionType.REANIMATED_WORKLET;
|
|
};
|
|
tmp2Result.updateGestureHandler = (config) => {
|
|
tmp2Result.config = config;
|
|
callback(closure_2[12]).updateGestureHandler(tmp2Result.handlerTag, config);
|
|
const obj = callback(closure_2[12]);
|
|
const result = tmp2Result(closure_2[17]).scheduleFlushOperations();
|
|
};
|
|
tmp2Result.config = {};
|
|
tmp2Result.propsRef = closure_9.createRef();
|
|
tmp2Result.isMountedRef = closure_9.createRef();
|
|
tmp2Result.state = { allowTouches: true };
|
|
if (Component.id) {
|
|
tmp7 = Handler;
|
|
tmp8 = closure_2;
|
|
num = 15;
|
|
if (undefined !== Handler(closure_2[15]).handlerIDToTag[Component.id]) {
|
|
tmp11 = globalThis;
|
|
_Error = Error;
|
|
_HermesInternal = HermesInternal;
|
|
str = "Handler with ID \"";
|
|
str2 = "\" already registered";
|
|
prototype = Error.prototype;
|
|
tmp12 = new.target;
|
|
tmp13 = new.target;
|
|
error = new Error("Handler with ID \"" + Component.id + "\" already registered");
|
|
tmp15 = error;
|
|
throw error;
|
|
} else {
|
|
tmp9 = Handler;
|
|
tmp10 = closure_2;
|
|
Handler(closure_2[15]).handlerIDToTag[Component.id] = tmp2Result.handlerTag;
|
|
}
|
|
}
|
|
return tmp2Result;
|
|
}
|
|
}
|
|
const name = Handler;
|
|
callback2(Handler, Component);
|
|
let obj = {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
const self = this;
|
|
const Handler = this;
|
|
this.isMountedRef.current = true;
|
|
if (callback6(this.props)) {
|
|
Handler(closure_2[18]).ghQueueMicrotask(() => {
|
|
self.update(1);
|
|
});
|
|
const obj = Handler(closure_2[18]);
|
|
}
|
|
if (callback2) {
|
|
let props = callback2(self.props);
|
|
} else {
|
|
props = self.props;
|
|
}
|
|
const items = [];
|
|
const obj2 = Handler(closure_2[17]);
|
|
self.createGestureHandler(obj2.filterConfig(props, items.concat(callback2(callback), callback2(closure_4)), closure_2));
|
|
if (self.viewNode) {
|
|
self.attachGestureHandler(callback(closure_2[20])(self.viewNode));
|
|
} else {
|
|
const _Error = Error;
|
|
const _HermesInternal = HermesInternal;
|
|
const error = new Error("[Gesture Handler] Failed to obtain view for " + Handler.displayName + ". Note that old API doesn't support functional components.");
|
|
throw error;
|
|
}
|
|
const tmp5 = callback2(callback);
|
|
}
|
|
};
|
|
const items = [obj, , , , , ];
|
|
obj = {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
const self = this;
|
|
const tmp = callback(closure_2[20])(this.viewNode);
|
|
if (this.viewTag !== tmp) {
|
|
self.attachGestureHandler(tmp);
|
|
}
|
|
self.update(1);
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
const self = this;
|
|
const inspectorToggleListener = this.inspectorToggleListener;
|
|
if (null != inspectorToggleListener) {
|
|
inspectorToggleListener.remove();
|
|
}
|
|
self.isMountedRef.current = false;
|
|
const result = Handler(closure_2[15]).unregisterOldGestureHandler(self.handlerTag);
|
|
const obj = Handler(closure_2[15]);
|
|
callback(closure_2[12]).dropGestureHandler(self.handlerTag);
|
|
const obj2 = callback(closure_2[12]);
|
|
const result1 = Handler(closure_2[17]).scheduleFlushOperations();
|
|
if (self.props.id) {
|
|
const handlerIDToTag = Handler(closure_2[15]).handlerIDToTag;
|
|
delete r2[r4];
|
|
}
|
|
const MountRegistry = Handler(closure_2[19]).MountRegistry;
|
|
const result2 = MountRegistry.gestureHandlerWillUnmount(self);
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "update",
|
|
value: function update(arg0) {
|
|
let self = this;
|
|
self = this;
|
|
if (this.isMountedRef.current) {
|
|
if (callback6(self.props)) {
|
|
if (arg0 > 0) {
|
|
Handler(closure_2[18]).ghQueueMicrotask(() => {
|
|
self.update(arg0 - 1);
|
|
});
|
|
const obj3 = Handler(closure_2[18]);
|
|
}
|
|
}
|
|
if (callback2) {
|
|
let props = callback2(self.props);
|
|
} else {
|
|
props = self.props;
|
|
}
|
|
const items = [];
|
|
const obj = Handler(closure_2[17]);
|
|
const filterConfigResult = obj.filterConfig(props, items.concat(callback2(self), callback2(closure_4)), closure_2);
|
|
const tmp8 = callback2(self);
|
|
if (!obj2.deepEqual(self.config, filterConfigResult)) {
|
|
self.updateGestureHandler(filterConfigResult);
|
|
}
|
|
const obj2 = Handler(closure_2[11]);
|
|
}
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "setNativeProps",
|
|
value: function setNativeProps(arg0) {
|
|
const self = this;
|
|
const merged = Object.assign({}, this.props, arg0);
|
|
let tmp2 = merged;
|
|
if (callback2) {
|
|
tmp2 = callback2(merged);
|
|
}
|
|
const items = [];
|
|
const obj = Handler(closure_2[17]);
|
|
self.updateGestureHandler(obj.filterConfig(tmp2, items.concat(callback2(closure_1), callback2(closure_4)), closure_2));
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "render",
|
|
value: function render() {
|
|
let onGestureEvent;
|
|
let onGestureHandlerEvent;
|
|
let onGestureHandlerEvent2;
|
|
let onGestureHandlerStateChange;
|
|
let onGestureHandlerStateChange2;
|
|
let onHandlerStateChange;
|
|
let props;
|
|
let props2;
|
|
const self = this;
|
|
({ onGestureHandlerEvent, props } = this);
|
|
({ onGestureEvent, onGestureHandlerEvent: onGestureHandlerEvent2 } = props);
|
|
if (onGestureEvent) {
|
|
if ("function" !== typeof onGestureEvent) {
|
|
let tmp = onGestureEvent;
|
|
if (onGestureHandlerEvent2) {
|
|
const _Error4 = Error;
|
|
const error = new Error("Nesting touch handlers with native animated driver is not supported yet");
|
|
throw error;
|
|
}
|
|
}
|
|
({ onGestureHandlerStateChange, props: props2 } = self);
|
|
({ onHandlerStateChange, onGestureHandlerStateChange: onGestureHandlerStateChange2 } = props2);
|
|
if (onHandlerStateChange) {
|
|
if ("function" !== typeof onHandlerStateChange) {
|
|
let tmp7 = onHandlerStateChange;
|
|
if (onGestureHandlerStateChange2) {
|
|
const _Error3 = Error;
|
|
const error1 = new Error("Nesting touch handlers with native animated driver is not supported yet");
|
|
throw error1;
|
|
}
|
|
}
|
|
let obj = {};
|
|
let tmp13;
|
|
if (self.state.allowTouches) {
|
|
tmp13 = tmp;
|
|
}
|
|
obj.onGestureHandlerEvent = tmp13;
|
|
let tmp14;
|
|
if (self.state.allowTouches) {
|
|
tmp14 = tmp7;
|
|
}
|
|
obj.onGestureHandlerStateChange = tmp14;
|
|
self.propsRef.current = obj;
|
|
const Children = React.Children;
|
|
const onlyResult = Children.only(self.props.children);
|
|
const _Object = Object;
|
|
obj = { ref: self.refHandler, collapsable: false };
|
|
let obj2 = Handler(closure_2[11]);
|
|
if (obj2.isTestEnv()) {
|
|
obj = { handlerType: Handler, handlerTag: self.handlerTag, enabled: self.props.enabled };
|
|
let obj1 = obj;
|
|
} else {
|
|
obj1 = {};
|
|
}
|
|
obj2 = {};
|
|
const testID = self.props.testID;
|
|
if (null != testID) {
|
|
let testID2 = testID;
|
|
} else {
|
|
testID2 = onlyResult.props.testID;
|
|
}
|
|
obj2.testID = testID2;
|
|
return React.cloneElement(onlyResult, Object.assign(obj, obj1, obj2, obj), onlyResult.props.children);
|
|
}
|
|
tmp7 = onGestureHandlerStateChange;
|
|
if (onGestureHandlerStateChange2) {
|
|
tmp7 = onGestureHandlerStateChange;
|
|
if ("function" !== typeof onGestureHandlerStateChange2) {
|
|
const _Error2 = Error;
|
|
const error2 = new Error("Nesting touch handlers with native animated driver is not supported yet");
|
|
throw error2;
|
|
}
|
|
}
|
|
}
|
|
tmp = onGestureHandlerEvent;
|
|
if (onGestureHandlerEvent2) {
|
|
tmp = onGestureHandlerEvent;
|
|
if ("function" !== typeof onGestureHandlerEvent2) {
|
|
const _Error = Error;
|
|
const error3 = new Error("Nesting touch handlers with native animated driver is not supported yet");
|
|
throw error3;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
return callback(Handler, items);
|
|
}(Component.Component);
|
|
tmp.displayName = name;
|
|
tmp.contextType = importDefault(dependencyMap[21]);
|
|
return tmp;
|
|
};
|