507 lines
13 KiB
JavaScript
507 lines
13 KiB
JavaScript
// Module ID: 345
|
|
// Function ID: 5062
|
|
// Name: _combineCallbacks
|
|
// Dependencies: []
|
|
|
|
// Module 345 (_combineCallbacks)
|
|
function _combineCallbacks(arg0, onComplete) {
|
|
let fn = arg0;
|
|
onComplete = arg0;
|
|
const arg2 = onComplete;
|
|
if (arg0) {
|
|
if (onComplete.onComplete) {
|
|
fn = () => {
|
|
if (arg1.onComplete) {
|
|
const onComplete = arg1.onComplete;
|
|
onComplete(...arguments);
|
|
}
|
|
if (arg0) {
|
|
arg0(...arguments);
|
|
}
|
|
};
|
|
}
|
|
return fn;
|
|
}
|
|
if (!fn) {
|
|
fn = onComplete.onComplete;
|
|
}
|
|
}
|
|
function maybeVectorAnim(arg0, obj, decayImpl) {
|
|
let a;
|
|
let b;
|
|
let g;
|
|
let r;
|
|
let x;
|
|
let y;
|
|
if (arg0 instanceof decayImpl(arg6[6])) {
|
|
const _Object5 = Object;
|
|
const merged = Object.assign({}, obj);
|
|
const _Object6 = Object;
|
|
const merged1 = Object.assign({}, obj);
|
|
for (const key10062 in arg1) {
|
|
let tmp23 = key10062;
|
|
({ x, y } = arg1[key10062]);
|
|
let tmp19 = undefined !== x;
|
|
if (tmp19) {
|
|
tmp19 = undefined !== y;
|
|
}
|
|
if (!tmp19) {
|
|
continue;
|
|
} else {
|
|
merged[key10062] = x;
|
|
merged1[key10062] = y;
|
|
// continue
|
|
}
|
|
continue;
|
|
}
|
|
const items = [decayImpl(arg0.x, merged), decayImpl(arg0.y, merged1)];
|
|
obj = { stopTogether: false };
|
|
return parallelImpl(items, obj);
|
|
} else if (arg0 instanceof decayImpl(arg6[7])) {
|
|
const _Object = Object;
|
|
const merged2 = Object.assign({}, obj);
|
|
const _Object2 = Object;
|
|
const merged3 = Object.assign({}, obj);
|
|
const _Object3 = Object;
|
|
const merged4 = Object.assign({}, obj);
|
|
const _Object4 = Object;
|
|
const merged5 = Object.assign({}, obj);
|
|
for (const key10036 in arg1) {
|
|
let tmp22 = key10036;
|
|
({ r, g, b, a } = arg1[key10036]);
|
|
let tmp10 = undefined !== r;
|
|
if (tmp10) {
|
|
tmp10 = undefined !== g;
|
|
}
|
|
if (tmp10) {
|
|
tmp10 = undefined !== b;
|
|
}
|
|
if (tmp10) {
|
|
tmp10 = undefined !== a;
|
|
}
|
|
if (!tmp10) {
|
|
continue;
|
|
} else {
|
|
merged2[key10036] = r;
|
|
merged3[key10036] = g;
|
|
merged4[key10036] = b;
|
|
merged5[key10036] = a;
|
|
// continue
|
|
}
|
|
continue;
|
|
}
|
|
const tmp11 = decayImpl(arg0.r, merged2);
|
|
const tmp12 = decayImpl(arg0.g, merged3);
|
|
const items1 = [tmp11, tmp12, decayImpl(arg0.b, merged4), decayImpl(arg0.a, merged5)];
|
|
obj = { stopTogether: false };
|
|
return parallelImpl(items1, obj);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
function springImpl(arg0, arg1) {
|
|
arg1 = arg0;
|
|
const arg2 = arg1;
|
|
function start(stopTracking, toValue) {
|
|
const tmp = callback(arg2, toValue);
|
|
stopTracking.stopTracking();
|
|
if (toValue.toValue instanceof toValue(start[8])) {
|
|
let tmp14 = toValue(start[9]);
|
|
const prototype2 = tmp14.prototype;
|
|
tmp14 = new tmp14(stopTracking, toValue.toValue, toValue(start[10]), toValue, tmp);
|
|
stopTracking.track(tmp14);
|
|
} else {
|
|
let tmp5 = toValue(start[10]);
|
|
const prototype = tmp5.prototype;
|
|
tmp5 = new tmp5(toValue);
|
|
stopTracking.animate(tmp5, tmp);
|
|
}
|
|
}
|
|
let tmp = maybeVectorAnim(arg0, arg1, springImpl);
|
|
if (!tmp) {
|
|
const obj = {
|
|
start(arg0) {
|
|
start(arg0, arg1, arg0);
|
|
},
|
|
stop() {
|
|
arg0.stopAnimation();
|
|
},
|
|
reset() {
|
|
arg0.resetAnimation();
|
|
},
|
|
_startNativeLoop(iterations) {
|
|
start(iterations, Object.assign({}, arg1, { iterations }));
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return arg1.useNativeDriver || false;
|
|
}
|
|
};
|
|
tmp = obj;
|
|
}
|
|
return tmp;
|
|
}
|
|
function timingImpl(arg0, arg1) {
|
|
arg1 = arg0;
|
|
const arg2 = arg1;
|
|
function start(stopTracking, toValue) {
|
|
const tmp = callback(arg2, toValue);
|
|
stopTracking.stopTracking();
|
|
if (toValue.toValue instanceof toValue(start[8])) {
|
|
let tmp14 = toValue(start[9]);
|
|
const prototype2 = tmp14.prototype;
|
|
tmp14 = new tmp14(stopTracking, toValue.toValue, toValue(start[11]), toValue, tmp);
|
|
stopTracking.track(tmp14);
|
|
} else {
|
|
let tmp5 = toValue(start[11]);
|
|
const prototype = tmp5.prototype;
|
|
tmp5 = new tmp5(toValue);
|
|
stopTracking.animate(tmp5, tmp);
|
|
}
|
|
}
|
|
let tmp = maybeVectorAnim(arg0, arg1, timingImpl);
|
|
if (!tmp) {
|
|
const obj = {
|
|
start(arg0, isLooping) {
|
|
start(arg0, Object.assign({}, isLooping, { isLooping }), arg0);
|
|
},
|
|
stop() {
|
|
arg0.stopAnimation();
|
|
},
|
|
reset() {
|
|
arg0.resetAnimation();
|
|
},
|
|
_startNativeLoop(iterations) {
|
|
start(iterations, Object.assign({}, arg1, { iterations }));
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return arg1.useNativeDriver || false;
|
|
}
|
|
};
|
|
tmp = obj;
|
|
}
|
|
return tmp;
|
|
}
|
|
function decayImpl(arg0, arg1) {
|
|
arg1 = arg0;
|
|
const arg2 = arg1;
|
|
function start(stopTracking) {
|
|
stopTracking.stopTracking();
|
|
let tmp3 = arg1(start[12]);
|
|
tmp3 = new tmp3(arg1);
|
|
stopTracking.animate(tmp3, callback(arg2, arg1));
|
|
}
|
|
let tmp = maybeVectorAnim(arg0, arg1, decayImpl);
|
|
if (!tmp) {
|
|
const obj = {
|
|
start(arg0) {
|
|
start(arg0, arg1, arg0);
|
|
},
|
|
stop() {
|
|
arg0.stopAnimation();
|
|
},
|
|
reset() {
|
|
arg0.resetAnimation();
|
|
},
|
|
_startNativeLoop(iterations) {
|
|
start(iterations, Object.assign({}, arg1, { iterations }));
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return arg1.useNativeDriver || false;
|
|
}
|
|
};
|
|
tmp = obj;
|
|
}
|
|
return tmp;
|
|
}
|
|
function sequenceImpl(arg0) {
|
|
const arg1 = arg0;
|
|
let closure_1 = 0;
|
|
return {
|
|
start(arg0, arg1) {
|
|
let closure_1 = arg1;
|
|
function onComplete(finished) {
|
|
if (finished.finished) {
|
|
const sum = closure_1 + 1;
|
|
closure_1 = sum;
|
|
if (sum === finished.length) {
|
|
closure_1 = 0;
|
|
if (finished) {
|
|
finished(finished);
|
|
}
|
|
} else {
|
|
finished[closure_1].start(onComplete, closure_1);
|
|
const obj = finished[closure_1];
|
|
}
|
|
} else if (finished) {
|
|
finished(finished);
|
|
}
|
|
}
|
|
if (0 === arg0.length) {
|
|
if (arg0) {
|
|
let obj = { finished: true };
|
|
arg0(obj);
|
|
}
|
|
} else {
|
|
obj = arg0[closure_1];
|
|
obj.start(onComplete, arg1);
|
|
}
|
|
},
|
|
stop() {
|
|
if (closure_1 < arg0.length) {
|
|
arg0[closure_1].stop();
|
|
const obj = arg0[closure_1];
|
|
}
|
|
},
|
|
reset() {
|
|
const item = arg0.forEach((reset) => {
|
|
if (arg1 <= closure_1) {
|
|
reset.reset();
|
|
}
|
|
});
|
|
let closure_1 = 0;
|
|
},
|
|
_startNativeLoop() {
|
|
const error = new Error("Loops run using the native driver cannot contain Animated.sequence animations");
|
|
throw error;
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return false;
|
|
}
|
|
};
|
|
}
|
|
function parallelImpl(items, stopTogether) {
|
|
stopTogether = items;
|
|
let closure_1 = 0;
|
|
let closure_2 = {};
|
|
let tmp = stopTogether;
|
|
if (stopTogether) {
|
|
tmp = false === stopTogether.stopTogether;
|
|
}
|
|
let closure_3 = !tmp;
|
|
const obj = {
|
|
start(arg0, arg1) {
|
|
let closure_1 = arg1;
|
|
if (closure_1 !== arg0.length) {
|
|
const item = arg0.forEach((start) => {
|
|
start = arg1;
|
|
function cb(finished) {
|
|
closure_2[arg1] = true;
|
|
const sum = closure_1 + 1;
|
|
closure_1 = sum;
|
|
if (sum === arg1.length) {
|
|
closure_1 = 0;
|
|
if (arg1) {
|
|
arg1(finished);
|
|
}
|
|
} else if (tmp2) {
|
|
closure_4.stop();
|
|
}
|
|
}
|
|
if (start) {
|
|
start.start(cb, arg1);
|
|
} else {
|
|
const obj = { finished: true };
|
|
cb(obj);
|
|
}
|
|
});
|
|
} else if (arg0) {
|
|
const obj = { finished: true };
|
|
arg0(obj);
|
|
}
|
|
},
|
|
stop() {
|
|
const item = arg0.forEach((stop) => {
|
|
if (!closure_2[arg1]) {
|
|
stop.stop();
|
|
}
|
|
closure_2[arg1] = true;
|
|
});
|
|
},
|
|
reset() {
|
|
const item = arg0.forEach((reset) => {
|
|
reset.reset();
|
|
closure_2[arg1] = false;
|
|
let closure_1 = 0;
|
|
});
|
|
},
|
|
_startNativeLoop() {
|
|
const error = new Error("Loops run using the native driver cannot contain Animated.parallel animations");
|
|
throw error;
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return false;
|
|
}
|
|
};
|
|
const maybeVectorAnim = obj;
|
|
return obj;
|
|
}
|
|
function delayImpl(delay) {
|
|
let tmp = arg2(arg6[13]);
|
|
tmp = new tmp(0);
|
|
const obj = { isArray: -1, ao: -1, test: false, y: "auto.ai.google_genai", delay };
|
|
return timingImpl(tmp, obj);
|
|
}
|
|
arg5.default = {
|
|
Value: arg2(arg6[13]),
|
|
ValueXY: arg2(arg6[6]),
|
|
Color: arg2(arg6[7]),
|
|
Interpolation: arg2(arg6[15]),
|
|
Node: arg2(arg6[8]),
|
|
decay: decayImpl,
|
|
timing: timingImpl,
|
|
spring: springImpl,
|
|
add: function addImpl(arg0, arg1) {
|
|
let tmp = arg2(arg6[0]);
|
|
tmp = new tmp(arg0, arg1);
|
|
return tmp;
|
|
},
|
|
subtract: function subtractImpl(arg0, arg1) {
|
|
let tmp = arg2(arg6[1]);
|
|
tmp = new tmp(arg0, arg1);
|
|
return tmp;
|
|
},
|
|
divide: function divideImpl(arg0, arg1) {
|
|
let tmp = arg2(arg6[2]);
|
|
tmp = new tmp(arg0, arg1);
|
|
return tmp;
|
|
},
|
|
multiply: function multiplyImpl(arg0, arg1) {
|
|
let tmp = arg2(arg6[3]);
|
|
tmp = new tmp(arg0, arg1);
|
|
return tmp;
|
|
},
|
|
modulo: function moduloImpl(arg0, arg1) {
|
|
let tmp = arg2(arg6[4]);
|
|
tmp = new tmp(arg0, arg1);
|
|
return tmp;
|
|
},
|
|
diffClamp: function diffClampImpl(arg0, arg1, arg2) {
|
|
let tmp = arg2(arg6[5]);
|
|
tmp = new tmp(arg0, arg1, arg2);
|
|
return tmp;
|
|
},
|
|
delay: delayImpl,
|
|
sequence: sequenceImpl,
|
|
parallel: parallelImpl,
|
|
stagger: function staggerImpl(arg0, arr) {
|
|
arr = arg0;
|
|
return parallelImpl(arr.map((arg0, arg1) => {
|
|
const items = [callback2(arg0 * arg1), arg0];
|
|
return callback(items);
|
|
}));
|
|
},
|
|
loop: function loopImpl(arg0) {
|
|
const arg1 = arg0;
|
|
if (arguments.length > 1) {
|
|
if (undefined !== arguments[1]) {
|
|
let obj = arguments[1];
|
|
}
|
|
const iterations = obj.iterations;
|
|
let num = -1;
|
|
if (undefined !== iterations) {
|
|
num = iterations;
|
|
}
|
|
const arg2 = num;
|
|
const resetBeforeIteration = obj.resetBeforeIteration;
|
|
let closure_2 = undefined === resetBeforeIteration || resetBeforeIteration;
|
|
let closure_3 = false;
|
|
let closure_4 = 0;
|
|
obj = {
|
|
start(self) {
|
|
function restart(self) {
|
|
if (arguments.length > 0) {
|
|
if (undefined !== arguments[0]) {
|
|
let first = arguments[0];
|
|
}
|
|
if (!closure_3) {
|
|
if (closure_4 !== restart) {
|
|
if (false !== first.finished) {
|
|
closure_4 = closure_4 + 1;
|
|
if (closure_2) {
|
|
self.reset();
|
|
}
|
|
self.start(restart, -1 === restart);
|
|
}
|
|
}
|
|
}
|
|
if (self) {
|
|
self(first);
|
|
}
|
|
}
|
|
first = { finished: true };
|
|
}
|
|
let num = restart;
|
|
if (self) {
|
|
num = 0;
|
|
if (0 !== num) {
|
|
if (self._isUsingNativeDriver()) {
|
|
self._startNativeLoop(num);
|
|
} else {
|
|
restart();
|
|
}
|
|
}
|
|
}
|
|
if (self) {
|
|
const obj = { finished: true };
|
|
self(obj);
|
|
}
|
|
},
|
|
stop() {
|
|
let closure_3 = true;
|
|
arg0.stop();
|
|
},
|
|
reset() {
|
|
let closure_4 = 0;
|
|
let closure_3 = false;
|
|
arg0.reset();
|
|
},
|
|
_startNativeLoop() {
|
|
const error = new Error("Loops run using the native driver cannot contain Animated.loop animations");
|
|
throw error;
|
|
},
|
|
_isUsingNativeDriver() {
|
|
return arg0._isUsingNativeDriver();
|
|
}
|
|
};
|
|
return obj;
|
|
}
|
|
obj = {};
|
|
},
|
|
event: function eventImpl(_argMapping, useNativeDriver) {
|
|
const animatedEvent = new useNativeDriver(arg6[14]).AnimatedEvent(_argMapping, useNativeDriver);
|
|
let __getHandlerResult = animatedEvent;
|
|
if (!animatedEvent.__isNative) {
|
|
__getHandlerResult = animatedEvent.__getHandler();
|
|
}
|
|
return __getHandlerResult;
|
|
},
|
|
createAnimatedComponent: arg2(arg6[16]),
|
|
attachNativeEvent: arg1(arg6[14]).attachNativeEventImpl,
|
|
forkEvent: function forkEventImpl(__addListener, listener) {
|
|
listener = __addListener;
|
|
const arg2 = listener;
|
|
if (!__addListener) {
|
|
return listener;
|
|
} else if (__addListener instanceof listener(arg6[14]).AnimatedEvent) {
|
|
__addListener.__addListener(listener);
|
|
let fn = __addListener;
|
|
} else {
|
|
fn = () => {
|
|
if ("function" === typeof arg0) {
|
|
arg0(...arguments);
|
|
}
|
|
arg1(...arguments);
|
|
};
|
|
}
|
|
},
|
|
unforkEvent: function unforkEventImpl(__removeListener) {
|
|
let tmp = __removeListener;
|
|
if (__removeListener) {
|
|
tmp = __removeListener instanceof arg1(arg6[14]).AnimatedEvent;
|
|
}
|
|
if (tmp) {
|
|
__removeListener.__removeListener(arg1);
|
|
}
|
|
},
|
|
Event: arg1(arg6[14]).AnimatedEvent
|
|
};
|