357 lines
11 KiB
JavaScript
357 lines
11 KiB
JavaScript
// Module ID: 357
|
|
// Function ID: 358
|
|
// Name: set
|
|
// Dependencies: [358, 361, 27, 70, 38, 92, 209]
|
|
|
|
// Module 357 (set)
|
|
import shouldUseTurboAnimatedModuleDefault from "shouldUseTurboAnimatedModule" /* 361 */;
|
|
import importDefaultResult from "shouldUseTurboAnimatedModule" /* 358 */;
|
|
import importAllResult1 from "javaScriptFlagGetter" /* 27 */;
|
|
|
|
let closure_0 = importDefault;
|
|
if (importDefaultResult == null) {
|
|
importDefaultResult = shouldUseTurboAnimatedModuleDefault;
|
|
}
|
|
let c4 = importDefaultResult;
|
|
let c5 = 1;
|
|
let c6 = 1;
|
|
const set = new Set();
|
|
let c8 = false;
|
|
let closure_9 = [];
|
|
let closure_10 = [];
|
|
let prop;
|
|
if (importDefaultResult != null) {
|
|
prop = importDefaultResult.queueAndExecuteBatchedOperations;
|
|
}
|
|
let result = null != prop;
|
|
if (result) {
|
|
result = importAllResult1.animatedShouldUseSingleOp();
|
|
const importAllResult = importAllResult1;
|
|
}
|
|
let closure_11 = null;
|
|
let closure_12 = {};
|
|
let closure_13 = {};
|
|
let c14 = null;
|
|
let c15 = null;
|
|
const result1 = importAllResult1.cxxNativeAnimatedEnabled();
|
|
let result2 = importAllResult1.cxxNativeAnimatedEnabled();
|
|
if (result2) {
|
|
result2 = importAllResult1.useSharedAnimatedBackend();
|
|
const importAllResult3 = importAllResult1;
|
|
}
|
|
let items = ["createAnimatedNode", "updateAnimatedNodeConfig", "getValue", "startListeningToAnimatedNodeValue", "stopListeningToAnimatedNodeValue", "connectAnimatedNodes", "disconnectAnimatedNodes", "startAnimatingNode", "stopAnimation", "setAnimatedNodeValue", "setAnimatedNodeOffset", "flattenAnimatedNodeOffset", "extractAnimatedNodeOffset", "connectAnimatedNodeToView", "disconnectAnimatedNodeFromView", "restoreDefaultValues", "dropAnimatedNode", "addAnimatedEventToView", "removeAnimatedEventFromView", "addListener", "removeListener"];
|
|
if (result2) {
|
|
items.push("connectAnimatedNodeToShadowNodeFamily");
|
|
}
|
|
let obj = {};
|
|
if (result) {
|
|
let num3 = 0;
|
|
let num4 = 0;
|
|
if (tmp9) {
|
|
do {
|
|
closure_0 = num3 + 1;
|
|
obj[items[num3]] = () => {
|
|
const items = [closure_0, ...HermesBuiltin.copyRestArgs()];
|
|
closure_10.push.apply(items);
|
|
if (result1) {
|
|
const _clearImmediate = clearImmediate;
|
|
clearImmediate(immediate);
|
|
const _setImmediate = setImmediate;
|
|
immediate = setImmediate(obj.flushQueue);
|
|
}
|
|
};
|
|
num3 = num4 + 1;
|
|
num4 = num3;
|
|
} while (num3 < length);
|
|
}
|
|
} else {
|
|
let num = 0;
|
|
let num2 = 0;
|
|
if (tmp9) {
|
|
do {
|
|
let tmp10 = items[num];
|
|
closure_0 = tmp10;
|
|
obj[tmp10] = () => {
|
|
const items = [...arguments];
|
|
closure_1 = undefined;
|
|
const tmp = callback(70)(importDefaultResult)[items];
|
|
closure_1 = tmp;
|
|
if (!c8) {
|
|
if (0 === arr.length) {
|
|
if (result1) {
|
|
arr = arr.push(() => callback(...items));
|
|
const _clearImmediate = clearImmediate;
|
|
clearImmediate(immediate);
|
|
const _setImmediate = setImmediate;
|
|
immediate = setImmediate(obj.flushQueue);
|
|
} else {
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items1, undefined);
|
|
}
|
|
}
|
|
}
|
|
arr = arr.push(() => callback(...items));
|
|
};
|
|
num = num2 + 1;
|
|
num2 = num;
|
|
} while (num < length);
|
|
}
|
|
}
|
|
obj = {
|
|
addAnimatedEventToView(c4, closure_0, arg2) {
|
|
const result = obj.addAnimatedEventToView(c4, closure_0, arg2);
|
|
},
|
|
connectAnimatedNodes(__getNativeTagResult, arg1) {
|
|
obj.connectAnimatedNodes(__getNativeTagResult, arg1);
|
|
},
|
|
connectAnimatedNodeToShadowNodeFamily(self, nodeFromPublicInstance) {
|
|
const connectAnimatedNodeToShadowNodeFamily = obj.connectAnimatedNodeToShadowNodeFamily;
|
|
if (connectAnimatedNodeToShadowNodeFamily != null) {
|
|
const result = connectAnimatedNodeToShadowNodeFamily(self, nodeFromPublicInstance);
|
|
}
|
|
},
|
|
connectAnimatedNodeToView(self, findNodeHandleResult) {
|
|
const result = obj.connectAnimatedNodeToView(self, findNodeHandleResult);
|
|
},
|
|
createAnimatedNode(newNodeTag, __getNativeConfigResult) {
|
|
if (__getNativeConfigResult.disableBatchingForNativeCreate) {
|
|
if (closure_4 != null) {
|
|
const animatedNode = obj.createAnimatedNode(newNodeTag, __getNativeConfigResult);
|
|
}
|
|
} else {
|
|
const animatedNode1 = obj.createAnimatedNode(newNodeTag, __getNativeConfigResult);
|
|
}
|
|
},
|
|
disableQueue() {
|
|
callback(38)(closure_4, "Native animated module is not available");
|
|
obj = importAllResult1;
|
|
if (obj.animatedShouldDebounceQueueFlush()) {
|
|
const _clearImmediate = clearImmediate;
|
|
clearImmediate(immediate);
|
|
const _setImmediate = setImmediate;
|
|
immediate = setImmediate(obj.flushQueue);
|
|
} else {
|
|
obj.flushQueue();
|
|
}
|
|
},
|
|
disconnectAnimatedNodeFromView(self, connectedViewTag) {
|
|
const result = obj.disconnectAnimatedNodeFromView(self, connectedViewTag);
|
|
},
|
|
disconnectAnimatedNodes(__getNativeTagResult, arg1) {
|
|
const result = obj.disconnectAnimatedNodes(__getNativeTagResult, arg1);
|
|
},
|
|
dropAnimatedNode(__nativeTag) {
|
|
obj.dropAnimatedNode(__nativeTag);
|
|
},
|
|
extractAnimatedNodeOffset(self) {
|
|
const result = obj.extractAnimatedNodeOffset(self);
|
|
},
|
|
flattenAnimatedNodeOffset(self) {
|
|
const result = obj.flattenAnimatedNodeOffset(self);
|
|
},
|
|
flushQueue: result ? (() => {
|
|
callback(38)(closure_4, "Native animated module is not available");
|
|
c11 = null;
|
|
if (0 !== closure_10.length) {
|
|
if (!closure_14) {
|
|
let tmpResult = tmp(92);
|
|
closure_14 = tmpResult.addListener("onNativeAnimatedModuleGetValue", (value) => {
|
|
if (table[value.tag]) {
|
|
tmp3(value.value);
|
|
delete tmp[tmp2];
|
|
}
|
|
});
|
|
tmpResult = tmp(92);
|
|
closure_15 = tmpResult.addListener("onNativeAnimatedModuleAnimationFinished", (arg0) => {
|
|
let tmp3 = arg0;
|
|
if (!Array.isArray(arg0)) {
|
|
const items = [arg0];
|
|
tmp3 = items;
|
|
}
|
|
for (const item10014 of tmp3) {
|
|
let animationId = item10014.animationId;
|
|
let tmp5 = animationId;
|
|
let tmp6 = table2;
|
|
let tmp7 = table2[animationId];
|
|
if (tmp7) {
|
|
let tmp9 = tmp7;
|
|
let tmp10 = item10014;
|
|
let tmp8Result = tmp8(tmp4);
|
|
let tmp12 = animationId;
|
|
delete tmp2[tmp];
|
|
}
|
|
continue;
|
|
}
|
|
});
|
|
}
|
|
if (tmp3 != null) {
|
|
const queueAndExecuteBatchedOperations = tmp3.queueAndExecuteBatchedOperations;
|
|
if (queueAndExecuteBatchedOperations != null) {
|
|
const result = queueAndExecuteBatchedOperations(tmp5);
|
|
}
|
|
}
|
|
tmp5.length = 0;
|
|
}
|
|
}) : (() => {
|
|
callback(38)(closure_4, "Native animated module is not available");
|
|
c11 = null;
|
|
if (0 !== arr.length) {
|
|
if (tmp != null) {
|
|
const startOperationBatch = tmp.startOperationBatch;
|
|
if (startOperationBatch != null) {
|
|
startOperationBatch();
|
|
}
|
|
}
|
|
let num2 = 0;
|
|
if (0 < arr.length) {
|
|
do {
|
|
let tmp4 = arr;
|
|
let tmp5 = arr[num2]();
|
|
num2 = num2 + 1;
|
|
} while (num2 < length);
|
|
}
|
|
arr.length = 0;
|
|
if (closure_4 != null) {
|
|
const finishOperationBatch = tmp6.finishOperationBatch;
|
|
if (finishOperationBatch != null) {
|
|
finishOperationBatch();
|
|
}
|
|
}
|
|
tmp6 = closure_4;
|
|
}
|
|
}),
|
|
getValue: result ? ((arg0, arg1) => {
|
|
if (arg1) {
|
|
closure_12[arg0] = arg1;
|
|
}
|
|
const value = obj.getValue(arg0);
|
|
}) : ((arg0, arg1) => {
|
|
const value = obj.getValue(arg0, arg1);
|
|
}),
|
|
removeAnimatedEventFromView(closure_4, closure_0, animatedValueTag) {
|
|
const result = obj.removeAnimatedEventFromView(closure_4, closure_0, animatedValueTag);
|
|
},
|
|
restoreDefaultValues(self) {
|
|
const restoreDefaultValues = obj.restoreDefaultValues;
|
|
if (restoreDefaultValues != null) {
|
|
restoreDefaultValues(self);
|
|
}
|
|
},
|
|
setAnimatedNodeOffset(self, _offset) {
|
|
const result = obj.setAnimatedNodeOffset(self, _offset);
|
|
},
|
|
setAnimatedNodeValue(self, _startingValue) {
|
|
obj.setAnimatedNodeValue(self, _startingValue);
|
|
},
|
|
setWaitingForIdentifier(combined) {
|
|
if (!result1) {
|
|
set.add(combined);
|
|
c8 = true;
|
|
obj = importAllResult1;
|
|
if (tmp6) {
|
|
const _clearImmediate = clearImmediate;
|
|
clearImmediate(closure_11);
|
|
}
|
|
tmp6 = importAllResult1.animatedShouldDebounceQueueFlush() && closure_11;
|
|
}
|
|
},
|
|
startAnimatingNode: result ? ((arg0, arg1, arg2, arg3) => {
|
|
if (arg3) {
|
|
closure_13[arg0] = arg3;
|
|
}
|
|
obj.startAnimatingNode(arg0, arg1, arg2);
|
|
}) : ((arg0, arg1, arg2, arg3) => {
|
|
obj.startAnimatingNode(arg0, arg1, arg2, arg3);
|
|
}),
|
|
startListeningToAnimatedNodeValue(__getNativeTagResult) {
|
|
const result = obj.startListeningToAnimatedNodeValue(__getNativeTagResult);
|
|
},
|
|
stopAnimation(arg0) {
|
|
obj.stopAnimation(arg0);
|
|
},
|
|
stopListeningToAnimatedNodeValue(closure_1) {
|
|
const result = obj.stopListeningToAnimatedNodeValue(closure_1);
|
|
},
|
|
unsetWaitingForIdentifier(combined) {
|
|
if (!result1) {
|
|
set.delete(combined);
|
|
if (0 === set.size) {
|
|
c8 = false;
|
|
obj.disableQueue();
|
|
}
|
|
}
|
|
},
|
|
updateAnimatedNodeConfig(arg0, self) {
|
|
const updateAnimatedNodeConfig = obj.updateAnimatedNodeConfig;
|
|
if (updateAnimatedNodeConfig != null) {
|
|
const result = updateAnimatedNodeConfig(arg0, self);
|
|
}
|
|
}
|
|
};
|
|
let c19 = false;
|
|
const obj1 = {
|
|
API: obj,
|
|
assertNativeAnimatedModule() {
|
|
callback(38)(closure_4, "Native animated module is not available");
|
|
},
|
|
generateNewAnimationId() {
|
|
closure_6 = tmp + 1;
|
|
return +closure_6;
|
|
},
|
|
generateNewNodeTag() {
|
|
closure_5 = tmp + 1;
|
|
return +closure_5;
|
|
}
|
|
};
|
|
Object.defineProperty(obj1, "nativeEventEmitter", {
|
|
get: () => {
|
|
let tmp = closure_3;
|
|
if (!closure_3) {
|
|
const tmp7 = new callback(209)(null);
|
|
closure_3 = tmp7;
|
|
tmp = tmp7;
|
|
}
|
|
return tmp;
|
|
},
|
|
set: undefined
|
|
});
|
|
obj1.shouldSignalBatch = result1;
|
|
obj1.shouldUseNativeDriver = function shouldUseNativeDriver(useNativeDriver) {
|
|
if (null == useNativeDriver.useNativeDriver) {
|
|
const _console = console;
|
|
console.warn("Animated: `useNativeDriver` was not specified. This is a required option and must be explicitly set to `true` or `false`");
|
|
}
|
|
if (true === useNativeDriver.useNativeDriver) {
|
|
if (!closure_4) {
|
|
let flag = false;
|
|
if (!c19) {
|
|
const _console2 = console;
|
|
console.warn("Animated: `useNativeDriver` is not supported because the native animated module is missing. Falling back to JS-based animation. To resolve this, add `RCTAnimation` module to this app, or remove `useNativeDriver`. Make sure to run `bundle exec pod install` first. Read more about autolinking: https://github.com/react-native-community/cli/blob/master/docs/autolinking.md");
|
|
c19 = true;
|
|
flag = false;
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
flag = useNativeDriver.useNativeDriver || false;
|
|
};
|
|
obj1.transformDataType = function transformDataType(str) {
|
|
if (typeof str !== "string") {
|
|
return str;
|
|
} else if (str.endsWith("deg")) {
|
|
const _parseFloat2 = parseFloat;
|
|
const _Math = Math;
|
|
let result = (parseFloat(str) || 0) * Math.PI / 180;
|
|
const tmp5 = parseFloat(str) || 0;
|
|
} else {
|
|
result = str;
|
|
if (str.endsWith("rad")) {
|
|
const _parseFloat = parseFloat;
|
|
result = parseFloat(str) || 0;
|
|
const tmp3 = parseFloat(str) || 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
export default obj1;
|