1034 lines
28 KiB
JavaScript
1034 lines
28 KiB
JavaScript
// Module ID: 354
|
|
// Function ID: 355
|
|
// Name: _combineCallbacks
|
|
// Dependencies: [355, 368, 369, 370, 371, 372, 373, 374, 367, 375, 376, 385, 386, 356, 384, 363, 387]
|
|
|
|
// Module 354 (_combineCallbacks)
|
|
import AnimatedEvent from "AnimatedEvent" /* 384 */;
|
|
|
|
require = arg1;
|
|
const module = arg2;
|
|
let dependencyMap = arg6;
|
|
function _combineCallbacks(arg0, arg1) {
|
|
|
|
}
|
|
function maybeVectorAnim(arg0, obj, decayImpl) {
|
|
if (arg0 instanceof _module(373)) {
|
|
obj = {};
|
|
const merged = Object.assign(obj);
|
|
obj = {};
|
|
const merged1 = Object.assign(obj);
|
|
for (const key10066 in arg1) {
|
|
let tmp34 = key10066;
|
|
({ x, y } = arg1[key10066]);
|
|
let tmp29 = undefined !== x;
|
|
if (tmp29) {
|
|
tmp29 = undefined !== y;
|
|
}
|
|
if (!tmp29) {
|
|
continue;
|
|
} else {
|
|
obj[key10066] = x;
|
|
obj[key10066] = y;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
const items = [decayImpl(arg0.x, obj), decayImpl(arg0.y, obj)];
|
|
if (typeof parallelImpl !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let items1 = items;
|
|
_module = 0;
|
|
dependencyMap = {};
|
|
closure_3 = false !== { stopTogether: false }.stopTogether;
|
|
obj1 = { start: null, stop: null, reset: null, _startNativeLoop: null, _isUsingNativeDriver: null };
|
|
obj1[0] = function start(arg0, arg1) {
|
|
mapped = arg0;
|
|
c1 = arg1;
|
|
if (c1 !== mapped.length) {
|
|
const item = mapped.forEach((start) => {
|
|
if (start) {
|
|
start.start(function cb(finished) {
|
|
closure_2_2[length] = true;
|
|
const sum = c1 + 1;
|
|
c1 = sum;
|
|
if (sum === length.length) {
|
|
c1 = 0;
|
|
if (length) {
|
|
tmp5(finished);
|
|
}
|
|
} else {
|
|
finished = finished.finished;
|
|
let tmp2 = !finished;
|
|
if (!finished) {
|
|
tmp2 = closure_2_3;
|
|
}
|
|
if (tmp2) {
|
|
closure_2_4.stop();
|
|
}
|
|
}
|
|
}, c1);
|
|
} else {
|
|
obj = { finished: true };
|
|
closure_1_2[arg1] = true;
|
|
let sum = c1 + 1;
|
|
c1 = sum;
|
|
if (sum === length.length) {
|
|
c1 = 0;
|
|
if (length) {
|
|
tmp8(obj);
|
|
}
|
|
} else {
|
|
let finished = obj.finished;
|
|
let tmp5 = !finished;
|
|
if (!finished) {
|
|
tmp5 = closure_1_3;
|
|
}
|
|
if (tmp5) {
|
|
closure_1_4.stop();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} else if (arg0) {
|
|
arg0({ finished: true });
|
|
}
|
|
};
|
|
obj1[1] = function stop() {
|
|
const item = mapped.forEach((stop) => {
|
|
if (!table[arg1]) {
|
|
stop.stop();
|
|
}
|
|
table[arg1] = true;
|
|
});
|
|
};
|
|
obj1[2] = function reset() {
|
|
const item = mapped.forEach((reset) => {
|
|
reset.reset();
|
|
closure_2[arg1] = false;
|
|
c1 = 0;
|
|
});
|
|
};
|
|
obj1[3] = function _startNativeLoop() {
|
|
error = new Error("Loops run using the native driver cannot contain Animated.parallel animations");
|
|
throw error;
|
|
};
|
|
obj1[4] = function _isUsingNativeDriver() {
|
|
return false;
|
|
};
|
|
let obj5 = obj1;
|
|
return obj1;
|
|
} else if (arg0 instanceof tmp(374)) {
|
|
obj = {};
|
|
const merged2 = Object.assign(obj);
|
|
const obj2 = {};
|
|
const merged3 = Object.assign(obj);
|
|
const obj3 = {};
|
|
const merged4 = Object.assign(obj);
|
|
const obj4 = {};
|
|
const merged5 = Object.assign(obj);
|
|
for (const key10031 in arg1) {
|
|
let tmp32 = key10031;
|
|
({ r, g, b, a } = arg1[key10031]);
|
|
let tmp17 = undefined !== r;
|
|
if (tmp17) {
|
|
tmp17 = undefined !== g;
|
|
}
|
|
if (tmp17) {
|
|
tmp17 = undefined !== b;
|
|
}
|
|
if (tmp17) {
|
|
tmp17 = undefined !== a;
|
|
}
|
|
if (!tmp17) {
|
|
continue;
|
|
} else {
|
|
obj[key10031] = r;
|
|
obj2[key10031] = g;
|
|
obj3[key10031] = b;
|
|
obj4[key10031] = a;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
const tmp18 = decayImpl(arg0.r, obj);
|
|
const tmp19 = decayImpl(arg0.g, obj2);
|
|
items1 = [tmp18, tmp19, decayImpl(arg0.b, obj3), decayImpl(arg0.a, obj4)];
|
|
if (typeof parallelImpl !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
_module = 0;
|
|
dependencyMap = {};
|
|
closure_3 = false !== { stopTogether: false }.stopTogether;
|
|
obj5 = { start: null, stop: null, reset: null, _startNativeLoop: null, _isUsingNativeDriver: null };
|
|
obj5[0] = function start(arg0, arg1) {
|
|
mapped = arg0;
|
|
c1 = arg1;
|
|
if (c1 !== mapped.length) {
|
|
const item = mapped.forEach((start) => {
|
|
if (start) {
|
|
start.start(function cb(finished) {
|
|
closure_2_2[length] = true;
|
|
const sum = c1 + 1;
|
|
c1 = sum;
|
|
if (sum === length.length) {
|
|
c1 = 0;
|
|
if (length) {
|
|
tmp5(finished);
|
|
}
|
|
} else {
|
|
finished = finished.finished;
|
|
let tmp2 = !finished;
|
|
if (!finished) {
|
|
tmp2 = closure_2_3;
|
|
}
|
|
if (tmp2) {
|
|
closure_2_4.stop();
|
|
}
|
|
}
|
|
}, c1);
|
|
} else {
|
|
obj = { finished: true };
|
|
closure_1_2[arg1] = true;
|
|
let sum = c1 + 1;
|
|
c1 = sum;
|
|
if (sum === length.length) {
|
|
c1 = 0;
|
|
if (length) {
|
|
tmp8(obj);
|
|
}
|
|
} else {
|
|
let finished = obj.finished;
|
|
let tmp5 = !finished;
|
|
if (!finished) {
|
|
tmp5 = closure_1_3;
|
|
}
|
|
if (tmp5) {
|
|
closure_1_4.stop();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} else if (arg0) {
|
|
arg0({ finished: true });
|
|
}
|
|
};
|
|
obj5[1] = function stop() {
|
|
const item = mapped.forEach((stop) => {
|
|
if (!table[arg1]) {
|
|
stop.stop();
|
|
}
|
|
table[arg1] = true;
|
|
});
|
|
};
|
|
obj5[2] = function reset() {
|
|
const item = mapped.forEach((reset) => {
|
|
reset.reset();
|
|
closure_2[arg1] = false;
|
|
c1 = 0;
|
|
});
|
|
};
|
|
obj5[3] = function _startNativeLoop() {
|
|
error = new Error("Loops run using the native driver cannot contain Animated.parallel animations");
|
|
throw error;
|
|
};
|
|
obj5[4] = function _isUsingNativeDriver() {
|
|
return false;
|
|
};
|
|
return obj5;
|
|
} else {
|
|
return null;
|
|
}
|
|
tmp = _module;
|
|
}
|
|
function springImpl(arg0, arg1) {
|
|
closure_0 = arg0;
|
|
closure_1 = arg1;
|
|
function start(stopTracking, onComplete) {
|
|
if (typeof closure_3 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let fn = arg2;
|
|
closure_0 = arg2;
|
|
const lib = onComplete;
|
|
if (arg2) {
|
|
if (onComplete.onComplete) {
|
|
fn = () => {
|
|
const items = [...arguments];
|
|
if (onComplete.onComplete) {
|
|
onComplete = tmp.onComplete;
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items1, tmp);
|
|
}
|
|
if (closure_0) {
|
|
const items2 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items2, undefined);
|
|
}
|
|
};
|
|
}
|
|
stopTracking.stopTracking();
|
|
if (onComplete.toValue instanceof lib(start[8])) {
|
|
let tmp3Result = tmp3(tmp4[9]);
|
|
tmp3Result = new tmp3Result(stopTracking, onComplete.toValue, tmp3(tmp4[10]), onComplete, fn);
|
|
stopTracking.track(tmp3Result);
|
|
} else {
|
|
const tmp8 = new tmp3(tmp4[10])(onComplete);
|
|
stopTracking.animate(tmp8, fn);
|
|
}
|
|
}
|
|
if (!fn) {
|
|
fn = onComplete.onComplete;
|
|
}
|
|
}
|
|
let tmp = maybeVectorAnim(arg0, arg1, springImpl);
|
|
if (!tmp) {
|
|
let obj = { start: null, stop: null, reset: null, _startNativeLoop: null, _isUsingNativeDriver: null };
|
|
obj[0] = function start(arg0) {
|
|
start(closure_0, closure_1, arg0);
|
|
};
|
|
obj[1] = function stop() {
|
|
closure_0.stopAnimation();
|
|
};
|
|
obj[2] = function reset() {
|
|
closure_0.resetAnimation();
|
|
};
|
|
obj[3] = function _startNativeLoop(iterations) {
|
|
const obj = {};
|
|
const merged = Object.assign(closure_1);
|
|
obj.iterations = iterations;
|
|
start(closure_0, obj);
|
|
};
|
|
obj[4] = function _isUsingNativeDriver() {
|
|
return lib.useNativeDriver || false;
|
|
};
|
|
tmp = obj;
|
|
}
|
|
return tmp;
|
|
}
|
|
function timingImpl(arg0, arg1) {
|
|
closure_0 = arg0;
|
|
closure_1 = arg1;
|
|
function start(stopTracking, onComplete) {
|
|
if (typeof closure_3 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let fn = arg2;
|
|
closure_0 = arg2;
|
|
const v0 = onComplete;
|
|
if (arg2) {
|
|
if (onComplete.onComplete) {
|
|
fn = () => {
|
|
const items = [...arguments];
|
|
if (onComplete.onComplete) {
|
|
onComplete = tmp.onComplete;
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items1, tmp);
|
|
}
|
|
if (closure_0) {
|
|
const items2 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items2, undefined);
|
|
}
|
|
};
|
|
}
|
|
stopTracking.stopTracking();
|
|
if (onComplete.toValue instanceof v0(start[8])) {
|
|
let tmp3Result = tmp3(tmp4[9]);
|
|
tmp3Result = new tmp3Result(stopTracking, onComplete.toValue, tmp3(tmp4[11]), onComplete, fn);
|
|
stopTracking.track(tmp3Result);
|
|
} else {
|
|
const tmp8 = new tmp3(tmp4[11])(onComplete);
|
|
stopTracking.animate(tmp8, fn);
|
|
}
|
|
}
|
|
if (!fn) {
|
|
fn = onComplete.onComplete;
|
|
}
|
|
}
|
|
let tmp = maybeVectorAnim(arg0, arg1, timingImpl);
|
|
if (!tmp) {
|
|
const obj = { start: null, stop: null, reset: null, _startNativeLoop: null, _isUsingNativeDriver: null };
|
|
obj[0] = function start(arg0, isLooping) {
|
|
obj = {};
|
|
const merged = Object.assign(c1);
|
|
obj.isLooping = isLooping;
|
|
start(items, obj, arg0);
|
|
};
|
|
obj[1] = function stop() {
|
|
items.stopAnimation();
|
|
};
|
|
obj[2] = function reset() {
|
|
items.resetAnimation();
|
|
};
|
|
obj[3] = function _startNativeLoop(iterations) {
|
|
obj = {};
|
|
const merged = Object.assign(c1);
|
|
obj.iterations = iterations;
|
|
start(items, obj);
|
|
};
|
|
obj[4] = function _isUsingNativeDriver() {
|
|
return v0.useNativeDriver || false;
|
|
};
|
|
tmp = obj;
|
|
}
|
|
return tmp;
|
|
}
|
|
function decayImpl(arg0, arg1) {
|
|
closure_0 = arg0;
|
|
closure_1 = arg1;
|
|
let tmp = maybeVectorAnim(arg0, arg1, decayImpl);
|
|
if (!tmp) {
|
|
let obj = { start: null, stop: null, reset: null, _startNativeLoop: null, _isUsingNativeDriver: null };
|
|
obj[0] = function start(arg0) {
|
|
if (typeof closure_1_3 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let fn = arg0;
|
|
closure_0 = arg0;
|
|
const lib = tmp;
|
|
if (arg0) {
|
|
if (tmp.onComplete) {
|
|
fn = () => {
|
|
const items = [...arguments];
|
|
if (onComplete.onComplete) {
|
|
onComplete = tmp.onComplete;
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items1, tmp);
|
|
}
|
|
if (closure_0) {
|
|
const items2 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items2, undefined);
|
|
}
|
|
};
|
|
}
|
|
obj.stopTracking();
|
|
const tmp8 = new lib(closure_1_2[12])(tmp);
|
|
obj.animate(tmp8, fn);
|
|
}
|
|
if (!fn) {
|
|
fn = tmp.onComplete;
|
|
}
|
|
};
|
|
obj[1] = function stop() {
|
|
closure_0.stopAnimation();
|
|
};
|
|
obj[2] = function reset() {
|
|
closure_0.resetAnimation();
|
|
};
|
|
obj[3] = function _startNativeLoop(iterations) {
|
|
const obj = {};
|
|
const merged = Object.assign(obj);
|
|
obj.iterations = iterations;
|
|
if (typeof closure_1_3 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
closure_0.stopTracking();
|
|
closure_0.animate(new lib(closure_1_2[12])(obj), obj.onComplete);
|
|
};
|
|
obj[4] = function _isUsingNativeDriver() {
|
|
return lib.useNativeDriver || false;
|
|
};
|
|
tmp = obj;
|
|
}
|
|
return tmp;
|
|
}
|
|
function sequenceImpl(arg0) {
|
|
closure_0 = arg0;
|
|
c1 = 0;
|
|
return {
|
|
start(arg0, arg1) {
|
|
items = arg0;
|
|
c1 = arg1;
|
|
function onComplete(finished) {
|
|
if (finished.finished) {
|
|
const sum = c1 + 1;
|
|
c1 = sum;
|
|
if (sum === length.length) {
|
|
c1 = 0;
|
|
if (length) {
|
|
tmp10(finished);
|
|
}
|
|
} else {
|
|
tmp5[c1].start(onComplete, c1);
|
|
obj = tmp5[c1];
|
|
}
|
|
} else if (length) {
|
|
tmp(finished);
|
|
}
|
|
}
|
|
if (0 === items.length) {
|
|
if (arg0) {
|
|
arg0({ finished: true });
|
|
}
|
|
} else {
|
|
tmp[c1].start(onComplete, arg1);
|
|
obj = tmp[c1];
|
|
}
|
|
},
|
|
stop() {
|
|
if (c1 < items.length) {
|
|
tmp[c1].stop();
|
|
obj = tmp[c1];
|
|
}
|
|
},
|
|
reset() {
|
|
const item = items.forEach((reset) => {
|
|
if (arg1 <= c1) {
|
|
reset.reset();
|
|
}
|
|
});
|
|
c1 = 0;
|
|
},
|
|
_startNativeLoop() {
|
|
error = new Error("Loops run using the native driver cannot contain Animated.sequence animations");
|
|
throw error;
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return false;
|
|
}
|
|
};
|
|
}
|
|
function parallelImpl(arg0, stopTogether) {
|
|
closure_0 = arg0;
|
|
c1 = 0;
|
|
closure_2 = {};
|
|
let tmp = stopTogether;
|
|
if (stopTogether) {
|
|
tmp = false === stopTogether.stopTogether;
|
|
}
|
|
closure_3 = !tmp;
|
|
const obj = {
|
|
start(arg0, arg1) {
|
|
mapped = arg0;
|
|
c1 = arg1;
|
|
if (c1 !== mapped.length) {
|
|
const item = mapped.forEach((start) => {
|
|
if (start) {
|
|
start.start(function cb(finished) {
|
|
closure_2_2[length] = true;
|
|
const sum = c1 + 1;
|
|
c1 = sum;
|
|
if (sum === length.length) {
|
|
c1 = 0;
|
|
if (length) {
|
|
tmp5(finished);
|
|
}
|
|
} else {
|
|
finished = finished.finished;
|
|
let tmp2 = !finished;
|
|
if (!finished) {
|
|
tmp2 = closure_2_3;
|
|
}
|
|
if (tmp2) {
|
|
closure_2_4.stop();
|
|
}
|
|
}
|
|
}, c1);
|
|
} else {
|
|
obj = { finished: true };
|
|
closure_1_2[arg1] = true;
|
|
let sum = c1 + 1;
|
|
c1 = sum;
|
|
if (sum === length.length) {
|
|
c1 = 0;
|
|
if (length) {
|
|
tmp8(obj);
|
|
}
|
|
} else {
|
|
let finished = obj.finished;
|
|
let tmp5 = !finished;
|
|
if (!finished) {
|
|
tmp5 = closure_1_3;
|
|
}
|
|
if (tmp5) {
|
|
closure_1_4.stop();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} else if (arg0) {
|
|
arg0({ finished: true });
|
|
}
|
|
},
|
|
stop() {
|
|
const item = mapped.forEach((stop) => {
|
|
if (!table[arg1]) {
|
|
stop.stop();
|
|
}
|
|
table[arg1] = true;
|
|
});
|
|
},
|
|
reset() {
|
|
const item = mapped.forEach((reset) => {
|
|
reset.reset();
|
|
closure_2[arg1] = false;
|
|
c1 = 0;
|
|
});
|
|
},
|
|
_startNativeLoop() {
|
|
error = new Error("Loops run using the native driver cannot contain Animated.parallel animations");
|
|
throw error;
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return false;
|
|
}
|
|
};
|
|
return obj;
|
|
}
|
|
function delayImpl(delay) {
|
|
const tmp2 = new obj(start[13])(0);
|
|
obj = { toValue: 0, delay, duration: 0, useNativeDriver: false };
|
|
if (typeof timingImpl !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
closure_0 = tmp2;
|
|
start = function start(stopTracking, onComplete) {
|
|
if (typeof closure_3 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let fn = arg2;
|
|
closure_0 = arg2;
|
|
const v0 = onComplete;
|
|
if (arg2) {
|
|
if (onComplete.onComplete) {
|
|
fn = () => {
|
|
const items = [...arguments];
|
|
if (onComplete.onComplete) {
|
|
onComplete = tmp.onComplete;
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items1, tmp);
|
|
}
|
|
if (closure_0) {
|
|
const items2 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items2, undefined);
|
|
}
|
|
};
|
|
}
|
|
stopTracking.stopTracking();
|
|
if (onComplete.toValue instanceof v0(start[8])) {
|
|
let tmp3Result = tmp3(tmp4[9]);
|
|
tmp3Result = new tmp3Result(stopTracking, onComplete.toValue, tmp3(tmp4[11]), onComplete, fn);
|
|
stopTracking.track(tmp3Result);
|
|
} else {
|
|
const tmp8 = new tmp3(tmp4[11])(onComplete);
|
|
stopTracking.animate(tmp8, fn);
|
|
}
|
|
}
|
|
if (!fn) {
|
|
fn = onComplete.onComplete;
|
|
}
|
|
};
|
|
let tmp3 = maybeVectorAnim(tmp2, obj, timingImpl);
|
|
if (!tmp3) {
|
|
obj = { start: null, stop: null, reset: null, _startNativeLoop: null, _isUsingNativeDriver: null };
|
|
obj[0] = function start(arg0, isLooping) {
|
|
obj = {};
|
|
const merged = Object.assign(c1);
|
|
obj.isLooping = isLooping;
|
|
start(items, obj, arg0);
|
|
};
|
|
obj[1] = function stop() {
|
|
items.stopAnimation();
|
|
};
|
|
obj[2] = function reset() {
|
|
items.resetAnimation();
|
|
};
|
|
obj[3] = function _startNativeLoop(iterations) {
|
|
obj = {};
|
|
const merged = Object.assign(c1);
|
|
obj.iterations = iterations;
|
|
start(items, obj);
|
|
};
|
|
obj[4] = function _isUsingNativeDriver() {
|
|
return v0.useNativeDriver || false;
|
|
};
|
|
tmp3 = obj;
|
|
}
|
|
return tmp3;
|
|
}
|
|
arg5.default = {
|
|
Value: require("_isNativeReflectConstruct"),
|
|
ValueXY: require("_isNativeReflectConstruct"),
|
|
Color: require("_isNativeReflectConstruct"),
|
|
Interpolation: require("_isNativeReflectConstruct"),
|
|
Node: require("_assertNativeAnimatedModule"),
|
|
decay: decayImpl,
|
|
timing: timingImpl,
|
|
spring: springImpl,
|
|
add(arg0, arg1) {
|
|
return new module(355)(arg0, arg1);
|
|
},
|
|
subtract(arg0, arg1) {
|
|
return new module(368)(arg0, arg1);
|
|
},
|
|
divide(arg0) {
|
|
return new module(369)(arg0, arg1);
|
|
},
|
|
multiply(arg0, arg1) {
|
|
return new module(370)(arg0, arg1);
|
|
},
|
|
modulo(arg0, arg1) {
|
|
return new module(371)(arg0, arg1);
|
|
},
|
|
diffClamp(interpolateResult, arg1, arg2) {
|
|
return new module(372)(interpolateResult, arg1, arg2);
|
|
},
|
|
delay: delayImpl,
|
|
sequence: sequenceImpl,
|
|
parallel: parallelImpl,
|
|
stagger(arg0, arr) {
|
|
let mapped = arg0;
|
|
mapped = arr.map((arg0, arg1) => {
|
|
const result = items * arg1;
|
|
if (typeof closure_1_10 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
const tmp4 = new v0(table[13])(0);
|
|
obj = { toValue: 0, delay: result, duration: 0, useNativeDriver: false };
|
|
if (typeof closure_1_6 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
items = tmp4;
|
|
v0 = obj;
|
|
function start(stopTracking, onComplete) {
|
|
if (typeof closure_3 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let fn = arg2;
|
|
closure_0 = arg2;
|
|
const v0 = onComplete;
|
|
if (arg2) {
|
|
if (onComplete.onComplete) {
|
|
fn = () => {
|
|
const items = [...arguments];
|
|
if (onComplete.onComplete) {
|
|
onComplete = tmp.onComplete;
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items1, tmp);
|
|
}
|
|
if (closure_0) {
|
|
const items2 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items2, undefined);
|
|
}
|
|
};
|
|
}
|
|
stopTracking.stopTracking();
|
|
if (onComplete.toValue instanceof v0(start[8])) {
|
|
let tmp3Result = tmp3(tmp4[9]);
|
|
tmp3Result = new tmp3Result(stopTracking, onComplete.toValue, tmp3(tmp4[11]), onComplete, fn);
|
|
stopTracking.track(tmp3Result);
|
|
} else {
|
|
const tmp8 = new tmp3(tmp4[11])(onComplete);
|
|
stopTracking.animate(tmp8, fn);
|
|
}
|
|
}
|
|
if (!fn) {
|
|
fn = onComplete.onComplete;
|
|
}
|
|
}
|
|
let tmp5 = obj(tmp4, obj, closure_1_6);
|
|
if (!tmp5) {
|
|
obj = { start: null, stop: null, reset: null, _startNativeLoop: null, _isUsingNativeDriver: null };
|
|
obj[0] = function start(arg0, isLooping) {
|
|
obj = {};
|
|
const merged = Object.assign(c1);
|
|
obj.isLooping = isLooping;
|
|
start(items, obj, arg0);
|
|
};
|
|
obj[1] = function stop() {
|
|
items.stopAnimation();
|
|
};
|
|
obj[2] = function reset() {
|
|
items.resetAnimation();
|
|
};
|
|
obj[3] = function _startNativeLoop(iterations) {
|
|
obj = {};
|
|
const merged = Object.assign(c1);
|
|
obj.iterations = iterations;
|
|
start(items, obj);
|
|
};
|
|
obj[4] = function _isUsingNativeDriver() {
|
|
return v0.useNativeDriver || false;
|
|
};
|
|
tmp5 = obj;
|
|
}
|
|
items = [tmp5, arg0];
|
|
if (typeof closure_1_8 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
v0 = 0;
|
|
obj = {
|
|
start(arg0, arg1) {
|
|
items = arg0;
|
|
c1 = arg1;
|
|
function onComplete(finished) {
|
|
if (finished.finished) {
|
|
const sum = c1 + 1;
|
|
c1 = sum;
|
|
if (sum === length.length) {
|
|
c1 = 0;
|
|
if (length) {
|
|
tmp10(finished);
|
|
}
|
|
} else {
|
|
tmp5[c1].start(onComplete, c1);
|
|
obj = tmp5[c1];
|
|
}
|
|
} else if (length) {
|
|
tmp(finished);
|
|
}
|
|
}
|
|
if (0 === items.length) {
|
|
if (arg0) {
|
|
arg0({ finished: true });
|
|
}
|
|
} else {
|
|
tmp[c1].start(onComplete, arg1);
|
|
obj = tmp[c1];
|
|
}
|
|
},
|
|
stop() {
|
|
if (c1 < items.length) {
|
|
tmp[c1].stop();
|
|
obj = tmp[c1];
|
|
}
|
|
},
|
|
reset() {
|
|
const item = items.forEach((reset) => {
|
|
if (arg1 <= c1) {
|
|
reset.reset();
|
|
}
|
|
});
|
|
c1 = 0;
|
|
},
|
|
_startNativeLoop() {
|
|
error = new Error("Loops run using the native driver cannot contain Animated.sequence animations");
|
|
throw error;
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return false;
|
|
}
|
|
};
|
|
return obj;
|
|
});
|
|
if (typeof parallelImpl !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
c1 = 0;
|
|
closure_2 = {};
|
|
c3 = true;
|
|
let obj = {
|
|
start(arg0, arg1) {
|
|
mapped = arg0;
|
|
c1 = arg1;
|
|
if (c1 !== mapped.length) {
|
|
const item = mapped.forEach((start) => {
|
|
if (start) {
|
|
start.start(function cb(finished) {
|
|
closure_2_2[length] = true;
|
|
const sum = c1 + 1;
|
|
c1 = sum;
|
|
if (sum === length.length) {
|
|
c1 = 0;
|
|
if (length) {
|
|
tmp5(finished);
|
|
}
|
|
} else {
|
|
finished = finished.finished;
|
|
let tmp2 = !finished;
|
|
if (!finished) {
|
|
tmp2 = closure_2_3;
|
|
}
|
|
if (tmp2) {
|
|
closure_2_4.stop();
|
|
}
|
|
}
|
|
}, c1);
|
|
} else {
|
|
obj = { finished: true };
|
|
closure_1_2[arg1] = true;
|
|
let sum = c1 + 1;
|
|
c1 = sum;
|
|
if (sum === length.length) {
|
|
c1 = 0;
|
|
if (length) {
|
|
tmp8(obj);
|
|
}
|
|
} else {
|
|
let finished = obj.finished;
|
|
let tmp5 = !finished;
|
|
if (!finished) {
|
|
tmp5 = closure_1_3;
|
|
}
|
|
if (tmp5) {
|
|
closure_1_4.stop();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} else if (arg0) {
|
|
arg0({ finished: true });
|
|
}
|
|
},
|
|
stop() {
|
|
const item = mapped.forEach((stop) => {
|
|
if (!table[arg1]) {
|
|
stop.stop();
|
|
}
|
|
table[arg1] = true;
|
|
});
|
|
},
|
|
reset() {
|
|
const item = mapped.forEach((reset) => {
|
|
reset.reset();
|
|
closure_2[arg1] = false;
|
|
c1 = 0;
|
|
});
|
|
},
|
|
_startNativeLoop() {
|
|
error = new Error("Loops run using the native driver cannot contain Animated.parallel animations");
|
|
throw error;
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return false;
|
|
}
|
|
};
|
|
return obj;
|
|
},
|
|
loop(arg0) {
|
|
closure_0 = arg0;
|
|
let obj = arg1;
|
|
if (arg1 === undefined) {
|
|
obj = {};
|
|
}
|
|
let num = obj.iterations;
|
|
if (num === undefined) {
|
|
num = -1;
|
|
}
|
|
let flag = obj.resetBeforeIteration;
|
|
if (flag === undefined) {
|
|
flag = true;
|
|
}
|
|
c3 = false;
|
|
c4 = 0;
|
|
obj = {
|
|
start(arg0) {
|
|
closure_0 = arg0;
|
|
function restart() {
|
|
let obj = arg0;
|
|
if (arg0 === undefined) {
|
|
obj = { finished: true };
|
|
}
|
|
if (!closure_1_3) {
|
|
if (closure_4 !== restart) {
|
|
if (false !== obj.finished) {
|
|
closure_4 = closure_4 + 1;
|
|
if (closure_1_2) {
|
|
navigation.reset();
|
|
}
|
|
navigation.start(restart, -1 === tmp2);
|
|
}
|
|
}
|
|
}
|
|
if (navigation) {
|
|
navigation(obj);
|
|
}
|
|
}
|
|
let obj = closure_0;
|
|
if (closure_0) {
|
|
if (0 !== restart) {
|
|
if (obj._isUsingNativeDriver()) {
|
|
obj._startNativeLoop(tmp);
|
|
} else {
|
|
obj = { finished: true };
|
|
if (!c3) {
|
|
if (closure_4 !== tmp) {
|
|
if (false !== obj.finished) {
|
|
closure_4 = closure_4 + 1;
|
|
if (flag) {
|
|
obj.reset();
|
|
}
|
|
obj.start(restart, -1 === tmp);
|
|
}
|
|
}
|
|
}
|
|
if (arg0) {
|
|
arg0(obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (arg0) {
|
|
arg0({ finished: true });
|
|
}
|
|
},
|
|
stop() {
|
|
c3 = true;
|
|
navigation.stop();
|
|
},
|
|
reset() {
|
|
c4 = 0;
|
|
c3 = false;
|
|
navigation.reset();
|
|
},
|
|
_startNativeLoop() {
|
|
error = new Error("Loops run using the native driver cannot contain Animated.loop animations");
|
|
throw error;
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return navigation._isUsingNativeDriver();
|
|
}
|
|
};
|
|
return obj;
|
|
},
|
|
event(items, useNativeDriver) {
|
|
const animatedEvent = new AnimatedEvent.AnimatedEvent(items, useNativeDriver);
|
|
let __getHandlerResult = animatedEvent;
|
|
if (!animatedEvent.__isNative) {
|
|
__getHandlerResult = animatedEvent.__getHandler();
|
|
}
|
|
return __getHandlerResult;
|
|
},
|
|
createAnimatedComponent: require("createAnimatedComponent"),
|
|
attachNativeEvent: require("AnimatedEvent").attachNativeEventImpl,
|
|
forkEvent: function forkEventImpl(__addListener, listener) {
|
|
const _require = __addListener;
|
|
closure_1 = listener;
|
|
if (!__addListener) {
|
|
return listener;
|
|
} else if (__addListener instanceof _require(384).AnimatedEvent) {
|
|
__addListener.__addListener(listener);
|
|
let fn = __addListener;
|
|
} else {
|
|
fn = () => {
|
|
const items = [...arguments];
|
|
if (typeof closure_0 === "function") {
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(items, 0);
|
|
HermesBuiltin.apply(items1, undefined);
|
|
}
|
|
listener(...items);
|
|
};
|
|
}
|
|
},
|
|
unforkEvent: function unforkEventImpl(__removeListener) {
|
|
let tmp = __removeListener;
|
|
if (__removeListener) {
|
|
tmp = __removeListener instanceof AnimatedEvent.AnimatedEvent;
|
|
}
|
|
if (tmp) {
|
|
__removeListener.__removeListener(arg1);
|
|
}
|
|
},
|
|
Event: require("AnimatedEvent").AnimatedEvent
|
|
};
|